/**

* AssemblyScript's intermediate representation describing a program's elements.

* @module program

*//***/

import {

CommonFlags,

PATH_DELIMITER,

STATIC_DELIMITER,

INSTANCE_DELIMITER,

LIBRARY_PREFIX,

GETTER_PREFIX,

SETTER_PREFIX,

FILESPACE_PREFIX

} from "./common";

import {

Options,

Feature

} from "./compiler";

import {

DiagnosticCode,

DiagnosticMessage,

DiagnosticEmitter

} from "./diagnostics";

import {

Type,

TypeKind,

TypeFlags,

Signature

} from "./types";

import {

Node,

NodeKind,

Source,

Range,

CommonTypeNode,

TypeParameterNode,

DecoratorNode,

DecoratorKind,

Expression,

IdentifierExpression,

LiteralExpression,

LiteralKind,

StringLiteralExpression,

ClassDeclaration,

DeclarationStatement,

EnumDeclaration,

EnumValueDeclaration,

ExportMember,

ExportStatement,

FieldDeclaration,

FunctionDeclaration,

ImportDeclaration,

ImportStatement,

InterfaceDeclaration,

MethodDeclaration,

NamespaceDeclaration,

TypeDeclaration,

VariableDeclaration,

VariableLikeDeclarationStatement,

VariableStatement,

decoratorNameToKind,

findDecorator

} from "./ast";

import {

Module,

NativeType,

FunctionRef,

ExpressionRef,

ExpressionId,

BinaryOp,

UnaryOp,

getExpressionId,

getGetLocalIndex,

isTeeLocal,

getSetLocalValue,

getBinaryOp,

getConstValueI32,

getBinaryLeft,

getBinaryRight,

getUnaryOp,

getExpressionType,

getLoadBytes,

isLoadSigned,

getIfTrue,

getIfFalse,

getSelectThen,

getSelectElse,

getCallTarget,

getBlockChildCount,

getBlockChild,

getBlockName,

getConstValueF32,

getConstValueF64,

getConstValueI64Low,

getGetGlobalName

} from "./module";

import {

CharCode,

bitsetIs,

bitsetSet

} from "./util";

import {

Resolver

} from "./resolver";

/** Represents a yet unresolved import. */

class QueuedImport {

localName: string;

externalName: string;

externalNameAlt: string;

declaration: ImportDeclaration | null; // not set if a filespace

}

/** Represents a yet unresolved export. */

class QueuedExport {

externalName: string;

isReExport: bool;

member: ExportMember;

}

/** Represents a type alias. */

class TypeAlias {

typeParameters: TypeParameterNode[] | null;

type: CommonTypeNode;

}

/** Represents a module-level export. */

class ModuleExport {

element: Element;

identifier: IdentifierExpression;

}

/** Represents the kind of an operator overload. */

export enum OperatorKind {

INVALID,

// indexed access

INDEXED_GET, // a[]

INDEXED_SET, // a[]=b

UNCHECKED_INDEXED_GET, // unchecked(a[])

UNCHECKED_INDEXED_SET, // unchecked(a[]=b)

// binary

ADD, // a + b

SUB, // a - b

MUL, // a * b

DIV, // a / b

REM, // a % b

POW, // a ** b

BITWISE_AND, // a & b

BITWISE_OR, // a | b

BITWISE_XOR, // a ^ b

BITWISE_SHL, // a << b

BITWISE_SHR, // a >> b

BITWISE_SHR_U, // a >>> b

EQ, // a == b

NE, // a != b

GT, // a > b

GE, // a >= b

LT, // a < b

LE, // a <= b

// unary prefix

PLUS, // +a

MINUS, // -a

NOT, // !a

BITWISE_NOT, // ~a

PREFIX_INC, // ++a

PREFIX_DEC, // --a

// unary postfix

POSTFIX_INC, // a++

POSTFIX_DEC // a--

// not overridable:

// IDENTITY // a === b

// LOGICAL_AND // a && b

// LOGICAL_OR // a || b

}

/** Returns the operator kind represented by the specified decorator and string argument. */

