/**

* @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 {

Range

} from "./diagnostics";

import {

Token

} from "./tokenizer";

import {

normalizePath,

resolvePath,

CharCode

} from "./util";

import {

ExpressionRef

} from "./module";

import {

Type

} from "./types";

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

export const enum NodeKind {

Source,

// types

NamedType,

FunctionType,

InferredType,

TypeName,

TypeParameter,

Parameter,

// expressions

Identifier,

Assertion,

Binary,

Call,

Class,

Comma,

ElementAccess,

False,

Function,

InstanceOf,

Literal,

New,

Null,

Omitted,

Parenthesized,

PropertyAccess,

Ternary,

Super,

This,

True,

Constructor,

UnaryPostfix,

UnaryPrefix,

Compiled,

// statements

Block,

Break,

Continue,

Do,

Empty,

Export,

ExportDefault,

ExportImport,

Expression,

For,

ForOf,

If,

Import,

Return,

Switch,

Throw,

Try,

Variable,

Void,

While,

Module,

// declaration statements

ClassDeclaration,

EnumDeclaration,

EnumValueDeclaration,

FieldDeclaration,

FunctionDeclaration,

ImportDeclaration,

InterfaceDeclaration,

MethodDeclaration,

NamespaceDeclaration,

TypeDeclaration,

VariableDeclaration,

// special

Decorator,

ExportMember,

SwitchCase,

IndexSignature,

Comment

}

/** Base class of all nodes. */

