/**

* Abstract syntax tree representing a source file once parsed.

* @module ast

*//***/

import {

CommonFlags,

CommonSymbols,

PATH_DELIMITER,

LIBRARY_PREFIX,

LIBRARY_SUBST

} 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

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,

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:

case NodeKind.SUPER: 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;

// types

static createTypeName(

name: IdentifierExpression,

range: Range

): TypeName {

var typeName = new TypeName();

typeName.range = range;

typeName.identifier = name;

typeName.next = null;

return typeName;

}

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 type = new NamedTypeNode();

type.range = range;

type.name = name;

type.typeArguments = typeArguments;

type.isNullable = isNullable;

return type;

}

static createFunctionType(

parameters: ParameterNode[],

returnType: TypeNode,

explicitThisType: NamedTypeNode | null,

isNullable: bool,

range: Range

): FunctionTypeNode {

var type = new FunctionTypeNode();

type.range = range;

type.parameters = parameters;

type.returnType = returnType;

type.explicitThisType = explicitThisType;

type.isNullable = isNullable;

return type;

}

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 elem = new TypeParameterNode();

elem.range = range;

elem.name = name;

elem.extendsType = extendsType;

elem.defaultType = defaultType;

return elem;

}

static createParameter(

name: IdentifierExpression,

type: TypeNode,

initializer: Expression | null,

kind: ParameterKind,

range: Range

): ParameterNode {

var elem = new ParameterNode();

elem.range = range;

elem.name = name;

elem.type = type;

elem.initializer = initializer;

elem.parameterKind = kind;

return elem;

}

// special

static createDecorator(

name: Expression,

args: Expression[] | null,

range: Range

): DecoratorNode {

var stmt = new DecoratorNode();

stmt.range = range;

stmt.name = name;

stmt.arguments = args;

stmt.decoratorKind = DecoratorKind.fromNode(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,

isQuoted: bool = false

): IdentifierExpression {

var expr = new IdentifierExpression();

expr.range = range;

expr.text = name; // TODO: extract from range

expr.symbol = name; // TODO: Symbol.for(name)

expr.isQuoted = isQuoted;

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;

return expr;

}

static createAssertionExpression(

assertionKind: AssertionKind,

expression: Expression,

toType: TypeNode | null,

range: Range

): AssertionExpression {

var expr = new AssertionExpression();

expr.range = range;

expr.assertionKind = assertionKind;

expr.expression = expression;

expr.toType = toType;

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;

expr.right = right;

return expr;

}

static createCallExpression(

expression: Expression,

typeArgs: TypeNode[] | null,

args: Expression[],

range: Range

): CallExpression {

var expr = new CallExpression();

expr.range = range;

expr.expression = expression;

expr.typeArguments = typeArgs;

expr.arguments = args;

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;

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;

expr.elementExpression = element;

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.range = declaration.range;

expr.declaration = declaration;

return expr;

}

static createInstanceOfExpression(

expression: Expression,

isType: TypeNode,

range: Range

): InstanceOfExpression {

var expr = new InstanceOfExpression();

expr.range = range;

expr.expression = expression;

expr.isType = isType;

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

args: Expression[],

range: Range

): NewExpression {

var expr = new NewExpression();

expr.range = range;

expr.expression = expression;

expr.typeArguments = typeArgs;

expr.arguments = args;

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;

return expr;

}

static createPropertyAccessExpression(

expression: Expression,

property: IdentifierExpression,

range: Range

): PropertyAccessExpression {

var expr = new PropertyAccessExpression();

expr.range = range;

expr.expression = expression;

expr.property = property;

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;

expr.ifThen = ifThen;

expr.ifElse = ifElse;

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;

return expr;

}

static createUnaryPrefixExpression(

operator: Token,

operand: Expression,

range: Range

): UnaryPrefixExpression {

var expr = new UnaryPrefixExpression();

expr.range = range;

expr.operator = operator;

expr.operand = operand;

return expr;

}

// statements

static createBlockStatement(

statements: Statement[],

range: Range

): BlockStatement {

var stmt = new BlockStatement();

stmt.range = range;

stmt.statements = statements;

return stmt;

}

static createBreakStatement(

label: IdentifierExpression | null,

range: Range

): BreakStatement {

var stmt = new BreakStatement();

stmt.range = range;

stmt.label = label;

return stmt;

}

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 stmt = new ClassDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = identifier;

stmt.typeParameters = typeParameters;

stmt.extendsType = extendsType;

stmt.implementsTypes = implementsTypes;

stmt.members = members;

stmt.decorators = decorators;

return stmt;

}

static createContinueStatement(

label: IdentifierExpression | null,

range: Range

): ContinueStatement {

var stmt = new ContinueStatement();

stmt.range = range;

stmt.label = label;

return stmt;

}

static createDoStatement(

statement: Statement,

condition: Expression,

range: Range

): DoStatement {

var stmt = new DoStatement();

stmt.range = range;

stmt.statement = statement;

stmt.condition = condition;

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;

stmt.values = members;

stmt.decorators = decorators;

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;

stmt.value = value;

return stmt;

}