function operatorKindFromDecorator(decoratorKind: DecoratorKind, arg: string): OperatorKind {

assert(arg.length);

switch (decoratorKind) {

case DecoratorKind.OPERATOR:

case DecoratorKind.OPERATOR_BINARY: {

switch (arg.charCodeAt(0)) {

case CharCode.OPENBRACKET: {

if (arg == "[]") return OperatorKind.INDEXED_GET;

if (arg == "[]=") return OperatorKind.INDEXED_SET;

break;

}

case CharCode.OPENBRACE: {

if (arg == "{}") return OperatorKind.UNCHECKED_INDEXED_GET;

if (arg == "{}=") return OperatorKind.UNCHECKED_INDEXED_SET;

break;

}

case CharCode.PLUS: {

if (arg == "+") return OperatorKind.ADD;

break;

}

case CharCode.MINUS: {

if (arg == "-") return OperatorKind.SUB;

break;

}

case CharCode.ASTERISK: {

if (arg == "*") return OperatorKind.MUL;

if (arg == "**") return OperatorKind.POW;

break;

}

case CharCode.SLASH: {

if (arg == "/") return OperatorKind.DIV;

break;

}

case CharCode.PERCENT: {

if (arg == "%") return OperatorKind.REM;

break;

}

case CharCode.AMPERSAND: {

if (arg == "&") return OperatorKind.BITWISE_AND;

break;

}

case CharCode.BAR: {

if (arg == "|") return OperatorKind.BITWISE_OR;

break;

}

case CharCode.CARET: {

if (arg == "^") return OperatorKind.BITWISE_XOR;

break;

}

case CharCode.EQUALS: {

if (arg == "==") return OperatorKind.EQ;

break;

}

case CharCode.EXCLAMATION: {

if (arg == "!=") return OperatorKind.NE;

break;

}

case CharCode.GREATERTHAN: {

if (arg == ">") return OperatorKind.GT;

if (arg == ">=") return OperatorKind.GE;

if (arg == ">>") return OperatorKind.BITWISE_SHR;

if (arg == ">>>") return OperatorKind.BITWISE_SHR_U;

break;

}

case CharCode.LESSTHAN: {

if (arg == "<") return OperatorKind.LT;

if (arg == "<=") return OperatorKind.LE;

if (arg == "<<") return OperatorKind.BITWISE_SHL;

break;

}

}

break;

}

case DecoratorKind.OPERATOR_PREFIX: {

switch (arg.charCodeAt(0)) {

case CharCode.PLUS: {

if (arg == "+") return OperatorKind.PLUS;

if (arg == "++") return OperatorKind.PREFIX_INC;

break;

}

case CharCode.MINUS: {

if (arg == "-") return OperatorKind.MINUS;

if (arg == "--") return OperatorKind.PREFIX_DEC;

break;

}

case CharCode.EXCLAMATION: {

if (arg == "!") return OperatorKind.NOT;

break;

}

case CharCode.TILDE: {

if (arg == "~") return OperatorKind.BITWISE_NOT;

break;

}

}

break;

}

case DecoratorKind.OPERATOR_POSTFIX: {

switch (arg.charCodeAt(0)) {

case CharCode.PLUS: {

if (arg == "++") return OperatorKind.POSTFIX_INC;

break;

}

case CharCode.MINUS: {

if (arg == "--") return OperatorKind.POSTFIX_DEC;

break;

}

}

break;

}

}

return OperatorKind.INVALID;

}

const noTypesYet = new Map<string,Type>();

/** Represents an AssemblyScript program. */

