/**

* @fileoverview AssemblyScript's intermediate representation.

*

* The compiler uses Binaryen IR, which is fairly low level, as its

* primary intermediate representation, with the following structures

* holding any higher level information that cannot be represented by

* Binaryen IR alone, for example higher level types.

*

* Similar to the AST being composed of `Node`s in `Source`s, the IR is

* composed of `Element`s in a `Program`. Each class or function is

* represented by a "prototype" holding all the relevant information,

* including each's concrete instances. If a class or function is not

* generic, there is exactly one instance, otherwise there is one for

* each concrete set of type arguments.

*

* @license Apache-2.0

*/

// Element Base class of all elements

// ├─DeclaredElement Base class of elements with a declaration

// │ ├─TypedElement Base class of elements resolving to a type

// │ │ ├─TypeDefinition Type alias declaration

// │ │ ├─VariableLikeElement Base class of all variable-like elements

// │ │ │ ├─EnumValue Enum value

// │ │ │ ├─Global File global

// │ │ │ ├─Local Function local

// │ │ │ ├─Field Class field (instance only)

// │ │ │ └─Property Class property

// │ │ ├─IndexSignature Class index signature

// │ │ ├─Function Concrete function instance

// │ │ └─Class Concrete class instance

// │ ├─Namespace Namespace with static members

// │ ├─FunctionPrototype Prototype of concrete function instances

// │ ├─FieldPrototype Prototype of concrete field instances

// │ ├─PropertyPrototype Prototype of concrete property instances

// │ └─ClassPrototype Prototype of concrete classe instances

// └─File File, analogous to Source in the AST

import {

CommonFlags,

PATH_DELIMITER,

STATIC_DELIMITER,

INSTANCE_DELIMITER,

GETTER_PREFIX,

SETTER_PREFIX,

INNER_DELIMITER,

LIBRARY_SUBST,

INDEX_SUFFIX,

STUB_DELIMITER,

CommonNames,

Feature,

Target

} from "./common";

import {

Options

} from "./compiler";

import {

DiagnosticCode,

DiagnosticMessage,

DiagnosticEmitter

} from "./diagnostics";

import {

Type,

TypeKind,

Signature,

TypeFlags

} from "./types";

import {

Token,

Range

} from "./tokenizer";

import {

Node,

NodeKind,

Source,

SourceKind,

DecoratorNode,

DecoratorKind,

TypeParameterNode,

TypeNode,

NamedTypeNode,

FunctionTypeNode,

ArrowKind,

Expression,

IdentifierExpression,

LiteralKind,

StringLiteralExpression,

Statement,

ClassDeclaration,

DeclarationStatement,

EnumDeclaration,

EnumValueDeclaration,

ExportMember,

ExportDefaultStatement,

ExportStatement,

FieldDeclaration,

FunctionDeclaration,

ImportDeclaration,

ImportStatement,

InterfaceDeclaration,

MethodDeclaration,

NamespaceDeclaration,

TypeDeclaration,

VariableDeclaration,

VariableLikeDeclarationStatement,

VariableStatement,

ParameterKind

} from "./ast";

import {

Module,

FunctionRef,

MemorySegment

} from "./module";

import {

CharCode,

writeI8,

writeI16,

writeI32,

writeF32,

writeF64,

writeI64,

writeI32AsI64,

writeI64AsI32

} from "./util";

import {

Resolver

} from "./resolver";

import {

Flow

} from "./flow";

import {

Parser

} from "./parser";

import {

BuiltinNames

} from "./builtins";

/** Represents a yet unresolved `import`. */

class QueuedImport {

constructor(

/** File being imported into. */

public localFile: File,

/** Identifier within the local file. */

public localIdentifier: IdentifierExpression,

/** Identifier within the other file. Is an `import *` if not set. */

public foreignIdentifier: IdentifierExpression | null,

/** Path to the other file. */

public foreignPath: string,

/** Alternative path to the other file. */

public foreignPathAlt: string

) {}

}

