/**

* Abstract syntax tree representing a source file once parsed.

* @module ast

*//***/

import {

CommonFlags,

PATH_DELIMITER,

STATIC_DELIMITER,

INSTANCE_DELIMITER,

LIBRARY_PREFIX

} from "./common";

import {

Token,

Tokenizer,

Range

} from "./tokenizer";

import {

normalizePath,

resolvePath,

CharCode

} from "./util";

export { Token, Range };

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

export enum NodeKind {

SOURCE,

// types

TYPE,

TYPEPARAMETER,

PARAMETER,

SIGNATURE,

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

EXPORTIMPORT,

EXPRESSION,

FOR,

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

}

/** Checks if a node represents a constant value. */

export function nodeIsConstantValue(kind: NodeKind): bool {

switch (kind) {

case NodeKind.LITERAL:

case NodeKind.NULL:

case NodeKind.TRUE:

case NodeKind.FALSE: return true;

}

return false;

}

/** Checks if a node might be callable. */

export function nodeIsCallable(kind: NodeKind): bool {

switch (kind) {

case NodeKind.IDENTIFIER:

case NodeKind.ASSERTION: // if kind=NONNULL

case NodeKind.CALL:

case NodeKind.ELEMENTACCESS:

case NodeKind.PARENTHESIZED:

case NodeKind.PROPERTYACCESS: return true;

}

return false;

}

/** Checks if a node might be callable with generic arguments. */

export function nodeIsGenericCallable(kind: NodeKind): bool {

switch (kind) {

case NodeKind.IDENTIFIER:

case NodeKind.PROPERTYACCESS: return true;

}

return false;

}

/** Base class of all nodes. */

export abstract class Node {

/** Node kind indicator. */

kind: NodeKind;

/** Source range. */

range: Range;

/** Parent node. */

parent: Node | 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; }

// types

static createType(

name: IdentifierExpression,

typeArguments: CommonTypeNode[] | null,

isNullable: bool,

range: Range

): TypeNode {

var type = new TypeNode();

type.range = range;

type.name = name; name.parent = type;

type.typeArguments = typeArguments; if (typeArguments) setParent(typeArguments, type);

type.isNullable = isNullable;

return type;

}

static createOmittedType(

range: Range

): TypeNode {

return Node.createType(

Node.createIdentifierExpression("", range),

null,

false,

range

);

}

static createTypeParameter(

name: IdentifierExpression,

extendsType: TypeNode | null,

defaultType: TypeNode | null,

range: Range

): TypeParameterNode {

var elem = new TypeParameterNode();

elem.range = range;

elem.name = name; name.parent = elem;

elem.extendsType = extendsType; if (extendsType) extendsType.parent = elem;

elem.defaultType = defaultType; if (defaultType) defaultType.parent = elem;

return elem;

}

static createParameter(

name: IdentifierExpression,

type: CommonTypeNode,

initializer: Expression | null,

kind: ParameterKind,

range: Range

): ParameterNode {

var elem = new ParameterNode();

elem.range = range;

elem.name = name; name.parent = elem;

elem.type = type; if (type) type.parent = elem;

elem.initializer = initializer; if (initializer) initializer.parent = elem;

elem.parameterKind = kind;

return elem;

}

static createSignature(

parameters: ParameterNode[],

returnType: CommonTypeNode,

explicitThisType: TypeNode | null,

isNullable: bool,

range: Range

): SignatureNode {

var sig = new SignatureNode();

sig.range = range;

sig.parameters = parameters; setParent(parameters, sig);

sig.returnType = returnType; returnType.parent = sig;

sig.explicitThisType = explicitThisType; if (explicitThisType) explicitThisType.parent = sig;

sig.isNullable = isNullable;

return sig;

}

// special

static createDecorator(

name: Expression,

args: Expression[] | null,

range: Range

): DecoratorNode {

var stmt = new DecoratorNode();

stmt.range = range;

stmt.name = name; name.parent = stmt;

stmt.arguments = args; if (args) setParent(args, stmt);

stmt.decoratorKind = decoratorNameToKind(name);

return stmt;

}

