mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-11 10:00:13 -06:00
Merge pull request #997 from Microsoft/fidelityParsingUpdates2
Adding support in fidelity for parsing union and parenthesized types
This commit is contained in:
CyrusNajmabadi
commit
e1dfdb4d25
@ -70,75 +70,6 @@ module TypeScript.ASTHelpers {
|
||||
return true;
|
||||
}
|
||||
|
||||
///
|
||||
/// Return the ISyntaxElement containing "position"
|
||||
///
|
||||
export function getAstAtPosition(script: ISyntaxElement, pos: number, useTrailingTriviaAsLimChar: boolean = true, forceInclusive: boolean = false): ISyntaxElement {
|
||||
var top: ISyntaxElement = null;
|
||||
|
||||
var pre = function (cur: ISyntaxElement, walker: IAstWalker) {
|
||||
if (!isShared(cur) && isValidAstNode(cur)) {
|
||||
var isInvalid1 = cur.kind() === SyntaxKind.ExpressionStatement && width(cur) === 0;
|
||||
|
||||
if (isInvalid1) {
|
||||
walker.options.goChildren = false;
|
||||
}
|
||||
else {
|
||||
// Add "cur" to the stack if it contains our position
|
||||
// For "identifier" nodes, we need a special case: A position equal to "limChar" is
|
||||
// valid, since the position corresponds to a caret position (in between characters)
|
||||
// For example:
|
||||
// bar
|
||||
// 0123
|
||||
// If "position === 3", the caret is at the "right" of the "r" character, which should be considered valid
|
||||
var inclusive =
|
||||
forceInclusive ||
|
||||
cur.kind() === SyntaxKind.IdentifierName ||
|
||||
cur.kind() === SyntaxKind.MemberAccessExpression ||
|
||||
cur.kind() === SyntaxKind.QualifiedName ||
|
||||
//cur.kind() === SyntaxKind.TypeRef ||
|
||||
cur.kind() === SyntaxKind.VariableDeclaration ||
|
||||
cur.kind() === SyntaxKind.VariableDeclarator ||
|
||||
cur.kind() === SyntaxKind.InvocationExpression ||
|
||||
pos === end(script) + lastToken(script).trailingTriviaWidth(); // Special "EOF" case
|
||||
|
||||
var minChar = start(cur);
|
||||
var limChar = end(cur) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(cur) : 0) + (inclusive ? 1 : 0);
|
||||
if (pos >= minChar && pos < limChar) {
|
||||
|
||||
// Ignore empty lists
|
||||
if ((cur.kind() !== SyntaxKind.List && cur.kind() !== SyntaxKind.SeparatedList) || end(cur) > start(cur)) {
|
||||
// TODO: Since ISyntaxElement is sometimes not correct wrt to position, only add "cur" if it's better
|
||||
// than top of the stack.
|
||||
if (top === null) {
|
||||
top = cur;
|
||||
}
|
||||
else if (start(cur) >= start(top) &&
|
||||
(end(cur) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(cur) : 0)) <= (end(top) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(top) : 0))) {
|
||||
// this new node appears to be better than the one we're
|
||||
// storing. Make this the new node.
|
||||
|
||||
// However, If the current top is a missing identifier, we
|
||||
// don't want to replace it with another missing identifier.
|
||||
// We want to return the first missing identifier found in a
|
||||
// depth first walk of the tree.
|
||||
if (width(top) !== 0 || width(cur) !== 0) {
|
||||
top = cur;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Don't go further down the tree if pos is outside of [minChar, limChar]
|
||||
walker.options.goChildren = (minChar <= pos && pos <= limChar);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
getAstWalkerFactory().walk(script, pre);
|
||||
return top;
|
||||
}
|
||||
|
||||
export function getExtendsHeritageClause(clauses: HeritageClauseSyntax[]): HeritageClauseSyntax {
|
||||
return getHeritageClause(clauses, SyntaxKind.ExtendsHeritageClause);
|
||||
}
|
||||
|
||||
@ -1,721 +0,0 @@
|
||||
//
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
///<reference path='references.ts' />
|
||||
|
||||
module TypeScript {
|
||||
function walkListChildren(preAst: ISyntaxNodeOrToken[], walker: AstWalker): void {
|
||||
for (var i = 0, n = preAst.length; i < n; i++) {
|
||||
walker.walk(preAst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
function walkThrowStatementChildren(preAst: ThrowStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkPrefixUnaryExpressionChildren(preAst: PrefixUnaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.operand);
|
||||
}
|
||||
|
||||
function walkPostfixUnaryExpressionChildren(preAst: PostfixUnaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.operand);
|
||||
}
|
||||
|
||||
function walkDeleteExpressionChildren(preAst: DeleteExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkTypeArgumentListChildren(preAst: TypeArgumentListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeArguments);
|
||||
}
|
||||
|
||||
function walkTupleTypeChildren(preAst: TupleTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.types);
|
||||
}
|
||||
|
||||
function walkTypeOfExpressionChildren(preAst: TypeOfExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkVoidExpressionChildren(preAst: VoidExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkArgumentListChildren(preAst: ArgumentListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeArgumentList);
|
||||
walker.walk(preAst.arguments);
|
||||
}
|
||||
|
||||
function walkArrayLiteralExpressionChildren(preAst: ArrayLiteralExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expressions);
|
||||
}
|
||||
|
||||
function walkSimplePropertyAssignmentChildren(preAst: SimplePropertyAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkFunctionPropertyAssignmentChildren(preAst: FunctionPropertyAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkGetAccessorChildren(preAst: GetAccessorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkSeparatedListChildren(preAst: ISyntaxNodeOrToken[], walker: AstWalker): void {
|
||||
for (var i = 0, n = preAst.length; i < n; i++) {
|
||||
walker.walk(preAst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
function walkSetAccessorChildren(preAst: SetAccessorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkObjectLiteralExpressionChildren(preAst: ObjectLiteralExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyAssignments);
|
||||
}
|
||||
|
||||
function walkCastExpressionChildren(preAst: CastExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkParenthesizedExpressionChildren(preAst: ParenthesizedExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkElementAccessExpressionChildren(preAst: ElementAccessExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentExpression);
|
||||
}
|
||||
|
||||
function walkMemberAccessExpressionChildren(preAst: MemberAccessExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.name);
|
||||
}
|
||||
|
||||
function walkQualifiedNameChildren(preAst: QualifiedNameSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.right);
|
||||
}
|
||||
|
||||
function walkBinaryExpressionChildren(preAst: BinaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.right);
|
||||
}
|
||||
|
||||
function walkEqualsValueClauseChildren(preAst: EqualsValueClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.value);
|
||||
}
|
||||
|
||||
function walkTypeParameterChildren(preAst: TypeParameterSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.constraint);
|
||||
}
|
||||
|
||||
function walkTypeParameterListChildren(preAst: TypeParameterListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameters);
|
||||
}
|
||||
|
||||
function walkGenericTypeChildren(preAst: GenericTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
walker.walk(preAst.typeArgumentList);
|
||||
}
|
||||
|
||||
function walkTypeAnnotationChildren(preAst: TypeAnnotationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkTypeQueryChildren(preAst: TypeQuerySyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
}
|
||||
|
||||
function walkInvocationExpressionChildren(preAst: InvocationExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentList);
|
||||
}
|
||||
|
||||
function walkObjectCreationExpressionChildren(preAst: ObjectCreationExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentList);
|
||||
}
|
||||
|
||||
function walkTrinaryExpressionChildren(preAst: ConditionalExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.whenTrue);
|
||||
walker.walk(preAst.whenFalse);
|
||||
}
|
||||
|
||||
function walkFunctionExpressionChildren(preAst: FunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkFunctionTypeChildren(preAst: FunctionTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkParenthesizedArrowFunctionExpressionChildren(preAst: ParenthesizedArrowFunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkSimpleArrowFunctionExpressionChildren(preAst: SimpleArrowFunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameter);
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkMemberFunctionDeclarationChildren(preAst: MemberFunctionDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkFuncDeclChildren(preAst: FunctionDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkIndexMemberDeclarationChildren(preAst: IndexMemberDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.indexSignature);
|
||||
}
|
||||
|
||||
function walkIndexSignatureChildren(preAst: IndexSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameters);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkCallSignatureChildren(preAst: CallSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkConstraintChildren(preAst: ConstraintSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeOrExpression);
|
||||
}
|
||||
|
||||
function walkConstructorDeclarationChildren(preAst: ConstructorDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkConstructorTypeChildren(preAst: FunctionTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkConstructSignatureChildren(preAst: ConstructSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
}
|
||||
|
||||
function walkParameterChildren(preAst: ParameterSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkParameterListChildren(preAst: ParameterListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameters);
|
||||
}
|
||||
|
||||
function walkPropertySignatureChildren(preAst: PropertySignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkVariableDeclaratorChildren(preAst: VariableDeclaratorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkMemberVariableDeclarationChildren(preAst: MemberVariableDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclarator);
|
||||
}
|
||||
|
||||
function walkMethodSignatureChildren(preAst: MethodSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
}
|
||||
|
||||
function walkReturnStatementChildren(preAst: ReturnStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkForStatementChildren(preAst: ForStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
walker.walk(preAst.initializer);
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.incrementor);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkForInStatementChildren(preAst: ForInStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkIfStatementChildren(preAst: IfStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
walker.walk(preAst.elseClause);
|
||||
}
|
||||
|
||||
function walkElseClauseChildren(preAst: ElseClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkWhileStatementChildren(preAst: WhileStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkDoStatementChildren(preAst: DoStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkBlockChildren(preAst: BlockSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkVariableDeclarationChildren(preAst: VariableDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclarators);
|
||||
}
|
||||
|
||||
function walkCaseSwitchClauseChildren(preAst: CaseSwitchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkDefaultSwitchClauseChildren(preAst: DefaultSwitchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkSwitchStatementChildren(preAst: SwitchStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.switchClauses);
|
||||
}
|
||||
|
||||
function walkTryStatementChildren(preAst: TryStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.catchClause);
|
||||
walker.walk(preAst.finallyClause);
|
||||
}
|
||||
|
||||
function walkCatchClauseChildren(preAst: CatchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkExternalModuleReferenceChildren(preAst: ExternalModuleReferenceSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.stringLiteral);
|
||||
}
|
||||
|
||||
function walkFinallyClauseChildren(preAst: FinallyClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkClassDeclChildren(preAst: ClassDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.heritageClauses);
|
||||
walker.walk(preAst.classElements);
|
||||
}
|
||||
|
||||
function walkScriptChildren(preAst: SourceUnitSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.moduleElements);
|
||||
}
|
||||
|
||||
function walkHeritageClauseChildren(preAst: HeritageClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeNames);
|
||||
}
|
||||
|
||||
function walkInterfaceDeclerationChildren(preAst: InterfaceDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.heritageClauses);
|
||||
walker.walk(preAst.body);
|
||||
}
|
||||
|
||||
function walkObjectTypeChildren(preAst: ObjectTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeMembers);
|
||||
}
|
||||
|
||||
function walkArrayTypeChildren(preAst: ArrayTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkModuleDeclarationChildren(preAst: ModuleDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
walker.walk(preAst.stringLiteral);
|
||||
walker.walk(preAst.moduleElements);
|
||||
}
|
||||
|
||||
function walkModuleNameModuleReferenceChildren(preAst: ModuleNameModuleReferenceSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.moduleName);
|
||||
}
|
||||
|
||||
function walkEnumDeclarationChildren(preAst: EnumDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.enumElements);
|
||||
}
|
||||
|
||||
function walkEnumElementChildren(preAst: EnumElementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkImportDeclarationChildren(preAst: ImportDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.moduleReference);
|
||||
}
|
||||
|
||||
function walkExportAssignmentChildren(preAst: ExportAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
}
|
||||
|
||||
function walkWithStatementChildren(preAst: WithStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkExpressionStatementChildren(preAst: ExpressionStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkLabeledStatementChildren(preAst: LabeledStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkVariableStatementChildren(preAst: VariableStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
}
|
||||
|
||||
var childrenWalkers: IAstWalkChildren[] = new Array<IAstWalkChildren>(SyntaxKind.LastNode + 1);
|
||||
|
||||
// Tokens/trivia can't ever be walked into.
|
||||
for (var i = SyntaxKind.FirstToken, n = SyntaxKind.LastToken; i <= n; i++) {
|
||||
childrenWalkers[i] = null;
|
||||
}
|
||||
for (var i = SyntaxKind.FirstTrivia, n = SyntaxKind.LastTrivia; i <= n; i++) {
|
||||
childrenWalkers[i] = null;
|
||||
}
|
||||
|
||||
childrenWalkers[SyntaxKind.AddAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AddExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AndAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AnyKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.ArgumentList] = walkArgumentListChildren;
|
||||
childrenWalkers[SyntaxKind.ArrayLiteralExpression] = walkArrayLiteralExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ArrayType] = walkArrayTypeChildren;
|
||||
childrenWalkers[SyntaxKind.SimpleArrowFunctionExpression] = walkSimpleArrowFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ParenthesizedArrowFunctionExpression] = walkParenthesizedArrowFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseAndExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseExclusiveOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseNotExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Block] = walkBlockChildren;
|
||||
childrenWalkers[SyntaxKind.BooleanKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.BreakStatement] = null;
|
||||
childrenWalkers[SyntaxKind.CallSignature] = walkCallSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.CaseSwitchClause] = walkCaseSwitchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.CastExpression] = walkCastExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.CatchClause] = walkCatchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ClassDeclaration] = walkClassDeclChildren;
|
||||
childrenWalkers[SyntaxKind.CommaExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ConditionalExpression] = walkTrinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Constraint] = walkConstraintChildren;
|
||||
childrenWalkers[SyntaxKind.ConstructorDeclaration] = walkConstructorDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.ConstructSignature] = walkConstructSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.ContinueStatement] = null;
|
||||
childrenWalkers[SyntaxKind.ConstructorType] = walkConstructorTypeChildren;
|
||||
childrenWalkers[SyntaxKind.DebuggerStatement] = null;
|
||||
childrenWalkers[SyntaxKind.DefaultSwitchClause] = walkDefaultSwitchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.DeleteExpression] = walkDeleteExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DivideAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DivideExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DoStatement] = walkDoStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ElementAccessExpression] = walkElementAccessExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ElseClause] = walkElseClauseChildren;
|
||||
childrenWalkers[SyntaxKind.EmptyStatement] = null;
|
||||
childrenWalkers[SyntaxKind.EnumDeclaration] = walkEnumDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.EnumElement] = walkEnumElementChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsValueClause] = walkEqualsValueClauseChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsWithTypeConversionExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ExclusiveOrAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ExportAssignment] = walkExportAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.ExpressionStatement] = walkExpressionStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ExtendsHeritageClause] = walkHeritageClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ExternalModuleReference] = walkExternalModuleReferenceChildren;
|
||||
childrenWalkers[SyntaxKind.FalseKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.FinallyClause] = walkFinallyClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ForInStatement] = walkForInStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ForStatement] = walkForStatementChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionDeclaration] = walkFuncDeclChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionExpression] = walkFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionPropertyAssignment] = walkFunctionPropertyAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionType] = walkFunctionTypeChildren;
|
||||
childrenWalkers[SyntaxKind.GenericType] = walkGenericTypeChildren;
|
||||
childrenWalkers[SyntaxKind.GetAccessor] = walkGetAccessorChildren;
|
||||
childrenWalkers[SyntaxKind.GreaterThanExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.GreaterThanOrEqualExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.IfStatement] = walkIfStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ImplementsHeritageClause] = walkHeritageClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ImportDeclaration] = walkImportDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.IndexMemberDeclaration] = walkIndexMemberDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.IndexSignature] = walkIndexSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.InExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.InstanceOfExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.InterfaceDeclaration] = walkInterfaceDeclerationChildren;
|
||||
childrenWalkers[SyntaxKind.InvocationExpression] = walkInvocationExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LabeledStatement] = walkLabeledStatementChildren;
|
||||
childrenWalkers[SyntaxKind.LeftShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LeftShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LessThanExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LessThanOrEqualExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.List] = walkListChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalAndExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalNotExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MemberAccessExpression] = walkMemberAccessExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MemberFunctionDeclaration] = walkMemberFunctionDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.MemberVariableDeclaration] = walkMemberVariableDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.MethodSignature] = walkMethodSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.ModuleDeclaration] = walkModuleDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.ModuleNameModuleReference] = walkModuleNameModuleReferenceChildren;
|
||||
childrenWalkers[SyntaxKind.ModuloAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ModuloExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MultiplyAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MultiplyExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.IdentifierName] = null;
|
||||
childrenWalkers[SyntaxKind.NegateExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.None] = null;
|
||||
childrenWalkers[SyntaxKind.NotEqualsExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.NotEqualsWithTypeConversionExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.NullKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.NumberKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.NumericLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.ObjectCreationExpression] = walkObjectCreationExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ObjectLiteralExpression] = walkObjectLiteralExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ObjectType] = walkObjectTypeChildren;
|
||||
childrenWalkers[SyntaxKind.OmittedExpression] = null;
|
||||
childrenWalkers[SyntaxKind.OrAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Parameter] = walkParameterChildren;
|
||||
childrenWalkers[SyntaxKind.ParameterList] = walkParameterListChildren;
|
||||
childrenWalkers[SyntaxKind.ParenthesizedExpression] = walkParenthesizedExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PlusExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PostDecrementExpression] = walkPostfixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PostIncrementExpression] = walkPostfixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PreDecrementExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PreIncrementExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PropertySignature] = walkPropertySignatureChildren;
|
||||
childrenWalkers[SyntaxKind.QualifiedName] = walkQualifiedNameChildren;
|
||||
childrenWalkers[SyntaxKind.RegularExpressionLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.ReturnStatement] = walkReturnStatementChildren;
|
||||
childrenWalkers[SyntaxKind.SourceUnit] = walkScriptChildren;
|
||||
childrenWalkers[SyntaxKind.SeparatedList] = walkSeparatedListChildren;
|
||||
childrenWalkers[SyntaxKind.SetAccessor] = walkSetAccessorChildren;
|
||||
childrenWalkers[SyntaxKind.SignedRightShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SignedRightShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SimplePropertyAssignment] = walkSimplePropertyAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.StringLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.StringKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.SubtractAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SubtractExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SuperKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.SwitchStatement] = walkSwitchStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ThisKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.ThrowStatement] = walkThrowStatementChildren;
|
||||
childrenWalkers[SyntaxKind.TriviaList] = null;
|
||||
childrenWalkers[SyntaxKind.TrueKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.TryStatement] = walkTryStatementChildren;
|
||||
childrenWalkers[SyntaxKind.TupleType] = walkTupleTypeChildren;
|
||||
childrenWalkers[SyntaxKind.TypeAnnotation] = walkTypeAnnotationChildren;
|
||||
childrenWalkers[SyntaxKind.TypeArgumentList] = walkTypeArgumentListChildren;
|
||||
childrenWalkers[SyntaxKind.TypeOfExpression] = walkTypeOfExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.TypeParameter] = walkTypeParameterChildren;
|
||||
childrenWalkers[SyntaxKind.TypeParameterList] = walkTypeParameterListChildren;
|
||||
childrenWalkers[SyntaxKind.TypeQuery] = walkTypeQueryChildren;
|
||||
childrenWalkers[SyntaxKind.UnsignedRightShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.UnsignedRightShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.VariableDeclaration] = walkVariableDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.VariableDeclarator] = walkVariableDeclaratorChildren;
|
||||
childrenWalkers[SyntaxKind.VariableStatement] = walkVariableStatementChildren;
|
||||
childrenWalkers[SyntaxKind.VoidExpression] = walkVoidExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.VoidKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.WhileStatement] = walkWhileStatementChildren;
|
||||
childrenWalkers[SyntaxKind.WithStatement] = walkWithStatementChildren;
|
||||
|
||||
// Verify the code is up to date with the enum
|
||||
for (var e in SyntaxKind) {
|
||||
if (SyntaxKind.hasOwnProperty(e) && StringUtilities.isString(SyntaxKind[e])) {
|
||||
TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + SyntaxKind[e]);
|
||||
}
|
||||
}
|
||||
|
||||
export class AstWalkOptions {
|
||||
public goChildren = true;
|
||||
public stopWalking = false;
|
||||
}
|
||||
|
||||
interface IAstWalkChildren {
|
||||
(preAst: ISyntaxElement, walker: AstWalker): void;
|
||||
}
|
||||
|
||||
export interface IAstWalker {
|
||||
options: AstWalkOptions;
|
||||
state: any
|
||||
}
|
||||
|
||||
interface AstWalker {
|
||||
walk(ast: ISyntaxElement): void;
|
||||
}
|
||||
|
||||
class SimplePreAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, state: any) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this.state);
|
||||
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class SimplePrePostAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, state: any) => void,
|
||||
private post: (ast: ISyntaxElement, state: any) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this.state);
|
||||
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
|
||||
this.post(ast, this.state);
|
||||
}
|
||||
}
|
||||
|
||||
class NormalAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, walker: IAstWalker) => void,
|
||||
private post: (ast: ISyntaxElement, walker: IAstWalker) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If we're stopping, then bail out immediately.
|
||||
if (this.options.stopWalking) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this);
|
||||
|
||||
// If we were asked to stop, then stop.
|
||||
if (this.options.stopWalking) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.options.goChildren) {
|
||||
// Call the "walkChildren" function corresponding to "nodeType".
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// no go only applies to children of node issuing it
|
||||
this.options.goChildren = true;
|
||||
}
|
||||
|
||||
if (this.post) {
|
||||
this.post(ast, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export class AstWalkerFactory {
|
||||
public walk(ast: ISyntaxElement, pre: (ast: ISyntaxElement, walker: IAstWalker) => void, post?: (ast: ISyntaxElement, walker: IAstWalker) => void, state?: any): void {
|
||||
new NormalAstWalker(pre, post, state).walk(ast);
|
||||
}
|
||||
|
||||
public simpleWalk(ast: ISyntaxElement, pre: (ast: ISyntaxElement, state: any) => void, post?: (ast: ISyntaxElement, state: any) => void, state?: any): void {
|
||||
if (post) {
|
||||
new SimplePrePostAstWalker(pre, post, state).walk(ast);
|
||||
}
|
||||
else {
|
||||
new SimplePreAstWalker(pre, state).walk(ast);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var globalAstWalkerFactory = new AstWalkerFactory();
|
||||
|
||||
export function getAstWalkerFactory(): AstWalkerFactory {
|
||||
return globalAstWalkerFactory;
|
||||
}
|
||||
}
|
||||
@ -46,6 +46,14 @@ module TypeScript {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
@ -3533,6 +3533,38 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function tryParseType(): ITypeSyntax {
|
||||
if (isFunctionType()) {
|
||||
return parseFunctionType();
|
||||
}
|
||||
|
||||
if (currentToken().kind() === SyntaxKind.NewKeyword) {
|
||||
return parseConstructorType();
|
||||
}
|
||||
|
||||
return tryParseUnionTypeOrHigher();
|
||||
}
|
||||
|
||||
function tryParseUnionTypeOrHigher(): ITypeSyntax {
|
||||
var type = tryParsePrimaryType();
|
||||
|
||||
if (type) {
|
||||
var barToken: ISyntaxToken;
|
||||
while ((barToken = currentToken()).kind() === SyntaxKind.BarToken) {
|
||||
consumeToken(barToken);
|
||||
var right = parsePrimaryType();
|
||||
|
||||
type = new syntaxFactory.UnionTypeSyntax(parseNodeData, type, barToken, right);
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
function parsePrimaryType(): ITypeSyntax {
|
||||
return tryParsePrimaryType() || eatIdentifierToken(DiagnosticCode.Type_expected);
|
||||
}
|
||||
|
||||
function tryParsePrimaryType(): ITypeSyntax {
|
||||
// First consume any underlying element type.
|
||||
var type = tryParseNonArrayType();
|
||||
|
||||
@ -3573,11 +3605,9 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
return consumeToken(_currentToken);
|
||||
case SyntaxKind.OpenParenToken:
|
||||
case SyntaxKind.LessThanToken: return tryParseFunctionType();
|
||||
case SyntaxKind.VoidKeyword: return consumeToken(_currentToken);
|
||||
case SyntaxKind.OpenParenToken: return parseParenthesizedType(_currentToken);
|
||||
case SyntaxKind.OpenBraceToken: return parseObjectType();
|
||||
case SyntaxKind.NewKeyword: return parseConstructorType();
|
||||
case SyntaxKind.TypeOfKeyword: return parseTypeQuery(_currentToken);
|
||||
case SyntaxKind.OpenBracketToken: return parseTupleType(_currentToken);
|
||||
}
|
||||
@ -3585,6 +3615,10 @@ module TypeScript.Parser {
|
||||
return tryParseNameOrGenericType();
|
||||
}
|
||||
|
||||
function parseParenthesizedType(openParenToken: ISyntaxToken): ParenthesizedTypeSyntax {
|
||||
return new syntaxFactory.ParenthesizedTypeSyntax(parseNodeData, consumeToken(openParenToken), parseType(), eatToken(SyntaxKind.CloseParenToken));
|
||||
}
|
||||
|
||||
function tryParseNameOrGenericType(): ITypeSyntax {
|
||||
var name = tryParseName(/*allowIdentifierNames*/ false);
|
||||
if (name === undefined) {
|
||||
@ -3605,18 +3639,71 @@ module TypeScript.Parser {
|
||||
: new syntaxFactory.GenericTypeSyntax(parseNodeData, name, typeArgumentList);
|
||||
}
|
||||
|
||||
function tryParseFunctionType(): FunctionTypeSyntax {
|
||||
var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
|
||||
var parameterList: ParameterListSyntax = undefined;
|
||||
if (typeParameterList === undefined) {
|
||||
parameterList = tryParseParameterList();
|
||||
if (parameterList === undefined) {
|
||||
return undefined;
|
||||
function isFunctionType(): boolean {
|
||||
var token0 = currentToken();
|
||||
var token0Kind = token0.kind();
|
||||
|
||||
// If we see a < then we consider ourselves to be definitely in a (generic) function type.
|
||||
if (token0Kind === SyntaxKind.LessThanToken) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// If we don't see a < then we have to see an open paren for this to be a function
|
||||
// type. However, an open paren may also start a parenthesized type. So we need to
|
||||
// do some lookahead to see what we've actually got. If we don't see enough to be
|
||||
// sure that it's a function type, then we go ahead with the assumption that it's a
|
||||
// parenthesized type.
|
||||
if (token0Kind === SyntaxKind.OpenParenToken) {
|
||||
var token1 = peekToken(1);
|
||||
var token1Kind = token1.kind();
|
||||
|
||||
if (token1Kind === SyntaxKind.CloseParenToken || token1Kind === SyntaxKind.DotDotDotToken) {
|
||||
// ()
|
||||
// (...
|
||||
//
|
||||
// Both are definitely function types, and could not be paren types.
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isModifierKind(token1Kind) || isIdentifier(token1)) {
|
||||
// (id
|
||||
// could be a function type or a parenthesized type.
|
||||
|
||||
var token2 = peekToken(2);
|
||||
var token2Kind = token2.kind();
|
||||
|
||||
if (token2Kind === SyntaxKind.ColonToken ||
|
||||
token2Kind === SyntaxKind.CommaToken ||
|
||||
token2Kind === SyntaxKind.QuestionToken ||
|
||||
token2Kind === SyntaxKind.EqualsToken ||
|
||||
isIdentifier(token2) ||
|
||||
isModifierKind(token2Kind)) {
|
||||
// ( id :
|
||||
// ( id ,
|
||||
// ( id ?
|
||||
// ( id =
|
||||
// ( modifier id
|
||||
//
|
||||
// All of these are definitely a function type and not a parenthesized type.
|
||||
return true;
|
||||
}
|
||||
|
||||
if (token2Kind === SyntaxKind.CloseParenToken) {
|
||||
// ( id )
|
||||
//
|
||||
// Only a function type if we see an arrow following it.
|
||||
return peekToken(3).kind() === SyntaxKind.EqualsGreaterThanToken;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
parameterList = parseParameterList();
|
||||
}
|
||||
|
||||
// Anything else is a parenthesized type.
|
||||
return false;
|
||||
}
|
||||
|
||||
function parseFunctionType(): FunctionTypeSyntax {
|
||||
var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
|
||||
var parameterList = parseParameterList();
|
||||
|
||||
return new syntaxFactory.FunctionTypeSyntax(parseNodeData,
|
||||
typeParameterList, parameterList, eatToken(SyntaxKind.EqualsGreaterThanToken), parseType());
|
||||
|
||||
@ -427,6 +427,20 @@ module TypeScript.PrettyPrinter {
|
||||
this.appendToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
|
||||
this.appendToken(node.openParenToken);
|
||||
this.appendElement(node.type);
|
||||
this.appendToken(node.closeParenToken);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): void {
|
||||
this.appendElement(node.left);
|
||||
this.ensureSpace();
|
||||
this.appendToken(node.barToken);
|
||||
this.ensureSpace();
|
||||
this.appendElement(node.right);
|
||||
}
|
||||
|
||||
public visitConstructorType(node: ConstructorTypeSyntax): void {
|
||||
this.appendToken(node.newKeyword);
|
||||
this.ensureSpace();
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
///<reference path='..\core\environment.ts' />
|
||||
///<reference path='syntaxFacts.ts' />
|
||||
///<reference path='syntaxKind.ts' />
|
||||
///<reference path='..\..\..\tests\fidelity\es5compat.ts' />
|
||||
|
||||
// Adds argument checking to the generated nodes. Argument checking appears to slow things down
|
||||
// parsing about 7%. If we want to get that perf back, we can always remove this.
|
||||
@ -365,6 +366,28 @@ var definitions:ITypeDefinition[] = [
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any> {
|
||||
name: 'UnionTypeSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
interfaces: ['ITypeSyntax'],
|
||||
children: [
|
||||
<any>{ name: 'left', type: 'ITypeSyntax' },
|
||||
<any>{ name: 'barToken', isToken: true, excludeFromAST: true },
|
||||
<any>{ name: 'right', type: 'ITypeSyntax' }
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any> {
|
||||
name: 'ParenthesizedTypeSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
interfaces: ['ITypeSyntax'],
|
||||
children: [
|
||||
<any>{ name: 'openParenToken', isToken: true, excludeFromAST: true },
|
||||
<any>{ name: 'type', type: 'ITypeSyntax' },
|
||||
<any>{ name: 'closeParenToken', isToken: true, excludeFromAST: true }
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any>{
|
||||
name: 'TypeAnnotationSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
|
||||
@ -159,6 +159,8 @@ module TypeScript {
|
||||
GenericType,
|
||||
TypeQuery,
|
||||
TupleType,
|
||||
UnionType,
|
||||
ParenthesizedType,
|
||||
|
||||
// Module elements.
|
||||
InterfaceDeclaration,
|
||||
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -14,6 +14,8 @@ module TypeScript {
|
||||
case SyntaxKind.GenericType: return visitor.visitGenericType(<GenericTypeSyntax>element);
|
||||
case SyntaxKind.TypeQuery: return visitor.visitTypeQuery(<TypeQuerySyntax>element);
|
||||
case SyntaxKind.TupleType: return visitor.visitTupleType(<TupleTypeSyntax>element);
|
||||
case SyntaxKind.UnionType: return visitor.visitUnionType(<UnionTypeSyntax>element);
|
||||
case SyntaxKind.ParenthesizedType: return visitor.visitParenthesizedType(<ParenthesizedTypeSyntax>element);
|
||||
case SyntaxKind.InterfaceDeclaration: return visitor.visitInterfaceDeclaration(<InterfaceDeclarationSyntax>element);
|
||||
case SyntaxKind.FunctionDeclaration: return visitor.visitFunctionDeclaration(<FunctionDeclarationSyntax>element);
|
||||
case SyntaxKind.ModuleDeclaration: return visitor.visitModuleDeclaration(<ModuleDeclarationSyntax>element);
|
||||
@ -111,6 +113,8 @@ module TypeScript {
|
||||
visitGenericType(node: GenericTypeSyntax): any;
|
||||
visitTypeQuery(node: TypeQuerySyntax): any;
|
||||
visitTupleType(node: TupleTypeSyntax): any;
|
||||
visitUnionType(node: UnionTypeSyntax): any;
|
||||
visitParenthesizedType(node: ParenthesizedTypeSyntax): any;
|
||||
visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): any;
|
||||
visitFunctionDeclaration(node: FunctionDeclarationSyntax): any;
|
||||
visitModuleDeclaration(node: ModuleDeclarationSyntax): any;
|
||||
|
||||
@ -109,6 +109,18 @@ module TypeScript {
|
||||
this.visitToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): void {
|
||||
this.visitNodeOrToken(node.left);
|
||||
this.visitToken(node.barToken);
|
||||
this.visitNodeOrToken(node.right);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.type);
|
||||
this.visitToken(node.closeParenToken);
|
||||
}
|
||||
|
||||
public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.interfaceKeyword);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user