/**

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

* @module program

*//***/

import {

CommonFlags,

PATH_DELIMITER,

STATIC_DELIMITER,

INSTANCE_DELIMITER,

GETTER_PREFIX,

SETTER_PREFIX,

INNER_DELIMITER,

LIBRARY_SUBST,

INDEX_SUFFIX,

CommonSymbols,

LibrarySymbols

} from "./common";

import {

Options,

Feature

} from "./compiler";

import {

DiagnosticCode,

DiagnosticMessage,

DiagnosticEmitter

} from "./diagnostics";

import {

Type,

TypeKind,

TypeFlags,

Signature

} from "./types";

import {

Node,

NodeKind,

Source,

SourceKind,

Range,

DecoratorNode,

DecoratorKind,

SignatureNode,

TypeParameterNode,

CommonTypeNode,

TypeNode,

ArrowKind,

Expression,

IdentifierExpression,

LiteralExpression,

LiteralKind,

StringLiteralExpression,

Statement,

ClassDeclaration,

DeclarationStatement,

EnumDeclaration,

EnumValueDeclaration,

ExportMember,

ExportStatement,

FieldDeclaration,

FunctionDeclaration,

ImportDeclaration,

ImportStatement,

InterfaceDeclaration,

MethodDeclaration,

NamespaceDeclaration,

TypeDeclaration,

VariableDeclaration,

VariableLikeDeclarationStatement,

VariableStatement,

decoratorNameToKind,

findDecorator

} from "./ast";

import {

Module,

FunctionRef

} from "./module";

import {

CharCode

} from "./util";

import {

Resolver

} from "./resolver";

import {

Flow

} from "./flow";

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

}

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

}

/** Represents an AssemblyScript program. */