static createComment(

text: string,

kind: CommentKind,

range: Range

): CommentNode {

var node = new CommentNode();

node.range = range;

node.commentKind = kind;

node.text = text;

return node;

}

// expressions

static createIdentifierExpression(

name: string,

range: Range

): IdentifierExpression {

var expr = new IdentifierExpression();

expr.range = range;

expr.text = name;

return expr;

}

static createEmptyIdentifierExpression(

range: Range

): IdentifierExpression {

var expr = new IdentifierExpression();

expr.range = range;

expr.text = "";

return expr;

}

static createArrayLiteralExpression(

elements: (Expression | null)[],

range: Range

): ArrayLiteralExpression {

var expr = new ArrayLiteralExpression();

expr.range = range;

expr.elementExpressions = elements; setParentIfNotNull(elements, expr);

return expr;

}

static createAssertionExpression(

assertionKind: AssertionKind,

expression: Expression,

toType: CommonTypeNode | null,

range: Range

): AssertionExpression {

var expr = new AssertionExpression();

expr.range = range;

expr.assertionKind = assertionKind;

expr.expression = expression; expression.parent = expr;

expr.toType = toType; if (toType) toType.parent = expr;

return expr;

}

static createBinaryExpression(

operator: Token,

left: Expression,

right: Expression,

range: Range

): BinaryExpression {

var expr = new BinaryExpression();

expr.range = range;

expr.operator = operator;

expr.left = left; left.parent = expr;

expr.right = right; right.parent = expr;

return expr;

}

static createCallExpression(

expression: Expression,

typeArgs: CommonTypeNode[] | null,

args: Expression[],

range: Range

): CallExpression {

var expr = new CallExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

expr.typeArguments = typeArgs; if (typeArgs) setParent(typeArgs, expr);

expr.arguments = args; setParent(args, expr);

return expr;

}

static createClassExpression(

declaration: ClassDeclaration

): ClassExpression {

var expr = new ClassExpression();

expr.range = declaration.range;

expr.declaration = declaration;

return expr;

}

static createCommaExpression(

expressions: Expression[],

range: Range

): CommaExpression {

var expr = new CommaExpression();

expr.range = range;

expr.expressions = expressions; setParent(expressions, expr);

return expr;

}

static createConstructorExpression(

range: Range

): ConstructorExpression {

var expr = new ConstructorExpression();

expr.range = range;

return expr;

}

static createElementAccessExpression(

expression: Expression,

element: Expression,

range: Range

): ElementAccessExpression {

var expr = new ElementAccessExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

expr.elementExpression = element; element.parent = expr;

return expr;

}

static createFalseExpression(

range: Range

): FalseExpression {

var expr = new FalseExpression();

expr.range = range;

return expr;

}

static createFloatLiteralExpression(

value: f64,

range: Range

): FloatLiteralExpression {

var expr = new FloatLiteralExpression();

expr.range = range;

expr.value = value;

return expr;

}

static createFunctionExpression(

declaration: FunctionDeclaration

): FunctionExpression {

var expr = new FunctionExpression();

expr.flags = declaration.flags & CommonFlags.ARROW;

expr.range = declaration.range;

expr.declaration = declaration;

return expr;

}

static createInstanceOfExpression(

expression: Expression,

isType: CommonTypeNode,

range: Range

): InstanceOfExpression {

var expr = new InstanceOfExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

expr.isType = isType; isType.parent = expr;

return expr;

}

static createIntegerLiteralExpression(

value: I64,

range: Range

): IntegerLiteralExpression {

var expr = new IntegerLiteralExpression();

expr.range = range;

expr.value = value;

return expr;

}

static createNewExpression(

expression: Expression,

typeArgs: CommonTypeNode[] | null,

args: Expression[],

range: Range

): NewExpression {

var expr = new NewExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

expr.typeArguments = typeArgs; if (typeArgs) setParent(typeArgs, expr);

expr.arguments = args; setParent(args, expr);

return expr;

}

static createNullExpression(

range: Range

): NullExpression {

var expr = new NullExpression();

expr.range = range;

return expr;

}

