Merge pull request microsoft#466 from sparecycles/fix/checker-declaration

sheetalkamat · sheetalkamat · commit 7a5512cdd030 · 2014-08-18T13:32:50.000-07:00
fix --declaration typechecking (complex case)
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -780,7 +780,7 @@ module ts {
                     // But it cant, hence the accessible is going to be undefined, but that doesnt mean m.c is accessible
                     // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
                     meaningToLook = getQualifiedLeftMeaning(meaning);
-                    symbol = symbol.parent;
+                    symbol = getParentOfSymbol(symbol);
                 }
 
                 // This could be a symbol that is not exported in the external module 
@@ -903,7 +903,7 @@ module ts {
                     if (accessibleSymbolChain && !needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
                         break;
                     }
-                    symbol = accessibleSymbolChain ? accessibleSymbolChain[0].parent : symbol.parent;
+                    symbol = getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol);
                     meaning = getQualifiedLeftMeaning(meaning);
                 }
 
diff --git a/tests/baselines/reference/moduleSymbolMerging.js b/tests/baselines/reference/moduleSymbolMerging.js
@@ -0,0 +1,42 @@
+//// [tests/cases/compiler/moduleSymbolMerging.ts] ////
+
+//// [A.ts]
+
+module A { export interface I {} }
+
+//// [B.ts]
+///<reference path="A.ts" />
+module A { ; }
+module B {
+	export function f(): A.I { return null; }
+}
+
+
+
+//// [A.js]
+//// [B.js]
+var A;
+(function (A) {
+    ;
+})(A || (A = {}));
+var B;
+(function (B) {
+    function f() {
+        return null;
+    }
+    B.f = f;
+})(B || (B = {}));
+
+
+//// [A.d.ts]
+declare module A {
+    interface I {
+    }
+}
+//// [B.d.ts]
+/// <reference path='A.d.ts' />
+declare module A {
+}
+declare module B {
+    function f(): A.I;
+}
diff --git a/tests/cases/compiler/moduleSymbolMerging.ts b/tests/cases/compiler/moduleSymbolMerging.ts
@@ -0,0 +1,12 @@
+// @declaration: true
+
+// @Filename: A.ts
+module A { export interface I {} }
+
+// @Filename: B.ts
+///<reference path="A.ts" />
+module A { ; }
+module B {
+	export function f(): A.I { return null; }
+}
+

Original file line number	Diff line number	Diff line change
`@@ -780,7 +780,7 @@ module ts {`
`780`	`780`	`// But it cant, hence the accessible is going to be undefined, but that doesnt mean m.c is accessible`
`781`	`781`	`// It is accessible if the parent m is accessible because then m.c can be accessed through qualification`
`782`	`782`	`meaningToLook = getQualifiedLeftMeaning(meaning);`
`783`		`- symbol = symbol.parent;`
	`783`	`+ symbol = getParentOfSymbol(symbol);`
`784`	`784`	`}`
`785`	`785`
`786`	`786`	`// This could be a symbol that is not exported in the external module`
`@@ -903,7 +903,7 @@ module ts {`
`903`	`903`	`if (accessibleSymbolChain && !needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {`
`904`	`904`	`break;`
`905`	`905`	`}`
`906`		`- symbol = accessibleSymbolChain ? accessibleSymbolChain[0].parent : symbol.parent;`
	`906`	`+ symbol = getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol);`
`907`	`907`	`meaning = getQualifiedLeftMeaning(meaning);`
`908`	`908`	`}`
`909`	`909`