JS Interop Facade generation polish.

lib/main.ts

+import * as dartStyle from 'dart-style';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
 import * as base from './base';
 import {Set, TranspilerBase} from './base';
-
+import DeclarationTranspiler from './declaration';
+import {FacadeConverter, NameRewriter} from './facade_converter';
+import * as merge from './merge';
 import mkdirP from './mkdirp';
-import DeclarationTranspiler from './declaration';
-import * as merge from './merge';
 import ModuleTranspiler from './module';
 import TypeTranspiler from './type';
-import {FacadeConverter, NameRewriter} from './facade_converter';
-import * as dartStyle from 'dart-style';
 
 export interface TranspilerOptions {
   /**
    * Fail on the first error, do not collect multiple. Allows easier debugging as stack traces lead
    * directly to the offending line.
    */
   failFast?: boolean;
-  /** Whether to generate 'library a.b.c;' names from relative file paths. */
-  generateLibraryName?: boolean;
+  /**
+   * Pass in a module name (e.g.) d3 instead of determining the module name fro the d.ts files.
+   * This is useful when using libraries that assume they will be loaded with a JS module loader
+   * without having to use a JS module loader.
+   */
+  moduleName?: string;
   /**
    * A base path to relativize absolute file paths against. This is useful for library name
    * generation (see above) and nicer file names in error messages.
    */
   basePath?: string;
   /**
-   * Use dart:html instead of the raw JavaScript DOM when generated Dart code.
-   */
-  useHtml?: boolean;
-  /**
    * Enforce conventions of public/private keyword and underscore prefix
    */
   enforceUnderscoreConventions?: boolean;
   /**
    * Sets a root path to look for typings used by the facade converter.
    */
   typingsRoot?: string;
 
   /**
    * Experimental JS Interop specific option to promote properties with function
@@ skipping 31 matching lines @@
   importsEmitted: Set;
   // Comments attach to all following AST nodes before the next 'physical' token. Track the earliest
   // offset to avoid printing comments multiple times.
   private lastCommentIdx: number = -1;
   private errors: string[] = [];
 
   private transpilers: TranspilerBase[];
   private declarationTranspiler: DeclarationTranspiler;
   private fc: FacadeConverter;
   private nameRewriter: NameRewriter;
+  private typeArgumentDepth = 0;
 
   constructor(private options: TranspilerOptions = {}) {
     this.nameRewriter = new NameRewriter();
-    this.fc = new FacadeConverter(this, options.typingsRoot, this.nameRewriter, options.useHtml);
+    this.fc = new FacadeConverter(this, options.typingsRoot, this.nameRewriter);
     this.declarationTranspiler = new DeclarationTranspiler(
         this, this.fc, options.enforceUnderscoreConventions, options.promoteFunctionLikeMembers);
     this.transpilers = [
+      new ModuleTranspiler(this, this.fc, options.moduleName),
       this.declarationTranspiler,
-      new ModuleTranspiler(this, this.fc, options.generateLibraryName),
       new TypeTranspiler(this, this.fc),
     ];
   }
 
   /**
    * Transpiles the given files to Dart.
    * @param fileNames The input files.
    * @param destination Location to write files to. Creates files next to their sources if absent.
    */
   transpile(fileNames: string[], destination?: string): void {
     if (this.options.basePath) {
       this.options.basePath = this.normalizeSlashes(path.resolve(this.options.basePath));
     }
     fileNames = fileNames.map((f) => this.normalizeSlashes(f));
     let host = this.createCompilerHost();
-    if (this.options.basePath && destination === undefined) {
-      throw new Error(
-          'Must have a destination path when a basePath is specified ' + this.options.basePath);
-    }
-    let destinationRoot = destination || this.options.basePath || '';
     let program = ts.createProgram(fileNames, this.getCompilerOptions(), host);
     this.fc.setTypeChecker(program.getTypeChecker());
     this.declarationTranspiler.setTypeChecker(program.getTypeChecker());
 
     // Only write files that were explicitly passed in.
     let fileSet: {[s: string]: boolean} = {};
     fileNames.forEach((f) => fileSet[f] = true);
     let sourceFiles = program.getSourceFiles().filter((sourceFile) => fileSet[sourceFile.fileName]);
 
     this.errors = [];
 
+    let sourceFileMap: {[s: string]: ts.SourceFile} = {};
+    sourceFiles.forEach((f: ts.SourceFile) => { sourceFileMap[f.fileName] = f; });
+
+    // Check for global module export declarations and propogate them to
+    // and propogate
+    sourceFiles.forEach((f: ts.SourceFile) => {
+      f.statements.forEach((n: ts.Node) => {
+        if (n.kind !== ts.SyntaxKind.GlobalModuleExportDeclaration) return;
+        // This is the name we are interested in for Dart purposes until Dart supports AMD module
+        // loaders. This module name should all be reflected by all modules exported by this
+        // library as we need to specify a global module location for every Dart library.
+        let globalModuleName = base.ident((n as ts.GlobalModuleExportDeclaration).name);
+        f.moduleName = globalModuleName;
+
+        f.statements.forEach((e: ts.Node) => {
+          if (e.kind !== ts.SyntaxKind.ExportDeclaration) return;
+          let exportDecl = e as ts.ExportDeclaration;
+          if (!exportDecl.moduleSpecifier) return;
+          let moduleLocation = <ts.StringLiteral>exportDecl.moduleSpecifier;
+          let location = moduleLocation.text;
+          let resolvedPath = host.resolveModuleNames([location], f.fileName);
+          resolvedPath.forEach((p) => {
+            if (p.isExternalLibraryImport) return;
+            let exportedFile = sourceFileMap[p.resolvedFileName];
+            exportedFile.moduleName = globalModuleName;
+          });
+        });
+      });
+    });
+
     sourceFiles.forEach((f: ts.SourceFile) => {
       let dartCode = this.translate(f);
-      let outputFile = this.getOutputPath(path.resolve(f.fileName), destinationRoot);
-      mkdirP(path.dirname(outputFile));
-      fs.writeFileSync(outputFile, dartCode);
+
+      if (destination) {
+        let outputFile = this.getOutputPath(path.resolve(f.fileName), destination);
+        console.log('Output file:', outputFile);
+        mkdirP(path.dirname(outputFile));
+        fs.writeFileSync(outputFile, dartCode);
+      } else {
+        console.log(dartCode);
+      }
     });
     this.checkForErrors(program);
   }
 
   translateProgram(program: ts.Program): {[path: string]: string} {
     this.fc.setTypeChecker(program.getTypeChecker());
     this.declarationTranspiler.setTypeChecker(program.getTypeChecker());
 
     let paths: {[path: string]: string} = {};
     this.errors = [];
@@ skipping 34 matching lines @@
       getCanonicalFileName: (filename) => filename,
       getCurrentDirectory: () => '',
       getNewLine: () => '\n',
     };
     compilerHost.resolveModuleNames = getModuleResolver(compilerHost);
     return compilerHost;
   }
 
   // Visible for testing.
   getOutputPath(filePath: string, destinationRoot: string): string {
-    let relative = this.getRelativeFileName(filePath);
-    let dartFile = relative.replace(/.(js|es6|d\.ts|ts)$/, '.dart');
-    return this.normalizeSlashes(path.join(destinationRoot, dartFile));
+    let relative = this.getDartFileName(filePath);
+    return this.normalizeSlashes(path.join(destinationRoot, relative));
   }
 
   public pushContext(context: OutputContext) { this.outputStack.push(this.outputs[context]); }
 
   public popContext() {
     if (this.outputStack.length === 0) {
       this.reportError(null, 'Attempting to pop output stack when already empty');
     }
     this.outputStack.pop();
   }
 
   private translate(sourceFile: ts.SourceFile): string {
     this.currentFile = sourceFile;
     this.outputs = [];
     this.outputStack = [];
     this.importsEmitted = {};
     for (let i = 0; i < NUM_OUTPUT_CONTEXTS; ++i) {
       this.outputs.push(new Output());
     }
 
     this.lastCommentIdx = -1;
-    merge.normalizeSourceFile(sourceFile);
+    merge.normalizeSourceFile(sourceFile, this.fc);
     this.pushContext(OutputContext.Default);
     this.visit(sourceFile);
     this.popContext();
     if (this.outputStack.length > 0) {
       this.reportError(
           sourceFile, 'Internal error managing output contexts. ' +
               'Inconsistent push and pop context calls.');
     }
     let result = '';
     for (let output of this.outputs) {
@@ skipping 41 matching lines @@
       let e = new Error(errors.join('\n'));
       e.name = 'DartFacadeError';
       throw e;
     }
   }
 
   /**
    * Returns `filePath`, relativized to the program's `basePath`.
    * @param filePath Optional path to relativize, defaults to the current file's path.
    */