export abstract class Node {

constructor(

/** Kind of this node. */

public kind: NodeKind,

/** Source range. */

public range: Range

) {}

// types

static createSimpleTypeName(

name: string,

range: Range

): TypeName {

return new TypeName(Node.createIdentifierExpression(name, range), null, range);

}

static createNamedType(

name: TypeName,

typeArguments: TypeNode[] | null,

isNullable: bool,

range: Range

): NamedTypeNode {

return new NamedTypeNode(name, typeArguments, isNullable, range);

}

static createFunctionType(

parameters: ParameterNode[],

returnType: TypeNode,

explicitThisType: NamedTypeNode | null,

isNullable: bool,

range: Range

): FunctionTypeNode {

return new FunctionTypeNode(parameters, returnType, explicitThisType, isNullable, range);

}

static createOmittedType(

range: Range

): NamedTypeNode {

return new NamedTypeNode(Node.createSimpleTypeName("", range), null, false, range);

}

static createInferredType(expr: Expression): InferredTypeNode {

return new InferredTypeNode(expr, expr.range);

}

static createTypeParameter(

name: IdentifierExpression,

extendsType: NamedTypeNode | null,

defaultType: NamedTypeNode | null,

range: Range

): TypeParameterNode {

return new TypeParameterNode(name, extendsType, defaultType, range);

}

static createParameter(

parameterKind: ParameterKind,

name: IdentifierExpression,

type: TypeNode,

initializer: Expression | null,

range: Range

): ParameterNode {

return new ParameterNode(parameterKind, name, type, initializer, range);

}

// special

static createDecorator(

name: Expression,

args: Expression[] | null,

range: Range

): DecoratorNode {

return new DecoratorNode(DecoratorKind.fromNode(name), name, args, range);

}

static createComment(

commentKind: CommentKind,

text: string,

range: Range

): CommentNode {

return new CommentNode(commentKind, text, range);

}

// expressions

static createIdentifierExpression(

text: string,

range: Range,

isQuoted: bool = false

): IdentifierExpression {

return new IdentifierExpression(text, isQuoted, range);

}

static createEmptyIdentifierExpression(

range: Range

): IdentifierExpression {

return new IdentifierExpression("", false, range);

}

static createArrayLiteralExpression(

elementExpressions: Expression[],

range: Range

): ArrayLiteralExpression {

return new ArrayLiteralExpression(elementExpressions, range);

}

static createAssertionExpression(

assertionKind: AssertionKind,

expression: Expression,

toType: TypeNode | null,

range: Range

): AssertionExpression {

return new AssertionExpression(assertionKind, expression, toType, range);

}

static createBinaryExpression(

operator: Token,

left: Expression,

right: Expression,

range: Range

): BinaryExpression {

return new BinaryExpression(operator, left, right, range);

}

static createCallExpression(

expression: Expression,

typeArguments: TypeNode[] | null,

args: Expression[],

range: Range

): CallExpression {

return new CallExpression(expression, typeArguments, args, range);

}

static createClassExpression(

declaration: ClassDeclaration

): ClassExpression {

return new ClassExpression(declaration);

}

static createCommaExpression(

expressions: Expression[],

range: Range

): CommaExpression {

return new CommaExpression(expressions, range);

}

static createConstructorExpression(

range: Range

): ConstructorExpression {

return new ConstructorExpression(range);

}

static createElementAccessExpression(

expression: Expression,

elementExpression: Expression,

range: Range

): ElementAccessExpression {

return new ElementAccessExpression(expression, elementExpression, range);

}

static createFalseExpression(

range: Range

): FalseExpression {

return new FalseExpression(range);

}

static createFloatLiteralExpression(

value: f64,

range: Range

): FloatLiteralExpression {

return new FloatLiteralExpression(value, range);

}

static createFunctionExpression(

declaration: FunctionDeclaration

): FunctionExpression {

return new FunctionExpression(declaration);

}

static createInstanceOfExpression(

expression: Expression,

isType: TypeNode,

range: Range

): InstanceOfExpression {

return new InstanceOfExpression(expression, isType, range);

}

static createIntegerLiteralExpression(

value: i64,

range: Range

): IntegerLiteralExpression {

return new IntegerLiteralExpression(value, range);

}

static createNewExpression(

typeName: TypeName,

typeArguments: TypeNode[] | null,

args: Expression[],

range: Range

): NewExpression {

return new NewExpression(typeName, typeArguments, args, range);

}

static createNullExpression(

range: Range

): NullExpression {

return new NullExpression(range);

}

static createObjectLiteralExpression(

names: IdentifierExpression[],

values: Expression[],

range: Range

): ObjectLiteralExpression {

return new ObjectLiteralExpression(names, values, range);

}

static createOmittedExpression(

range: Range

): OmittedExpression {

return new OmittedExpression(range);

}

static createParenthesizedExpression(

expression: Expression,

range: Range

): ParenthesizedExpression {

return new ParenthesizedExpression(expression, range);

}

static createPropertyAccessExpression(

expression: Expression,

property: IdentifierExpression,

range: Range

): PropertyAccessExpression {

return new PropertyAccessExpression(expression, property, range);

}

static createRegexpLiteralExpression(

pattern: string,

patternFlags: string,

range: Range

): RegexpLiteralExpression {

return new RegexpLiteralExpression(pattern, patternFlags, range);

}

static createTernaryExpression(

condition: Expression,

ifThen: Expression,

ifElse: Expression,

range: Range

): TernaryExpression {

return new TernaryExpression(condition, ifThen, ifElse, range);

}

static createStringLiteralExpression(

value: string,

range: Range

): StringLiteralExpression {

return new StringLiteralExpression(value, range);

}

static createSuperExpression(

range: Range

): SuperExpression {

return new SuperExpression(range);

}

static createTemplateLiteralExpression(

tag: Expression | null,

parts: string[],

rawParts: string[],

expressions: Expression[],

range: Range

): TemplateLiteralExpression {

return new TemplateLiteralExpression(tag, parts, rawParts, expressions, range);

}

static createThisExpression(

range: Range

): ThisExpression {

return new ThisExpression(range);

}

static createTrueExpression(

range: Range

): TrueExpression {

return new TrueExpression(range);

}

static createUnaryPostfixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPostfixExpression {

return new UnaryPostfixExpression(operator, operand, range);

}

static createUnaryPrefixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPrefixExpression {

return new UnaryPrefixExpression(operator, operand, range);

}

static createCompiledExpression(

expr: ExpressionRef,

type: Type,

range: Range

): Expression {

return new CompiledExpression(expr, type, range);

}

// statements

static createBlockStatement(

statements: Statement[],

range: Range

): BlockStatement {

return new BlockStatement(statements, range);

}

static createBreakStatement(

label: IdentifierExpression | null,

range: Range

): BreakStatement {

return new BreakStatement(label, range);

}

static createClassDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

typeParameters: TypeParameterNode[] | null,

extendsType: NamedTypeNode | null,

implementsTypes: NamedTypeNode[] | null,

members: DeclarationStatement[],

range: Range

): ClassDeclaration {

return new ClassDeclaration(name, decorators, flags, typeParameters, extendsType, implementsTypes, members, range);

}