export class Program extends DiagnosticEmitter {

/** Array of source files. */

sources: Source[];

/** Resolver instance. */

resolver: Resolver;

/** Diagnostic offset used where successively obtaining the next diagnostic. */

diagnosticsOffset: i32 = 0;

/** Compiler options. */

options: Options;

/** Elements by internal name. */

elementsLookup: Map<string,Element> = new Map();

/** Class and function instances by internal name. */

instancesLookup: Map<string,Element> = new Map();

/** Types by internal name. */

typesLookup: Map<string,Type> = noTypesYet;

/** Declared type aliases. */

typeAliases: Map<string,TypeAlias> = new Map();

/** File-level exports by exported name. */

fileLevelExports: Map<string,Element> = new Map();

/** Module-level exports by exported name. */

moduleLevelExports: Map<string,ModuleExport> = new Map();

/** Classes backing basic types like `i32`. */

basicClasses: Map<TypeKind,Class> = new Map();

/** ArrayBuffer instance reference. */

arrayBufferInstance: Class | null = null;

/** Array prototype reference. */

arrayPrototype: ClassPrototype | null = null;

/** String instance reference. */

stringInstance: Class | null = null;

/** Start function reference. */

startFunction: FunctionPrototype;

/** Main function reference, if present. */

mainFunction: FunctionPrototype | null = null;

/** Abort function reference, if present. */

abortInstance: Function | null = null;

/** Memory allocation function. */

memoryAllocateInstance: Function | null = null;

/** Whether a garbage collector is present or not. */

hasGC: bool = false;

/** Garbage collector allocation function. */

gcAllocateInstance: Function | null = null;

/** Garbage collector link function called when a managed object is referenced from a parent. */

gcLinkInstance: Function | null = null;

/** Garbage collector mark function called to on reachable managed objects. */

gcMarkInstance: Function | null = null;

/** Size of a managed object header. */

gcHeaderSize: u32 = 0;

/** Offset of the GC hook. */

gcHookOffset: u32 = 0;

/** Currently processing filespace. */

currentFilespace: Filespace;

/** Constructs a new program, optionally inheriting parser diagnostics. */

constructor(diagnostics: DiagnosticMessage[] | null = null) {

super(diagnostics);

this.resolver = new Resolver(this);

this.sources = [];

}

/** Gets a source by its exact path. */

getSource(normalizedPath: string): Source | null {

var sources = this.sources;

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

let source = sources[i];

if (source.normalizedPath == normalizedPath) return source;

}

return null;

}

/** Looks up the source for the specified possibly ambiguous path. */

lookupSourceByPath(normalizedPathWithoutExtension: string): Source | null {

var tmp: string;

return (

this.getSource(normalizedPathWithoutExtension + ".ts") ||

this.getSource(normalizedPathWithoutExtension + "/index.ts") ||

this.getSource((tmp = LIBRARY_PREFIX + normalizedPathWithoutExtension) + ".ts") ||

this.getSource( tmp + "/index.ts")

);

}

/** Initializes the program and its elements prior to compilation. */

initialize(options: Options): void {

this.options = options;

// add built-in types

this.typesLookup = new Map([

["i8", Type.i8],

["i16", Type.i16],

["i32", Type.i32],

["i64", Type.i64],

["isize", options.isizeType],

["u8", Type.u8],

["u16", Type.u16],

["u32", Type.u32],

["u64", Type.u64],

["usize", options.usizeType],

["bool", Type.bool],

["f32", Type.f32],

["f64", Type.f64],

["void", Type.void],

["number", Type.f64],

["boolean", Type.bool]

]);

// add compiler hints

this.setConstantInteger("ASC_TARGET", Type.i32,

i64_new(options.isWasm64 ? 2 : 1));

this.setConstantInteger("ASC_NO_TREESHAKING", Type.bool,

i64_new(options.noTreeShaking ? 1 : 0, 0));

this.setConstantInteger("ASC_NO_ASSERT", Type.bool,

i64_new(options.noAssert ? 1 : 0, 0));

this.setConstantInteger("ASC_MEMORY_BASE", Type.i32,

i64_new(options.memoryBase, 0));

this.setConstantInteger("ASC_OPTIMIZE_LEVEL", Type.i32,

i64_new(options.optimizeLevelHint, 0));

this.setConstantInteger("ASC_SHRINK_LEVEL", Type.i32,

i64_new(options.shrinkLevelHint, 0));

this.setConstantInteger("ASC_FEATURE_MUTABLE_GLOBAL", Type.bool,

i64_new(options.hasFeature(Feature.MUTABLE_GLOBAL) ? 1 : 0, 0));

this.setConstantInteger("ASC_FEATURE_SIGN_EXTENSION", Type.bool,

i64_new(options.hasFeature(Feature.SIGN_EXTENSION) ? 1 : 0, 0));

// remember deferred elements

var queuedImports = new Array<QueuedImport>();

var queuedExports = new Map<string,QueuedExport>();

var queuedExtends = new Array<ClassPrototype>();

var queuedImplements = new Array<ClassPrototype>();

// build initial lookup maps of internal names to declarations

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

let source = this.sources[i];

// create one filespace per source

let filespace = new Filespace(this, source);

this.elementsLookup.set(filespace.internalName, filespace);

this.currentFilespace = filespace;

// process this source's statements

let statements = source.statements;

for (let j = 0, l = statements.length; j < l; ++j) {

let statement = statements[j];

switch (statement.kind) {

case NodeKind.CLASSDECLARATION: {

this.initializeClass(<ClassDeclaration>statement, queuedExtends, queuedImplements);

break;

}

case NodeKind.ENUMDECLARATION: {

this.initializeEnum(<EnumDeclaration>statement);

break;

}

case NodeKind.EXPORT: {

this.initializeExports(<ExportStatement>statement, queuedExports);

break;

}

case NodeKind.FUNCTIONDECLARATION: {

this.initializeFunction(<FunctionDeclaration>statement);

break;

}

case NodeKind.IMPORT: {

this.initializeImports(<ImportStatement>statement, queuedExports, queuedImports);

break;

}

case NodeKind.INTERFACEDECLARATION: {

this.initializeInterface(<InterfaceDeclaration>statement);

break;

}

case NodeKind.NAMESPACEDECLARATION: {

this.initializeNamespace(<NamespaceDeclaration>statement, queuedExtends, queuedImplements);

break;

}

case NodeKind.TYPEDECLARATION: {

this.initializeTypeAlias(<TypeDeclaration>statement);

break;

}

case NodeKind.VARIABLE: {

this.initializeVariables(<VariableStatement>statement);

break;

}

}

}

}