static createExportStatement(

members: ExportMember[] | null,

path: StringLiteralExpression | null,

isDeclare: bool,

range: Range

): ExportStatement {

var stmt = new ExportStatement();

stmt.range = range;

stmt.members = members;

stmt.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;

}

stmt.internalPath = mangleInternalPath(normalizedPath);

} else {

stmt.internalPath = null;

}

stmt.isDeclare = isDeclare;

return stmt;

}

static createExportDefaultStatement(

declaration: DeclarationStatement,

range: Range

): ExportDefaultStatement {

var stmt = new ExportDefaultStatement();

stmt.declaration = declaration;

stmt.range = range;

return stmt;

}

static createExportImportStatement(

name: IdentifierExpression,

externalName: IdentifierExpression,

range: Range

): ExportImportStatement {

var stmt = new ExportImportStatement();

stmt.range = range;

stmt.name = name;

stmt.externalName = externalName;

return stmt;

}

static createExportMember(

name: IdentifierExpression,

externalName: IdentifierExpression | null,

range: Range

): ExportMember {

var elem = new ExportMember();

elem.range = range;

elem.localName = name;

if (!externalName) externalName = name;

elem.exportedName = externalName;

return elem;

}

static createExpressionStatement(

expression: Expression

): ExpressionStatement {

var stmt = new ExpressionStatement();

stmt.range = expression.range;

stmt.expression = expression;

return stmt;

}

static createIfStatement(

condition: Expression,

ifTrue: Statement,

ifFalse: Statement | null,

range: Range

): IfStatement {

var stmt = new IfStatement();

stmt.range = range;

stmt.condition = condition;

stmt.ifTrue = ifTrue;

stmt.ifFalse = ifFalse;

return stmt;

}

static createImportStatement(

decls: ImportDeclaration[] | null,

path: StringLiteralExpression,

range: Range

): ImportStatement {

var stmt = new ImportStatement();

stmt.range = range;

stmt.declarations = decls;

stmt.namespaceName = null;

stmt.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;

}

stmt.internalPath = mangleInternalPath(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;

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;

}

stmt.internalPath = mangleInternalPath(normalizedPath);

return stmt;

}

static createImportDeclaration(

foreignName: IdentifierExpression,

name: IdentifierExpression | null,

range: Range

): ImportDeclaration {

var elem = new ImportDeclaration();

elem.range = range;

elem.foreignName = foreignName;

if (!name) name = foreignName;

elem.name = name;

return elem;

}

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 stmt = new InterfaceDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name;

stmt.typeParameters = typeParameters;

stmt.extendsType = extendsType;

stmt.members = members;

stmt.decorators = decorators;

return stmt;

}

static createFieldDeclaration(

name: IdentifierExpression,

type: TypeNode | 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;

stmt.type = type;

stmt.initializer = initializer;

stmt.decorators = decorators;

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;

stmt.condition = condition;

stmt.incrementor = incrementor;

stmt.statement = statement;

return stmt;

}

static createFunctionDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

arrowKind: ArrowKind,

range: Range

): FunctionDeclaration {

var stmt = new FunctionDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name;

stmt.typeParameters = typeParameters;

stmt.signature = signature;

stmt.body = body;

stmt.decorators = decorators;

stmt.arrowKind = arrowKind;

return stmt;

}

static createIndexSignatureDeclaration(

keyType: NamedTypeNode,

valueType: TypeNode,

range: Range

): IndexSignatureDeclaration {

var elem = new IndexSignatureDeclaration();

elem.range = range;

elem.keyType = keyType;

elem.valueType = valueType;

return elem;

}

static createMethodDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

signature: FunctionTypeNode,

body: Statement | null,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range

): MethodDeclaration {

var stmt = new MethodDeclaration();

stmt.range = range;

stmt.flags = flags;

stmt.name = name;

stmt.typeParameters = typeParameters;

stmt.signature = signature;

stmt.body = body;

stmt.decorators = decorators;

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;

stmt.members = members;

stmt.decorators = decorators;

return stmt;

}

static createReturnStatement(

value: Expression | null,

range: Range

): ReturnStatement {

var stmt = new ReturnStatement();

stmt.range = range;

stmt.value = value;

return stmt;

}

static createSwitchStatement(

condition: Expression,

cases: SwitchCase[],

range: Range

): SwitchStatement {

var stmt = new SwitchStatement();

stmt.range = range;

stmt.condition = condition;

stmt.cases = cases;

return stmt;

}

static createSwitchCase(

label: Expression | null,

statements: Statement[],

range: Range

): SwitchCase {

var elem = new SwitchCase();

elem.range = range;

elem.label = label;

elem.statements = statements;

return elem;

}

static createThrowStatement(

value: Expression,

range: Range

): ThrowStatement {

var stmt = new ThrowStatement();

stmt.range = range;

stmt.value = value;

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;

stmt.catchVariable = catchVariable;

stmt.catchStatements = catchStatements;

stmt.finallyStatements = finallyStatements;

return stmt;

}

static createTypeDeclaration(

name: IdentifierExpression,

typeParameters: TypeParameterNode[] | null,

alias: TypeNode,

decorators: DecoratorNode[] | null,

flags: CommonFlags,

range: Range