static createContinueStatement(

label: IdentifierExpression | null,

range: Range

): ContinueStatement {

return new ContinueStatement(label, range);

}

static createDoStatement(

body: Statement,

condition: Expression,

range: Range

): DoStatement {

return new DoStatement(body, condition, range);

}

static createEmptyStatement(

range: Range

): EmptyStatement {

return new EmptyStatement(range);

}

static createEnumDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

values: EnumValueDeclaration[],

range: Range

): EnumDeclaration {

return new EnumDeclaration(name, decorators, flags, values, range);

}

static createEnumValueDeclaration(

name: IdentifierExpression,

flags: CommonFlags,

initializer: Expression | null,

range: Range

): EnumValueDeclaration {

return new EnumValueDeclaration(name, flags, initializer, range);

}

static createExportStatement(

members: ExportMember[] | null,

path: StringLiteralExpression | null,

isDeclare: bool,

range: Range

): ExportStatement {

return new ExportStatement(members, path, isDeclare, range);

}

static createExportDefaultStatement(

declaration: DeclarationStatement,

range: Range

): ExportDefaultStatement {

return new ExportDefaultStatement(declaration, range);

}

static createExportImportStatement(

name: IdentifierExpression,

externalName: IdentifierExpression,

range: Range

): ExportImportStatement {

return new ExportImportStatement(name, externalName, range);

}

static createExportMember(

localName: IdentifierExpression,

exportedName: IdentifierExpression | null,

range: Range

): ExportMember {

if (!exportedName) exportedName = localName;

return new ExportMember(localName, exportedName, range);

}

static createExpressionStatement(

expression: Expression

): ExpressionStatement {

return new ExpressionStatement(expression);

}

static createIfStatement(

condition: Expression,

ifTrue: Statement,

ifFalse: Statement | null,

range: Range

): IfStatement {

return new IfStatement(condition, ifTrue, ifFalse, range);

}

static createImportStatement(

declarations: ImportDeclaration[] | null,

path: StringLiteralExpression,

range: Range

): ImportStatement {

return new ImportStatement(declarations, null, path, range);

}

static createWildcardImportStatement(

namespaceName: IdentifierExpression,

path: StringLiteralExpression,

range: Range

): ImportStatement {

return new ImportStatement(null, namespaceName, path, range);

}

static createImportDeclaration(

foreignName: IdentifierExpression,

name: IdentifierExpression | null,

range: Range

): ImportDeclaration {

if (!name) name = foreignName;

return new ImportDeclaration(name, foreignName, range);

}

static createInterfaceDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

typeParameters: TypeParameterNode[] | null,

extendsType: NamedTypeNode | null,

implementsTypes: NamedTypeNode[] | null,

members: DeclarationStatement[],

range: Range

): InterfaceDeclaration {

return new InterfaceDeclaration(name, decorators, flags, typeParameters, extendsType, implementsTypes, members, range);

}

static createFieldDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

type: TypeNode | null,

initializer: Expression | null,

range: Range

): FieldDeclaration {

return new FieldDeclaration(name, decorators, flags, type, initializer, -1, range);

}

static createForStatement(

initializer: Statement | null,

condition: Expression | null,

incrementor: Expression | null,

body: Statement,

range: Range

): ForStatement {

return new ForStatement(initializer, condition, incrementor, body, range);

}

static createForOfStatement(

variable: Statement,

iterable: Expression,

body: Statement,

range: Range

): ForOfStatement {

return new ForOfStatement(variable, iterable, body, range);

}

static createFunctionDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

arrowKind: ArrowKind,

range: Range

): FunctionDeclaration {

return new FunctionDeclaration(name, decorators, flags, typeParameters, signature, body, arrowKind, range);

}

static createIndexSignature(

keyType: NamedTypeNode,

valueType: TypeNode,

flags: CommonFlags,

range: Range

): IndexSignatureNode {

return new IndexSignatureNode(keyType, valueType, flags, range);

}

static createMethodDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

range: Range

): MethodDeclaration {

return new MethodDeclaration(name, decorators, flags, typeParameters, signature, body, range);

}

static createNamespaceDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

members: Statement[],

range: Range

): NamespaceDeclaration {

return new NamespaceDeclaration(name, decorators, flags, members, range);

}

