Merge pull request dart-archive#47 from derekxu16/master

Prevented lib.dom.d.ts files from being compiled when the --generate-html flag is set

Author: derekxu16

lib/main.ts

@@ -151,7 +151,7 @@ export class Transpiler {
           let moduleLocation = <ts.StringLiteral>exportDecl.moduleSpecifier;
           let location = moduleLocation.text;
           let resolvedPath = host.resolveModuleNames(
-              [location], f.fileName, undefined, undefined, COMPILER_OPTIONS);
+              [location], f.fileName, undefined, undefined, this.getCompilerOptions());
           resolvedPath.forEach((p) => {
             if (p.isExternalLibraryImport) return;
             let exportedFile = sourceFileMap[p.resolvedFileName];
@@ -192,21 +192,26 @@ export class Transpiler {
     return paths;
   }
 
-  private getCompilerOptions() {
+  getCompilerOptions() {
     let opts: ts.CompilerOptions = {};
     for (let k of Object.keys(COMPILER_OPTIONS)) opts[k] = COMPILER_OPTIONS[k];
     opts.rootDir = this.options.basePath;
+    if (this.options.generateHTML) {
+      // Prevent the TypeScript DOM library files from being compiled
+      opts.lib = ['lib.es2015.d.ts', 'lib.scripthost.d.ts'];
+    }
     return opts;
   }
 
   private createCompilerHost(): ts.CompilerHost {
-    let compilerHost = ts.createCompilerHost(COMPILER_OPTIONS);
-    let defaultLibFileName = ts.getDefaultLibFileName(COMPILER_OPTIONS);
+    const compilerOptions = this.getCompilerOptions();
+    let compilerHost = ts.createCompilerHost(compilerOptions);
+    let defaultLibFileName = ts.getDefaultLibFileName(compilerOptions);
     defaultLibFileName = this.normalizeSlashes(defaultLibFileName);
     compilerHost.getSourceFile = (sourceName) => {
       let sourcePath = sourceName;
       if (sourceName === defaultLibFileName) {
-        sourcePath = ts.getDefaultLibFilePath(COMPILER_OPTIONS);
+        sourcePath = ts.getDefaultLibFilePath(compilerOptions);
       }
       if (!fs.existsSync(sourcePath)) return undefined;
       let contents = fs.readFileSync(sourcePath, 'utf-8');

test/declaration_test.ts

@@ -494,6 +494,31 @@ abstract class XStatic {
   // Constructors on anonymous interfaces are not yet supported.
   /*external factory XStatic(String|bool a, b);*/
   external foo();
+}`);
+  });
+
+  // If the lib.dom.d.ts file is compiled, it creates conflicting interface definitions which causes
+  // a problem for variable declarations that we have merged into classes. The main problem was that
+  // when the declaration transpiler performed the notSimpleBagOfProperties check, it was checking
+  // the lib.dom.d.ts definition of the interface, which made it think the class didn't have a
+  // constructor defined when in reality it did.
+  it('does not compile DOM library files when the --generate-html flag is set', () => {
+    const generateHTMLOpts = {failFast: true, generateHTML: true};
+    expectTranslate(
+        `declare var AbstractRange: {prototype: AbstractRange; new (): AbstractRange;};
+
+            declare interface AbstractRange {
+              readonly collapsed: boolean;
+              readonly endOffset: number;
+              readonly startOffset: number;
+            }`,
+        generateHTMLOpts)
+        .to.equal(`@JS("AbstractRange")
+abstract class AbstractRange {
+  external bool get collapsed;
+  external num get endOffset;
+  external num get startOffset;
+  external factory AbstractRange();
 }`);
   });
 });

test/facade_converter_test.ts

@@ -69,6 +69,15 @@ abstract class XMLHttpRequest {
   external num get LOADING;
   external num get OPENED;
   external num get UNSENT;
+  external factory XMLHttpRequest(
+      {num readyState,
+      dynamic response,
+      String responseText,
+      num DONE,
+      num HEADERS_RECEIVED,
+      num LOADING,
+      num OPENED,
+      num UNSENT});
 }
 
 @JS()

test/test_support.ts

@@ -24,16 +24,17 @@ let compilerOptions = main.COMPILER_OPTIONS;
 let defaultLibFileName = ts.getDefaultLibFileName(compilerOptions);
 let libSourceFiles: Map<string, ts.SourceFile> = new Map();
 
-export function parseFiles(nameToContent: StringMap): ts.Program {
+export function parseFiles(
+    nameToContent: StringMap, customCompilerOptions: ts.CompilerOptions): ts.Program {
   let result: string;
-  let compilerHost = ts.createCompilerHost(compilerOptions);
+  let compilerHost = ts.createCompilerHost(customCompilerOptions);
   compilerHost.getSourceFile = (sourceName) => {
     let sourcePath = sourceName;
     if (sourcePath === defaultLibFileName) {
-      sourcePath = ts.getDefaultLibFilePath(compilerOptions);
+      sourcePath = ts.getDefaultLibFilePath(customCompilerOptions);
     } else if (nameToContent.hasOwnProperty(sourcePath)) {
       return ts.createSourceFile(
-          sourcePath, nameToContent[sourcePath], compilerOptions.target, true);
+          sourcePath, nameToContent[sourcePath], customCompilerOptions.target, true);
     } else if (!fs.existsSync(sourcePath)) {
       return undefined;
     }
@@ -43,7 +44,7 @@ export function parseFiles(nameToContent: StringMap): ts.Program {
       // Cache to avoid excessive test times.
       libSourceFiles.set(
           sourcePath,
-          ts.createSourceFile(sourcePath, contents, main.COMPILER_OPTIONS.target, true));
+          ts.createSourceFile(sourcePath, contents, customCompilerOptions.target, true));
     }
     return libSourceFiles.get(sourcePath);
   };
@@ -61,7 +62,7 @@ export function parseFiles(nameToContent: StringMap): ts.Program {
 
   // Create a program from inputs
   let entryPoints = Object.keys(nameToContent);
-  let program: ts.Program = ts.createProgram(entryPoints, compilerOptions, compilerHost);
+  let program: ts.Program = ts.createProgram(entryPoints, customCompilerOptions, compilerHost);
   if (program.getSyntacticDiagnostics().length > 0) {
     // Throw first error.
     let first = program.getSyntacticDiagnostics()[0];
@@ -76,6 +77,7 @@ export function translateSources(contents: Input, options?: main.TranspilerOptio
   options = options || {};
   // Default to quick stack traces.
   if (!options.hasOwnProperty('failFast')) options.failFast = true;
+
   let namesToContent: StringMap;
   if (typeof contents === 'string') {
     namesToContent = {};
@@ -85,7 +87,7 @@ export function translateSources(contents: Input, options?: main.TranspilerOptio
   }
   options.enforceUnderscoreConventions = true;
   let transpiler = new main.Transpiler(options);
-  let program = parseFiles(namesToContent);
+  let program = parseFiles(namesToContent, transpiler.getCompilerOptions());
   return transpiler.translateProgram(program);
 }