.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.vscode/
+out/

README.md

@@ -208,5 +208,5 @@ From the master branch run:
 ```
 npm config set registry https://wombat-dressing-room.appspot.com
 npm login
-npm publish
+npm publish  # runs a clean build & test automatically
 ```

demo/demo.ts

@@ -164,15 +164,16 @@ export function toClosureJS(
     pathToModuleName: (context, fileName) =>
         tsickle.pathToModuleName(rootModulePath, context, fileName),
     fileNameToModuleId: (fileName) => path.relative(rootModulePath, fileName),
-    es5Mode: true,
     googmodule: true,
     transformDecorators: true,
     transformTypesToClosure: true,
     typeBlackListPaths: new Set(),
     untyped: false,
-    logWarning: (warning) => console.error(ts.formatDiagnostics([warning], compilerHost)),
+    logWarning: (warning) =>
+        console.error(ts.formatDiagnostics([warning], compilerHost)),
     options,
     moduleResolutionHost: compilerHost,
+    generateExtraSuppressions: true,
   };
   const diagnostics = ts.getPreEmitDiagnostics(program);
   if (diagnostics.length > 0) {

demo/package.json

@@ -8,14 +8,14 @@
   "dependencies": {
     "minimist": "^1.2.3",
     "tsickle": "file:../",
-    "typescript": "h-joo/TypeScript#ts45-no-double-comments"
+    "typescript": "4.7.2"
   },
   "devDependencies": {
     "@types/minimist": "1.2.0",
     "@types/node": "^10.5.6"
   },
   "scripts": {
-    "build": "(cd ../ && yarn build) && node_modules/typescript/bin/tsc",
+    "build": "(cd ../ && yarn build) && tsc",
     "demo": "node --preserve-symlinks build/demo.js -- --outDir `pwd`/tsickle-out"
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsickle",
-  "version": "0.46.0",
+  "version": "0.46.3",
   "description": "Transpile TypeScript code to JavaScript with Closure annotations.",
   "main": "out/src/tsickle.js",
   "typings": "out/src/tsickle.d.ts",
@@ -11,30 +11,31 @@
     "out/src/*"
   ],
   "peerDependencies": {
-    "typescript": "h-joo/TypeScript#ts45-no-double-comments"
+    "typescript": "~4.7.2"
   },
   "devDependencies": {
     "@types/diff-match-patch": "^1.0.32",
-    "@types/glob": "5.0.35",
-    "@types/jasmine": "^3.7.7",
-    "@types/node": "^10.5.6",
+    "@types/glob": "7.2.0",
+    "@types/jasmine": "^4.0.2",
+    "@types/node": "^17.0.24",
     "@types/source-map-support": "^0.5.3",
     "diff-match-patch": "^1.0.5",
-    "glob": "7.1.2",
-    "google-closure-compiler": "^20211006.0.0",
-    "jasmine": "^3.7.0",
+    "glob": "8.0.1",
+    "google-closure-compiler": "^20220405.0.0",
+    "jasmine": "^4.1.0",
     "jasmine-node": "^3.0.0",
     "source-map": "^0.7.3",
     "source-map-support": "^0.5.19",
     "tslib": "^2.2.0",
     "tslint": "^6.1.3",
-    "typescript": "h-joo/TypeScript#ts45-no-double-comments"
+    "typescript": "4.7.2"
   },
   "scripts": {
-    "build": "tsc ",
+    "build": "tsc",
     "clean": "rm -r out",
     "lint": "tslint -c tslint.json -p tsconfig.json",
-    "test": "jasmine out/test/*.js && (cd demo && yarn && tsc) && npm run lint"
+    "test": "jasmine out/test/*.js && (cd demo && yarn && tsc) && yarn run lint",
+    "prepack": "yarn run clean && yarn run build && yarn run test"
   },
   "repository": {
     "type": "git",

src/closure_externs.js

@@ -52,26 +52,11 @@ var NodeListOf;
  */
 var RegExpExecArray;
 
-/**
- * @record
- * @template T
- * @extends {Array<T>}
- */
-function ReadonlyArray() {}
+/** @typedef {!Map} */
+var ReadonlyMap;
 
-/**
- * @constructor
- * @template K, V
- * @extends {Map<K, V>}
- */
-function ReadonlyMap() {}
-
-/**
- * @constructor
- * @template T
- * @extends {Set<T>}
- */
-function ReadonlySet() {}
+/** @typedef {!Set} */
+var ReadonlySet;
 
 /**
  * @record
@@ -110,6 +95,12 @@ function CryptoKeyPair() {};
 /** @typedef {!{handleEvent: function(Event):void}} */
 var EventListenerObject;
 
+/** @typedef {!ITemplateArray} */
+var TemplateStringsArray;
+
+/** @typedef {!RegExpResult} */
+var RegExpMatchArray;
+
 /** @record */
 function ImportMeta() {};
 
@@ -131,3 +122,5 @@ class WindowEventMap {}
 class GlobalEventHandlersEventMap {}
 /** @interface */
 class DocumentAndElementEventHandlersEventMap {}
+/** @interface */
+class EventSourceEventMap {}

src/clutz.ts

@@ -53,11 +53,11 @@ export function makeDeclarationTransformerFactory(
         if (imports.length > 0) {
           importStmts = imports.map(fileName => {
             fileName = path.relative(options.rootDir!, fileName);
-            return ts.createImportDeclaration(
+            return ts.factory.createImportDeclaration(
                 /* decorators */ undefined,
                 /* modifiers */ undefined,
                 /* importClause */ undefined,
-                /* moduleSpecifier */ ts.createStringLiteral(fileName),
+                /* moduleSpecifier */ ts.factory.createStringLiteral(fileName),
             );
           });
         }
@@ -70,7 +70,7 @@ export function makeDeclarationTransformerFactory(
         // Only need to transform file if we needed one of the above additions.
         if (!importStmts && !globalBlock) return file;
 
-        return ts.updateSourceFileNode(file, [
+        return ts.factory.updateSourceFile(file, [
           ...(importStmts ?? []),
           ...file.statements,
           ...(globalBlock ? [globalBlock] : []),
@@ -216,53 +216,50 @@ function generateClutzAliases(
     const mangledName = `module$contents$${clutzModuleName}_${symbol.name}`;
     // These ExportSpecifiers are the `foo as bar` bits as found in a larger
     // `export {foo as bar}` statement, which is constructed after this loop.
-    globalExports.push(ts.createExportSpecifier(
-        /* isTypeOnly */ false, ts.createIdentifier(localName),
-        ts.createIdentifier(mangledName)));
-    nestedExports.push(ts.createExportSpecifier(
+    globalExports.push(ts.factory.createExportSpecifier(
+        /* isTypeOnly */ false, ts.factory.createIdentifier(localName),
+        ts.factory.createIdentifier(mangledName)));
+    nestedExports.push(ts.factory.createExportSpecifier(
         /* isTypeOnly */ false,
         localName === symbol.name ? undefined : localName,
-        ts.createIdentifier(symbol.name)));
+        ts.factory.createIdentifier(symbol.name)));
   }
 
   // Create two export statements that will be used to contribute to the
   // ಠ_ಠ.clutz namespace.
   const globalDeclarations: ts.Statement[] = [
     // 1) For globalExports,
     //      export {...};
-    ts.createExportDeclaration(
+    ts.factory.createExportDeclaration(
         /* decorators */ undefined,
         /* modifiers */ undefined,
-        ts.createNamedExports(globalExports),
-        ),
+        /* isTypeOnly */ false, ts.factory.createNamedExports(globalExports)),
     // 2) For nestedExports
     //      namespace module$exports$module$name$here {
     //        export {...};
     //      }
-    ts.createModuleDeclaration(
+    ts.factory.createModuleDeclaration(
         /* decorators */ undefined,
-        /* modifiers */[ts.createModifier(ts.SyntaxKind.ExportKeyword)],
-        ts.createIdentifier(`module$exports$${clutzModuleName}`),
-        ts.createModuleBlock([
-          ts.createExportDeclaration(
+        /* modifiers */[ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createIdentifier(`module$exports$${clutzModuleName}`),
+        ts.factory.createModuleBlock([
+          ts.factory.createExportDeclaration(
               /* decorators */ undefined,
               /* modifiers */ undefined,
-              ts.createNamedExports(nestedExports),
-              ),
+              /* isTypeOnly */ false,
+              ts.factory.createNamedExports(nestedExports)),
         ]),
-        ts.NodeFlags.Namespace,
-        ),
+        ts.NodeFlags.Namespace),
   ];
 
 
   // Wrap a `declare global { namespace ಠ_ಠ.clutz { ... } }` around
   // the statements in globalDeclarations.
-  return ts.createModuleDeclaration(
+  return ts.factory.createModuleDeclaration(
       /* decorators */ undefined,
-      /* modifiers */[ts.createModifier(ts.SyntaxKind.DeclareKeyword)],
-      ts.createIdentifier('global'),
-      ts.createModuleBlock([
-        ts.createModuleDeclaration(
+      /* modifiers */[ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
+      ts.factory.createIdentifier('global'), ts.factory.createModuleBlock([
+        ts.factory.createModuleDeclaration(
             /* decorators */ undefined,
             /* modifiers */ undefined,
             // Note: it's not exactly right to use a '.' within an identifier
@@ -271,13 +268,11 @@ function generateClutzAliases(
             // ModuleDeclaration, but nesting another ModuleDeclaration in here
             // always created a new {} block, despite trying the
             // 'NestedNamespace' flag.
-            ts.createIdentifier('ಠ_ಠ.clutz'),
-            ts.createModuleBlock(globalDeclarations),
-            ts.NodeFlags.Namespace | ts.NodeFlags.NestedNamespace,
-            ),
+            ts.factory.createIdentifier('ಠ_ಠ.clutz'),
+            ts.factory.createModuleBlock(globalDeclarations),
+            ts.NodeFlags.Namespace | ts.NodeFlags.NestedNamespace),
       ]),
-      ts.NodeFlags.GlobalAugmentation,
-  );
+      ts.NodeFlags.GlobalAugmentation);
 }
 
 /**

src/decorators.ts

@@ -96,7 +96,7 @@ export function transformDecoratorsOutputForClosurePropertyRenaming(diagnostics:
     const result: ts.Transformer<ts.SourceFile> = (sourceFile: ts.SourceFile) => {
       let nodeNeedingGoogReflect: undefined|ts.Node = undefined;
       const visitor: ts.Visitor = (node) => {
-        const replacementNode = rewriteDecorator(node, context);
+        const replacementNode = rewriteDecorator(node);
         if (replacementNode) {
           nodeNeedingGoogReflect = node;
           return replacementNode;
@@ -113,16 +113,19 @@ export function transformDecoratorsOutputForClosurePropertyRenaming(diagnostics:
               'Internal tsickle error: could not find goog.module statement to import __tsickle_googReflect for decorator compilation.');
           return sourceFile;
         }
-        const googRequireReflectObjectProperty = ts.createVariableStatement(
-            undefined,
-            ts.createVariableDeclarationList(
-                [ts.createVariableDeclaration(
-                    '__tsickle_googReflect', undefined,
-
-                    ts.createCall(
-                        ts.createPropertyAccess(ts.createIdentifier('goog'), 'require'), undefined,
-                        [ts.createStringLiteral('goog.reflect')]))],
-                ts.NodeFlags.Const));
+        const googRequireReflectObjectProperty =
+            ts.factory.createVariableStatement(
+                undefined,
+                ts.factory.createVariableDeclarationList(
+                    [ts.factory.createVariableDeclaration(
+                        '__tsickle_googReflect',
+                        /* exclamationToken */ undefined, /* type */ undefined,
+                        ts.factory.createCallExpression(
+                            ts.factory.createPropertyAccessExpression(
+                                ts.factory.createIdentifier('goog'), 'require'),
+                            undefined,
+                            [ts.factory.createStringLiteral('goog.reflect')]))],
+                    ts.NodeFlags.Const));
         // The boilerplate we produce has a goog.module line, then two related
         // lines dealing with the `module` variable. Insert our goog.require
         // after that to avoid visually breaking up the module info, and to be
@@ -131,7 +134,8 @@ export function transformDecoratorsOutputForClosurePropertyRenaming(diagnostics:
         updatedSourceFile = ts.factory.updateSourceFile(
             updatedSourceFile,
             ts.setTextRange(
-                ts.createNodeArray(statements), updatedSourceFile.statements),
+                ts.factory.createNodeArray(statements),
+                updatedSourceFile.statements),
             updatedSourceFile.isDeclarationFile,
             updatedSourceFile.referencedFiles,
             updatedSourceFile.typeReferenceDirectives,
@@ -151,7 +155,7 @@ export function transformDecoratorsOutputForClosurePropertyRenaming(diagnostics:
  *
  * Returns undefined if no modification is necessary.
  */
-function rewriteDecorator(node: ts.Node, context: ts.TransformationContext): ts.Node|undefined {
+function rewriteDecorator(node: ts.Node): ts.Node|undefined {
   if (!ts.isCallExpression(node)) {
     return;
   }
@@ -178,10 +182,14 @@ function rewriteDecorator(node: ts.Node, context: ts.TransformationContext): ts.
     return;
   }
   const fieldNameLiteral = untypedFieldNameLiteral;
-  args[2] = ts.createCall(
-      ts.createPropertyAccess(ts.createIdentifier('__tsickle_googReflect'), 'objectProperty'),
-      undefined, [ts.createStringLiteral(fieldNameLiteral.text), ts.getMutableClone(args[1])]);
-  return ts.updateCall(node, node.expression, node.typeArguments, args);
+  args[2] = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier('__tsickle_googReflect'),
+          'objectProperty'),
+      undefined,
+      [ts.factory.createStringLiteral(fieldNameLiteral.text), args[1]]);
+  return ts.factory.updateCallExpression(
+      node, node.expression, node.typeArguments, args);
 }
 
 function isGoogModuleStatement(statement: ts.Node) {
@@ -235,7 +243,7 @@ function sanitizeDecorateComments(comments: ts.SynthesizedComment[]):
  */
 export function transformDecoratorJsdoc():
     ts.TransformerFactory<ts.SourceFile> {
-  return (context: ts.TransformationContext) => {
+  return () => {
     const transformer: ts.Transformer<ts.SourceFile> =
         (sourceFile: ts.SourceFile) => {
           for (const stmt of sourceFile.statements) {