static createReturnStatement(

value: Expression | null,

range: Range

): ReturnStatement {

return new ReturnStatement(value, range);

}

static createSwitchStatement(

condition: Expression,

cases: SwitchCase[],

range: Range

): SwitchStatement {

return new SwitchStatement(condition, cases, range);

}

static createSwitchCase(

label: Expression | null,

statements: Statement[],

range: Range

): SwitchCase {

return new SwitchCase(label, statements, range);

}

static createThrowStatement(

value: Expression,

range: Range

): ThrowStatement {

return new ThrowStatement(value, range);

}

static createTryStatement(

bodyStatements: Statement[],

catchVariable: IdentifierExpression | null,

catchStatements: Statement[] | null,

finallyStatements: Statement[] | null,

range: Range

): TryStatement {

return new TryStatement(bodyStatements, catchVariable, catchStatements, finallyStatements, range);

}

static createTypeDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

typeParameters: TypeParameterNode[] | null,

type: TypeNode,

range: Range

): TypeDeclaration {

return new TypeDeclaration(name, decorators, flags, typeParameters, type, range);

}

static createModuleDeclaration(

name: string,

flags: CommonFlags,

range: Range

): ModuleDeclaration {

return new ModuleDeclaration(name, flags, range);

}

static createVariableStatement(

decorators: DecoratorNode[] | null,

declarations: VariableDeclaration[],

range: Range

): VariableStatement {

return new VariableStatement(decorators, declarations, range);

}

static createVariableDeclaration(

name: IdentifierExpression,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

type: TypeNode | null,

initializer: Expression | null,

range: Range

): VariableDeclaration {

return new VariableDeclaration(name, decorators, flags, type, initializer, range);

}

static createVoidStatement(

expression: Expression,

range: Range

): VoidStatement {

return new VoidStatement(expression, range);

}

static createWhileStatement(

condition: Expression,

statement: Statement,

range: Range

): WhileStatement {

return new WhileStatement(condition, statement, range);

}

/** Tests if this node is a literal of the specified kind. */

isLiteralKind(literalKind: LiteralKind): bool {

return this.kind == NodeKind.Literal

&& (<LiteralExpression>changetype<Node>(this)).literalKind == literalKind; // TS

}

/** Tests if this node is a literal of a numeric kind (float or integer). */

get isNumericLiteral(): bool {

if (this.kind == NodeKind.Literal) {

switch ((<LiteralExpression>changetype<Node>(this)).literalKind) { // TS

case LiteralKind.Float:

case LiteralKind.Integer: return true;

}

}

return false;

}

/** Tests whether this node is guaranteed to compile to a constant value. */

get compilesToConst(): bool {

switch (this.kind) {

case NodeKind.Literal: {

switch ((<LiteralExpression>changetype<Node>(this)).literalKind) { // TS

case LiteralKind.Float:

case LiteralKind.Integer:

case LiteralKind.String: return true;

}

break;

}

case NodeKind.Null:

case NodeKind.True:

case NodeKind.False: return true;

}

return false;

}

private isAccessOn(kind: NodeKind): bool {

let node = changetype<Node>(this);

if (node.kind == NodeKind.Call) {

node = (<CallExpression>node).expression;

}

if (node.kind == NodeKind.PropertyAccess) {

let target = (<PropertyAccessExpression>node).expression;

if (target.kind == kind) return true;

}

return false;

}

/** Checks if this node accesses a method or property on `this`. */

get isAccessOnThis(): bool {

return this.isAccessOn(NodeKind.This);

}

/** Checks if this node accesses a method or property on `super`. */

get isAccessOnSuper(): bool {

return this.isAccessOn(NodeKind.Super);

}

get isEmpty(): bool {

return this.kind == NodeKind.Empty;

}

}

// types

