package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsickle",
-  "version": "0.37.1",
+  "version": "0.38.1",
   "description": "Transpile TypeScript code to JavaScript with Closure annotations.",
   "main": "src/tsickle.js",
   "typings": "src/tsickle.d.ts",
@@ -11,7 +11,7 @@
     "src/*"
   ],
   "peerDependencies": {
-    "typescript": "~3.6.4"
+    "typescript": "~3.8.2"
   },
   "devDependencies": {
     "@bazel/bazel": "^0.29.0",
@@ -29,8 +29,9 @@
     "prettier": "1.14.0",
     "source-map": "^0.7.3",
     "source-map-support": "^0.5.6",
+    "tslib": "1.11",
     "tslint": "5.11.0",
-    "typescript": "3.6.4"
+    "typescript": "3.8.2"
   },
   "scripts": {
     "build": "bazel build //:npm_package",

src/enum_transformer.ts

@@ -196,7 +196,11 @@ export function enumTransformer(typeChecker: ts.TypeChecker, diagnostics: ts.Dia
       for (const member of node.members) {
         const memberName = member.name;
         const memberType = getEnumMemberType(typeChecker, member);
-        if (memberType !== 'number') continue;
+        // Enum members cannot be named with a private identifier, although it
+        // is technically valid in the AST.
+        if (memberType !== 'number' || ts.isPrivateIdentifier(memberName)) {
+          continue;
+        }
 
         // TypeScript enum members can have Identifier names or String names.
         // We need to emit slightly different code to support these two syntaxes:

src/externs.ts

@@ -518,6 +518,12 @@ export function generateExterns(
           debugLocationStr(exportDeclaration, namespace)}\n`);
       return;
     }
+    if (ts.isNamespaceExport(exportDeclaration.exportClause)) {
+      // TODO(#1135): Support generating externs using this syntax.
+      emit(`\n// TODO(tsickle): export * as declaration in ${
+          debugLocationStr(exportDeclaration, namespace)}\n`);
+      return;
+    }
     for (const exportSpecifier of exportDeclaration.exportClause.elements) {
       // No need to do anything for properties exported under their original name.
       if (!exportSpecifier.propertyName) continue;

src/fileoverview_comment_transformer.ts

@@ -49,7 +49,15 @@ function augmentFileoverviewComments(
     suppressions = new Set((suppressTag.type || '').split(',').map(s => s.trim()));
   } else {
     suppressTag = {tagName: 'suppress', text: 'checked by tsc'};
-    tags.push(suppressTag);
+    // Special case the @license tag because all text following this tag is
+    // treated by the compiler as part of the license, so we need to place the
+    // new @suppress tag before @license.
+    const licenseTagIndex = tags.findIndex(t => t.tagName === 'license');
+    if (licenseTagIndex !== -1) {
+      tags.splice(licenseTagIndex, 0, suppressTag);
+    } else {
+      tags.push(suppressTag);
+    }
     suppressions = new Set();
   }
 

src/googmodule.ts

@@ -281,7 +281,7 @@ export function commonJsToGoogmoduleTransformer(
       // that a bundle by definition cannot be a goog.module()). The cast through any is necessary
       // to remain compatible with earlier TS versions.
       // tslint:disable-next-line:no-any
-      if ((sf as any).kind !== ts.SyntaxKind.SourceFile) return sf;
+      if ((sf as any)['kind'] !== ts.SyntaxKind.SourceFile) return sf;
 
       // JS scripts (as opposed to modules), must not be rewritten to
       // goog.modules.
@@ -428,6 +428,45 @@ export function commonJsToGoogmoduleTransformer(
             ts.setTextRange(ts.createStatement(createGoogCall('require', arg)), stmt), stmt);
       }
 
+      /**
+       * Rewrites code generated by `export * as ns from 'ns'` to something like:
+       *
+       * ```
+       * const tsickle_module_n_ = goog.require('ns');
+       * exports.ns = tsickle_module_n_;
+       * ```
+       *
+       * Separating the `goog.require` and `exports.ns` assignment is required by Closure to
+       * correctly infer the type of the exported namespace.
+       */
+      function maybeRewriteExportStarAsNs(stmt: ts.Statement): ts.Statement[]|null {
+        // Ensure this looks something like `exports.ns = require('ns);`.
+        if (!ts.isExpressionStatement(stmt)) return null;
+        if (!ts.isBinaryExpression(stmt.expression)) return null;
+        if (stmt.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return null;
+
+        // Ensure the left side of the expression is an access on `exports`.
+        if (!ts.isPropertyAccessExpression(stmt.expression.left)) return null;
+        if (!ts.isIdentifier(stmt.expression.left.expression)) return null;
+        if (stmt.expression.left.expression.escapedText !== 'exports') return null;
+
+        // Grab the call to `require`, and exit early if not calling `require`.
+        if (!ts.isCallExpression(stmt.expression.right)) return null;
+        const ident = ts.createIdentifier(nextModuleVar());
+        const require = maybeCreateGoogRequire(stmt, stmt.expression.right, ident);
+        if (!require) return null;
+
+        const exportedName = stmt.expression.left.name;
+        const exportStmt = ts.setOriginalNode(
+            ts.setTextRange(
+                ts.createStatement(ts.createAssignment(
+                    ts.createPropertyAccess(ts.createIdentifier('exports'), exportedName), ident)),
+                stmt),
+            stmt);
+
+        return [require, exportStmt];
+      }
+
       /**
        * visitTopLevelStatement implements the main CommonJS to goog.module conversion. It visits a
        * SourceFile level statement and adds a (possibly) transformed representation of it into
@@ -480,6 +519,14 @@ export function commonJsToGoogmoduleTransformer(
               return;
             }
             // Check for:
+            //   exports.ns = require('...');
+            // which is generated by the `export * as ns from` syntax.
+            const exportStarAsNs = maybeRewriteExportStarAsNs(exprStmt);
+            if (exportStarAsNs) {
+              stmts.push(...exportStarAsNs);
+              return;
+            }
+            // Check for:
             //   "require('foo');" (a require for its side effects)
             const expr = exprStmt.expression;
             if (!ts.isCallExpression(expr)) break;
@@ -573,6 +620,35 @@ export function commonJsToGoogmoduleTransformer(
             ts.createAssignment(ts.createIdentifier('module'), ts.createIdentifier('module'))));
       }
 
+      // Add `goog.require('tslib');` if not JS transpilation, and it hasn't already been required.
+      // Rationale:
+      // TS gets compiled to Development mode (ES5) and Closure mode (~ES6)
+      // sources. Tooling generates module manifests from the Closure version.
+      // These manifests are used both with the Closure version and the
+      // Development mode version. 'tslib' is sometimes required by the
+      // development version but not the Closure version. Inserting the import
+      // below unconditionally makes sure that the module manifests are
+      // identical between Closure and Development mode, avoiding breakages
+      // caused by missing module dependencies.
+      if (!host.isJsTranspilation) {
+        // Get a copy of the already resolved module names before calling
+        // resolveModuleName on 'tslib'. Otherwise, resolveModuleName will
+        // add 'tslib' to namespaceToModuleVarName and prevent checking whether
+        // 'tslib' has already been required.
+        const resolvedModuleNames = [...namespaceToModuleVarName.keys()];
+
+        const tslibModuleName =
+            host.pathToModuleName(sf.fileName, resolveModuleName(host, sf.fileName, 'tslib'));
+
+        // Only add the extra require if it hasn't already been required
+        if (resolvedModuleNames.indexOf(tslibModuleName) === -1) {
+          const tslibImport = ts.createExpressionStatement(
+              createGoogCall('require', createSingleQuoteStringLiteral(tslibModuleName)));
+
+          // Place the goog.require('tslib') statement right after the goog.module statements
+          headerStmts.push(tslibImport);
+        }
+      }
       // Insert goog.module() etc after any leading comments in the source file. The comments have
       // been converted to NotEmittedStatements by transformer_util, which this depends on.
       const insertionIdx = stmts.findIndex(s => s.kind !== ts.SyntaxKind.NotEmittedStatement);

src/jsdoc_transformer.ts

@@ -341,9 +341,18 @@ function createClosurePropertyDeclaration(
     optional: boolean): ts.Statement {
   const name = propertyName(prop);
   if (!name) {
-    mtt.debugWarn(prop, `handle unnamed member:\n${escapeForComment(prop.getText())}`);
-    return transformerUtil.createMultiLineComment(
-        prop, `Skipping unnamed member:\n${escapeForComment(prop.getText())}`);
+    // Skip warning for private identifiers because it is expected they are skipped in the
+    // Closure output.
+    // TODO(rdel): Once Closure Compiler determines how private properties should be represented,
+    // adjust this output accordingly.
+    if (ts.isPrivateIdentifier(prop.name)) {
+      return transformerUtil.createMultiLineComment(
+          prop, `Skipping private member:\n${escapeForComment(prop.getText())}`);
+    } else {
+      mtt.debugWarn(prop, `handle unnamed member:\n${escapeForComment(prop.getText())}`);
+      return transformerUtil.createMultiLineComment(
+          prop, `Skipping unnamed member:\n${escapeForComment(prop.getText())}`);
+    }
   }
 
   if (name === 'prototype') {
@@ -891,10 +900,13 @@ export function jsdocTransformer(
               typesToExport.push([sym.name, sym]);
             }
           }
+          const isTypeOnlyExport = false;
           exportDecl = ts.updateExportDeclaration(
               exportDecl, exportDecl.decorators, exportDecl.modifiers,
-              ts.createNamedExports(exportSpecifiers), exportDecl.moduleSpecifier);
-        } else {
+              ts.createNamedExports(exportSpecifiers), exportDecl.moduleSpecifier,
+              isTypeOnlyExport);
+        } else if (ts.isNamedExports(exportDecl.exportClause)) {
+          // export {a, b, c} from 'abc';
           for (const exp of exportDecl.exportClause.elements) {
             const exportedName = transformerUtil.getIdentifierText(exp.name);
             typesToExport.push(

src/module_type_translator.ts

@@ -368,10 +368,11 @@ export class ModuleTypeTranslator {
     if ((type.flags & ts.TypeFlags.Object) !== 0 &&
         (type as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference) {
       const typeRef = type as ts.TypeReference;
-      if (!typeRef.typeArguments) {
+      const typeArgs = this.typeChecker.getTypeArguments(typeRef);
+      if (!typeArgs) {
         throw new Error('rest parameter does not resolve to a reference type');
       }
-      newTag.type = this.typeToClosure(fnDecl, typeRef.typeArguments![0]);
+      newTag.type = this.typeToClosure(fnDecl, typeArgs[0]);
       return;
     }
     // If we fail to unwrap the Array<> type, emit an unknown type.
@@ -507,7 +508,7 @@ export class ModuleTypeTranslator {
         // parameter. It's not clear how to resolve the two conflicting this types best, the current
         // solution prefers the explicitly given `this` parameter.
         // tslint:disable-next-line:no-any accessing TS internal field.
-        if ((retType as any).isThisType && !hasThisParam) {
+        if ((retType as any)['isThisType'] && !hasThisParam) {
           // foo(): this
           thisReturnType = retType;
           addTag({tagName: 'template', text: 'THIS'});

src/transformer_util.ts

@@ -178,7 +178,7 @@ export function isTypeNodeKind(kind: ts.SyntaxKind) {
 export function createSingleQuoteStringLiteral(text: string): ts.StringLiteral {
   const stringLiteral = ts.createLiteral(text);
   // tslint:disable-next-line:no-any accessing TS internal API.
-  (stringLiteral as any).singleQuote = true;
+  (stringLiteral as any)['singleQuote'] = true;
   return stringLiteral;
 }
 

src/tsickle.ts

@@ -280,7 +280,7 @@ function addClutzAliases(
       // This uses an internal TS API, assuming that accessing this will be more stable compared to
       // implementing our own version.
       // tslint:disable-next-line: no-any
-      if (options.stripInternal && (ts as any).isInternalDeclaration(d, origSourceFile)) {
+      if (options.stripInternal && (ts as any)['isInternalDeclaration'](d, origSourceFile)) {
         return false;
       }
 

src/type_translator.ts

@@ -540,7 +540,7 @@ export class TypeTranslator {
       // In that case, take the parent symbol of the enum member, which should be the enum
       // declaration.
       // tslint:disable-next-line:no-any working around a TS API deficiency.
-      const parent: ts.Symbol|undefined = (symbol as any).parent;
+      const parent: ts.Symbol|undefined = (symbol as any)['parent'];
       if (!parent) return '?';
       symbol = parent;
     }
@@ -620,8 +620,9 @@ export class TypeTranslator {
       // Translate can return '?' for a number of situations, e.g. type/value conflicts.
       // `?<?>` is illegal syntax in Closure Compiler, so just return `?` here.
       if (typeStr === '?') return '?';
-      if (referenceType.typeArguments) {
-        const params = referenceType.typeArguments.map(t => this.translate(t));
+      const typeArgs = this.typeChecker.getTypeArguments(referenceType);
+      if (typeArgs) {
+        const params = typeArgs.map(t => this.translate(t));
         typeStr += `<${params.join(', ')}>`;
       }
       return typeStr;
@@ -852,14 +853,14 @@ export class TypeTranslator {
           paramTypes.push('!Array<?>');
           continue;
         }
-        const typeRef = paramType as ts.TypeReference;
-        if (!typeRef.typeArguments) {
+        const typeArgs = this.typeChecker.getTypeArguments(paramType as ts.TypeReference);
+        if (typeArgs.length === 0) {
           // When a rest argument resolves empty, i.e. the concrete instantiation does not take any
           // arguments, the type arguments are empty. Emit a function type that takes no arg in this
           // position then.
           continue;
         }
-        paramType = typeRef.typeArguments[0];
+        paramType = typeArgs[0];
       }
       let typeStr = this.translate(paramType);
       if (varArgs) typeStr = '...' + typeStr;