/** Represents a yet unresolved `export`. */

class QueuedExport {

constructor(

/** Identifier within the local file. */

public localIdentifier: IdentifierExpression,

/** Identifier within the other file. */

public foreignIdentifier: IdentifierExpression,

/** Path to the other file if a re-export. */

public foreignPath: string | null,

/** Alternative path to the other file if a re-export. */

public foreignPathAlt: string | null

) {}

}

/** Represents a yet unresolved `export *`. */

class QueuedExportStar {

// stored in a map with localFile as the key

constructor(

/** Path to the other file. */

public foreignPath: string,

/** Alternative path to the other file. */

public foreignPathAlt: string,

/** Reference to the path literal for reporting. */

public pathLiteral: StringLiteralExpression

) {}

}

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

}

export namespace OperatorKind {

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

export function fromDecorator(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;

}

/** Converts a binary operator token to the respective operator kind. */

export function fromBinaryToken(token: Token): OperatorKind {

switch (token) {

case Token.PLUS:

case Token.PLUS_EQUALS: return OperatorKind.ADD;

case Token.MINUS:

case Token.MINUS_EQUALS: return OperatorKind.SUB;

case Token.ASTERISK:

case Token.ASTERISK_EQUALS: return OperatorKind.MUL;

case Token.SLASH:

case Token.SLASH_EQUALS: return OperatorKind.DIV;

case Token.PERCENT:

case Token.PERCENT_EQUALS: return OperatorKind.REM;

case Token.ASTERISK_ASTERISK:

case Token.ASTERISK_ASTERISK_EQUALS: return OperatorKind.POW;

case Token.AMPERSAND:

case Token.AMPERSAND_EQUALS: return OperatorKind.BITWISE_AND;

case Token.BAR:

case Token.BAR_EQUALS: return OperatorKind.BITWISE_OR;

case Token.CARET:

case Token.CARET_EQUALS: return OperatorKind.BITWISE_XOR;

case Token.LESSTHAN_LESSTHAN:

case Token.LESSTHAN_LESSTHAN_EQUALS: return OperatorKind.BITWISE_SHL;

case Token.GREATERTHAN_GREATERTHAN:

case Token.GREATERTHAN_GREATERTHAN_EQUALS: return OperatorKind.BITWISE_SHR;

case Token.GREATERTHAN_GREATERTHAN_GREATERTHAN:

case Token.GREATERTHAN_GREATERTHAN_GREATERTHAN_EQUALS: return OperatorKind.BITWISE_SHR_U;

case Token.EQUALS_EQUALS: return OperatorKind.EQ;

case Token.EXCLAMATION_EQUALS: return OperatorKind.NE;

case Token.GREATERTHAN: return OperatorKind.GT;

case Token.GREATERTHAN_EQUALS: return OperatorKind.GE;

case Token.LESSTHAN: return OperatorKind.LT;

case Token.LESSTHAN_EQUALS: return OperatorKind.LE;

}

return OperatorKind.INVALID;

}

/** Converts a unary prefix operator token to the respective operator kind. */

export function fromUnaryPrefixToken(token: Token): OperatorKind {

switch (token) {

case Token.PLUS: return OperatorKind.PLUS;

case Token.MINUS: return OperatorKind.MINUS;

case Token.EXCLAMATION: return OperatorKind.NOT;

case Token.TILDE: return OperatorKind.BITWISE_NOT;

case Token.PLUS_PLUS: return OperatorKind.PREFIX_INC;

case Token.MINUS_MINUS: return OperatorKind.PREFIX_DEC;

}

return OperatorKind.INVALID;

}

/** Converts a unary postfix operator token to the respective operator kind. */

export function fromUnaryPostfixToken(token: Token): OperatorKind {

switch (token) {

case Token.PLUS_PLUS: return OperatorKind.POSTFIX_INC;

case Token.MINUS_MINUS: return OperatorKind.POSTFIX_DEC;

}

return OperatorKind.INVALID;

}

}

