/**

* @fileoverview Abstract syntax tree representing a source file once parsed.

*

* Each node in the AST is represented by an instance of a subclass of `Node`,

* with its `Node#kind` represented by one of the `NodeKind` constants, which

* dependent code typically switches over. The intended way to create a node

* is to use the respective `Node.createX` method instead of its constructor.

*

* Note that the AST does not contain any type information except type names.

*

* @license Apache-2.0

*/

// TODO: Make the AST more easily serializable by refactoring `Node#range` so

// it doesn't reference the non-serializable `Source` object.

import {

CommonFlags,

PATH_DELIMITER,

LIBRARY_PREFIX,

LIBRARY_SUBST

} from "./common";

import {

Token,

Range

} from "./tokenizer";

import {

normalizePath,

resolvePath,

CharCode,

isTrivialAlphanum

} from "./util";

/** Indicates the kind of a node. */

export enum NodeKind {

SOURCE,

// types

NAMEDTYPE,

FUNCTIONTYPE,

TYPENAME,

TYPEPARAMETER,

PARAMETER,

// expressions

IDENTIFIER,

ASSERTION,

BINARY,

CALL,

CLASS,

COMMA,

ELEMENTACCESS,

FALSE,

FUNCTION,

INSTANCEOF,

LITERAL,

NEW,

NULL,

PARENTHESIZED,

PROPERTYACCESS,

TERNARY,

SUPER,

THIS,

TRUE,

CONSTRUCTOR,

UNARYPOSTFIX,

UNARYPREFIX,

// statements

BLOCK,

BREAK,

CONTINUE,

DO,

EMPTY,

EXPORT,

EXPORTDEFAULT,

EXPORTIMPORT,

EXPRESSION,

FOR,

FOROF,

IF,

IMPORT,

RETURN,

SWITCH,

THROW,

TRY,

VARIABLE,

VOID,

WHILE,

// declaration statements

CLASSDECLARATION,

ENUMDECLARATION,

ENUMVALUEDECLARATION,

FIELDDECLARATION,

FUNCTIONDECLARATION,

IMPORTDECLARATION,

INDEXSIGNATUREDECLARATION,

INTERFACEDECLARATION,

METHODDECLARATION,

NAMESPACEDECLARATION,

TYPEDECLARATION,

VARIABLEDECLARATION,

// special

DECORATOR,

EXPORTMEMBER,

SWITCHCASE,

COMMENT

}

/** Base class of all nodes. */