// queued imports should be resolvable now through traversing exports and queued exports

for (let i = 0; i < queuedImports.length;) {

let queuedImport = queuedImports[i];

let declaration = queuedImport.declaration;

if (declaration) { // named

let element = this.tryLocateImport(queuedImport.externalName, queuedExports);

if (element) {

this.elementsLookup.set(queuedImport.localName, element);

queuedImports.splice(i, 1);

} else {

if (element = this.tryLocateImport(queuedImport.externalNameAlt, queuedExports)) {

this.elementsLookup.set(queuedImport.localName, element);

queuedImports.splice(i, 1);

} else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

declaration.range,

(<ImportStatement>declaration.parent).path.value,

declaration.externalName.text

);

++i;

}

}

} else { // filespace

let element = this.elementsLookup.get(queuedImport.externalName);

if (element) {

this.elementsLookup.set(queuedImport.localName, element);

queuedImports.splice(i, 1);

} else {

if (element = this.elementsLookup.get(queuedImport.externalNameAlt)) {

this.elementsLookup.set(queuedImport.localName, element);

queuedImports.splice(i, 1);

} else {

assert(false); // already reported by the parser not finding the file

++i;

}

}

}

}

// queued exports should be resolvable now that imports are finalized

for (let [exportName, queuedExport] of queuedExports) {

let currentExport: QueuedExport | null = queuedExport; // nullable below

let element: Element | null;

do {

if (currentExport.isReExport) {

if (element = this.fileLevelExports.get(currentExport.externalName)) {

this.setExportAndCheckLibrary(

exportName,

element,

queuedExport.member.externalName

);

break;

}

currentExport = queuedExports.get(currentExport.externalName);

if (!currentExport) {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

queuedExport.member.externalName.range,

(<StringLiteralExpression>(<ExportStatement>queuedExport.member.parent).path).value,

queuedExport.member.externalName.text

);

}

} else {

if (

// normal export

(element = this.elementsLookup.get(currentExport.externalName)) ||

// library re-export

(element = this.elementsLookup.get(currentExport.member.name.text))

) {

this.setExportAndCheckLibrary(

exportName,

element,

queuedExport.member.externalName

);

} else {

this.error(

DiagnosticCode.Cannot_find_name_0,

queuedExport.member.range, queuedExport.member.name.text

);

}

break;

}

} while (currentExport);

}

// resolve base prototypes of derived classes

var resolver = this.resolver;

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

let derivedPrototype = queuedExtends[i];

let derivedDeclaration = derivedPrototype.declaration;

let derivedType = assert(derivedDeclaration.extendsType);

let baseElement = resolver.resolveIdentifier(derivedType.name, null, null); // reports