export class Program extends DiagnosticEmitter {

/** Resolver instance. */

resolver: Resolver;

/** Array of sources. */

sources: Source[] = [];

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

diagnosticsOffset: i32 = 0;

/** Compiler options. */

options: Options;

/** Special native code source. */

nativeSource: Source;

/** Special native code file. */

nativeFile: File;

/** Explicitly annotated start function. */

explicitStartFunction: FunctionPrototype | null = null;

// 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 backing basic types like `i32`. */

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

// runtime references

/** ArrayBuffer instance reference. */

arrayBufferInstance: Class | null = null;

/** Array prototype reference. */

arrayPrototype: ClassPrototype | null = null;

/** String instance reference. */

stringInstance: Class | null = null;

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

abortInstance: Function | null = null;

/** Memory allocation function. */

memoryAllocateInstance: Function | null = null;

// gc integration

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

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

constructor(

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

diagnostics: DiagnosticMessage[] | null = null

) {

super(diagnostics);

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

this.nativeSource = nativeSource;

var nativeFile = new File(this, nativeSource);

this.nativeFile = nativeFile;

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

this.resolver = new Resolver(this);

}

/** 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, null, null, flags, 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,

Node.createOmittedType(range),

null, flags, range

);

}

// a dummy signature for programmatically generated native functions

private nativeDummySignature: SignatureNode | 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;

return Node.createFunctionDeclaration(

Node.createIdentifierExpression(name, range),

null,

this.nativeDummySignature || (this.nativeDummySignature = Node.createSignature([],

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

Node.createSimpleTypeName(CommonSymbols.void_, range),

null, false, range

),

null, false, range)

),

null, null, flags, 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

),

signature

);

}

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

getElementByDeclaration(declaration: DeclarationStatement): DeclaredElement {

var elementsByDeclaration = this.elementsByDeclaration;

assert(elementsByDeclaration.has(declaration));

return elementsByDeclaration.get(declaration)!;

}

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

initialize(options: Options): void {

this.options = options;

// register native types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CommonSymbols.native,

this.nativeFile,

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

DecoratorFlags.BUILTIN

));

if (options.hasFeature(Feature.SIMD)) this.registerNativeType(CommonSymbols.v128, Type.v128);

// register compiler hints

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

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

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

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

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

i64_new(options.memoryBase, 0));

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

i64_new(options.optimizeLevelHint, 0));

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

i64_new(options.shrinkLevelHint, 0));

this.registerConstantInteger(LibrarySymbols.ASC_FEATURE_MUTABLE_GLOBAL, Type.bool,

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

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

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

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

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

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

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

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

i64_new(options.hasFeature(Feature.THREADS) ? 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.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);

break;

}

case NodeKind.NAMESPACEDECLARATION: {

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

break;

}

case NodeKind.TYPEDECLARATION: {

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

break;

}

}

}

}

// queued exports * should be linkable now that all files have been processed

for (let [file, exportsStar] of queuedExportsStar) {

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

let exportStar = exportsStar[i];

let foreignFile = this.lookupForeignFile(exportStar.foreignPath, exportStar.foreignPathAlt);

if (!foreignFile) {

this.error(

DiagnosticCode.File_0_not_found,

exportStar.pathLiteral.range, exportStar.pathLiteral.value

);

continue;

}

file.ensureExportStar(foreignFile);

}

}

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

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

let queuedImport = queuedImports[i];

let foreignIdentifier = queuedImport.foreignIdentifier;

if (foreignIdentifier) { // i.e. import { foo [as bar] } from "./baz"

let element = this.lookupForeign(

foreignIdentifier.text,

queuedImport.foreignPath,

queuedImport.foreignPathAlt,

queuedExports

);

if (element) {

queuedImport.localFile.add(

queuedImport.localIdentifier.text,

element,

true // isImport

);

} else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

foreignIdentifier.range,

queuedImport.foreignPath,

foreignIdentifier.text

);

}

} else { // i.e. import * as bar from "./bar"

let foreignFile = this.lookupForeignFile(queuedImport.foreignPath, queuedImport.foreignPathAlt);

if (foreignFile) {

let localFile = queuedImport.localFile;

let localName = queuedImport.localIdentifier.text;

localFile.add(

localName,

foreignFile.asImportedNamespace(

localName,

localFile

),

true // isImport

);

} else {

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

}

}

}

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

for (let [file, exports] of queuedExports) {

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

let localName = queuedExport.localIdentifier.text;

let foreignPath = queuedExport.foreignPath;

if (foreignPath) { // i.e. export { foo [as bar] } from "./baz"

let element = this.lookupForeign(

localName,

foreignPath,

assert(queuedExport.foreignPathAlt), // must be set if foreignPath is

queuedExports

);

if (element) {

file.ensureExport(exportName, element);

} else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

queuedExport.localIdentifier.range,

foreignPath, localName

);

}

} else { // i.e. export { foo [as bar] }

let element = file.lookupInSelf(localName);

if (element) {

file.ensureExport(exportName, element);

} else {

let globalElement = this.lookupGlobal(localName);

if (globalElement && globalElement instanceof DeclaredElement) { // export { memory }

file.ensureExport(exportName, <DeclaredElement>globalElement);

} else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

queuedExport.foreignIdentifier.range,

file.internalName, queuedExport.foreignIdentifier.text

);

}

}

}

}

}

// register classes backing basic types

this.registerNativeTypeClass(TypeKind.I8, LibrarySymbols.I8);

this.registerNativeTypeClass(TypeKind.I16, LibrarySymbols.I16);

this.registerNativeTypeClass(TypeKind.I32, LibrarySymbols.I32);

this.registerNativeTypeClass(TypeKind.I64, LibrarySymbols.I64);

this.registerNativeTypeClass(TypeKind.ISIZE, LibrarySymbols.Isize);

this.registerNativeTypeClass(TypeKind.U8, LibrarySymbols.U8);

this.registerNativeTypeClass(TypeKind.U16, LibrarySymbols.U16);

this.registerNativeTypeClass(TypeKind.U32, LibrarySymbols.U32);

this.registerNativeTypeClass(TypeKind.U64, LibrarySymbols.U64);

this.registerNativeTypeClass(TypeKind.USIZE, LibrarySymbols.Usize);

this.registerNativeTypeClass(TypeKind.BOOL, LibrarySymbols.Bool);

this.registerNativeTypeClass(TypeKind.F32, LibrarySymbols.F32);

this.registerNativeTypeClass(TypeKind.F64, LibrarySymbols.F64);

if (options.hasFeature(Feature.SIMD)) this.registerNativeTypeClass(TypeKind.V128, LibrarySymbols.V128);

// resolve base prototypes of derived classes

var resolver = this.resolver;

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

let thisPrototype = queuedExtends[i];

let extendsNode = assert(thisPrototype.extendsNode); // must be present if in queuedExtends

let baseElement = resolver.resolveTypeName(extendsNode.name, thisPrototype.parent); // reports

if (!baseElement) continue;

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

let basePrototype = <ClassPrototype>baseElement;

if (basePrototype.hasDecorator(DecoratorFlags.SEALED)) {

this.error(

DiagnosticCode.Class_0_is_sealed_and_cannot_be_extended,

extendsNode.range, (<ClassPrototype>baseElement).identifierNode.text

);

}

if (

basePrototype.hasDecorator(DecoratorFlags.UNMANAGED) !=

thisPrototype.hasDecorator(DecoratorFlags.UNMANAGED)

) {

this.error(

DiagnosticCode.Unmanaged_classes_cannot_extend_managed_classes_and_vice_versa,

Range.join(thisPrototype.identifierNode.range, extendsNode.range)

);

}

thisPrototype.basePrototype = basePrototype;

} else {

this.error(

DiagnosticCode.A_class_may_only_extend_another_class,

extendsNode.range

);

}

}

// set up global aliases

{

let globalAliases = options.globalAliases;

if (globalAliases) {

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

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

let elementsByName = this.elementsByName;

let element = elementsByName.get(name);

if (element) {

if (elementsByName.has(alias)) throw new Error("duplicate global element: " + name);

elementsByName.set(alias, element);

}

else throw new Error("no such global element: " + name);

}

}

}

// register global library elements

{

let element: Element | null;

if (element = this.lookupGlobal(LibrarySymbols.String)) {

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

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

}

if (element = this.lookupGlobal(LibrarySymbols.ArrayBuffer)) {

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

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

}

if (element = this.lookupGlobal(LibrarySymbols.Array)) {

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

this.arrayPrototype = <ClassPrototype>element;

}

if (element = this.lookupGlobal(LibrarySymbols.abort)) {

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

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

}

if (element = this.lookupGlobal(LibrarySymbols.memory)) {

if (element = element.lookupInSelf(LibrarySymbols.allocate)) {

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

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

}

}

}

// register GC hooks if present

// FIXME: think about a better way than globals to model this, maybe a GC namespace that can be

// dynamically extended by a concrete implementation but then has `@unsafe` methods that normal

// code cannot call without explicitly enabling it with a flag.

if (

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

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

this.elementsByName.has("__gc_mark")

) {

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

let element = <Element>this.elementsByName.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.elementsByName.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.elementsByName.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;

}

// mark module exports, i.e. to apply proper wrapping behavior on the boundaries

for (let file of this.filesByName.values()) {

let exports = file.exports;

if (!(file.source.isEntry && exports)) continue;

for (let element of exports.values()) this.markModuleExport(element);

}

}

/** Marks an element and its children as a module export. */

private markModuleExport(element: Element): void {

element.set(CommonFlags.MODULE_EXPORT);

switch (element.kind) {

case ElementKind.CLASS_PROTOTYPE: {

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

if (instanceMembers) for (let member of instanceMembers.values()) this.markModuleExport(member);

break;

}

case ElementKind.PROPERTY_PROTOTYPE: {

let getterPrototype = (<PropertyPrototype>element).getterPrototype;

if (getterPrototype) this.markModuleExport(getterPrototype);

let setterPrototype = (<PropertyPrototype>element).setterPrototype;

if (setterPrototype) this.markModuleExport(setterPrototype);

break;

}

case ElementKind.PROPERTY:

case ElementKind.FUNCTION:

case ElementKind.FIELD:

case ElementKind.CLASS: assert(false); // assumes that there are no instances yet

}

{

let members = element.members;

if (members) for (let member of members.values()) this.markModuleExport(member);

}

}

/** Registers a native type with the program. */

private registerNativeType(name: string, type: Type): void {

var element = new TypeDefinition(

name,

this.nativeFile,

this.makeNativeTypeDeclaration(name, CommonFlags.EXPORT),

DecoratorFlags.BUILTIN

);

element.setType(type);

this.nativeFile.add(name, element);

}

/** Registers the backing class of a native type. */

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

assert(!this.typeClasses.has(typeKind));

var element = this.lookupGlobal(className);

if (element) {

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

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

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

}

}

