specially handle "import {foo}" for jsdoc

Summary:
Translate
  import {foo} from 'bar';
as
  import {foo as tsickle_foo} from 'bar';
  const foo = tsickle_foo;

This is because JSDoc comments will use plain "foo", but the ES6->ES5
translation done by the TS emit will namespace all references to imports.

More work on #112.

Reviewers: rkirov, mprobst

Reviewed By: mprobst

Subscribers: mprobst, typescript-eng

Differential Revision: https://reviews.angular.io/D128

Author: evmar

src/tsickle.ts

@@ -191,6 +191,9 @@ class Annotator extends Rewriter {
     }
 
     switch (node.kind) {
+      case ts.SyntaxKind.ImportDeclaration:
+        this.emitImportDeclaration(node as ts.ImportDeclaration);
+        return true;
       case ts.SyntaxKind.ExportDeclaration:
         let exportDecl = <ts.ExportDeclaration>node;
         if (!exportDecl.exportClause && exportDecl.moduleSpecifier) {
@@ -360,6 +363,64 @@ class Annotator extends Rewriter {
     return Object.keys(reexports);
   }
 
+  /**
+   * Handles emit of an "import ..." statement.
+   * We need to do a bit of rewriting so that imported types show up under the
+   * correct name in JSDoc.
+   */
+  private emitImportDeclaration(decl: ts.ImportDeclaration) {
+    if (this.options.untyped) return;
+
+    const importClause = decl.importClause;
+    // Skip "import './foo';" statements.
+    if (!importClause) {
+      this.writeNode(decl);
+      return;
+    }
+
+    if (importClause.name) {
+      // import foo from ...;
+      this.writeNode(decl);
+      this.errorUnimplementedKind(decl, 'TODO: default import');
+    } else if (importClause.namedBindings.kind === ts.SyntaxKind.NamespaceImport) {
+      // import * as foo from ...;
+      // This is the format we already work fine with, so do nothing.
+      this.writeNode(decl);
+    } else if (importClause.namedBindings.kind === ts.SyntaxKind.NamedImports) {
+      // import {a as b} from ...;
+      // Rewrite it to:
+      //   import {a as tsickle_b} from ...; const b = tsickle_b;
+      // This is because in the generated ES5, tsickle_b will instead get a generated
+      // name like module_import.tsickle_b.  But in our JSDoc we still refer to it
+      // as just "b".  Importing under a different name and then making a local alias
+      // evades this.  (TS uses the namespace-qualified name so that updates to the
+      // module are reflected in the aliases.  We only do this to types, which can't
+      // change, so the namespace qualification is not needed.)
+      const namedImports = importClause.namedBindings as ts.NamedImports;
+
+      this.writeRange(decl.getFullStart(), decl.getStart());
+      // Emit the "import" part, with rewritten binding names.
+      this.emit('import {');
+      for (const imp of namedImports.elements) {
+        // imp.propertyName is the name of the property in the module we're importing from,
+        // while imp.name is the local name.
+        this.emit(
+            `${getIdentifierText(imp.propertyName || imp.name)} as tsickle_${getIdentifierText(imp.name)},`);
+      }
+      this.emit('} from');
+      this.writeNode(decl.moduleSpecifier);
+      this.emit(';\n');
+
+      // Emit aliases that bring the renamed name back into the local name.
+      for (const imp of namedImports.elements) {
+        this.emit(
+            `const ${getIdentifierText(imp.name)} = tsickle_${getIdentifierText(imp.name)};\n`);
+      }
+    } else {
+      this.errorUnimplementedKind(decl, 'unexpected kind of import');
+    }
+  }
+
   private emitFunctionType(fnDecl: ts.SignatureDeclaration, extraTags: JSDocTag[] = []) {
     let typeChecker = this.program.getTypeChecker();
     let sig = typeChecker.getSignatureFromDeclaration(fnDecl);

test_files/export/export.js

@@ -14,3 +14,6 @@ exports.exportLocal = 3;
 // it to the exports list.  export2 should only show up once in the
 // above two "export *" lines, though.
 let /** @type {number} */ export2 = 3;
+// This is just an import, so export5 should still be included.
+var export_helper_3 = export_helper_1;
+const export5 = export_helper_3.export5;

test_files/export/export.tsickle.ts

@@ -15,4 +15,6 @@ export var /** @type {number} */ exportLocal = 3;
 let /** @type {number} */ export2 = 3;
 
 // This is just an import, so export5 should still be included.
-import {export5} from './export_helper';
+import {export5 as tsickle_export5,} from './export_helper';
+const export5 = tsickle_export5;
+

test_files/jsdoc_types/jsdoc_types.js

@@ -4,6 +4,16 @@ goog.module('tsickle_test.jsdoc_types.jsdoc_types');/**
  */
 
 var module1 = goog.require('tsickle_test.jsdoc_types.module1');
+var module2_1 = goog.require('tsickle_test.jsdoc_types.module2');
+const ClassOne = module2_1.ClassOne;
+var module2_2 = module2_1;
+const RenamedClassOne = module2_2.ClassOne;
+var module2_3 = module2_1;
+const RenamedClassTwo = module2_3.ClassTwo;
 // Check that imported types get the proper names in JSDoc.
 let /** @type {module1.Class} */ x1 = new module1.Class();
 let /** @type {module1.Interface} */ x2 = null;
+// Should be refer to the names in module2.
+let /** @type {ClassOne} */ x3 = new ClassOne();
+let /** @type {ClassOne} */ x4 = new RenamedClassOne();
+let /** @type {RenamedClassTwo} */ x5 = new RenamedClassTwo();

test_files/jsdoc_types/jsdoc_types.ts

@@ -4,7 +4,15 @@
  */
 
 import * as module1 from './module1';
+import {ClassOne} from './module2';
+import {ClassOne as RenamedClassOne} from './module2';
+import {ClassTwo as RenamedClassTwo} from './module2';
 
 // Check that imported types get the proper names in JSDoc.
 let x1 = new module1.Class();
 let x2: module1.Interface = null;
+
+// Should be refer to the names in module2.
+let x3 = new ClassOne();
+let x4 = new RenamedClassOne();
+let x5 = new RenamedClassTwo();

test_files/jsdoc_types/jsdoc_types.tsickle.ts

@@ -4,7 +4,21 @@
  */
 
 import * as module1 from './module1';
+import {ClassOne as tsickle_ClassOne,} from './module2';
+const ClassOne = tsickle_ClassOne;
+
+import {ClassOne as tsickle_RenamedClassOne,} from './module2';
+const RenamedClassOne = tsickle_RenamedClassOne;
+
+import {ClassTwo as tsickle_RenamedClassTwo,} from './module2';
+const RenamedClassTwo = tsickle_RenamedClassTwo;
+
 
 // Check that imported types get the proper names in JSDoc.
 let /** @type {module1.Class} */ x1 = new module1.Class();
 let /** @type {module1.Interface} */ x2: module1.Interface = null;
+
+// Should be refer to the names in module2.
+let /** @type {ClassOne} */ x3 = new ClassOne();
+let /** @type {ClassOne} */ x4 = new RenamedClassOne();
+let /** @type {RenamedClassTwo} */ x5 = new RenamedClassTwo();

test_files/jsdoc_types/module2.js

@@ -0,0 +1,12 @@
+goog.module('tsickle_test.jsdoc_types.module2');
+class ClassOne {
+}
+exports.ClassOne = ClassOne;
+class ClassTwo {
+}
+exports.ClassTwo = ClassTwo;
+/** @record */
+function Interface() { }
+exports.Interface = Interface;
+/** @type {number} */
+Interface.prototype.x;

test_files/jsdoc_types/module2.ts

@@ -0,0 +1,3 @@
+export class ClassOne {}
+export class ClassTwo {}
+export interface Interface { x: number }

test_files/jsdoc_types/module2.tsickle.ts

@@ -0,0 +1,9 @@
+export class ClassOne {}
+export class ClassTwo {}
+/** @record */
+function Interface() {}
+ /** @type {number} */
+Interface.prototype.x;
+export {Interface};
+
+export interface Interface { x: number }