Strip more unused features.

lib/module.ts

 import * as ts from 'typescript';
+
 import * as base from './base';
-import {Transpiler} from './main';
 import {FacadeConverter} from './facade_converter';
+import {OutputContext, Transpiler} from './main';
 
 export default class ModuleTranspiler extends base.TranspilerBase {
   constructor(tr: Transpiler, private fc: FacadeConverter, private generateLibraryName: boolean) {
     super(tr);
   }
 
   visitNode(node: ts.Node): boolean {
     switch (node.kind) {
       case ts.SyntaxKind.SourceFile:
-        if (this.generateLibraryName) {
-          this.emit('library');
-          this.emit(this.getLibraryName());
-          this.emit(';');
-        }
-        this.fc.emitExtraImports(<ts.SourceFile>node);
+        this.pushContext(OutputContext.Import);
+        this.emit('@JS()');
+        this.emit('library');
+        this.emit(this.getLibraryName());
+        this.emit(';');
+        this.popContext();
+
+        this.emitImport('package:js/js.dart');
         ts.forEachChild(node, this.visit.bind(this));
         break;
       case ts.SyntaxKind.EndOfFileToken:
         ts.forEachChild(node, this.visit.bind(this));
         break;
       case ts.SyntaxKind.ImportDeclaration:
         let importDecl = <ts.ImportDeclaration>node;
         if (importDecl.importClause) {
           if (this.isEmptyImport(importDecl)) return true;
           this.emit('import');
@@ skipping 44 matching lines @@
         if (exportDecl.moduleSpecifier) {
           this.visitExternalModuleReferenceExpr(exportDecl.moduleSpecifier);
         } else {
           this.reportError(node, 're-exports must have a module URL (export x from "./y").');
         }
         if (exportDecl.exportClause) this.visit(exportDecl.exportClause);
         this.emit(';');
         break;
       case ts.SyntaxKind.ImportEqualsDeclaration:
         let importEqDecl = <ts.ImportEqualsDeclaration>node;
+        this.pushContext(OutputContext.Import);
         this.emit('import');
         this.visit(importEqDecl.moduleReference);
         this.emit('as');
         this.fc.visitTypeName(importEqDecl.name);
         this.emit(';');
+        this.popContext();
         break;
       case ts.SyntaxKind.ExternalModuleReference:
         this.visitExternalModuleReferenceExpr((<ts.ExternalModuleReference>node).expression);
         break;
 
       default:
         return false;
     }
     return true;
   }
 
-  private static isIgnoredImport(e: ts.ImportSpecifier) {
-    // TODO: unify with facade_converter.ts
-    let name = base.ident(e.name);
-    switch (name) {
-      case 'CONST':
-      case 'CONST_EXPR':
-      case 'normalizeBlank':
-      case 'forwardRef':
-      case 'ABSTRACT':
-      case 'IMPLEMENTS':
-        return true;
-      default:
-        return false;
-    }
-  }
+  private static isIgnoredImport(e: ts.ImportSpecifier) { return false; }
 
   private visitExternalModuleReferenceExpr(expr: ts.Expression) {
     // TODO: what if this isn't a string literal?
     let moduleName = <ts.StringLiteral>expr;
     let text = moduleName.text;
     if (text.match(/^\.\//)) {
       // Strip './' to be more Dart-idiomatic.
       text = text.substring(2);
     } else if (!text.match(/^\.\.\//)) {
       // Unprefixed imports are package imports.
       text = 'package:' + text;
     }
     this.emit(JSON.stringify(text + '.dart'));
   }
 
   private isEmptyImport(n: ts.ImportDeclaration): boolean {
     let bindings = n.importClause.namedBindings;
     if (bindings.kind !== ts.SyntaxKind.NamedImports) return false;
     let elements = (<ts.NamedImports>bindings).elements;
-    // An import list being empty *after* filtering is ok, but if it's empty in the code itself,
-    // it's nonsensical code, so probably a programming error.
-    if (elements.length === 0) this.reportError(n, 'empty import list');
+    if (elements.length === 0) return true;
     return elements.every(ModuleTranspiler.isIgnoredImport);
   }
 
   private filterImports(ns: ts.ImportOrExportSpecifier[]) {
     return ns.filter((e) => !ModuleTranspiler.isIgnoredImport(e));
   }
 
-  // For the Dart keyword list see
-  // https://www.dartlang.org/docs/dart-up-and-running/ch02.html#keywords
-  private static DART_RESERVED_WORDS =
-      ('assert break case catch class const continue default do else enum extends false final ' +
-       'finally for if in is new null rethrow return super switch this throw true try let void ' +
-       'while with')
-          .split(/ /);
-
   getLibraryName(nameForTest?: string) {
     let fileName = this.getRelativeFileName(nameForTest);
     let parts = fileName.split('/');
     return parts.filter((p) => p.length > 0)
         .map((p) => p.replace(/[^\w.]/g, '_'))
+        .map((p) => p.replace(/\.d\.ts$/g, ''))
         .map((p) => p.replace(/\.[jt]s$/g, ''))
-        .map((p) => ModuleTranspiler.DART_RESERVED_WORDS.indexOf(p) !== -1 ? '_' + p : p)
+        .map((p) => p.replace(/\./g, ''))
+        .map((p) => FacadeConverter.DART_RESERVED_WORDS.indexOf(p) !== -1 ? '_' + p : p)
+        .filter((p) => p.length > 0)
         .join('.');
   }
 }