JS Interop Facade generation polish.

lib/module.ts

 import * as ts from 'typescript';
 
 import * as base from './base';
 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) {
+  constructor(tr: Transpiler, private fc: FacadeConverter, private moduleName: string) {
     super(tr);
   }
 
   visitNode(node: ts.Node): boolean {
     switch (node.kind) {
       case ts.SyntaxKind.SourceFile:
         this.pushContext(OutputContext.Import);
-        this.emit('@JS()');
+        let sourceFile = node as ts.SourceFile;
+        let moduleName = this.moduleName;
+        if (sourceFile.moduleName) {
+          moduleName = sourceFile.moduleName;
+        }
+        sourceFile.statements.forEach((n: ts.Node) => {
+          if (n.kind === ts.SyntaxKind.GlobalModuleExportDeclaration) {
+            let decl = n as ts.GlobalModuleExportDeclaration;
+            moduleName = base.ident(decl.name);
+          }
+        });
+        if (moduleName) {
+          this.emit('@JS("' + moduleName + '")');
+        } else {
+          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;
+        // The declaration transpiler is responsible for emitting the contents of the source file.
+        return false;
       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');
           this.visitExternalModuleReferenceExpr(importDecl.moduleSpecifier);
           this.visit(importDecl.importClause);
@@ skipping 29 matching lines @@
         this.visitList((<ts.NamedExports>node).elements);
         break;
       case ts.SyntaxKind.ImportSpecifier:
       case ts.SyntaxKind.ExportSpecifier:
         let spec = <ts.ImportOrExportSpecifier>node;
         if (spec.propertyName) {
           this.reportError(spec.propertyName, 'import/export renames are unsupported in Dart');
         }
         this.fc.visitTypeName(spec.name);
         break;
+      case ts.SyntaxKind.GlobalModuleExportDeclaration:
+        // We handle this globally exporting all files in the packge with the specified global
+        // module export location.
+        break;
       case ts.SyntaxKind.ExportDeclaration:
         let exportDecl = <ts.ExportDeclaration>node;
         this.emit('export');
         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(';');
+        this.emit(';\n');
         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.emit(';\n');
         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) { 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;
+    } else {
+      // TODO(jacobr): actually handle imports in different directories. We assume for now that all
+      // files in a library will be output to a single directory for codegen simplicity.
+      let parts = text.split('/');
+      text = parts[parts.length - 1];
     }
+
     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;
     if (elements.length === 0) return true;
     return elements.every(ModuleTranspiler.isIgnoredImport);
   }
 
   private filterImports(ns: ts.ImportOrExportSpecifier[]) {
     return ns.filter((e) => !ModuleTranspiler.isIgnoredImport(e));
   }
 
-  getLibraryName(nameForTest?: string) {
-    let fileName = this.getRelativeFileName(nameForTest);
+  getLibraryName(jsFileName?: string) {
+    let fileName = this.getDartFileName(jsFileName);
     let parts = fileName.split('/');
-    return parts.filter((p) => p.length > 0)
+    return parts.filter((p) => p.length > 0 && p !== '..')
         .map((p) => p.replace(/[^\w.]/g, '_'))
-        .map((p) => p.replace(/\.d\.ts$/g, ''))
-        .map((p) => p.replace(/\.[jt]s$/g, ''))
-        .map((p) => p.replace(/\./g, ''))
+        .map((p) => p.replace(/\.dart$/, ''))
         .map((p) => FacadeConverter.DART_RESERVED_WORDS.indexOf(p) !== -1 ? '_' + p : p)
         .filter((p) => p.length > 0)
         .join('.');
   }
 }