Skip to content

Commit f5cd414

Browse files
committed
Merge branch 'master' into unionTypes
Conflicts: src/compiler/types.ts src/services/services.ts
2 parents 4f4f59a + 63c0a88 commit f5cd414

13 files changed

+184
-66
lines changed

src/compiler/checker.ts

Lines changed: 22 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -105,10 +105,12 @@ module ts {
105105
writeTypeParameter: writeTypeParameter,
106106
writeTypeParametersOfSymbol: writeTypeParametersOfSymbol,
107107
isImplementationOfOverload: isImplementationOfOverload,
108-
getAliasedSymbol: resolveImport
108+
getAliasedSymbol: resolveImport,
109+
isUndefinedSymbol: symbol => symbol === undefinedSymbol,
110+
isArgumentsSymbol: symbol => symbol === argumentsSymbol
109111
};
110112

111-
var undefinedSymbol = createSymbol(SymbolFlags.Undefined | SymbolFlags.Property | SymbolFlags.Transient, "undefined");
113+
var undefinedSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "undefined");
112114
var argumentsSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "arguments");
113115
var unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
114116
var resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
@@ -737,7 +739,7 @@ module ts {
737739
return rightMeaning === SymbolFlags.Value ? SymbolFlags.Value : SymbolFlags.Namespace;
738740
}
739741

740-
function getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): Symbol[] {
742+
function getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, useOnlyExternalAliasing: boolean): Symbol[] {
741743
function getAccessibleSymbolChainFromSymbolTable(symbols: SymbolTable): Symbol[] {
742744
function canQualifySymbol(symbolFromSymbolTable: Symbol, meaning: SymbolFlags) {
743745
// If the symbol is equivalent and doesn't need further qualification, this symbol is accessible
@@ -746,7 +748,7 @@ module ts {
746748
}
747749

748750
// If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
749-
var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning));
751+
var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
750752
return !!accessibleParent;
751753
}
752754

@@ -768,16 +770,21 @@ module ts {
768770
// Check if symbol is any of the alias
769771
return forEachValue(symbols, symbolFromSymbolTable => {
770772
if (symbolFromSymbolTable.flags & SymbolFlags.Import) {
771-
var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable);
772-
if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) {
773-
return [symbolFromSymbolTable];
774-
}
773+
if (!useOnlyExternalAliasing || // We can use any type of alias to get the name
774+
// Is this external alias, then use it to name
775+
ts.forEach(symbolFromSymbolTable.declarations, declaration =>
776+
declaration.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>declaration).externalModuleName)) {
777+
var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable);
778+
if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) {
779+
return [symbolFromSymbolTable];
780+
}
775781

776-
// Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
777-
// but only if the symbolFromSymbolTable can be qualified
778-
var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
779-
if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
780-
return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
782+
// Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
783+
// but only if the symbolFromSymbolTable can be qualified
784+
var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
785+
if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
786+
return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
787+
}
781788
}
782789
}
783790
});
@@ -823,7 +830,7 @@ module ts {
823830
var meaningToLook = meaning;
824831
while (symbol) {
825832
// Symbol is accessible if it by itself is accessible
826-
var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook);
833+
var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
827834
if (accessibleSymbolChain) {
828835
var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
829836
if (!hasAccessibleDeclarations) {
@@ -1006,7 +1013,7 @@ module ts {
10061013
writer.trackSymbol(symbol, enclosingDeclaration, meaning);
10071014
function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
10081015
if (symbol) {
1009-
var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning);
1016+
var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
10101017

10111018
if (!accessibleSymbolChain ||
10121019
needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {

src/compiler/types.ts

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -661,6 +661,8 @@ module ts {
661661
writeTypeParameter(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
662662
writeTypeParametersOfSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;
663663
isImplementationOfOverload(node: FunctionDeclaration): boolean;
664+
isUndefinedSymbol(symbol: Symbol): boolean;
665+
isArgumentsSymbol(symbol: Symbol): boolean;
664666

665667
// Returns the constant value of this enum member, or 'undefined' if the enum member has a
666668
// computed value.
@@ -700,6 +702,9 @@ module ts {
700702
// eg. class C<T> { p: T } <-- Show p as C<T>.p here
701703
// var a: C<number>;
702704
// var p = a.p; <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
705+
UseOnlyExternalAliasing = 0x00000002, // Use only external alias information to get the symbol name in the given context
706+
// eg. module m { export class c { } } import x = m.c;
707+
// When this flag is specified m.c will be used to refer to the class instead of alias symbol x
703708
}
704709

705710
export enum SymbolAccessibility {
@@ -772,6 +777,7 @@ module ts {
772777
Undefined = 0x10000000, // Symbol for the undefined
773778

774779
Value = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor | UnionProperty,
780+
775781
Type = Class | Interface | Enum | TypeLiteral | ObjectLiteral | TypeParameter,
776782
Namespace = ValueModule | NamespaceModule,
777783
Module = ValueModule | NamespaceModule,

0 commit comments

Comments
 (0)