export abstract class TypeNode extends Node {

constructor(

/** Kind of the type node. */

kind: NodeKind,

/** Whether nullable or not. */

public isNullable: bool,

/** Source range. */

range: Range

) {

super(kind, range);

}

/** Whether this type node is currently in the process of being resolved. */

currentlyResolving: bool = false;

/** Tests if this type has a generic component matching one of the given type parameters. */

hasGenericComponent(typeParameterNodes: TypeParameterNode[]): bool {

if (this.kind == NodeKind.NamedType) {

let namedTypeNode = <NamedTypeNode>changetype<TypeNode>(this); // TS

if (!namedTypeNode.name.next) {

let typeArgumentNodes = namedTypeNode.typeArguments;

if (typeArgumentNodes && typeArgumentNodes.length > 0) {

for (let i = 0, k = typeArgumentNodes.length; i < k; ++i) {

if (typeArgumentNodes[i].hasGenericComponent(typeParameterNodes)) return true;

}

} else {

let name = namedTypeNode.name.identifier.text;

for (let i = 0, k = typeParameterNodes.length; i < k; ++i) {

if (typeParameterNodes[i].name.text == name) return true;

}

}

}

} else if (this.kind == NodeKind.FunctionType) {

let functionTypeNode = <FunctionTypeNode>changetype<TypeNode>(this); // TS

let parameterNodes = functionTypeNode.parameters;

for (let i = 0, k = parameterNodes.length; i < k; ++i) {

if (parameterNodes[i].type.hasGenericComponent(typeParameterNodes)) return true;

}

if (functionTypeNode.returnType.hasGenericComponent(typeParameterNodes)) return true;

let explicitThisType = functionTypeNode.explicitThisType;

if (explicitThisType && explicitThisType.hasGenericComponent(typeParameterNodes)) return true;

} else {

assert(false);

}

return false;

}

}

/** Represents a type name. */

export class TypeName extends Node {

constructor(

/** Identifier of this part. */

public identifier: IdentifierExpression,

/** Next part of the type name or `null` if this is the last part. */

public next: TypeName | null,

/** Source range. */

range: Range

) {

super(NodeKind.TypeName, range);

}

}

/** Represents a named type. */

export class NamedTypeNode extends TypeNode {

constructor(

/** Type name. */

public name: TypeName,

/** Type argument references. */

public typeArguments: TypeNode[] | null,

/** Whether nullable or not. */

isNullable: bool,

/** Source range. */

range: Range

) {

super(NodeKind.NamedType, isNullable, range);

}

/** Checks if this type node has type arguments. */

get hasTypeArguments(): bool {

let typeArguments = this.typeArguments;

return typeArguments != null && typeArguments.length > 0;

}

/** Tests if this type is "null". */

get isNull(): bool {

return this.name.identifier.text == "null";

}

}

/** Represents a function type. */

export class FunctionTypeNode extends TypeNode {

constructor(

/** Function parameters. */

public parameters: ParameterNode[],

/** Return type. */

public returnType: TypeNode,

/** Explicitly provided this type, if any. */

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

/** Whether nullable or not. */

isNullable: bool,

/** Source range. */

range: Range

) {

super(NodeKind.FunctionType, isNullable, range);

}

}

export class InferredTypeNode extends TypeNode {

constructor(

/** Function parameters. */

public expr: Expression,

/** Source range. */

range: Range

) {

super(NodeKind.InferredType, false, range);

}

}

/** Represents a type parameter. */

export class TypeParameterNode extends Node {

constructor(

/** Identifier reference. */

public name: IdentifierExpression,

/** Extended type reference, if any. */

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

/** Default type if omitted, if any. */

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

/** Source range. */

range: Range

) {

super(NodeKind.TypeParameter, range);

}

}

/** Represents the kind of a parameter. */

export const enum ParameterKind {

/** No specific flags. */

Default,

/** Is an optional parameter. */

Optional,

/** Is a rest parameter. */

Rest

}

/** Represents a function parameter. */

export class ParameterNode extends Node {

constructor(

/** Parameter kind. */

public parameterKind: ParameterKind,

/** Parameter name. */

public name: IdentifierExpression,

/** Parameter type. */

public type: TypeNode,

/** Initializer expression, if any. */

public initializer: Expression | null,

/** Source range. */

range: Range

) {

super(NodeKind.Parameter, range);

}

/** Implicit field declaration, if applicable. */

implicitFieldDeclaration: FieldDeclaration | null = null;

/** Common flags indicating specific traits. */

flags: CommonFlags = CommonFlags.None;

/** Tests if this node has the specified flag or flags. */

is(flag: CommonFlags): bool { return (this.flags & flag) == flag; }

/** Tests if this node has one of the specified flags. */

isAny(flag: CommonFlags): bool { return (this.flags & flag) != 0; }

/** Sets a specific flag or flags. */