/** Represents an AssemblyScript program. */

export class Program extends DiagnosticEmitter {

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

constructor(

/** Compiler options. */

public options: Options,

/** Shared array of diagnostic messages (emitted so far). */

diagnostics: DiagnosticMessage[] | null = null

) {

super(diagnostics);

var nativeSource = new Source(SourceKind.LIBRARY_ENTRY, LIBRARY_SUBST + ".wasm", "[native code]");

this.nativeSource = nativeSource;

this.parser = new Parser(this.diagnostics, this.sources);

this.resolver = new Resolver(this);

var nativeFile = new File(this, nativeSource);

this.nativeFile = nativeFile;

this.filesByName.set(nativeFile.internalName, nativeFile);

}

/** Parser instance. */

parser: Parser;

/** Resolver instance. */

resolver!: Resolver;

/** Array of sources. */

sources: Source[] = [];

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

diagnosticsOffset: i32 = 0;

/** Special native code source. */

nativeSource: Source;

/** Special native code file. */

nativeFile!: File;

/** Next class id. */

nextClassId: u32 = 0;

/** Next signature id. */

nextSignatureId: i32 = 0;

/** An indicator if the program has been initialized. */

initialized: bool = false;

// Lookup maps

/** Files by unique internal name. */

filesByName: Map<string,File> = new Map();

/** Elements by unique internal name in element space. */

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

/** Elements by declaration. */

elementsByDeclaration: Map<DeclarationStatement,DeclaredElement> = new Map();

/** Element instances by unique internal name. */

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

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

wrapperClasses: Map<Type,Class> = new Map();

/** Managed classes contained in the program, by id. */

managedClasses: Map<i32,Class> = new Map();

/** A set of unique function signatures contained in the program, by id. */

uniqueSignatures: Signature[] = new Array<Signature>(0);

// Standard library

/** Gets the standard `ArrayBufferView` instance. */

get arrayBufferViewInstance(): Class {

var cached = this._arrayBufferViewInstance;

if (!cached) this._arrayBufferViewInstance = cached = this.requireClass(CommonNames.ArrayBufferView);

return cached;

}

private _arrayBufferViewInstance: Class | null = null;

/** Gets the standard `ArrayBuffer` instance. */

get arrayBufferInstance(): Class {

var cached = this._arrayBufferInstance;

if (!cached) this._arrayBufferInstance = cached = this.requireClass(CommonNames.ArrayBuffer);

return cached;

}

private _arrayBufferInstance: Class | null = null;

/** Gets the standard `Array` prototype. */

get arrayPrototype(): ClassPrototype {

var cached = this._arrayPrototype;

if (!cached) this._arrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _arrayPrototype: ClassPrototype | null = null;

/** Gets the standard `StaticArray` prototype. */

get staticArrayPrototype(): ClassPrototype {

var cached = this._staticArrayPrototype;

if (!cached) this._staticArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.StaticArray, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _staticArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Set` prototype. */

get setPrototype(): ClassPrototype {

var cached = this._setPrototype;

if (!cached) this._setPrototype = cached = <ClassPrototype>this.require(CommonNames.Set, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _setPrototype: ClassPrototype | null = null;

/** Gets the standard `Map` prototype. */

get mapPrototype(): ClassPrototype {

var cached = this._mapPrototype;

if (!cached) this._mapPrototype = cached = <ClassPrototype>this.require(CommonNames.Map, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _mapPrototype: ClassPrototype | null = null;

/** Gets the standard `Function` prototype. */

get functionPrototype(): ClassPrototype {

var cached = this._functionPrototype;

if (!cached) this._functionPrototype = cached = <ClassPrototype>this.require(CommonNames.Function, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _functionPrototype: ClassPrototype | null = null;

/** Gets the standard `Int8Array` prototype. */

get int8ArrayPrototype(): ClassPrototype {

var cached = this._int8ArrayPrototype;

if (!cached) this._int8ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Int8Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _int8ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Int16Array` prototype. */

get int16ArrayPrototype(): ClassPrototype {

var cached = this._int16ArrayPrototype;

if (!cached) this._int16ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Int16Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _int16ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Int32Array` prototype. */

get int32ArrayPrototype(): ClassPrototype {

var cached = this._int32ArrayPrototype;

if (!cached) this._int32ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Int32Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _int32ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Int64Array` prototype. */

get int64ArrayPrototype(): ClassPrototype {

var cached = this._int64ArrayPrototype;

if (!cached) this._int64ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Int64Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _int64ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Uint8Array` prototype. */

get uint8ArrayPrototype(): ClassPrototype {

var cached = this._uint8ArrayPrototype;

if (!cached) this._uint8ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Uint8Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _uint8ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Uint8ClampedArray` prototype. */

get uint8ClampedArrayPrototype(): ClassPrototype {

var cached = this._uint8ClampedArrayPrototype;

if (!cached) this._uint8ClampedArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Uint8ClampedArray, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _uint8ClampedArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Uint16Array` prototype. */

get uint16ArrayPrototype(): ClassPrototype {

var cached = this._uint16ArrayPrototype;

if (!cached) this._uint16ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Uint16Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _uint16ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Uint32Array` prototype. */

get uint32ArrayPrototype(): ClassPrototype {

var cached = this._uint32ArrayPrototype;

if (!cached) this._uint32ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Uint32Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _uint32ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Uint64Array` prototype. */

get uint64ArrayPrototype(): ClassPrototype {

var cached = this._uint64ArrayPrototype;

if (!cached) this._uint64ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Uint64Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _uint64ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Float32Array` prototype. */

get float32ArrayPrototype(): ClassPrototype {

var cached = this._float32ArrayPrototype;

if (!cached) this._float32ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Float32Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _float32ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `Float64Array` prototype. */

get float64ArrayPrototype(): ClassPrototype {

var cached = this._float64ArrayPrototype;

if (!cached) this._float64ArrayPrototype = cached = <ClassPrototype>this.require(CommonNames.Float64Array, ElementKind.CLASS_PROTOTYPE);

return cached;

}

private _float64ArrayPrototype: ClassPrototype | null = null;

/** Gets the standard `String` instance. */

get stringInstance(): Class {

var cached = this._stringInstance;

if (!cached) this._stringInstance = cached = this.requireClass(CommonNames.String);

return cached;

}

private _stringInstance: Class | null = null;

/** Gets the standard `abort` instance, if not explicitly disabled. */

get abortInstance(): Function | null {

return this.lookupFunction(CommonNames.abort);

}

// Runtime interface

/** Gets the runtime `__alloc(size: usize, id: u32): usize` instance. */

get allocInstance(): Function {

var cached = this._allocInstance;

if (!cached) this._allocInstance = cached = this.requireFunction(CommonNames.alloc);

return cached;

}

private _allocInstance: Function | null = null;

/** Gets the runtime `__realloc(ptr: usize, newSize: usize): usize` instance. */

get reallocInstance(): Function {

var cached = this._reallocInstance;

if (!cached) this._reallocInstance = cached = this.requireFunction(CommonNames.realloc);

return cached;

}

private _reallocInstance: Function | null = null;

/** Gets the runtime `__free(ptr: usize): void` instance. */

get freeInstance(): Function {

var cached = this._freeInstance;

if (!cached) this._freeInstance = cached = this.requireFunction(CommonNames.free);

return cached;

}

private _freeInstance: Function | null = null;

/** Gets the runtime `__retain(ptr: usize): usize` instance. */

get retainInstance(): Function {

var cached = this._retainInstance;

if (!cached) this._retainInstance = cached = this.requireFunction(CommonNames.retain);

return cached;

}

private _retainInstance: Function | null = null;

/** Gets the runtime `__release(ptr: usize): void` instance. */

get releaseInstance(): Function {

var cached = this._releaseInstance;

if (!cached) this._releaseInstance = cached = this.requireFunction(CommonNames.release);

return cached;

}

private _releaseInstance: Function | null = null;

/** Gets the runtime `__collect(): void` instance. */

get collectInstance(): Function {

var cached = this._collectInstance;

if (!cached) this._collectInstance = cached = this.requireFunction(CommonNames.collect);

return cached;

}

private _collectInstance: Function | null = null;

/** Gets the runtime `__visit(ptr: usize, cookie: u32): void` instance. */

get visitInstance(): Function {

var cached = this._visitInstance;

if (!cached) this._visitInstance = cached = this.requireFunction(CommonNames.visit);

return cached;

}

private _visitInstance: Function | null = null;

/** Gets the runtime `__typeinfo(id: u32): RTTIFlags` instance. */

get typeinfoInstance(): Function {

var cached = this._typeinfoInstance;

if (!cached) this._typeinfoInstance = cached = this.requireFunction(CommonNames.typeinfo);

return cached;

}

private _typeinfoInstance: Function | null = null;

/** Gets the runtime `__instanceof(ptr: usize, superId: u32): bool` instance. */

get instanceofInstance(): Function {

var cached = this._instanceofInstance;

if (!cached) this._instanceofInstance = cached = this.requireFunction(CommonNames.instanceof_);

return cached;

}

private _instanceofInstance: Function | null = null;

/** Gets the runtime `__allocBuffer(size: usize, id: u32, data: usize = 0): usize` instance. */

get allocBufferInstance(): Function {

var cached = this._allocBufferInstance;

if (!cached) this._allocBufferInstance = cached = this.requireFunction(CommonNames.allocBuffer);

return cached;

}

private _allocBufferInstance: Function | null = null;

/** Gets the runtime `__allocArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize` instance. */

get allocArrayInstance(): Function {

var cached = this._allocArrayInstance;

if (!cached) this._allocArrayInstance = cached = this.requireFunction(CommonNames.allocArray);

return cached;

}

private _allocArrayInstance: Function | null = null;

// Utility

/** Tests whether this is a WASI program. */

get isWasi(): bool {

return this.elementsByName.has(CommonNames.ASC_WASI);

}

/** Obtains the source matching the specified internal path. */

getSource(internalPath: string): string | null {

var sources = this.sources;

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

let source = sources[i];

if (source.internalPath == internalPath) return source.text;

}

return null;

}

/** Gets the size of a runtime header. */

get runtimeHeaderSize(): i32 {

return 16;

}

/** Creates a native variable declaration. */

makeNativeVariableDeclaration(

/** The simple name of the variable */

name: string,

/** Flags indicating specific traits, e.g. `CONST`. */

flags: CommonFlags = CommonFlags.NONE

): VariableDeclaration {

var range = this.nativeSource.range;

return Node.createVariableDeclaration(

Node.createIdentifierExpression(name, range),

null, flags, null, null, range

);

}

/** Creates a native type declaration. */

makeNativeTypeDeclaration(

/** The simple name of the type. */

name: string,

/** Flags indicating specific traits, e.g. `GENERIC`. */

flags: CommonFlags = CommonFlags.NONE

): TypeDeclaration {

var range = this.nativeSource.range;

var identifier = Node.createIdentifierExpression(name, range);

return Node.createTypeDeclaration(

identifier,

null, flags, null,

Node.createOmittedType(range),

range

);

}

// a dummy signature for programmatically generated native functions

private nativeDummySignature: FunctionTypeNode | null = null;

/** Creates a native function declaration. */

makeNativeFunctionDeclaration(

/** The simple name of the function. */

name: string,

/** Flags indicating specific traits, e.g. `DECLARE`. */

flags: CommonFlags = CommonFlags.NONE

): FunctionDeclaration {

var range = this.nativeSource.range;

var signature = this.nativeDummySignature;

if (!signature) {

this.nativeDummySignature = signature = Node.createFunctionType([],

Node.createNamedType( // ^ AST signature doesn't really matter, is overridden anyway

Node.createSimpleTypeName(CommonNames.void_, range),

null, false, range

),

null, false, range

);

}

return Node.createFunctionDeclaration(

Node.createIdentifierExpression(name, range),

null, flags, null, signature, null, ArrowKind.NONE, range

);

}

/** Creates a native namespace declaration. */

makeNativeNamespaceDeclaration(

/** The simple name of the namespace. */

name: string,

/** Flags indicating specific traits, e.g. `EXPORT`. */

flags: CommonFlags = CommonFlags.NONE

): NamespaceDeclaration {

var range = this.nativeSource.range;

return Node.createNamespaceDeclaration(

Node.createIdentifierExpression(name, range),

null, flags, [], range

);

}

/** Creates a native function. */

makeNativeFunction(

/** The simple name of the function. */

name: string,

/** Concrete function signature. */

signature: Signature,

/** Parent element, usually a file, class or namespace. */

parent: Element = this.nativeFile,

/** Flags indicating specific traits, e.g. `GENERIC`. */

flags: CommonFlags = CommonFlags.NONE,

/** Decorator flags representing built-in decorators. */

decoratorFlags: DecoratorFlags = DecoratorFlags.NONE

): Function {

return new Function(

name,

new FunctionPrototype(

name,

parent,

this.makeNativeFunctionDeclaration(name, flags),

decoratorFlags

),

null,

signature

);

}

/** Gets the (possibly merged) program element linked to the specified declaration. */

getElementByDeclaration(declaration: DeclarationStatement): DeclaredElement | null {

var elementsByDeclaration = this.elementsByDeclaration;

return elementsByDeclaration.has(declaration)

? assert(elementsByDeclaration.get(declaration))

: null;

}

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

initialize(): void {

if (this.initialized) return;

this.initialized = true;

var options = this.options;

// register native types

this.registerNativeType(CommonNames.i8, Type.i8);

this.registerNativeType(CommonNames.i16, Type.i16);

this.registerNativeType(CommonNames.i32, Type.i32);

this.registerNativeType(CommonNames.i64, Type.i64);

this.registerNativeType(CommonNames.isize, options.isizeType);

this.registerNativeType(CommonNames.u8, Type.u8);

this.registerNativeType(CommonNames.u16, Type.u16);

this.registerNativeType(CommonNames.u32, Type.u32);

this.registerNativeType(CommonNames.u64, Type.u64);

this.registerNativeType(CommonNames.usize, options.usizeType);

this.registerNativeType(CommonNames.bool, Type.bool);

this.registerNativeType(CommonNames.f32, Type.f32);

this.registerNativeType(CommonNames.f64, Type.f64);

this.registerNativeType(CommonNames.void_, Type.void);

this.registerNativeType(CommonNames.number, Type.f64); // alias

this.registerNativeType(CommonNames.boolean, Type.bool); // alias

this.nativeFile.add(CommonNames.native, new TypeDefinition(

CommonNames.native,

this.nativeFile,

this.makeNativeTypeDeclaration(CommonNames.native, CommonFlags.EXPORT | CommonFlags.GENERIC),

DecoratorFlags.BUILTIN

));

this.nativeFile.add(CommonNames.indexof, new TypeDefinition(

CommonNames.indexof,

this.nativeFile,

this.makeNativeTypeDeclaration(CommonNames.indexof, CommonFlags.EXPORT | CommonFlags.GENERIC),

DecoratorFlags.BUILTIN

));

this.nativeFile.add(CommonNames.valueof, new TypeDefinition(

CommonNames.valueof,

this.nativeFile,

this.makeNativeTypeDeclaration(CommonNames.valueof, CommonFlags.EXPORT | CommonFlags.GENERIC),

DecoratorFlags.BUILTIN

));

this.nativeFile.add(CommonNames.returnof, new TypeDefinition(

CommonNames.returnof,

this.nativeFile,

this.makeNativeTypeDeclaration(CommonNames.returnof, CommonFlags.EXPORT | CommonFlags.GENERIC),

DecoratorFlags.BUILTIN

));

// The following types might not be enabled by compiler options, so the

// compiler needs to check this condition whenever such a value is created

// respectively stored or loaded.

this.registerNativeType(CommonNames.v128, Type.v128);

this.registerNativeType(CommonNames.externref, Type.externref);

// register compiler hints

this.registerConstantInteger(CommonNames.ASC_TARGET, Type.i32,

i64_new(options.isWasm64 ? Target.WASM64 : Target.WASM32));

this.registerConstantInteger(CommonNames.ASC_NO_ASSERT, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_MEMORY_BASE, Type.i32,

i64_new(options.memoryBase, 0));

this.registerConstantInteger(CommonNames.ASC_TABLE_BASE, Type.i32,

i64_new(options.tableBase, 0));

this.registerConstantInteger(CommonNames.ASC_OPTIMIZE_LEVEL, Type.i32,

i64_new(options.optimizeLevelHint, 0));

this.registerConstantInteger(CommonNames.ASC_SHRINK_LEVEL, Type.i32,

i64_new(options.shrinkLevelHint, 0));

this.registerConstantInteger(CommonNames.ASC_LOW_MEMORY_LIMIT, Type.i32,

i64_new(options.lowMemoryLimit, 0));

// register feature hints

this.registerConstantInteger(CommonNames.ASC_FEATURE_SIGN_EXTENSION, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_MUTABLE_GLOBALS, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_NONTRAPPING_F2I, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_BULK_MEMORY, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_SIMD, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_THREADS, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_EXCEPTION_HANDLING, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_TAIL_CALLS, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_REFERENCE_TYPES, Type.bool,

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

this.registerConstantInteger(CommonNames.ASC_FEATURE_MULTI_VALUE, Type.bool,

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

// remember deferred elements

var queuedImports = new Array<QueuedImport>();

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

var queuedExportsStar = new Map<File,QueuedExportStar[]>();

var queuedExtends = new Array<ClassPrototype>();

var queuedImplements = new Array<ClassPrototype>();

// initialize relevant declaration-like statements of the entire program

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

let source = this.sources[i];

let file = new File(this, source);

this.filesByName.set(file.internalName, file);

let statements = source.statements;

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

let statement = statements[j];

switch (statement.kind) {

case NodeKind.EXPORT: {

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

break;

}

case NodeKind.EXPORTDEFAULT: {

this.initializeExportDefault(<ExportDefaultStatement>statement, file, queuedExtends, queuedImplements);

break;

}

case NodeKind.IMPORT: {

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

break;

}

case NodeKind.VARIABLE: {

this.initializeVariables(<VariableStatement>statement, file);

break;

}

case NodeKind.CLASSDECLARATION: {

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

break;

}

case NodeKind.ENUMDECLARATION: {

this.initializeEnum(<EnumDeclaration>statement, file);

break;

}

case NodeKind.FUNCTIONDECLARATION: {

this.initializeFunction(<FunctionDeclaration>statement, file);

break;

}

case NodeKind.INTERFACEDECLARATION: {

this.initializeInterface(<InterfaceDeclaration>statement, file, queuedExtends);

break;

}

case NodeKind.NAMESPACEDECLARATION: {

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

break;

}

case NodeKind.TYPEDECLARATION: {

this.initializeTypeDefinition(<TypeDeclaration>statement, file);

break;

}

}