maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

localize special case (globalArrayType === undefined) in getTypeFromArrayTypeNode

Browse source
This commit is contained in:
Vladimir Matveev 2014-07-25 16:42:09 -07:00
parent 442ad4b032
commit 956b6398e0
1 changed files with 19 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
src/compiler/checker.ts
View file

@ -43,10 +43,9 @@ module ts {
var globals: SymbolTable = {};
var globalArrayTypeSymbolLinks: SymbolLinks;
var globalObjectType: ObjectType;
var globalFunctionType: ObjectType;
var globalArrayType: ObjectType;
var globalStringType: ObjectType;
var globalNumberType: ObjectType;
var globalBooleanType: ObjectType;
@ -774,7 +773,7 @@ module ts {
}
function writeTypeReference(type: TypeReference) {
if (type.target === globalArrayTypeSymbolLinks.declaredType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
// If we are writing array element type the arrow style signatures are not allowed as
// we need to surround it by curlies, eg. { (): T; }[]; as () => T[] would mean something different
writeType(type.typeArguments[0], /*allowFunctionOrConstructorTypeLiteral*/ false);
@ -1806,7 +1805,7 @@ module ts {
function getRestTypeOfSignature(signature: Signature): Type {
if (signature.hasRestParameter) {
var type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayTypeSymbolLinks.declaredType) {
if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType) {
return (<TypeReference>type).typeArguments[0];
}
}
@ -2017,11 +2016,8 @@ module ts {
return links.resolvedType;
}
function resolveGlobalTypeSymbol(name: string): Symbol {
return resolveName(undefined, name, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0, name);
}
function getGlobalType(name: string, arity: number = 0): ObjectType {
function resolveGlobalType(symbol: Symbol, arity: number): ObjectType {
function getTypeDeclaration(symbol: Symbol): Declaration {
var declarations = symbol.declarations;
for (var i = 0; i < declarations.length; i++) {
@ -2036,6 +2032,8 @@ module ts {
}
}
}
var symbol = resolveName(undefined, name, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0, name);
if (!symbol) {
return emptyObjectType;
}
@ -2051,19 +2049,22 @@ module ts {
return <ObjectType>type;
}
function getGlobalType(name: string, arity: number = 0): ObjectType {
return resolveGlobalType(resolveGlobalTypeSymbol(name), arity);
}
function createArrayType(elementType: Type): Type {
var globalArrayType = globalArrayTypeSymbolLinks.declaredType;
return globalArrayType !== emptyObjectType ? createTypeReference(<GenericType>globalArrayType, [elementType]) : emptyObjectType;
function createArrayType(elementType: Type, arrayType?: ObjectType): Type {
var type = globalArrayType || arrayType;
return type !== emptyObjectType ? createTypeReference(<GenericType>type, [elementType]) : emptyObjectType;
}
function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
var links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
var arrayType = globalArrayType;
if (!arrayType) {
var arrayTypeSymbol = resolveName(node, "Array", SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
Debug.assert(arrayTypeSymbol);
arrayType = getDeclaredTypeOfSymbol(arrayTypeSymbol);
Debug.assert(arrayType);
}
links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType), arrayType);
}
return links.resolvedType;
}
@ -2951,7 +2952,7 @@ module ts {
}
function isArrayType(type: Type): boolean {
return type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayTypeSymbolLinks.declaredType;
return type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType;
}
function getInnermostTypeOfNestedArrayTypes(type: Type): Type {
@ -6289,22 +6290,7 @@ module ts {
getSymbolLinks(unknownSymbol).type = unknownType;
globals[undefinedSymbol.name] = undefinedSymbol;
// Initialize special types
// Initialize array type.
// Note:
// if user code extends Array type so extension contains signatures that involve arrays (sample below)
// then just calling getGlobalType(Array) will try to access globalArrayType before it is initialized
// to handle this instead of storing Array as type we store SymbolLinks for Array symbol and access type as links.declaredType.
// interface Array<T> { (): any[] }
//
var globalArraySymbol = resolveGlobalTypeSymbol("Array");
if (!globalArraySymbol) {
globalArrayTypeSymbolLinks = { declaredType: emptyObjectType };
}
else {
globalArrayTypeSymbolLinks = getSymbolLinks(globalArraySymbol);
globalArrayTypeSymbolLinks.declaredType = resolveGlobalType(globalArraySymbol, 1);
}
globalArrayType = getGlobalType("Array", 1);
globalObjectType = getGlobalType("Object");
globalFunctionType = getGlobalType("Function");
globalStringType = getGlobalType("String");