static createObjectLiteralExpression(

names: IdentifierExpression[],

values: Expression[],

range: Range

): ObjectLiteralExpression {

var expr = new ObjectLiteralExpression();

expr.range = range;

expr.names = names;

expr.values = values;

return expr;

}

static createParenthesizedExpression(

expression: Expression,

range: Range

): ParenthesizedExpression {

var expr = new ParenthesizedExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

return expr;

}

static createPropertyAccessExpression(

expression: Expression,

property: IdentifierExpression,

range: Range

): PropertyAccessExpression {

var expr = new PropertyAccessExpression();

expr.range = range;

expr.expression = expression; expression.parent = expr;

expr.property = property; property.parent = expr;

return expr;

}

static createRegexpLiteralExpression(

pattern: string,

flags: string,

range: Range

): RegexpLiteralExpression {

var expr = new RegexpLiteralExpression();

expr.range = range;

expr.pattern = pattern;

expr.patternFlags = flags;

return expr;

}

static createTernaryExpression(

condition: Expression,

ifThen: Expression,

ifElse: Expression,

range: Range

): TernaryExpression {

var expr = new TernaryExpression();

expr.range = range;

expr.condition = condition; condition.parent = expr;

expr.ifThen = ifThen; ifThen.parent = expr;

expr.ifElse = ifElse; ifElse.parent = expr;

return expr;

}

static createStringLiteralExpression(

value: string,

range: Range

): StringLiteralExpression {

var expr = new StringLiteralExpression();

expr.range = range;

expr.value = value;

return expr;

}

static createSuperExpression(

range: Range

): SuperExpression {

var expr = new SuperExpression();

expr.range = range;

return expr;

}

static createThisExpression(

range: Range

): ThisExpression {

var expr = new ThisExpression();

expr.range = range;

return expr;

}

static createTrueExpression(

range: Range

): TrueExpression {

var expr = new TrueExpression();

expr.range = range;

return expr;

}

static createUnaryPostfixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPostfixExpression {

var expr = new UnaryPostfixExpression();

expr.range = range;

expr.operator = operator;

expr.operand = operand; operand.parent = expr;

return expr;

}

static createUnaryPrefixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPrefixExpression {

var expr = new UnaryPrefixExpression();

expr.range = range;

expr.operator = operator;

expr.operand = operand; operand.parent = expr;

return expr;

}

// statements

static createBlockStatement(

statements: Statement[],

range: Range

): BlockStatement {

var stmt = new BlockStatement();

stmt.range = range;

stmt.statements = statements; setParent(statements, stmt);

return stmt;

}

static createBreakStatement(

label: IdentifierExpression | null,

range: Range

): BreakStatement {

var stmt = new BreakStatement();

stmt.range = range;

stmt.label = label; if (label) label.parent = stmt;

return stmt;

}