export abstract class Node {

/** Node kind indicator. */

kind: NodeKind;

/** Source range. */

range: Range;

// types

static createTypeName(

name: IdentifierExpression,

range: Range

): TypeName {

var node = new TypeName();

node.kind = NodeKind.TYPENAME;

node.range = range;

node.identifier = name;

node.next = null;

return node;

}

static createSimpleTypeName(

name: string,

range: Range

): TypeName {

return Node.createTypeName(Node.createIdentifierExpression(name, range), range);

}

static createNamedType(

name: TypeName,

typeArguments: TypeNode[] | null,

isNullable: bool,

range: Range

): NamedTypeNode {

var node = new NamedTypeNode();

node.kind = NodeKind.NAMEDTYPE;

node.range = range;

node.name = name;

node.typeArguments = typeArguments;

node.isNullable = isNullable;

return node;

}

static createFunctionType(

parameters: ParameterNode[],

returnType: TypeNode,

explicitThisType: NamedTypeNode | null,

isNullable: bool,

range: Range

): FunctionTypeNode {

var node = new FunctionTypeNode();

node.kind = NodeKind.FUNCTIONTYPE;

node.range = range;

node.parameters = parameters;

node.returnType = returnType;

node.explicitThisType = explicitThisType;

node.isNullable = isNullable;

return node;

}

static createOmittedType(

range: Range

): NamedTypeNode {

return Node.createNamedType(

Node.createSimpleTypeName("", range),

null,

false,

range

);

}

static createTypeParameter(

name: IdentifierExpression,

extendsType: NamedTypeNode | null,

defaultType: NamedTypeNode | null,

range: Range

): TypeParameterNode {

var node = new TypeParameterNode();

node.kind = NodeKind.TYPEPARAMETER;

node.range = range;

node.name = name;

node.extendsType = extendsType;

node.defaultType = defaultType;

return node;

}

static createParameter(

name: IdentifierExpression,

type: TypeNode,

initializer: Expression | null,

kind: ParameterKind,

range: Range

): ParameterNode {

var node = new ParameterNode();

node.kind = NodeKind.PARAMETER;

node.range = range;

node.name = name;

node.type = type;

node.initializer = initializer;

node.parameterKind = kind;

return node;

}

// special

static createDecorator(

name: Expression,

args: Expression[] | null,

range: Range

): DecoratorNode {

var node = new DecoratorNode();

node.kind = NodeKind.DECORATOR;

node.range = range;

node.name = name;

node.arguments = args;

node.decoratorKind = DecoratorKind.fromNode(name);

return node;

}

static createComment(

text: string,

kind: CommentKind,

range: Range

): CommentNode {

var node = new CommentNode();

node.kind = NodeKind.COMMENT;

node.range = range;

node.commentKind = kind;

node.text = text;

return node;

}

// expressions

static createIdentifierExpression(

name: string,

range: Range,

isQuoted: bool = false

): IdentifierExpression {

var node = new IdentifierExpression();

node.kind = NodeKind.IDENTIFIER;

node.range = range;

node.text = name;

node.isQuoted = isQuoted;

return node;

}

static createEmptyIdentifierExpression(

range: Range

): IdentifierExpression {

var node = new IdentifierExpression();

node.kind = NodeKind.IDENTIFIER;

node.range = range;

node.text = "";

return node;

}

static createArrayLiteralExpression(

elements: (Expression | null)[],

range: Range

): ArrayLiteralExpression {

var node = new ArrayLiteralExpression();

node.kind = NodeKind.LITERAL;

node.range = range;

node.literalKind = LiteralKind.ARRAY;

node.elementExpressions = elements;

return node;

}

static createAssertionExpression(

assertionKind: AssertionKind,

expression: Expression,

toType: TypeNode | null,

range: Range

): AssertionExpression {

var node = new AssertionExpression();

node.kind = NodeKind.ASSERTION;

node.range = range;

node.assertionKind = assertionKind;

node.expression = expression;

node.toType = toType;

return node;

}

static createBinaryExpression(

operator: Token,

left: Expression,

right: Expression,

range: Range

): BinaryExpression {

var node = new BinaryExpression();

node.kind = NodeKind.BINARY;

node.range = range;

node.operator = operator;

node.left = left;

node.right = right;

return node;

}

static createCallExpression(

expression: Expression,

typeArgs: TypeNode[] | null,

args: Expression[],

range: Range

): CallExpression {

var node = new CallExpression();

node.kind = NodeKind.CALL;

node.range = range;

node.expression = expression;

node.typeArguments = typeArgs;

node.arguments = args;

return node;

}

static createClassExpression(

declaration: ClassDeclaration

): ClassExpression {

var node = new ClassExpression();

node.kind = NodeKind.CLASS;

node.range = declaration.range;

node.declaration = declaration;

return node;

}

static createCommaExpression(

expressions: Expression[],

range: Range

): CommaExpression {

var node = new CommaExpression();

node.kind = NodeKind.COMMA;

node.range = range;

node.expressions = expressions;

return node;

}

static createConstructorExpression(

range: Range

): ConstructorExpression {

var node = new ConstructorExpression();

node.kind = NodeKind.CONSTRUCTOR;

node.range = range;

node.text = "constructor";

return node;

}

static createElementAccessExpression(

expression: Expression,

element: Expression,

range: Range

): ElementAccessExpression {

var node = new ElementAccessExpression();

node.kind = NodeKind.ELEMENTACCESS;

node.range = range;

node.expression = expression;

node.elementExpression = element;

return node;

}

static createFalseExpression(

range: Range

): FalseExpression {

var node = new FalseExpression();

node.kind = NodeKind.FALSE;

node.range = range;

node.text = "false";

return node;

}

static createFloatLiteralExpression(

value: f64,

range: Range

): FloatLiteralExpression {

var node = new FloatLiteralExpression();

node.kind = NodeKind.LITERAL;

node.literalKind = LiteralKind.FLOAT;

node.range = range;

node.value = value;

return node;

}

static createFunctionExpression(

declaration: FunctionDeclaration

): FunctionExpression {

var node = new FunctionExpression();

node.kind = NodeKind.FUNCTION;

node.range = declaration.range;

node.declaration = declaration;

return node;

}

static createInstanceOfExpression(

expression: Expression,

isType: TypeNode,

range: Range

): InstanceOfExpression {

var node = new InstanceOfExpression();

node.kind = NodeKind.INSTANCEOF;

node.range = range;

node.expression = expression;

node.isType = isType;

return node;

}

static createIntegerLiteralExpression(

value: i64,

range: Range

): IntegerLiteralExpression {

var node = new IntegerLiteralExpression();

node.kind = NodeKind.LITERAL;

node.literalKind = LiteralKind.INTEGER;

node.range = range;

node.value = value;

return node;

}

static createNewExpression(

typeName: TypeName,

typeArgs: TypeNode[] | null,

args: Expression[],

range: Range

): NewExpression {

var node = new NewExpression();

node.kind = NodeKind.NEW;

node.range = range;

node.typeName = typeName;

node.typeArguments = typeArgs;

node.arguments = args;

return node;

}

static createNullExpression(

range: Range

): NullExpression {

var node = new NullExpression();

node.kind = NodeKind.NULL;

node.range = range;

node.text = "null";

return node;

}

static createObjectLiteralExpression(

names: IdentifierExpression[],

values: Expression[],

range: Range

): ObjectLiteralExpression {

var node = new ObjectLiteralExpression();

node.kind = NodeKind.LITERAL;

node.literalKind = LiteralKind.OBJECT;

node.range = range;

node.names = names;

node.values = values;

return node;

}

static createParenthesizedExpression(

expression: Expression,

range: Range

): ParenthesizedExpression {

var node = new ParenthesizedExpression();

node.kind = NodeKind.PARENTHESIZED;

node.range = range;

node.expression = expression;

return node;

}

static createPropertyAccessExpression(

expression: Expression,

property: IdentifierExpression,

range: Range

): PropertyAccessExpression {

var node = new PropertyAccessExpression();

node.kind = NodeKind.PROPERTYACCESS;

node.range = range;

node.expression = expression;

node.property = property;

return node;

}

static createRegexpLiteralExpression(

pattern: string,

flags: string,

range: Range

): RegexpLiteralExpression {

var node = new RegexpLiteralExpression();

node.kind = NodeKind.LITERAL;

node.literalKind = LiteralKind.REGEXP;

node.range = range;

node.pattern = pattern;

node.patternFlags = flags;

return node;

}

static createTernaryExpression(

condition: Expression,

ifThen: Expression,

ifElse: Expression,

range: Range

): TernaryExpression {

var node = new TernaryExpression();

node.kind = NodeKind.TERNARY;

node.range = range;

node.condition = condition;

node.ifThen = ifThen;

node.ifElse = ifElse;

return node;

}

static createStringLiteralExpression(

value: string,

range: Range

): StringLiteralExpression {

var node = new StringLiteralExpression();

node.kind = NodeKind.LITERAL;

node.literalKind = LiteralKind.STRING;

node.range = range;

node.value = value;

return node;

}

static createSuperExpression(

range: Range

): SuperExpression {

var node = new SuperExpression();

node.kind = NodeKind.SUPER;

node.range = range;

node.text = "super";

return node;

}

static createThisExpression(

range: Range

): ThisExpression {

var node = new ThisExpression();

node.kind = NodeKind.THIS;

node.range = range;

node.text = "this";

return node;

}

static createTrueExpression(

range: Range

): TrueExpression {

var node = new TrueExpression();

node.kind = NodeKind.TRUE;

node.range = range;

node.text = "true";

return node;

}

static createUnaryPostfixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPostfixExpression {

var node = new UnaryPostfixExpression();

node.kind = NodeKind.UNARYPOSTFIX;

node.range = range;

node.operator = operator;

node.operand = operand;

return node;

}

static createUnaryPrefixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPrefixExpression {

var node = new UnaryPrefixExpression();

node.kind = NodeKind.UNARYPREFIX;

node.range = range;

node.operator = operator;

node.operand = operand;

return node;

}

// statements

static createBlockStatement(

statements: Statement[],

range: Range

): BlockStatement {

var node = new BlockStatement();

node.kind = NodeKind.BLOCK;

node.range = range;

node.statements = statements;

return node;

}

static createBreakStatement(

label: IdentifierExpression | null,

range: Range

): BreakStatement {

var node = new BreakStatement();

node.kind = NodeKind.BREAK;

node.range = range;

node.label = label;

return node;

}

static createClassDeclaration(

identifier: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

extendsType: NamedTypeNode | null, // can't be a function

implementsTypes: NamedTypeNode[] | null, // can't be functions

members: DeclarationStatement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): ClassDeclaration {

var node = new ClassDeclaration();

node.kind = NodeKind.CLASSDECLARATION;

node.range = range;

node.flags = flags;

node.name = identifier;

node.typeParameters = typeParameters;

node.extendsType = extendsType;

node.implementsTypes = implementsTypes;

node.members = members;

node.decorators = decorators;

return node;

}

static createContinueStatement(

label: IdentifierExpression | null,

range: Range

): ContinueStatement {

var node = new ContinueStatement();

node.kind = NodeKind.CONTINUE;

node.range = range;

node.label = label;

return node;

}

static createDoStatement(

statement: Statement,

condition: Expression,

range: Range

): DoStatement {

var node = new DoStatement();

node.kind = NodeKind.DO;

node.range = range;

node.statement = statement;

node.condition = condition;

return node;

}

static createEmptyStatement(

range: Range

): EmptyStatement {

var node = new EmptyStatement();

node.kind = NodeKind.EMPTY;

node.range = range;

return node;

}

static createEnumDeclaration(

name: IdentifierExpression,

members: EnumValueDeclaration[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): EnumDeclaration {

var node = new EnumDeclaration();

node.kind = NodeKind.ENUMDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.values = members;

node.decorators = decorators;

return node;

}

static createEnumValueDeclaration(

name: IdentifierExpression,

initializer: Expression | null,

flags: CommonFlags,

range: Range

): EnumValueDeclaration {

var node = new EnumValueDeclaration();

node.kind = NodeKind.ENUMVALUEDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.initializer = initializer;

return node;

}

static createExportStatement(

members: ExportMember[] | null,

path: StringLiteralExpression | null,

isDeclare: bool,

range: Range

): ExportStatement {

var node = new ExportStatement();

node.kind = NodeKind.EXPORT;

node.range = range;

node.members = members;

node.path = path;

if (path) {

let normalizedPath = normalizePath(path.value);

if (path.value.startsWith(".")) { // relative

normalizedPath = resolvePath(normalizedPath, range.source.internalPath);

} else { // absolute

if (!normalizedPath.startsWith(LIBRARY_PREFIX)) normalizedPath = LIBRARY_PREFIX + normalizedPath;

}

node.internalPath = normalizedPath;

} else {

node.internalPath = null;

}

node.isDeclare = isDeclare;

return node;

}

static createExportDefaultStatement(

declaration: DeclarationStatement,

range: Range

): ExportDefaultStatement {

var node = new ExportDefaultStatement();

node.kind = NodeKind.EXPORTDEFAULT;

node.declaration = declaration;

node.range = range;

return node;

}

static createExportImportStatement(

name: IdentifierExpression,

externalName: IdentifierExpression,

range: Range

): ExportImportStatement {

var node = new ExportImportStatement();

node.kind = NodeKind.EXPORTIMPORT;

node.range = range;

node.name = name;

node.externalName = externalName;

return node;

}

static createExportMember(

name: IdentifierExpression,

externalName: IdentifierExpression | null,

range: Range

): ExportMember {

var node = new ExportMember();

node.kind = NodeKind.EXPORTMEMBER;

node.range = range;

node.localName = name;

if (!externalName) externalName = name;

node.exportedName = externalName;

return node;

}

static createExpressionStatement(

expression: Expression

): ExpressionStatement {

var node = new ExpressionStatement();

node.kind = NodeKind.EXPRESSION;

node.range = expression.range;

node.expression = expression;

return node;

}

static createIfStatement(

condition: Expression,

ifTrue: Statement,

ifFalse: Statement | null,

range: Range

): IfStatement {

var node = new IfStatement();

node.kind = NodeKind.IF;

node.range = range;

node.condition = condition;

node.ifTrue = ifTrue;

node.ifFalse = ifFalse;

return node;

}

static createImportStatement(

decls: ImportDeclaration[] | null,

path: StringLiteralExpression,

range: Range

): ImportStatement {

var node = new ImportStatement();

node.kind = NodeKind.IMPORT;

node.range = range;

node.declarations = decls;

node.namespaceName = null;

node.path = path;

var normalizedPath = normalizePath(path.value);

if (path.value.startsWith(".")) { // relative in project

normalizedPath = resolvePath(normalizedPath, range.source.internalPath);

} else { // absolute in library

if (!normalizedPath.startsWith(LIBRARY_PREFIX)) normalizedPath = LIBRARY_PREFIX + normalizedPath;

}

node.internalPath = normalizedPath;

return node;

}

static createImportStatementWithWildcard(

identifier: IdentifierExpression,

path: StringLiteralExpression,

range: Range

): ImportStatement {

var node = new ImportStatement();

node.kind = NodeKind.IMPORT;

node.range = range;

node.declarations = null;

node.namespaceName = identifier;

node.path = path;

var normalizedPath = normalizePath(path.value);

if (path.value.startsWith(".")) {

normalizedPath = resolvePath(normalizedPath, range.source.internalPath);

} else {

if (!normalizedPath.startsWith(LIBRARY_PREFIX)) normalizedPath = LIBRARY_PREFIX + normalizedPath;

}

node.internalPath = normalizedPath;

return node;

}

static createImportDeclaration(

foreignName: IdentifierExpression,

name: IdentifierExpression | null,

range: Range

): ImportDeclaration {

var node = new ImportDeclaration();

node.kind = NodeKind.IMPORTDECLARATION;

node.range = range;

node.foreignName = foreignName;

if (!name) name = foreignName;

node.name = name;

return node;

}

static createInterfaceDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

extendsType: NamedTypeNode | null, // can't be a function

members: DeclarationStatement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): InterfaceDeclaration {

var node = new InterfaceDeclaration();

node.kind = NodeKind.INTERFACEDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.typeParameters = typeParameters;

node.extendsType = extendsType;

node.members = members;

node.decorators = decorators;

return node;

}

static createFieldDeclaration(

name: IdentifierExpression,

type: TypeNode | null,

initializer: Expression | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): FieldDeclaration {

var node = new FieldDeclaration();

node.kind = NodeKind.FIELDDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.type = type;

node.initializer = initializer;

node.decorators = decorators;

return node;

}

static createForStatement(

initializer: Statement | null,

condition: Expression | null,

incrementor: Expression | null,

statement: Statement,

range: Range

): ForStatement {

var node = new ForStatement();

node.kind = NodeKind.FOR;

node.range = range;

node.initializer = initializer;

node.condition = condition;

node.incrementor = incrementor;

node.statement = statement;

return node;

}

static createForOfStatement(

variable: Statement,

iterable: Expression,

statement: Statement,

range: Range

): ForOfStatement {

var node = new ForOfStatement();

node.kind = NodeKind.FOROF;

node.range = range;

node.variable = variable;

node.iterable = iterable;

node.statement = statement;

return node;

}

static createFunctionDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

arrowKind: ArrowKind,

range: Range

): FunctionDeclaration {

var node = new FunctionDeclaration();

node.kind = NodeKind.FUNCTIONDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.typeParameters = typeParameters;

node.signature = signature;

node.body = body;

node.decorators = decorators;

node.arrowKind = arrowKind;

return node;

}

static createIndexSignatureDeclaration(

keyType: NamedTypeNode,

valueType: TypeNode,

flags: CommonFlags,

range: Range

): IndexSignatureDeclaration {

var node = new IndexSignatureDeclaration();

node.kind = NodeKind.INDEXSIGNATUREDECLARATION;

node.range = range;

node.keyType = keyType;

node.valueType = valueType;

node.flags = flags;

return node;

}

static createMethodDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): MethodDeclaration {

var node = new MethodDeclaration();

node.kind = NodeKind.METHODDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.typeParameters = typeParameters;

node.signature = signature;

node.body = body;

node.decorators = decorators;

return node;

}

static createNamespaceDeclaration(

name: IdentifierExpression,

members: Statement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): NamespaceDeclaration {

var node = new NamespaceDeclaration();

node.kind = NodeKind.NAMESPACEDECLARATION;

node.range = range;

node.flags = flags;

node.name = name;

node.members = members;

node.decorators = decorators;

return node;

}

static createReturnStatement(

value: Expression | null,

range: Range

): ReturnStatement {

var node = new ReturnStatement();

node.kind = NodeKind.RETURN;