From c6693983f42d570fd4b30f73c2c4506d11a6b326 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Sat, 11 Mar 2017 09:10:26 -0800 Subject: [PATCH 1/2] Revert "temp" This reverts commit fd65966a5028d3403dda934f97fe285cee427198. Accidentally pushed to the wrong branch. --- src/compiler/checker.ts | 191 ---------------------------------------- src/compiler/factory.ts | 37 +------- src/compiler/types.ts | 21 ++--- 3 files changed, 9 insertions(+), 240 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 109e6f33ea3..aa7908f52c1 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2388,198 +2388,11 @@ namespace ts { } } - function createTypeNode(type: Type) { - let encounteredError = false; - let checkAlias = true; - - return createTypeNodeWorker(type); - - function createTypeNodeWorker(type: Type): TypeNode { - if(!type) { - return undefined; - } - - if (checkAlias && type.aliasSymbol) { - const name = getNameOfSymbol(type.aliasSymbol); - const typeArguments = mapToTypeNodeArray(type.aliasTypeArguments); - return createTypeReferenceNode(createIdentifier(name), typeArguments); - } - checkAlias = false; - - - if(type.flags & TypeFlags.Any) { - // TODO: add other case where type ends up being `any`. - return createKeywordTypeNode(SyntaxKind.StringKeyword); - } - if(type.flags & TypeFlags.String) { - return createKeywordTypeNode(SyntaxKind.StringKeyword); - } - if(type.flags & TypeFlags.Number) { - return createKeywordTypeNode(SyntaxKind.NumberKeyword); - } - if(type.flags & (TypeFlags.Boolean | TypeFlags.StringOrNumberLiteral)) { - // TODO: check if this actually works with boolean. - return createLiteralTypeNode((type).text); - } - if(type.flags & TypeFlags.Void) { - return createKeywordTypeNode(SyntaxKind.VoidKeyword); - } - if(type.flags & TypeFlags.Undefined) { - return createKeywordTypeNode(SyntaxKind.UndefinedKeyword); - } - if(type.flags & TypeFlags.Null) { - return createKeywordTypeNode(SyntaxKind.NullKeyword); - } - if(type.flags & TypeFlags.Never) { - return createKeywordTypeNode(SyntaxKind.NeverKeyword); - } - if(type.flags & TypeFlags.Enum) { - throw new Error("not implemented"); - } - if(type.flags & TypeFlags.ESSymbol) { - throw new Error("not implemented"); - } - if(type.flags & TypeFlags.TypeParameter) { - const constraint = createTypeNodeWorker(getConstraintFromTypeParameter(type)); - const defaultParameter = createTypeNodeWorker(getDefaultFromTypeParameter(type)); - if(!type.symbol) { - encounteredError = true; - throw new Error("No symbol for type parameter so can't get name"); - } - const name = getNameOfSymbol(type.symbol); - return createTypeParameterNode(name, constraint, defaultParameter); - } - if(type.flags & TypeFlags.Union) { - throw new Error("not implemented"); - } - if(type.flags & TypeFlags.Intersection) { - throw new Error("not implemented"); - } - if(type.flags & TypeFlags.Index) { - throw new Error("not implemented"); - } - if(type.flags & TypeFlags.IndexedAccess) { - throw new Error("not implemented"); - } - - // if(type.flags & TypeFlags.Object) { - // throw new Error("not implemented"); - // } - - // TODO: should these be within the if above (check with asserts) - const objectFlags = getObjectFlags(type); - - if (objectFlags & ObjectFlags.ClassOrInterface) { - Debug.assert(!!(type.flags & TypeFlags.Object)); - // If type is a class or interface type that wasn't hit by the isSymbolAccessible check above, - // type must be an anonymous class or interface. - return false; - } - - if (objectFlags & ObjectFlags.Reference) { - Debug.assert(!!(type.flags & TypeFlags.Object)); - // and vice versa. - // this case includes tuple types - const typeArguments = (type as TypeReference).typeArguments || emptyArray; - return allTypesVisible(typeArguments); - } - - // keyword types - // this type node - // function type node - // constructor type node - // type reference node - // type predicate node - is Foo (for return types) - // type query node -- typeof number - // type literal node (like object literal) - // array type - // tuple type - // union type - // might need parens - // intersection type - // Type operator node (eg (ie?): keyof T) - // IndexedAccess Type Node - // mapped type node - // literal type node - - // if (inTypeAlias && type.aliasSymbol) { - // return isSymbolAccessible(type.aliasSymbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/false).accessibility === SymbolAccessibility.Accessible - // && (!type.aliasTypeArguments || allTypesVisible(type.aliasTypeArguments)); - // } - // const typeSymbolAccessibility = type.symbol && isSymbolAccessible(type.symbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false).accessibility; - // if (type.flags & TypeFlags.TypeParameter) { - // if (inObjectLiteral && (type as TypeParameter).isThisType) { - // return false; - // } - // const constraint = getConstraintFromTypeParameter((type)); - // return typeSymbolAccessibility === SymbolAccessibility.Accessible - // && (!constraint || isTypeAccessibleWorker(constraint, inObjectLiteral, /*inTypeAlias*/false)); - // } - // if (typeSymbolAccessibility === SymbolAccessibility.Accessible) { - // return true; - // } - // if (type.flags & (TypeFlags.Intrinsic | TypeFlags.Literal)) { - // return true; - // } - // const objectFlags = getObjectFlags(type); - // if (objectFlags & ObjectFlags.ClassOrInterface) { - // // If type is a class or interface type that wasn't hit by the isSymbolAccessible check above, - // // type must be an anonymous class or interface. - // return false; - // } - // if (objectFlags & ObjectFlags.Reference) { - // // and vice versa. - // // this case includes tuple types - // const typeArguments = (type as TypeReference).typeArguments || emptyArray; - // return allTypesVisible(typeArguments); - // } - // if (type.flags & TypeFlags.UnionOrIntersection) { - // return allTypesVisible((type as UnionOrIntersectionType).types); - // } - - if (objectFlags & ObjectFlags.Mapped) { - Debug.assert(!!(type.flags & TypeFlags.Object)); - const typeParameter = getTypeParameterFromMappedType(type); - const constraintType = getConstraintTypeFromMappedType(type); - const templateType = getTemplateTypeFromMappedType(type); - } - - if (objectFlags & ObjectFlags.Anonymous) { - Debug.assert(!!(type.flags & TypeFlags.Object)); - // The type is an object literal type. - if (!type.symbol) { - // Anonymous types without symbols are literals. - return true; - } - // what case is this? - const members = type.symbol.members; - let allVisible = true; - members && members.forEach((member) => { - const memberType = getTypeOfSymbolAtLocation(member, enclosingDeclaration); - allVisible = allVisible && isTypeAccessibleWorker(memberType, /*inObjectLiteral*/ true, /*inTypeAlias*/false); - }); - return allVisible; - } - - Debug.fail("Should be unreachable here"); - - /** Note that mapToTypeNodeArray(undefined) === undefined. */ - function mapToTypeNodeArray(types: Type[]): NodeArray { - return asNodeArray(types && types.map(createTypeNodeWorker)); - } - // function allTypesVisible(types: Type[]): boolean { - // return types.every(type => isTypeAccessibleWorker(type, inObjectLiteral, /*inTypeAlias*/false)); - // } - } - } - function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]) { const globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike; let inObjectTypeLiteral = false; return writeType(type, globalFlags); - const typeNode = createTypeNode(type, enclosingDeclaration); - function writeType(type: Type, flags: TypeFormatFlags) { const nextFlags = flags & ~TypeFormatFlags.InTypeAlias; // Write undefined/null type as any @@ -7126,10 +6939,6 @@ namespace ts { } } - // export function synthesizeTypeNode(type: Type, enclosingDeclaration: Node): TypeNode { - // throw new Error("Not implemented" + enclosingDeclaration); - // } - function instantiateList(items: T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): T[] { if (items && items.length) { const result: T[] = []; diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index 1e5395fe7b2..669c66c4337 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -213,43 +213,8 @@ namespace ts { : node; } - // Types - - export function createLiteralTypeNode(value: string | number | boolean) { - const literal = createLiteral(value); - const literalTypeNode = createSynthesizedNode(SyntaxKind.LiteralType) as LiteralTypeNode; - literalTypeNode.literal = literal; - return literalTypeNode; - } - - export function createTypeReferenceNode(typeName: string | EntityName, typeArguments?: NodeArray) { - const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode; - typeReference.typeName = asName(typeName); - typeReference.typeName.parent - typeReference.typeArguments = typeArguments; - return typeReference; - } - - export function createTypeParameterNode(name: string | Identifier, constraint?: TypeNode, defaultParameter?: TypeNode) { - const typeParameter = createSynthesizedNode(SyntaxKind.TypeParameter) as TypeParameterDeclaration; - typeParameter.name = asName(name); - typeParameter.constraint = constraint; - typeParameter.default = defaultParameter; - - return typeParameter; - } - // Signature elements - export function createSignature(kind: SyntaxKind, parameters: NodeArray, name?: PropertyName, typeParameters?: NodeArray, returnType?: TypeNode): SignatureDeclaration { - const signature = createSynthesizedNode(kind) as SignatureDeclaration; - signature.parameters = parameters; - signature.name = name; - signature.typeParameters = typeParameters; - signature.type = returnType; - return signature; - } - export function createParameter(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression) { const node = createSynthesizedNode(SyntaxKind.Parameter); node.decorators = asNodeArray(decorators); @@ -1836,7 +1801,7 @@ namespace ts { return typeof value === "string" || typeof value === "number" ? createLiteral(value) : value; } - export function asNodeArray(array: T[] | undefined): NodeArray | undefined { + function asNodeArray(array: T[] | undefined): NodeArray | undefined { return array ? createNodeArray(array) : undefined; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 52207920b48..1492a106d2b 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -849,19 +849,14 @@ namespace ts { _typeNodeBrand: any; } - export type KeywordKind = SyntaxKind.AnyKeyword - | SyntaxKind.NumberKeyword - | SyntaxKind.ObjectKeyword - | SyntaxKind.BooleanKeyword - | SyntaxKind.StringKeyword - | SyntaxKind.SymbolKeyword - | SyntaxKind.VoidKeyword - | SyntaxKind.UndefinedKeyword - | SyntaxKind.NullKeyword - | SyntaxKind.NeverKeyword; - export interface KeywordTypeNode extends TypeNode { - kind: KeywordKind; + kind: SyntaxKind.AnyKeyword + | SyntaxKind.NumberKeyword + | SyntaxKind.ObjectKeyword + | SyntaxKind.BooleanKeyword + | SyntaxKind.StringKeyword + | SyntaxKind.SymbolKeyword + | SyntaxKind.VoidKeyword; } export interface ThisTypeNode extends TypeNode { @@ -897,7 +892,7 @@ namespace ts { exprName: EntityName; } - /** A TypeLiteral is the declaration node for an anonymous symbol. */ + // A TypeLiteral is the declaration node for an anonymous symbol. export interface TypeLiteralNode extends TypeNode, Declaration { kind: SyntaxKind.TypeLiteral; members: NodeArray; From c46a2e7e1b6f05ce79fb2fa551edaec1b481a39c Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Mon, 13 Mar 2017 12:45:28 -0700 Subject: [PATCH 2/2] always create new node array when assigning positions --- src/services/textChanges.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts index 5c345e6e4e4..5b9f0f5ef4d 100644 --- a/src/services/textChanges.ts +++ b/src/services/textChanges.ts @@ -380,7 +380,7 @@ namespace ts.textChanges { return visited; } // clone nodearray if necessary - const nodeArray = visited === nodes ? createNodeArray(visited) : visited; + const nodeArray = visited === nodes ? createNodeArray(visited.slice(0)) : visited; nodeArray.pos = getPos(nodes); nodeArray.end = getEnd(nodes); return nodeArray;