Check for the accessible symbol from exported import

eg:
// @filename: w1.ts
export = Widget1
class Widget1 { name = 'one'; }

// @filename: exporter.ts
export import w = require('./w1');

// @filename: consumer.ts
import e = require('./exporter');

export function w(): e.w { // Should be OK
    return new e.w();
}

In this looking for the name of return type of function w,
not just look for the alias == SymbolOfReturnType but also
look for alias.exportedSymbols === symbolOfReturnType
and qualify it during the toString

Author: sheetalkamat

src/compiler/checker.ts

@@ -661,38 +661,52 @@ module ts {
             return callback(globals);
         }
 
-        function getAccessibleSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) {
-            function getAccessibleSymbolFromSymbolTable(symbols: SymbolTable) {
+        function getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): Symbol[] {
+            function getAccessibleSymbolChainFromSymbolTable(symbols: SymbolTable): Symbol[]{
+                function canQualifySymbol(symbolFromSymbolTable: Symbol, meaning: SymbolFlags) {
+                    // If the symbol is equivalent and doesnt need futher qualification, this symbol is accessible
+                    if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) {
+                        return true;
+                    }
+
+                    // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
+                    var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, SymbolFlags.Namespace);
+                    return !!accessibleParent;
+                }
+
                 function isAccessible(symbolFromSymbolTable: Symbol, resolvedAliasSymbol?: Symbol) {
                     if (symbol === (resolvedAliasSymbol || symbolFromSymbolTable)) {
-                        // If the symbol is equivalent and doesnt need futher qualification, this symbol is accessible
-                        if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) {
-                            return true;
-                        }
-
-                        // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
-                        var accessibleParent = getAccessibleSymbol(symbolFromSymbolTable.parent, enclosingDeclaration, SymbolFlags.Namespace);
-                        return !!accessibleParent;
+                        // if symbolfrom symbolTable or alias resolution matches the symbol, 
+                        // check the symbol can be qualified, it is only then this symbol is accessible
+                        return canQualifySymbol(symbolFromSymbolTable, meaning);
                     }
                 }
 
                 // If symbol is directly available by its name in the symbol table
                 if (isAccessible(lookUp(symbols, symbol.name))) {
-                    return symbol;
+                    return [symbol];
                 }
 
                 // Check if symbol is any of the alias
                 return forEachValue(symbols, symbolFromSymbolTable => {
                     if (symbolFromSymbolTable.flags & SymbolFlags.Import) {
+                        var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable);
                         if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) {
-                            return symbolFromSymbolTable;
+                            return [symbolFromSymbolTable];
+                        }
+
+                        // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
+                        // but only if the symbolFromSymbolTable can be qualified
+                        var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports): undefined;
+                        if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, SymbolFlags.Namespace)) {
+                            return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
                         }
                     }
                 });
             }
 
             if (symbol) {
-                return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolFromSymbolTable);
+                return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
             }
         }
 
@@ -732,9 +746,9 @@ module ts {
                 var meaningToLook = meaning;
                 while (symbol) {
                     // Symbol is accessible if it by itself is accessible
-                    var accessibleSymbol = getAccessibleSymbol(symbol, enclosingDeclaration, meaningToLook);
-                    if (accessibleSymbol) {
-                        if (forEach(accessibleSymbol.declarations, declaration => !getIsDeclarationVisible(declaration))) {
+                    var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook);
+                    if (accessibleSymbolChain) {
+                        if (forEach(accessibleSymbolChain[0].declarations, declaration => !getIsDeclarationVisible(declaration))) {
                             return {
                                 accessibility: SymbolAccessibility.NotAccessible,
                                 errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
@@ -819,12 +833,13 @@ module ts {
                 while (symbol) { 
                     var isFirstName = !symbolName;
                     var meaningToLook = isFirstName ? meaning : SymbolFlags.Namespace;
-                    var accessibleSymbol = getAccessibleSymbol(symbol, enclosingDeclaration, meaningToLook);
-                    symbolName = getSymbolName(accessibleSymbol || symbol) + (isFirstName ? "" : ("." + symbolName));
-                    if (accessibleSymbol && !needsQualification(accessibleSymbol, enclosingDeclaration, meaningToLook)) {
+                    var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook);
+                    var currentSymbolName = accessibleSymbolChain ? ts.map(accessibleSymbolChain, accessibleSymbol => getSymbolName(accessibleSymbol)).join(".") : getSymbolName(symbol);
+                    symbolName = currentSymbolName + (isFirstName ? "" : ("." + symbolName));
+                    if (accessibleSymbolChain && !needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaningToLook : SymbolFlags.Namespace)) {
                         break;
                     }
-                    symbol = accessibleSymbol ? accessibleSymbol.parent : symbol.parent;
+                    symbol = accessibleSymbolChain ? accessibleSymbolChain[0].parent : symbol.parent;
                 }
 
                 return symbolName;

tests/baselines/reference/declFileExportImportChain.errors.txt

@@ -73,3 +73,6 @@ import b = require("declFileExportImportChain_b");
 export = b;
 //// [declFileExportImportChain_c.d.ts]
 export import b1 = require("declFileExportImportChain_b1");
+//// [declFileExportImportChain_d.d.ts]
+import c = require("declFileExportImportChain_c");
+export declare var x: c.b1.a.m2.c1;

tests/baselines/reference/declFileExportImportChain.js

@@ -64,3 +64,6 @@ import a = require("declFileExportImportChain2_a");
 export = a;
 //// [declFileExportImportChain2_c.d.ts]
 export import b = require("declFileExportImportChain2_b");
+//// [declFileExportImportChain2_d.d.ts]
+import c = require("declFileExportImportChain2_c");
+export declare var x: c.b.m2.c1;

tests/baselines/reference/declFileExportImportChain2.errors.txt

@@ -186,10 +186,10 @@ export declare module M.Q {
     }
     interface b extends M.C {
     }
-    interface I extends M.N.I {
+    interface I extends M.c.I {
     }
     module c {
-        interface I extends M.N.I {
+        interface I extends M.c.I {
         }
     }
 }
@@ -242,10 +242,10 @@ export declare module M.Q {
         }
         interface b extends M.C {
         }
-        interface I extends M.N.I {
+        interface I extends M.c.I {
         }
         module c {
-            interface I extends M.N.I {
+            interface I extends M.c.I {
             }
         }
     }

tests/baselines/reference/declFileExportImportChain2.js

@@ -45,3 +45,6 @@ declare class Widget1 {
 }
 //// [exporter.d.ts]
 export import w = require('./w1');
+//// [consumer.d.ts]
+import e = require('./exporter');
+export declare function w(): e.w;

tests/baselines/reference/declarationEmit_nameConflicts.js

@@ -37,3 +37,6 @@ interface Widget1 {
 }
 //// [exporter.d.ts]
 export import w = require('./w1');
+//// [consumer.d.ts]
+import e = require('./exporter');
+export declare function w(): e.w;