/** Registers a constant integer value within the global scope. */

private registerConstantInteger(name: string, type: Type, value: I64): void {

assert(type.is(TypeFlags.INTEGER)); // must be an integer type

var global = new Global(

name,

this.nativeFile,

DecoratorFlags.NONE,

this.makeNativeVariableDeclaration(name, CommonFlags.CONST | CommonFlags.EXPORT)

);

global.setConstantIntegerValue(value, type);

this.nativeFile.add(name, global);

}

/** Registers a constant float value within the global scope. */

private registerConstantFloat(name: string, type: Type, value: f64): void {

assert(type.is(TypeFlags.FLOAT)); // must be a float type

var global = new Global(

name,

this.nativeFile,

DecoratorFlags.NONE,

this.makeNativeVariableDeclaration(name, CommonFlags.CONST | CommonFlags.EXPORT)

);

global.setConstantFloatValue(value, type);

this.nativeFile.add(name, global);

}

/** Ensures that the given global element exists. Attempts to merge duplicates. */

ensureGlobal(name: string, element: DeclaredElement): void {

var elementsByName = this.elementsByName;

if (elementsByName.has(name)) {

let actual = elementsByName.get(name);

// NOTE: this is effectively only performed when merging native types with

// their respective namespaces in std/builtins, but can also trigger when a

// user has multiple global elements of the same name in different files,

// which might result in unexpected shared symbols accross files. considering

// this a wonky feature for now that we might want to revisit later.

if (actual !== element) {

let merged = tryMerge(elementsByName.get(name)!, element);

if (!merged) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

element.identifierNode.range, name

);

return;

}

element = merged;

}

}

