Merge pull request #1466 from Microsoft/linked_imports

defer decision whether import used on the right side of import declarati...

tests/baselines/reference/importedAliasesInTypePositions.js

@@ -0,0 +1,55 @@
+//// [tests/cases/compiler/importedAliasesInTypePositions.ts] ////
+
+//// [file1.ts]
+export module elaborate.nested.mod.name {
+    export class ReferredTo {
+        doSomething(): void {
+        }
+    }
+}
+
+//// [file2.ts]
+import RT_ALIAS = require("file1");
+import ReferredTo = RT_ALIAS.elaborate.nested.mod.name.ReferredTo;
+
+export module ImportingModule {
+    class UsesReferredType {
+        constructor(private referred: ReferredTo) { }
+    }
+}
+
+//// [file1.js]
+define(["require", "exports"], function (require, exports) {
+    var elaborate;
+    (function (elaborate) {
+        var nested;
+        (function (nested) {
+            var mod;
+            (function (mod) {
+                var name;
+                (function (name) {
+                    var ReferredTo = (function () {
+                        function ReferredTo() {
+                        }
+                        ReferredTo.prototype.doSomething = function () {
+                        };
+                        return ReferredTo;
+                    })();
+                    name.ReferredTo = ReferredTo;
+                })(name = mod.name || (mod.name = {}));
+            })(mod = nested.mod || (nested.mod = {}));
+        })(nested = elaborate.nested || (elaborate.nested = {}));
+    })(elaborate = exports.elaborate || (exports.elaborate = {}));
+});
+//// [file2.js]
+define(["require", "exports"], function (require, exports) {
+    var ImportingModule;
+    (function (ImportingModule) {
+        var UsesReferredType = (function () {
+            function UsesReferredType(referred) {
+                this.referred = referred;
+            }
+            return UsesReferredType;
+        })();
+    })(ImportingModule = exports.ImportingModule || (exports.ImportingModule = {}));
+});

tests/baselines/reference/importedAliasesInTypePositions.types

@@ -0,0 +1,40 @@
+=== tests/cases/compiler/file2.ts ===
+import RT_ALIAS = require("file1");
+>RT_ALIAS : typeof RT_ALIAS
+
+import ReferredTo = RT_ALIAS.elaborate.nested.mod.name.ReferredTo;
+>ReferredTo : typeof ReferredTo
+>RT_ALIAS : typeof RT_ALIAS
+>elaborate : typeof RT_ALIAS.elaborate
+>nested : typeof RT_ALIAS.elaborate.nested
+>mod : typeof RT_ALIAS.elaborate.nested.mod
+>name : typeof RT_ALIAS.elaborate.nested.mod.name
+>ReferredTo : ReferredTo
+
+export module ImportingModule {
+>ImportingModule : typeof ImportingModule
+
+    class UsesReferredType {
+>UsesReferredType : UsesReferredType
+
+        constructor(private referred: ReferredTo) { }
+>referred : ReferredTo
+>ReferredTo : ReferredTo
+    }
+}
+=== tests/cases/compiler/file1.ts ===
+export module elaborate.nested.mod.name {
+>elaborate : typeof elaborate
+>nested : typeof nested
+>mod : typeof mod
+>name : typeof name
+
+    export class ReferredTo {
+>ReferredTo : ReferredTo
+
+        doSomething(): void {
+>doSomething : () => void
+        }
+    }
+}
+

tests/cases/compiler/importedAliasesInTypePositions.ts

@@ -0,0 +1,19 @@
+// @module:amd
+// @Filename: file1.ts
+export module elaborate.nested.mod.name {
+    export class ReferredTo {
+        doSomething(): void {
+        }
+    }
+}
+
+// @Filename: file2.ts
+// @module: amd
+import RT_ALIAS = require("file1");
+import ReferredTo = RT_ALIAS.elaborate.nested.mod.name.ReferredTo;
+
+export module ImportingModule {
+    class UsesReferredType {
+        constructor(private referred: ReferredTo) { }
+    }
+}