Overhaul export support to allow for manual mangling of reserved words

README.md

@@ -110,6 +110,28 @@ export default {
 }
 ```
 
+### Additional Mangle Protection
+
+If your source uses reserved words for identifiers or declarations, you can supply the list of words you would like to ensure are mangled before compilation, and renewed if they are used in an import or export statement.
+
+```js
+// rollup.config.js
+import compiler from '@ampproject/rollup-plugin-closure-compiler';
+
+export default {
+  input: 'main.js',
+  output: {
+    file: 'bundle.js',
+    format: 'es',
+  },
+  plugins: [
+    compiler({}, {
+      mangleReservedWords: ['Plugin', 'Storage'],
+    }),
+  ],
+}
+```
+
 ## Security disclosures
 
 The AMP Project accepts responsible security disclosures through the [Google Application Security program](https://www.google.com/about/appsecurity/).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ampproject/rollup-plugin-closure-compiler",
-  "version": "0.8.3",
+  "version": "0.9.0-beta.5",
   "description": "Rollup + Google Closure Compiler",
   "main": "dist/index.js",
   "jsnext:main": "dist/index.mjs",
@@ -52,7 +52,8 @@
   "files": [
     "dist/index.d.ts",
     "dist/index.js",
-    "dist/index.mjs"
+    "dist/index.mjs",
+    "dist/types.ts"
   ],
   "lint-staged": {
     "*.ts": [

rollup.config.js

@@ -18,27 +18,35 @@ import pkg from './package.json';
 import builtins from 'builtins';
 import copy from 'rollup-plugin-copy';
 
-export default {
-  input: './transpile/index.js',
-  external: [
-    ...builtins(),
-    ...Object.keys(pkg.dependencies || {}),
-    ...Object.keys(pkg.peerDependencies || {}),
-  ],
-  plugins: [
-    copy({
-      './transpile/index.d.ts': './dist/index.d.ts',
-      verbose: true,
-    }),
-  ],
-  output: [
-    {
+const input = './transpile/index.js';
+const external = [
+  ...builtins(),
+  ...Object.keys(pkg.dependencies || {}),
+  ...Object.keys(pkg.peerDependencies || {}),
+];
+
+export default [
+  {
+    input,
+    external,
+    plugins: [
+      copy({
+        './transpile/index.d.ts': './dist/index.d.ts',
+        './src/types.ts': './dist/types.ts',
+        verbose: true,
+      }),
+    ],
+    output: {
       file: './dist/index.mjs',
       format: 'es',
     },
-    {
+  },
+  {
+    input,
+    external,
+    output: {
       file: './dist/index.js',
       format: 'cjs',
     },
-  ],
-};
+  }
+]

src/acorn.ts

@@ -15,7 +15,7 @@
  */
 
 import { Program } from 'estree';
-import { DYNAMIC_IMPORT_DECLARATION } from './types';
+import { DYNAMIC_IMPORT_DECLARATION, SourceRange } from './types';
 const acorn = require('acorn');
 const acornWalk = require('acorn-walk');
 const dynamicImport = require('acorn-dynamic-import');
@@ -38,8 +38,13 @@ const DEFAULT_ACORN_OPTIONS = {
   sourceType: 'module',
   preserveParens: false,
   ranges: true,
+  locations: true,
 };
 
 export function parse(source: string): Program {
   return acorn.Parser.extend(dynamicImport.default).parse(source, DEFAULT_ACORN_OPTIONS);
 }
+
+export function range(node: any): SourceRange {
+  return node.range ? [node.range[0], node.range[1]] : [0, 0];
+}

src/compiler.ts

@@ -19,8 +19,10 @@ const {
   getNativeImagePath,
   getFirstSupportedPlatform,
 } = require('google-closure-compiler/lib/utils.js');
-import { Transform } from './types';
 import { postCompilation } from './transforms';
+import { Transform } from './transformers/transform';
+import { RenderedChunk } from 'rollup';
+import { MangledWords } from './types';
 
 enum Platform {
   NATIVE = 'native',
@@ -38,7 +40,9 @@ const PLATFORM_PRECEDENCE = [Platform.NATIVE, Platform.JAVA, Platform.JAVASCRIPT
  */
 export default function(
   compileOptions: CompileOptions,
+  chunk: RenderedChunk,
   transforms: Array<Transform>,
+  moduleMangledWords: MangledWords,
 ): Promise<string> {
   return new Promise((resolve: (stdOut: string) => void, reject: (error: any) => void) => {
     const instance = new compiler(compileOptions);
@@ -62,7 +66,7 @@ export default function(
       } else if (exitCode !== 0) {
         reject(new Error(`Google Closure Compiler exit ${exitCode}: ${stdErr}`));
       } else {
-        resolve(await postCompilation(code, transforms));
+        resolve(await postCompilation(code, chunk, transforms, moduleMangledWords));
       }
     });
   });

src/debug.ts

@@ -16,9 +16,9 @@
 
 import { sync } from 'temp-write';
 
-const DEBUG_ENABLED = false;
+const DEBUG_ENABLED: boolean = false;
 
-export const logSource = (preamble: string, source: string, code?: string) => {
+export const logSource = (preamble: string, source: string, code?: string): void => {
   if (DEBUG_ENABLED) {
     console.log(preamble);
     console.log(sync(source));
@@ -28,7 +28,7 @@ export const logSource = (preamble: string, source: string, code?: string) => {
   }
 };
 
-export const log = (preamble: string, message: string): void | null => {
+export const log = (preamble: string, message: string): void => {
   if (DEBUG_ENABLED) {
     console.log(preamble);
     console.log(message);

src/index.ts

@@ -28,7 +28,8 @@ import {
 import compiler from './compiler';
 import options from './options';
 import { preCompilation, createTransforms } from './transforms';
-import { Transform } from './types';
+import { Transform } from './transformers/transform';
+import { TransformOptions, MangledWords } from './types';
 
 const readFile = promisify(fs.readFile);
 
@@ -40,33 +41,39 @@ const readFile = promisify(fs.readFile);
  * @param outputOptions Rollup Output Options.
  * @return Closure Compiled form of the Rollup Chunk
  */
-const renderChunk = async (
+async function renderChunk(
   transforms: Array<Transform>,
   requestedCompileOptions: CompileOptions = {},
   sourceCode: string,
+  chunk: RenderedChunk,
   outputOptions: OutputOptions,
-): Promise<{ code: string; map: RawSourceMap } | void> => {
-  const code = await preCompilation(sourceCode, outputOptions, transforms);
+  globallyMangledWords: MangledWords,
+): Promise<{ code: string; map: RawSourceMap } | void> {
+  const preCompiled = await preCompilation(sourceCode, chunk, transforms, globallyMangledWords);
   const [compileOptions, mapFile] = options(
     requestedCompileOptions,
     outputOptions,
-    code,
+    preCompiled.code,
     transforms,
   );
 
-  return compiler(compileOptions, transforms).then(
+  return compiler(compileOptions, chunk, transforms, preCompiled.moduleMangledWords).then(
     async code => {
       return { code, map: JSON.parse(await readFile(mapFile, 'utf8')) };
     },
     (error: Error) => {
       throw error;
     },
   );
-};
+}
 
-export default function closureCompiler(requestedCompileOptions: CompileOptions = {}): Plugin {
+export default function closureCompiler(
+  requestedCompileOptions: CompileOptions = {},
+  transformOptions: TransformOptions = {},
+): Plugin {
   let inputOptions: InputOptions;
   let context: PluginContext;
+  const globallyMangledWords: MangledWords = new MangledWords(transformOptions.mangleReservedWords);
 
   return {
     name: 'closure-compiler',
@@ -84,8 +91,15 @@ export default function closureCompiler(requestedCompileOptions: CompileOptions
       }
     },
     renderChunk: async (code: string, chunk: RenderedChunk, outputOptions: OutputOptions) => {
-      const transforms = createTransforms(context, inputOptions);
-      return await renderChunk(transforms, requestedCompileOptions, code, outputOptions);
+      const transforms = createTransforms(context, inputOptions, outputOptions, transformOptions);
+      return await renderChunk(
+        transforms,
+        requestedCompileOptions,
+        code,
+        chunk,
+        outputOptions,
+        globallyMangledWords,
+      );
     },
   };
 }

src/mangle.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright 2018 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SourceRange, MangledWords, CodeTransform } from './types';
+import { walk, range } from './acorn';
+import {
+  Program,
+  ClassDeclaration,
+  Identifier,
+  VariableDeclaration,
+  FunctionDeclaration,
+} from 'estree';
+
+export function mangleWord(name: string, range: SourceRange, mangled: MangledWords): CodeTransform {
+  const mangleName = mangled.getFinal(name);
+  if (mangleName) {
+    mangled.store(name, mangleName);
+    return {
+      type: 'overwrite',
+      range,
+      content: mangleName,
+    };
+  }
+
+  return null;
+}
+
+function remedyWord(name: string, range: SourceRange, mangled: MangledWords): CodeTransform {
+  const remedyWord = mangled.getInitial(name);
+  if (remedyWord) {
+    return {
+      type: 'overwrite',
+      range,
+      content: remedyWord,
+    };
+  }
+
+  return null;
+}
+export async function remedy(
+  program: Program,
+  mangled: MangledWords,
+): Promise<Array<CodeTransform>> {
+  const changes: Array<CodeTransform> = [];
+
+  walk.simple(program, {
+    ClassDeclaration(node: ClassDeclaration) {
+      if (node.id !== null) {
+        changes.push(remedyWord(node.id.name, range(node.id), mangled));
+      }
+    },
+    Identifier(node: Identifier) {
+      changes.push(remedyWord(node.name, range(node), mangled));
+    },
+    VariableDeclaration(node: VariableDeclaration) {
+      node.declarations.forEach(declarator => {
+        if (declarator.id.type === 'Identifier') {
+          changes.push(remedyWord(declarator.id.name, range(declarator.id), mangled));
+        }
+      });
+    },
+    FunctionDeclaration(node: FunctionDeclaration) {
+      if (node.id) {
+        changes.push(remedyWord(node.id.name, range(node.id), mangled));
+      }
+    },
+  });
+
+  return changes;
+}

src/options.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-import { Transform } from './types';
 import { ModuleFormat, OutputOptions } from 'rollup';
 import { CompileOptions } from 'google-closure-compiler';
 import { sync } from 'temp-write';
 import { logSource } from './debug';
+import { Transform } from './transformers/transform';
 
 export const ERROR_WARNINGS_ENABLED_LANGUAGE_OUT_UNSPECIFIED =
   'Providing the warning_level=VERBOSE compile option also requires a valid language_out compile option.';

src/parsers/ExportDefaultDeclaration.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2018 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ExportDefaultDeclaration } from 'estree';
+import { DiscoveredExport } from '../types';
+import { range } from '../acorn';
+
+/**
+ * Find information about the ExportDefaultDeclaration passed
+ * @param node ExportDefaultDeclaration
+ * @return Interesting information about the default export.
+ */
+export function exportDefaultParser(node: ExportDefaultDeclaration): DiscoveredExport | null {
+  const declaration = node.declaration;
+  if (declaration.type === 'Identifier') {
+    // This is a default export of a known identifier
+    // Rollup will call unnamed default exports 'main' or another safeword.
+    return {
+      local: declaration.name,
+      exported: declaration.name,
+      default: true,
+      range: range(node),
+    };
+  }
+
+  return null;
+}