if (!baseElement) continue;

if (baseElement.kind == ElementKind.CLASS_PROTOTYPE) {

let basePrototype = <ClassPrototype>baseElement;

derivedPrototype.basePrototype = basePrototype;

} else {

this.error(

DiagnosticCode.A_class_may_only_extend_another_class,

derivedType.range

);

}

}

// set up global aliases

{

let globalAliases = options.globalAliases;

if (globalAliases) {

for (let [alias, name] of globalAliases) {

if (!name.length) continue; // explicitly disabled

let element = this.elementsLookup.get(name);

if (element) this.elementsLookup.set(alias, element);

else throw new Error("element not found: " + name);

}

}

}

// register 'ArrayBuffer'

if (this.elementsLookup.has("ArrayBuffer")) {

let element = assert(this.elementsLookup.get("ArrayBuffer"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

this.arrayBufferInstance = resolver.resolveClass(<ClassPrototype>element, null);

}

// register 'Array'

if (this.elementsLookup.has("Array")) {

let element = assert(this.elementsLookup.get("Array"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

this.arrayPrototype = <ClassPrototype>element;

}

// register 'String'

if (this.elementsLookup.has("String")) {

let element = assert(this.elementsLookup.get("String"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

let instance = resolver.resolveClass(<ClassPrototype>element, null);

if (instance) {

if (this.typesLookup.has("string")) {

let declaration = (<ClassPrototype>element).declaration;

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, declaration.programLevelInternalName

);

} else {

this.stringInstance = instance;

this.typesLookup.set("string", instance.type);

}

}

}

// register classes backing basic types

this.registerBasicClass(TypeKind.I8, "I8");

this.registerBasicClass(TypeKind.I16, "I16");

this.registerBasicClass(TypeKind.I32, "I32");

this.registerBasicClass(TypeKind.I64, "I64");

this.registerBasicClass(TypeKind.ISIZE, "Isize");

this.registerBasicClass(TypeKind.U8, "U8");

this.registerBasicClass(TypeKind.U16, "U16");

this.registerBasicClass(TypeKind.U32, "U32");

this.registerBasicClass(TypeKind.U64, "U64");

this.registerBasicClass(TypeKind.USIZE, "Usize");

this.registerBasicClass(TypeKind.BOOL, "Bool");

this.registerBasicClass(TypeKind.F32, "F32");

this.registerBasicClass(TypeKind.F64, "F64");

// register 'start'

{

let element = assert(this.elementsLookup.get("start"));

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

this.startFunction = <FunctionPrototype>element;

}

// register 'main' if present

if (this.moduleLevelExports.has("main")) {

let element = (<ModuleExport>this.moduleLevelExports.get("main")).element;

if (

element.kind == ElementKind.FUNCTION_PROTOTYPE &&

!(<FunctionPrototype>element).isAny(CommonFlags.GENERIC | CommonFlags.AMBIENT)

) {

(<FunctionPrototype>element).set(CommonFlags.MAIN);

this.mainFunction = <FunctionPrototype>element;

}

}

// register 'abort' if present

if (this.elementsLookup.has("abort")) {

let element = <Element>this.elementsLookup.get("abort");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let instance = this.resolver.resolveFunction(<FunctionPrototype>element, null);

if (instance) this.abortInstance = instance;

}

// register 'memory.allocate' if present

if (this.elementsLookup.has("memory")) {

let element = <Element>this.elementsLookup.get("memory");

let members = element.members;

if (members) {

if (members.has("allocate")) {

element = assert(members.get("allocate"));

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let instance = this.resolver.resolveFunction(<FunctionPrototype>element, null);

if (instance) this.memoryAllocateInstance = instance;

}

}

}

// register GC hooks if present

if (

this.elementsLookup.has("__gc_allocate") &&

this.elementsLookup.has("__gc_link") &&

this.elementsLookup.has("__gc_mark")

) {

// __gc_allocate(usize, (ref: usize) => void): usize

let element = <Element>this.elementsLookup.get("__gc_allocate");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcAllocateInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

let signature = gcAllocateInstance.signature;

assert(signature.parameterTypes.length == 2);

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.parameterTypes[1].signatureReference);

assert(signature.returnType == this.options.usizeType);

// __gc_link(usize, usize): void

element = <Element>this.elementsLookup.get("__gc_link");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcLinkInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

signature = gcLinkInstance.signature;

assert(signature.parameterTypes.length == 2);

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.parameterTypes[1] == this.options.usizeType);

assert(signature.returnType == Type.void);

// __gc_mark(usize): void

element = <Element>this.elementsLookup.get("__gc_mark");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcMarkInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

signature = gcMarkInstance.signature;

assert(signature.parameterTypes.length == 1);

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.returnType == Type.void);

this.gcAllocateInstance = gcAllocateInstance;

this.gcLinkInstance = gcLinkInstance;

this.gcMarkInstance = gcMarkInstance;

let gcHookOffset = 2 * options.usizeType.byteSize; // .next + .prev

this.gcHookOffset = gcHookOffset;

this.gcHeaderSize = (gcHookOffset + 4 + 7) & ~7; // + .hook index + alignment

this.hasGC = true;

}

}

private registerBasicClass(typeKind: TypeKind, className: string): void {

if (this.elementsLookup.has(className)) {

let element = assert(this.elementsLookup.get(className));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

let classElement = this.resolver.resolveClass(<ClassPrototype>element, null);

if (classElement) this.basicClasses.set(typeKind, classElement);

}

}

/** Sets a constant integer value. */

setConstantInteger(globalName: string, type: Type, value: I64): void {

assert(type.is(TypeFlags.INTEGER));

var global = new Global(this, globalName, globalName, type, null, DecoratorFlags.NONE)

.withConstantIntegerValue(value);

global.set(CommonFlags.RESOLVED);

this.elementsLookup.set(globalName, global);

}

/** Sets a constant float value. */

setConstantFloat(globalName: string, type: Type, value: f64): void {

assert(type.is(TypeFlags.FLOAT));

var global = new Global(this, globalName, globalName, type, null, DecoratorFlags.NONE)

.withConstantFloatValue(value);

global.set(CommonFlags.RESOLVED);

this.elementsLookup.set(globalName, global);

}

/** Tries to locate an import by traversing exports and queued exports. */

private tryLocateImport(

externalName: string,

queuedNamedExports: Map<string,QueuedExport>

): Element | null {

var element: Element | null;

var fileLevelExports = this.fileLevelExports;

do {

if (element = fileLevelExports.get(externalName)) return element;

let queuedExport = queuedNamedExports.get(externalName);

if (!queuedExport) break;

if (queuedExport.isReExport) {

externalName = queuedExport.externalName;

continue;

}

return this.elementsLookup.get(queuedExport.externalName);

} while (true);

return null;

}

/** Checks that only supported decorators are present. */

private checkDecorators(

decorators: DecoratorNode[],

acceptedFlags: DecoratorFlags

): DecoratorFlags {

var presentFlags = DecoratorFlags.NONE;

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

let decorator = decorators[i];

let kind = decoratorNameToKind(decorator.name);

let flag = decoratorKindToFlag(kind);

if (flag) {

if (flag == DecoratorFlags.BUILTIN) {

if (decorator.range.source.isLibrary) {

presentFlags |= flag;

} else {

this.error(

DiagnosticCode.Decorator_0_is_not_valid_here,

decorator.range, decorator.name.range.toString()

);

}

} else if (!(acceptedFlags & flag)) {

this.error(

DiagnosticCode.Decorator_0_is_not_valid_here,

decorator.range, decorator.name.range.toString()

);

} else if (presentFlags & flag) {

this.error(

DiagnosticCode.Duplicate_decorator,

decorator.range, decorator.name.range.toString()

);

} else {

presentFlags |= flag;

}

}

}

return presentFlags;

}

