mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-11-18 17:21:48 +00:00
Adding support in fidelity for parsing union and parenthesized types
This commit is contained in:
Cyrus Najmabadi committed
1 parent
5ce3baf339
commit
0e2058c0ab
12 files changed
+232
-806
No files matched your search
@@ -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);
|
||||
}
|
||||
|
||||
+100
-13
@@ -3532,6 +3532,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();
|
||||
|
||||
@@ -3572,11 +3604,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);
|
||||
}
|
||||
@@ -3584,6 +3614,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 === null) {
|
||||
@@ -3604,18 +3638,71 @@ module TypeScript.Parser {
|
||||
: new syntaxFactory.GenericTypeSyntax(parseNodeData, name, typeArgumentList);
|
||||
}
|
||||
|
||||
function tryParseFunctionType(): FunctionTypeSyntax {
|
||||
var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
|
||||
var parameterList: ParameterListSyntax = null;
|
||||
if (typeParameterList === null) {
|
||||
parameterList = tryParseParameterList();
|
||||
if (parameterList === null) {
|
||||
return null;
|
||||
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,
|
||||
|
||||
@@ -119,6 +119,30 @@ module TypeScript.Syntax.Abstract {
|
||||
!isShared(types) && (types.parent = this);
|
||||
}
|
||||
}
|
||||
export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public left: ITypeSyntax;
|
||||
public barToken: ISyntaxToken;
|
||||
public right: ITypeSyntax;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
|
||||
super(data);
|
||||
this.left = left,
|
||||
this.right = right,
|
||||
left.parent = this,
|
||||
right.parent = this;
|
||||
}
|
||||
}
|
||||
export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public openParenToken: ISyntaxToken;
|
||||
public type: ITypeSyntax;
|
||||
public closeParenToken: ISyntaxToken;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.type = type,
|
||||
type.parent = this;
|
||||
}
|
||||
}
|
||||
export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
|
||||
public modifiers: ISyntaxToken[];
|
||||
public interfaceKeyword: ISyntaxToken;
|
||||
@@ -1201,5 +1225,5 @@ module TypeScript.Syntax.Abstract {
|
||||
}
|
||||
}
|
||||
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax)Line truncated
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kiLine truncated
|
||||
}
|
||||
@@ -141,6 +141,36 @@ module TypeScript.Syntax.Concrete {
|
||||
closeBracketToken.parent = this;
|
||||
}
|
||||
}
|
||||
export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public left: ITypeSyntax;
|
||||
public barToken: ISyntaxToken;
|
||||
public right: ITypeSyntax;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
|
||||
super(data);
|
||||
this.left = left,
|
||||
this.barToken = barToken,
|
||||
this.right = right,
|
||||
left.parent = this,
|
||||
barToken.parent = this,
|
||||
right.parent = this;
|
||||
}
|
||||
}
|
||||
export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public openParenToken: ISyntaxToken;
|
||||
public type: ITypeSyntax;
|
||||
public closeParenToken: ISyntaxToken;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.openParenToken = openParenToken,
|
||||
this.type = type,
|
||||
this.closeParenToken = closeParenToken,
|
||||
openParenToken.parent = this,
|
||||
type.parent = this,
|
||||
closeParenToken.parent = this;
|
||||
}
|
||||
}
|
||||
export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
|
||||
public modifiers: ISyntaxToken[];
|
||||
public interfaceKeyword: ISyntaxToken;
|
||||
@@ -1435,5 +1465,5 @@ module TypeScript.Syntax.Concrete {
|
||||
}
|
||||
}
|
||||
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax)Line truncated
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kiLine truncated
|
||||
}
|
||||
@@ -47,6 +47,16 @@ module TypeScript {
|
||||
types: ITypeSyntax[];
|
||||
closeBracketToken: ISyntaxToken;
|
||||
}
|
||||
export interface UnionTypeSyntax extends ISyntaxNode, ITypeSyntax {
|
||||
left: ITypeSyntax;
|
||||
barToken: ISyntaxToken;
|
||||
right: ITypeSyntax;
|
||||
}
|
||||
export interface ParenthesizedTypeSyntax extends ISyntaxNode, ITypeSyntax {
|
||||
openParenToken: ISyntaxToken;
|
||||
type: ITypeSyntax;
|
||||
closeParenToken: ISyntaxToken;
|
||||
}
|
||||
export interface InterfaceDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax {
|
||||
modifiers: ISyntaxToken[];
|
||||
interfaceKeyword: ISyntaxToken;
|
||||
@@ -483,7 +493,7 @@ module TypeScript {
|
||||
moduleName: INameSyntax;
|
||||
}
|
||||
|
||||
export var nodeMetadata: string[][] = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],["moduleElements","endOfFileToken"],["left","dotToken","right"],["openBraceToken","typeMembers","closeBraceToken"],["typeParameterList","parameterList","equalsGreaterThanToken","type"],["type","openBracketToken","closeBracketToken"],["newKeyword","typeParameterList","parameterList","equalsGreaterThanToken","type"],["name","typeArgumentList"],["typeOfKeyword","name"],["openBracketToken","types","closeBracketToken"],["modifiers","interfaceKeyword","identifier","typeParameterList","heritageClauses","body"],["modifiers","functionKeyword","identifier","callSignature","block","semicolonToken"],["modifiers","moduleKeyword","name","stringLiteral","openBraceToken","moduleElements","closeBraceToken"],["modifiers","classKeyword","identifier","typeParameterList","heritageClauses","openBraceToken","classElements","closeBraceToken"],["modifiers","enumKeyword","identifier","openBraceToken","enumElements","closeBraceToken"],["modifiers","importKeyword","identifier","equalsToken","moduleReference","semicolonToken"],["exportKeyword","equalsToken","identifier","semicolonToken"],["modifiers","propertyName","callSignature","block","semicolonToken"],["modifiers","variableDeclarator","semicolonToken"],["modifiers","constructorKeyword","callSignature","block","semicolonToken"],["modifiers","indexSignature","semicolonToken"],["modifiers","getKeyword","propertyName","callSignature","block"],["modifiers","setKeyword","propertyName","callSignature","block"],["propertyName","questionToken","typeAnnotation"],["typeParameterList","parameterList","typeAnnotation"],["newKeyword","callSignature"],["openBracketToken","parameters","closeBracketToken","typeAnnotation"],["propertyName","questionToken","callSignature"],["openBraceToken","statements","closeBraceToken"],["ifKeyword","openParenToken","condition","closeParenToken","statement","elseClause"],["modifiers","variableDeclaration","semicolonToken"],["expression","semicolonToken"],["returnKeyword","expression","semicolonToken"],["switchKeyword","openParenToken","expression","closeParenToken","openBraceToken","switchClauses","closeBraceToken"],["breakKeyword","identifier","semicolonToken"],["continueKeyword","identifier","semicolonToken"],["forKeyword","openParenToken","variableDeclaration","initializer","firstSemicolonToken","condition","secondSemicolonToken","incrementor","closeParenToken","statement"],["forKeyword","openParenToken","variableDeclaration","left","inKeyword","expression","closeParenToken","statement"],["semicolonToken"],["throwKeyword","expression","semicolonToken"],["whileKeyword","openParenToken","condition","closeParenToken","statement"],["tryKeyword","block","catchClause","finallyClause"],["identifier","colonToken","statement"],["doKeyword","statement","whileKeyword","openParenToken","condition","closeParenToken","semicolonToken"],["debuggerKeyword","semicolonToken"],["withKeyword","openParenToken","condition","closeParenToken","statement"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["deleteKeyword","expression"],["typeOfKeyword","expression"],["voidKeyword","expression"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["condition","questionToken","whenTrue","colonToken","whenFalse"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["operand","operatorToken"],["operand","operatorToken"],["expression","dotToken","name"],["expression","argumentList"],["openBracketToken","expressions",Line truncated
|
||||
export var nodeMetadata: string[][] = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],["moduleElements","endOfFileToken"],["left","dotToken","right"],["openBraceToken","typeMembers","closeBraceToken"],["typeParameterList","parameterList","equalsGreaterThanToken","type"],["type","openBracketToken","closeBracketToken"],["newKeyword","typeParameterList","parameterList","equalsGreaterThanToken","type"],["name","typeArgumentList"],["typeOfKeyword","name"],["openBracketToken","types","closeBracketToken"],["left","barToken","right"],["openParenToken","type","closeParenToken"],["modifiers","interfaceKeyword","identifier","typeParameterList","heritageClauses","body"],["modifiers","functionKeyword","identifier","callSignature","block","semicolonToken"],["modifiers","moduleKeyword","name","stringLiteral","openBraceToken","moduleElements","closeBraceToken"],["modifiers","classKeyword","identifier","typeParameterList","heritageClauses","openBraceToken","classElements","closeBraceToken"],["modifiers","enumKeyword","identifier","openBraceToken","enumElements","closeBraceToken"],["modifiers","importKeyword","identifier","equalsToken","moduleReference","semicolonToken"],["exportKeyword","equalsToken","identifier","semicolonToken"],["modifiers","propertyName","callSignature","block","semicolonToken"],["modifiers","variableDeclarator","semicolonToken"],["modifiers","constructorKeyword","callSignature","block","semicolonToken"],["modifiers","indexSignature","semicolonToken"],["modifiers","getKeyword","propertyName","callSignature","block"],["modifiers","setKeyword","propertyName","callSignature","block"],["propertyName","questionToken","typeAnnotation"],["typeParameterList","parameterList","typeAnnotation"],["newKeyword","callSignature"],["openBracketToken","parameters","closeBracketToken","typeAnnotation"],["propertyName","questionToken","callSignature"],["openBraceToken","statements","closeBraceToken"],["ifKeyword","openParenToken","condition","closeParenToken","statement","elseClause"],["modifiers","variableDeclaration","semicolonToken"],["expression","semicolonToken"],["returnKeyword","expression","semicolonToken"],["switchKeyword","openParenToken","expression","closeParenToken","openBraceToken","switchClauses","closeBraceToken"],["breakKeyword","identifier","semicolonToken"],["continueKeyword","identifier","semicolonToken"],["forKeyword","openParenToken","variableDeclaration","initializer","firstSemicolonToken","condition","secondSemicolonToken","incrementor","closeParenToken","statement"],["forKeyword","openParenToken","variableDeclaration","left","inKeyword","expression","closeParenToken","statement"],["semicolonToken"],["throwKeyword","expression","semicolonToken"],["whileKeyword","openParenToken","condition","closeParenToken","statement"],["tryKeyword","block","catchClause","finallyClause"],["identifier","colonToken","statement"],["doKeyword","statement","whileKeyword","openParenToken","condition","closeParenToken","semicolonToken"],["debuggerKeyword","semicolonToken"],["withKeyword","openParenToken","condition","closeParenToken","statement"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["deleteKeyword","expression"],["typeOfKeyword","expression"],["voidKeyword","expression"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["condition","questionToken","whenTrue","colonToken","whenFalse"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["operand","operatorToken"],["operand","operatorToken"],["expression","dotToken",Line truncated
|
||||
|
||||
export module Syntax {
|
||||
export interface ISyntaxFactory {
|
||||
@@ -497,6 +507,8 @@ module TypeScript {
|
||||
GenericTypeSyntax: { new(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax };
|
||||
TypeQuerySyntax: { new(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax };
|
||||
TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken): TupleTypeSyntax };
|
||||
UnionTypeSyntax: { new(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax };
|
||||
ParenthesizedTypeSyntax: { new(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax };
|
||||
InterfaceDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax };
|
||||
FunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax };
|
||||
ModuleDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax };
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user