Merge pull request #940 from Microsoft/asynchrounousAliasWriteCrash

Fix the crash in declaration file emit when alias is used before its declaration

src/compiler/emitter.ts

@@ -345,13 +345,22 @@ module ts {
             var oldWriter = writer;
             forEach(importDeclarations, aliasToWrite => {
                 var aliasEmitInfo = forEach(aliasDeclarationEmitInfo, declEmitInfo => declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined);
-                writer = createTextWriter(newLine, trackSymbol);
-                for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) {
-                    writer.increaseIndent();
+                // If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration
+                // then we don't need to write it at this point. We will write it when we actually see its declaration
+                // Eg.
+                // export function bar(a: foo.Foo) { }
+                // import foo = require("foo");
+                // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing, 
+                // we would write alias foo declaration when we visit it since it would now be marked as visible
+                if (aliasEmitInfo) {
+                    writer = createTextWriter(newLine, trackSymbol);
+                    for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) {
+                        writer.increaseIndent();
+                    }
+
+                    writeImportDeclaration(aliasToWrite);
+                    aliasEmitInfo.asynchronousOutput = writer.getText();
                 }
-
-                writeImportDeclaration(aliasToWrite);
-                aliasEmitInfo.asynchronousOutput = writer.getText();
             });
             writer = oldWriter;
         }

tests/baselines/reference/declFileAliasUseBeforeDeclaration.js

@@ -0,0 +1,29 @@
+//// [tests/cases/compiler/declFileAliasUseBeforeDeclaration.ts] ////
+
+//// [declFileAliasUseBeforeDeclaration_foo.ts]
+
+export class Foo { }
+
+//// [declFileAliasUseBeforeDeclaration_test.ts]
+export function bar(a: foo.Foo) { }
+import foo = require("declFileAliasUseBeforeDeclaration_foo");
+
+//// [declFileAliasUseBeforeDeclaration_foo.js]
+var Foo = (function () {
+    function Foo() {
+    }
+    return Foo;
+})();
+exports.Foo = Foo;
+//// [declFileAliasUseBeforeDeclaration_test.js]
+function bar(a) {
+}
+exports.bar = bar;
+
+
+//// [declFileAliasUseBeforeDeclaration_foo.d.ts]
+export declare class Foo {
+}
+//// [declFileAliasUseBeforeDeclaration_test.d.ts]
+export declare function bar(a: foo.Foo): void;
+import foo = require("declFileAliasUseBeforeDeclaration_foo");

tests/baselines/reference/declFileAliasUseBeforeDeclaration.types

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/declFileAliasUseBeforeDeclaration_test.ts ===
+export function bar(a: foo.Foo) { }
+>bar : (a: foo.Foo) => void
+>a : foo.Foo
+>foo : unknown
+>Foo : foo.Foo
+
+import foo = require("declFileAliasUseBeforeDeclaration_foo");
+>foo : typeof foo
+
+=== tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts ===
+
+export class Foo { }
+>Foo : Foo
+

tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js

@@ -0,0 +1,25 @@
+//// [declFileAliasUseBeforeDeclaration2.ts]
+
+declare module "test" {
+    module A {
+        class C {
+        }
+    }
+    class B extends E {
+    }
+    import E = A.C;
+}
+
+//// [declFileAliasUseBeforeDeclaration2.js]
+
+
+//// [declFileAliasUseBeforeDeclaration2.d.ts]
+declare module "test" {
+    module A {
+        class C {
+        }
+    }
+    class B extends E {
+    }
+    import E = A.C;
+}

tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts ===
+
+declare module "test" {
+    module A {
+>A : typeof A
+
+        class C {
+>C : C
+        }
+    }
+    class B extends E {
+>B : B
+>E : E
+    }
+    import E = A.C;
+>E : typeof E
+>A : typeof A
+>C : E
+}

tests/cases/compiler/declFileAliasUseBeforeDeclaration.ts

@@ -0,0 +1,9 @@
+//@module: commonjs
+//@declaration: true
+
+// @Filename: declFileAliasUseBeforeDeclaration_foo.ts
+export class Foo { }
+
+// @Filename: declFileAliasUseBeforeDeclaration_test.ts
+export function bar(a: foo.Foo) { }
+import foo = require("declFileAliasUseBeforeDeclaration_foo");

tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts

@@ -0,0 +1,12 @@
+//@module: commonjs
+//@declaration: true
+
+declare module "test" {
+    module A {
+        class C {
+        }
+    }
+    class B extends E {
+    }
+    import E = A.C;
+}