elementsByName.set(name, element);

}

/** Looks up the element of the specified name in the global scope. */

lookupGlobal(name: string): Element | null {

var elements = this.elementsByName;

if (elements.has(name)) return elements.get(name);

return null;

}

/** Tries to locate a foreign file given its normalized path. */

private lookupForeignFile(

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

foreignPath: string,

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

foreignPathAlt: string

): File | null {

var filesByName = this.filesByName;

return filesByName.has(foreignPath)

? filesByName.get(foreignPath)!

: filesByName.has(foreignPathAlt)

? filesByName.get(foreignPathAlt)!

: null;

}

/** Tries to locate a foreign element by traversing exports and queued exports. */

private lookupForeign(

/** Identifier within the other file. */

foreignName: string,

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

foreignPath: string,

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

foreignPathAlt: string,

/** So far queued exports. */

queuedExports: Map<File,Map<string,QueuedExport>>

): DeclaredElement | null {

do {

let foreignFile = this.lookupForeignFile(foreignPath, foreignPathAlt);

if (!foreignFile) return null; // no such file

// search already resolved exports

let element = foreignFile.lookupExport(foreignName);

if (element) return element;

// otherwise traverse queued exports

if (queuedExports.has(foreignFile)) {

let fileQueuedExports = queuedExports.get(foreignFile)!;

if (fileQueuedExports.has(foreignName)) {

let queuedExport = fileQueuedExports.get(foreignName)!;

if (queuedExport.foreignPath) { // imported from another file

foreignName = queuedExport.localIdentifier.text;

foreignPath = queuedExport.foreignPath;

foreignPathAlt = assert(queuedExport.foreignPathAlt);

continue;

} else { // local element of this file

element = foreignFile.lookupInSelf(queuedExport.localIdentifier.text);

if (element) return element;

}

}

}

break;

} while (true);

return null;

}

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

private checkDecorators(

/** Decorators present on an element. */

decorators: DecoratorNode[] | null,