-  getRelativeFileName(filePath?: string) {
+  getRelativeFileName(filePath?: string): string {
     if (filePath === undefined) filePath = path.resolve(this.currentFile.fileName);
-    // TODO(martinprobst): Use path.isAbsolute on node v0.12.
+    // TODO(jacobr): Use path.isAbsolute on node v0.12.
     if (this.normalizeSlashes(path.resolve('/x/', filePath)) !== filePath) {
       return filePath;  // already relative.
     }
     let base = this.options.basePath || '';
     if (filePath.indexOf(base) !== 0 && !filePath.match(/\.d\.ts$/)) {
       throw new Error(`Files must be located under base, got ${filePath} vs ${base}`);
     }
     return this.normalizeSlashes(path.relative(base, filePath));
   }
 
+  getDartFileName(filePath?: string): string {
+    if (filePath === undefined) filePath = path.resolve(this.currentFile.fileName);
+    filePath = this.normalizeSlashes(filePath);
+    filePath = filePath.replace(/\.(js|es6|d\.ts|ts)$/, '.dart');
+    // Normalize from node module file path pattern to
+    filePath = filePath.replace(/([^/]+)\/index.dart$/, '$1.dart');
+    return this.getRelativeFileName(filePath);
+  }
+
+  isJsModuleFile(): boolean {
+    // Treat files as being part of js modules if they match the node module file location
+    // convention of module_name/index.js.
+    return !('/' + this.currentFile.fileName).match(/\/index\.(js|es6|d\.ts|ts)$/);
+  }
+
   private get currentOutput(): Output { return this.outputStack[this.outputStack.length - 1]; }
 
   emit(s: string) { this.currentOutput.emit(s); }
   emitNoSpace(s: string) { this.currentOutput.emitNoSpace(s); }
   maybeLineBreak() { return this.currentOutput.maybeLineBreak(); }
   enterCodeComment() { return this.currentOutput.enterCodeComment(); }
   exitCodeComment() { return this.currentOutput.exitCodeComment(); }
+
+  enterTypeArgument() { this.typeArgumentDepth++; }
+  exitTypeArgument() { this.typeArgumentDepth--; }
+  get insideTypeArgument(): boolean { return this.typeArgumentDepth > 0; }
+
   emitType(s: string, comment: string) { return this.currentOutput.emitType(s, comment); }
   get insideCodeComment() { return this.currentOutput.insideCodeComment; }
 
   reportError(n: ts.Node, message: string) {
     let file = n.getSourceFile() || this.currentFile;
     let fileName = this.getRelativeFileName(file.fileName);
     let start = n.getStart(file);
     let pos = file.getLineAndCharacterOfPosition(start);
     // Line and character are 0-based.
     let fullMessage = `${fileName}:${pos.line + 1}:${pos.character + 1}: ${message}`;
@@ skipping 104 matching lines @@
       // Avoid line breaks inside code comments.
       return;
     }
 
     if (!this.firstColumn) {
       this.emitNoSpace('\n');
     }
   }
 
   emit(str: string) {
-    if (this.result.length > 0) {
-      let buffer = this.insideCodeComment ? this.codeCommentResult : this.result;
-      let lastChar = buffer[buffer.length - 1];
+    let buffer = this.insideCodeComment ? this.codeCommentResult : this.result;
+    if (buffer.length > 0) {
+      let lastChar = buffer.slice(-1);
       if (lastChar !== ' ' && lastChar !== '(' && lastChar !== '<' && lastChar !== '[') {
         // Avoid emitting a space in obvious cases where a space is not required
         // to make the output slightly prettier in cases where the DartFormatter
         // cannot run such as within a comment where code we emit is not quite
         // valid Dart code.
         this.emitNoSpace(' ');
       }
     }
     this.emitNoSpace(str);
   }
 
   emitNoSpace(str: string) {
     if (str.length === 0) return;
     if (this.insideCodeComment) {
       this.codeCommentResult += str;
       return;
     }
     this.result += str;
-    this.firstColumn = str[str.length - 1] === '\n';
+    this.firstColumn = str.slice(-1) === '\n';
   }
 
   enterCodeComment() {
     if (this.insideCodeComment) {
       throw 'Cannot nest code comments' + this.codeCommentResult;
     }
     this.insideCodeComment = true;
     this.codeCommentResult = '';
   }
 
@@ skipping 48 matching lines @@
   try {
     let transpiler = new Transpiler(args);
     console.error('Transpiling', args._, 'to', args.destination);
     transpiler.transpile(args._, args.destination);
   } catch (e) {
     if (e.name !== 'DartFacadeError') throw e;
     console.error(e.message);
     process.exit(1);
   }
 }