static createClassDeclaration(

identifier: IdentifierExpression,

typeParameters: TypeParameterNode[],

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

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

members: DeclarationStatement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): ClassDeclaration {

var stmt = new ClassDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = identifier; identifier.parent = stmt;

stmt.typeParameters = typeParameters; setParent(typeParameters, stmt);

stmt.extendsType = extendsType; if (extendsType) extendsType.parent = stmt;

stmt.implementsTypes = implementsTypes; if (implementsTypes) setParent(implementsTypes, stmt);

stmt.members = members; setParent(members, stmt);

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createContinueStatement(

label: IdentifierExpression | null,

range: Range

): ContinueStatement {

var stmt = new ContinueStatement();

stmt.range = range;

stmt.label = label; if (label) label.parent = stmt;

return stmt;

}

static createDoStatement(

statement: Statement,

condition: Expression,

range: Range

): DoStatement {

var stmt = new DoStatement();

stmt.range = range;

stmt.statement = statement; statement.parent = stmt;

stmt.condition = condition; condition.parent = stmt;

return stmt;

}

static createEmptyStatement(

range: Range

): EmptyStatement {

var stmt = new EmptyStatement();

stmt.range = range;

return stmt;

}

static createEnumDeclaration(

name: IdentifierExpression,

members: EnumValueDeclaration[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): EnumDeclaration {

var stmt = new EnumDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.values = members; setParent(members, stmt);

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createEnumValueDeclaration(

name: IdentifierExpression,

value: Expression | null,

flags: CommonFlags,

range: Range

): EnumValueDeclaration {

var stmt = new EnumValueDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.value = value; if (value) value.parent = stmt;

return stmt;

}

static createExportStatement(

members: ExportMember[] | null,

path: StringLiteralExpression | null,

flags: CommonFlags,

range: Range

): ExportStatement {

var stmt = new ExportStatement();

stmt.range = range;

stmt.flags = flags;

stmt.members = members; if (members) setParent(members, stmt);

stmt.path = path;

if (path) {

let normalizedPath = normalizePath(path.value);

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

stmt.normalizedPath = resolvePath(

normalizedPath,

range.source.normalizedPath

);

} else { // absolute

stmt.normalizedPath = normalizedPath;

}

stmt.internalPath = mangleInternalPath(stmt.normalizedPath);

} else {

stmt.normalizedPath = null;

stmt.internalPath = null;

}

return stmt;

}

static createExportImportStatement(

name: IdentifierExpression,

externalName: IdentifierExpression,

range: Range

): ExportImportStatement {

var stmt = new ExportImportStatement();

stmt.range = range;

stmt.name = name; name.parent = stmt;

stmt.externalName = externalName; externalName.parent = stmt;

return stmt;

}

static createExportMember(

name: IdentifierExpression,

externalName: IdentifierExpression | null,

range: Range

): ExportMember {

var elem = new ExportMember();

elem.range = range;

elem.name = name; name.parent = elem;

if (!externalName) {

externalName = name;

} else {

externalName.parent = elem;

}

elem.externalName = externalName;

return elem;

}

static createExpressionStatement(

expression: Expression

): ExpressionStatement {

var stmt = new ExpressionStatement();

stmt.range = expression.range;

stmt.expression = expression; expression.parent = stmt;

return stmt;

}

static createIfStatement(

condition: Expression,

ifTrue: Statement,

ifFalse: Statement | null,

range: Range

): IfStatement {

var stmt = new IfStatement();

stmt.range = range;

stmt.condition = condition; condition.parent = stmt;

stmt.ifTrue = ifTrue; ifTrue.parent = stmt;

stmt.ifFalse = ifFalse; if (ifFalse) ifFalse.parent = stmt;

return stmt;

}

static createImportStatement(

decls: ImportDeclaration[] | null,

path: StringLiteralExpression,

range: Range

): ImportStatement {

var stmt = new ImportStatement();

stmt.range = range;

stmt.declarations = decls; if (decls) setParent(decls, stmt);

stmt.namespaceName = null;

stmt.path = path;

var normalizedPath = normalizePath(path.value);

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

stmt.normalizedPath = resolvePath(

normalizedPath,

range.source.normalizedPath

);

} else { // absolute in library

if (!normalizedPath.startsWith(LIBRARY_PREFIX)) {

normalizedPath = LIBRARY_PREFIX + normalizedPath;

}

stmt.normalizedPath = normalizedPath;

}

stmt.internalPath = mangleInternalPath(stmt.normalizedPath);

return stmt;

}

static createImportStatementWithWildcard(

identifier: IdentifierExpression,

path: StringLiteralExpression,

range: Range

): ImportStatement {

var stmt = new ImportStatement();

stmt.range = range;

stmt.declarations = null;

stmt.namespaceName = identifier;

stmt.path = path;

stmt.normalizedPath = resolvePath(

normalizePath(path.value),

range.source.normalizedPath

);

stmt.internalPath = mangleInternalPath(stmt.normalizedPath);

return stmt;

}

static createImportDeclaration(

externalName: IdentifierExpression,

name: IdentifierExpression | null,

range: Range

): ImportDeclaration {

var elem = new ImportDeclaration();

elem.range = range;

elem.externalName = externalName; externalName.parent = elem;

if (!name) {

name = externalName;

} else {

name.parent = elem;

}

elem.name = name;

return elem;

}

static createInterfaceDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[],

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

members: DeclarationStatement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): InterfaceDeclaration {

var stmt = new InterfaceDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.typeParameters = typeParameters; if (typeParameters) setParent(typeParameters, stmt);

stmt.extendsType = extendsType; if (extendsType) extendsType.parent = stmt;

stmt.members = members; setParent(members, stmt);

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createFieldDeclaration(

name: IdentifierExpression,

type: CommonTypeNode | null,

initializer: Expression | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): FieldDeclaration {

var stmt = new FieldDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.type = type; if (type) type.parent = stmt;

stmt.initializer = initializer; if (initializer) initializer.parent = stmt;

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createForStatement(

initializer: Statement | null,

condition: Expression | null,

incrementor: Expression | null,

statement: Statement,

range: Range

): ForStatement {

var stmt = new ForStatement();

stmt.range = range;

stmt.initializer = initializer; if (initializer) initializer.parent = stmt;

stmt.condition = condition; if (condition) condition.parent = stmt;

stmt.incrementor = incrementor; if (incrementor) incrementor.parent = stmt;

stmt.statement = statement; statement.parent = stmt;

return stmt;

}

static createFunctionDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: SignatureNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): FunctionDeclaration {

var stmt = new FunctionDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.typeParameters = typeParameters; if (typeParameters) setParent(typeParameters, stmt);

stmt.signature = signature; signature.parent = stmt;

stmt.body = body; if (body) body.parent = stmt;

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createIndexSignatureDeclaration(

keyType: TypeNode,

valueType: CommonTypeNode,

range: Range

): IndexSignatureDeclaration {

var elem = new IndexSignatureDeclaration();

elem.range = range;

elem.keyType = keyType; keyType.parent = elem;

elem.valueType = valueType; valueType.parent = elem;

return elem;

}

static createMethodDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: SignatureNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): MethodDeclaration {

var stmt = new MethodDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.typeParameters = typeParameters; if (typeParameters) setParent(typeParameters, stmt);

stmt.signature = signature; signature.parent = stmt;

stmt.body = body; if (body) body.parent = stmt;

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createNamespaceDeclaration(

name: IdentifierExpression,

members: Statement[],

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): NamespaceDeclaration {

var stmt = new NamespaceDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;

stmt.members = members; setParent(members, stmt);

stmt.decorators = decorators; if (decorators) setParent(decorators, stmt);

return stmt;

}

static createReturnStatement(

value: Expression | null,

range: Range

): ReturnStatement {

var stmt = new ReturnStatement();

stmt.range = range;

stmt.value = value; if (value) value.parent = stmt;

return stmt;

}

static createSwitchStatement(

condition: Expression,

cases: SwitchCase[],

range: Range

): SwitchStatement {

var stmt = new SwitchStatement();

stmt.range = range;

stmt.condition = condition; condition.parent = stmt;

stmt.cases = cases; setParent(cases, stmt);

return stmt;

}

static createSwitchCase(

label: Expression | null,

statements: Statement[],

range: Range

): SwitchCase {

var elem = new SwitchCase();

elem.range = range;

elem.label = label; if (label) label.parent = elem;

elem.statements = statements; setParent(statements, elem);

return elem;

}

static createThrowStatement(

value: Expression,

range: Range

): ThrowStatement {

var stmt = new ThrowStatement();

stmt.range = range;

stmt.value = value; value.parent = stmt;

return stmt;

}

static createTryStatement(

statements: Statement[],

catchVariable: IdentifierExpression | null,

catchStatements: Statement[] | null,

finallyStatements: Statement[] | null,

range: Range

): TryStatement {

var stmt = new TryStatement();

stmt.range = range;

stmt.statements = statements; setParent(statements, stmt);

stmt.catchVariable = catchVariable;

if (catchVariable) catchVariable.parent = stmt;

stmt.catchStatements = catchStatements;

if (catchStatements) setParent(catchStatements, stmt);

stmt.finallyStatements = finallyStatements;

if (finallyStatements) setParent(finallyStatements, stmt);

return stmt;

}

static createTypeDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

alias: CommonTypeNode,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): TypeDeclaration {

var stmt = new TypeDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name; name.parent = stmt;