/**

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

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 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 | null)[],

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 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 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);

}

// 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(

statement: Statement,

condition: Expression,

range: Range

): DoStatement {

return new DoStatement(statement, 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,

statement: Statement,

range: Range

): ForStatement {

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

}

static createForOfStatement(

variable: Statement,

iterable: Expression,

statement: Statement,

range: Range

): ForOfStatement {

return new ForOfStatement(variable, iterable, statement, 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(

statements: Statement[],

catchVariable: IdentifierExpression | null,

catchStatements: Statement[] | null,

finallyStatements: Statement[] | null,

range: Range

): TryStatement {

return new TryStatement(statements, 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 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);

}

}

// 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);

}

/** 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 !== null && 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 !== null && 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 {

var typeArguments = this.typeArguments;

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

}

}

/** 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);

}

}

/** 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 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. */

set(flag: CommonFlags): void { this.flags |= flag; }

}

// special

/** Built-in decorator kinds. */

export enum DecoratorKind {

CUSTOM,

GLOBAL,

OPERATOR,

OPERATOR_BINARY,

OPERATOR_PREFIX,

OPERATOR_POSTFIX,

UNMANAGED,

FINAL,

INLINE,

EXTERNAL,

BUILTIN,

LAZY,

UNSAFE

}

export namespace DecoratorKind {

/** Returns the kind of the specified decorator name node. Defaults to {@link DecoratorKind.CUSTOM}. */

export function fromNode(nameNode: Expression): DecoratorKind {

if (nameNode.kind == NodeKind.IDENTIFIER) {

let nameStr = (<IdentifierExpression>nameNode).text;

assert(nameStr.length);

switch (nameStr.charCodeAt(0)) {

case CharCode.b: {

if (nameStr == "builtin") return DecoratorKind.BUILTIN;

break;

}

case CharCode.e: {

if (nameStr == "external") return DecoratorKind.EXTERNAL;

break;

}

case CharCode.f: {

if (nameStr == "final") return DecoratorKind.FINAL;

break;

}

case CharCode.g: {

if (nameStr == "global") return DecoratorKind.GLOBAL;

break;

}

case CharCode.i: {

if (nameStr == "inline") return DecoratorKind.INLINE;

break;

}

case CharCode.l: {

if (nameStr == "lazy") return DecoratorKind.LAZY;

break;

}

case CharCode.o: {

if (nameStr == "operator") return DecoratorKind.OPERATOR;

break;

}

case CharCode.u: {

if (nameStr == "unmanaged") return DecoratorKind.UNMANAGED;

if (nameStr == "unsafe") return DecoratorKind.UNSAFE;

break;

}

}

} else if (nameNode.kind == NodeKind.PROPERTYACCESS) {

let propertyAccessNode = <PropertyAccessExpression>nameNode;

let expression = propertyAccessNode.expression;

if (expression.kind == NodeKind.IDENTIFIER) {

let nameStr = (<IdentifierExpression>expression).text;

assert(nameStr.length);

let propStr = propertyAccessNode.property.text;

assert(propStr.length);

if (nameStr == "operator") {