/** Checks and sets up global options of an element. */

private checkGlobal(

element: Element,

declaration: DeclarationStatement

): void {

var parentNode = declaration.parent;

// alias globally if explicitly annotated @global or exported from a top-level library file

if (

(element.hasDecorator(DecoratorFlags.GLOBAL)) ||

(

declaration.range.source.isLibrary &&

element.is(CommonFlags.EXPORT) &&

(

assert(parentNode).kind == NodeKind.SOURCE ||

(

<Node>parentNode).kind == NodeKind.VARIABLE &&

assert((<Node>parentNode).parent).kind == NodeKind.SOURCE

)

)

) {

let globalName = declaration.programLevelInternalName;

if (this.elementsLookup.has(globalName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, element.internalName

);

} else {

this.elementsLookup.set(globalName, element);

}

}

// builtins use the global name directly

if (element.hasDecorator(DecoratorFlags.BUILTIN)) {

element.internalName = declaration.programLevelInternalName;

}

}

/** Initializes a class declaration. */

private initializeClass(

declaration: ClassDeclaration,

queuedExtends: ClassPrototype[],

queuedImplements: ClassPrototype[],

namespace: Element | null = null

): void {

var internalName = declaration.fileLevelInternalName;

if (this.elementsLookup.has(internalName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, internalName

);

return;

}

var decorators = declaration.decorators;

var simpleName = declaration.name.text;

var prototype = new ClassPrototype(

this,

simpleName,

internalName,

declaration,

decorators

? this.checkDecorators(decorators,

DecoratorFlags.GLOBAL |

DecoratorFlags.SEALED |

DecoratorFlags.UNMANAGED

)

: DecoratorFlags.NONE

);

prototype.parent = namespace;

this.elementsLookup.set(internalName, prototype);

var implementsTypes = declaration.implementsTypes;

if (implementsTypes) {

let numImplementsTypes = implementsTypes.length;

if (prototype.hasDecorator(DecoratorFlags.UNMANAGED)) {

if (numImplementsTypes) {

this.error(

DiagnosticCode.Unmanaged_classes_cannot_implement_interfaces,

Range.join(

declaration.name.range,

implementsTypes[numImplementsTypes - 1].range

)

);

}

// remember classes that implement interfaces

} else if (numImplementsTypes) {

for (let i = 0; i < numImplementsTypes; ++i) {

this.warning( // TODO

DiagnosticCode.Operation_not_supported,

implementsTypes[i].range

);

}

queuedImplements.push(prototype);

}

}

// remember classes that extend another one

if (declaration.extendsType) queuedExtends.push(prototype);

// add as namespace member if applicable

if (namespace) {

if (namespace.members) {

if (namespace.members.has(simpleName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, internalName

);

return;

}

} else {

namespace.members = new Map();

}

namespace.members.set(simpleName, prototype);

if (namespace.is(CommonFlags.MODULE_EXPORT) && prototype.is(CommonFlags.EXPORT)) {

prototype.set(CommonFlags.MODULE_EXPORT);

}

// otherwise add to file-level exports if exported

} else if (prototype.is(CommonFlags.EXPORT)) {

if (this.fileLevelExports.has(internalName)) {

this.error(

DiagnosticCode.Export_declaration_conflicts_with_exported_declaration_of_0,

declaration.name.range, internalName

);

return;

}

this.fileLevelExports.set(internalName, prototype);

this.currentFilespace.members.set(simpleName, prototype);

if (prototype.is(CommonFlags.EXPORT) && declaration.range.source.isEntry) {

if (this.moduleLevelExports.has(simpleName)) {

let existingExport = <ModuleExport>this.moduleLevelExports.get(simpleName);

this.error(

DiagnosticCode.Export_declaration_conflicts_with_exported_declaration_of_0,

declaration.name.range, existingExport.element.internalName

);

return;

}

prototype.set(CommonFlags.MODULE_EXPORT);

this.moduleLevelExports.set(simpleName, <ModuleExport>{

element: prototype,

identifier: declaration.name

});

}

}

// initialize members

var memberDeclarations = declaration.members;

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

let memberDeclaration = memberDeclarations[i];

switch (memberDeclaration.kind) {

case NodeKind.FIELDDECLARATION: {

this.initializeField(<FieldDeclaration>memberDeclaration, prototype);

break;

}

case NodeKind.METHODDECLARATION: {

if (memberDeclaration.isAny(CommonFlags.GET | CommonFlags.SET)) {

this.initializeAccessor(<MethodDeclaration>memberDeclaration, prototype);

} else {

this.initializeMethod(<MethodDeclaration>memberDeclaration, prototype);

}

break;

}

case NodeKind.INDEXSIGNATUREDECLARATION: break; // ignored for now

default: {

assert(false); // should have been reported while parsing

return;

}