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

update visitor/factory

Browse source
This commit is contained in:
Arthur Ozga 2017-03-13 16:51:43 -07:00
parent ef72c2e5d5
commit 1b14ed4d0e
2 changed files with 49 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
src/compiler/factory.ts
View file

@ -189,11 +189,11 @@ namespace ts {
}
export function createTrue() {
return <BooleanLiteral>createSynthesizedNode(SyntaxKind.TrueKeyword);
return <BooleanLiteral & TypeNode>createSynthesizedNode(SyntaxKind.TrueKeyword);
}
export function createFalse() {
return <BooleanLiteral>createSynthesizedNode(SyntaxKind.FalseKeyword);
return <BooleanLiteral & TypeNode>createSynthesizedNode(SyntaxKind.FalseKeyword);
}
// Names
@ -226,15 +226,6 @@ namespace ts {
// Type Elements
export function createPropertySignature(name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): PropertySignature {
const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;
propertySignature.name = name;
propertySignature.questionToken = questionToken;
propertySignature.type = type;
propertySignature.initializer = initializer;
return propertySignature;
}
export function createConstructSignature() {
throw new Error("not implemented.");
}
@ -258,14 +249,26 @@ namespace ts {
}
// TODO: handle qualified names, ie EntityName's.
export function createTypeReferenceNode(typeName: string | Identifier, typeArguments?: NodeArray<TypeNode>) {
export function createTypeReferenceNode(typeName: string | EntityName, typeArguments?: NodeArray<TypeNode>) {
const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode;
typeReference.typeName = asName(typeName);
typeReference.typeName = isQualifiedName(<EntityName>typeName) ? <QualifiedName>typeName : asName(<string | Identifier>typeName);
typeReference.typeArguments = typeArguments;
return typeReference;
}
export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: Identifier, typeArguments?: NodeArray<TypeNode>) {
export function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode {
const arrayTypeNode = createSynthesizedNode(SyntaxKind.ArrayType) as ArrayTypeNode;
arrayTypeNode.elementType = elementType;
return arrayTypeNode;
}
export function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode {
return node.elementType !== elementType
? updateNode(createArrayTypeNode(elementType), node)
: node;
}
export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments?: NodeArray<TypeNode>) {
return node.typeName !== typeName
|| node.typeArguments !== typeArguments
? updateNode(createTypeReferenceNode(typeName, typeArguments), node)
@ -288,7 +291,7 @@ namespace ts {
}
export function createTypeLiteralNode(members: TypeElement[]) {
const typeLiteralNode = createSynthesizedNode(SyntaxKind.LiteralType) as TypeLiteralNode;
const typeLiteralNode = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode;
typeLiteralNode.members = asNodeArray(members);
return typeLiteralNode;
}
@ -332,7 +335,24 @@ namespace ts {
// Signature elements
/** Note, can also be used to construct index signatures. */
export function createPropertySignature(name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): PropertySignature {
const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;
propertySignature.name = name;
propertySignature.questionToken = questionToken;
propertySignature.type = type;
propertySignature.initializer = initializer;
return propertySignature;
}
export function updatePropertySignature(node: PropertySignature, name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression) {
return node.name !== name
|| node.questionToken !== questionToken
|| node.type !== type
|| node.initializer !== initializer
? updateNode(createPropertySignature(name, questionToken, type, initializer), node)
: node;
}
export function createSignature(kind: SyntaxKind, parameters: NodeArray<ParameterDeclaration>, name?: PropertyName, typeParameters?: NodeArray<TypeParameterDeclaration>, returnType?: TypeNode): SignatureDeclaration {
const signature = createSynthesizedNode(kind) as SignatureDeclaration;
signature.parameters = parameters;

19
src/compiler/visitor.ts
View file

@ -279,7 +279,7 @@ namespace ts {
return updateDecorator(<Decorator>node,
visitNode((<Decorator>node).expression, visitor, isExpression));
// Keyword Types
// Keyword Types and This
case SyntaxKind.AnyKeyword:
case SyntaxKind.NumberKeyword:
@ -292,6 +292,7 @@ namespace ts {
case SyntaxKind.NullKeyword:
case SyntaxKind.NeverKeyword:
case SyntaxKind.NeverKeyword:
case SyntaxKind.ThisKeyword:
return node;
// Types
@ -300,8 +301,8 @@ namespace ts {
throw new Error("reached unsupported type in visitor.");
case SyntaxKind.TypeReference:
return updateTypeReferenceNode(<TypeReferenceNode>node
, visitNode((<TypeReferenceNode>node).typeName as Identifier, visitor)
, nodesVisitor((<TypeReferenceNode>node).typeArguments, visitor)
, visitNode((<TypeReferenceNode>node).typeName, visitor, isEntityName)
, nodesVisitor((<TypeReferenceNode>node).typeArguments, visitor, isTypeNode)
);
case SyntaxKind.FunctionType:
throw new Error("reached unsupported type in visitor.");
@ -310,9 +311,9 @@ namespace ts {
case SyntaxKind.TypeQuery:
throw new Error("reached unsupported type in visitor.");
case SyntaxKind.TypeLiteral:
throw new Error("reached unsupported type in visitor.");
return updateTypeLiteralNode((<TypeLiteralNode>node), nodesVisitor((<TypeLiteralNode>node).members, visitor));
case SyntaxKind.ArrayType:
throw new Error("reached unsupported type in visitor.");
return updateArrayTypeNode(<ArrayTypeNode>node, visitNode((<ArrayTypeNode>node).elementType, visitor, isTypeNode));
case SyntaxKind.TupleType:
throw new Error("reached unsupported type in visitor.");
case SyntaxKind.UnionType:
@ -342,8 +343,14 @@ namespace ts {
// Type members
case SyntaxKind.PropertySignature:
return updatePropertySignature((<PropertySignature>node)
, visitNode((<PropertySignature>node).name, visitor, isPropertyName)
, visitNode((<PropertySignature>node).questionToken, visitor, isToken)
, visitNode((<PropertySignature>node).type, visitor, isTypeNode));
case SyntaxKind.IndexSignature:
updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node
return updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node
, nodesVisitor((<IndexSignatureDeclaration>node).parameters, visitor, isParameter)
, visitNode((<IndexSignatureDeclaration>node).type, visitor, isTypeNode)
, nodesVisitor((<IndexSignatureDeclaration>node).decorators, visitor, isDecorator)