/**

* @fileoverview The AssemblyScript compiler.

* @license Apache-2.0

*/

import {

BuiltinNames,

BuiltinContext,

builtins,

compileVisitGlobals,

compileVisitMembers,

compileRTTI,

compileClassInstanceOf,

} from "./builtins";

import {

DiagnosticCode,

DiagnosticEmitter

} from "./diagnostics";

import {

Module,

MemorySegment,

ExpressionRef,

UnaryOp,

BinaryOp,

NativeType,

FunctionRef,

ExpressionId,

GlobalRef,

FeatureFlags,

Index,

getExpressionId,

getExpressionType,

getConstValueI32,

getConstValueI64Low,

getConstValueI64High,

getConstValueF32,

getConstValueF64,

getBlockChildCount,

getBlockChild,

getBlockName,

getLocalGetIndex,

isLocalTee,

getLocalSetIndex,

needsExplicitUnreachable,

getLocalSetValue,

getGlobalGetName,

isGlobalMutable,

createType,

hasSideEffects

} from "./module";

import {

CommonFlags,

INSTANCE_DELIMITER,

STATIC_DELIMITER,

GETTER_PREFIX,

SETTER_PREFIX,

CommonNames,

INDEX_SUFFIX,

Feature,

Target

} from "./common";

import {

Program,

ClassPrototype,

Class,

Element,

ElementKind,

Enum,

Field,

FunctionPrototype,

Function,

FunctionTarget,

Global,

Local,

EnumValue,

Property,

VariableLikeElement,

ConstantValueKind,

OperatorKind,

DecoratorFlags,

PropertyPrototype,

IndexSignature,

File,

mangleInternalName

} from "./program";

import {

FlowFlags,

Flow,

LocalFlags,

ConditionKind,

findUsedLocals

} from "./flow";

import {

Resolver,

ReportMode

} from "./resolver";

import {

Token,

Range,

operatorTokenToString

} from "./tokenizer";

import {

Node,

NodeKind,

DecoratorKind,

AssertionKind,

SourceKind,

Statement,

BlockStatement,

BreakStatement,

ClassDeclaration,

ContinueStatement,

DeclarationStatement,

DoStatement,

EmptyStatement,

EnumDeclaration,

ExportDefaultStatement,

ExportStatement,

ExpressionStatement,

FieldDeclaration,

ForStatement,

ForOfStatement,

FunctionDeclaration,

IfStatement,

ImportStatement,

InstanceOfExpression,

NamespaceDeclaration,

ReturnStatement,

SwitchStatement,

ThrowStatement,

TryStatement,

VariableStatement,

VoidStatement,

WhileStatement,

Expression,

AssertionExpression,

BinaryExpression,

CallExpression,

CommaExpression,

ElementAccessExpression,

FloatLiteralExpression,

FunctionExpression,

IdentifierExpression,

IntegerLiteralExpression,

LiteralExpression,

LiteralKind,

NewExpression,

ObjectLiteralExpression,

ParenthesizedExpression,

PropertyAccessExpression,

TernaryExpression,

ArrayLiteralExpression,

StringLiteralExpression,

UnaryPostfixExpression,

UnaryPrefixExpression,

NamedTypeNode,

findDecorator,

isTypeOmitted

} from "./ast";

import {

Type,

TypeKind,

TypeFlags,

Signature,

typesToNativeTypes

} from "./types";

import {

writeI8,

writeI16,

writeI32,

writeI64,

writeF32,

writeF64,

makeMap

} from "./util";

/** Compiler options. */

export class Options {

/** WebAssembly target. Defaults to {@link Target.WASM32}. */

target: Target = Target.WASM32;

/** If true, replaces assertions with nops. */

noAssert: bool = false;

/** If true, imports the memory provided by the embedder. */

importMemory: bool = false;

/** If greater than zero, declare memory as shared by setting max memory to sharedMemory. */

sharedMemory: i32 = 0;

/** If true, imports the function table provided by the embedder. */

importTable: bool = false;

/** If true, exports the function table. */

exportTable: bool = false;

/** If true, generates information necessary for source maps. */

sourceMap: bool = false;

/** If true, generates an explicit start function. */

explicitStart: bool = false;

/** Static memory start offset. */

memoryBase: i32 = 0;

/** Static table start offset. */

tableBase: i32 = 0;

/** Global aliases, mapping alias names as the key to internal names to be aliased as the value. */

globalAliases: Map<string,string> | null = null;

/** Features to activate by default. These are the finished proposals. */

features: Feature = Feature.MUTABLE_GLOBALS;

/** If true, disallows unsafe features in user code. */

noUnsafe: bool = false;

/** If true, enables pedantic diagnostics. */

pedantic: bool = false;

/** Indicates a very low (<64k) memory limit. */

lowMemoryLimit: i32 = 0;

/** Hinted optimize level. Not applied by the compiler itself. */

optimizeLevelHint: i32 = 0;

/** Hinted shrink level. Not applied by the compiler itself. */

shrinkLevelHint: i32 = 0;

/** Tests if the target is WASM64 or, otherwise, WASM32. */

get isWasm64(): bool {

return this.target == Target.WASM64;

}

/** Gets the unsigned size type matching the target. */

get usizeType(): Type {

return this.target == Target.WASM64 ? Type.usize64 : Type.usize32;

}

/** Gets the signed size type matching the target. */

get isizeType(): Type {

return this.target == Target.WASM64 ? Type.isize64 : Type.isize32;

}

/** Gets the native size type matching the target. */

get nativeSizeType(): NativeType {

return this.target == Target.WASM64 ? NativeType.I64 : NativeType.I32;

}

/** Gets if any optimizations will be performed. */

get willOptimize(): bool {

return this.optimizeLevelHint > 0 || this.shrinkLevelHint > 0;

}

/** Tests if a specific feature is activated. */

hasFeature(feature: Feature): bool {

return (this.features & feature) != 0;

}

}

/** Various constraints in expression compilation. */

export const enum Constraints {

NONE = 0,

/** Must implicitly convert to the target type. */

CONV_IMPLICIT = 1 << 0,

/** Must explicitly convert to the target type. */

CONV_EXPLICIT = 1 << 1,

/** Must wrap small integer values to match the target type. */

MUST_WRAP = 1 << 2,

/** Indicates that the value will be dropped immediately. */

WILL_DROP = 1 << 3,

/** Indicates that the value will be retained immediately. */

WILL_RETAIN = 1 << 4,

/** Indicates that static data is preferred. */

PREFER_STATIC = 1 << 5

}

/** Runtime features to be activated by the compiler. */

export const enum RuntimeFeatures {

NONE = 0,

/** Requires heap setup. */

HEAP = 1 << 0,

/** Requires runtime type information setup. */

RTTI = 1 << 1,

/** Requires the built-in globals visitor. */

visitGlobals = 1 << 2,

/** Requires the built-in members visitor. */

visitMembers = 1 << 3

}

/** Exported names of compiler-generated elements. */

export namespace ExportNames {

/** Name of the explicit start function, if applicable. */

export const start = "_start"; // match WASI

/** Name of the argumentsLength varargs helper global. */

export const argumentsLength = "__argumentsLength";

/** Name of the alternative argumentsLength setter function. */

export const setArgumentsLength = "__setArgumentsLength";

/** Name of the memory instance, if exported. */

export const memory = "memory";

/** Name of the table instance, if exported. */

export const table = "table";

}

/** Compiler interface. */

export class Compiler extends DiagnosticEmitter {

/** Program reference. */

program: Program;

/** Resolver reference. */

get resolver(): Resolver { return this.program.resolver; }

/** Provided options. */

get options(): Options { return this.program.options; }

/** Module instance being compiled. */

module: Module;

/** Current control flow. */

currentFlow: Flow;

/** Current parent element if not a function, i.e. an enum or namespace. */

currentParent: Element | null = null;

/** Current type in compilation. */

currentType: Type = Type.void;

/** Start function statements. */

currentBody: ExpressionRef[];

/** Counting memory offset. */

memoryOffset: i64;

/** Memory segments being compiled. */

memorySegments: MemorySegment[] = [];

/** Map of already compiled static string segments. */

stringSegments: Map<string,MemorySegment> = new Map();

/** Function table being compiled. First elem is blank. */

functionTable: string[] = [];

/** Arguments length helper global. */

builtinArgumentsLength: GlobalRef = 0;

/** Requires runtime features. */

runtimeFeatures: RuntimeFeatures = RuntimeFeatures.NONE;

/** Expressions known to have skipped an autorelease. Usually function returns. */

skippedAutoreleases: Set<ExpressionRef> = new Set();

/** Current inline functions stack. */

inlineStack: Function[] = [];

/** Lazily compiled library functions. */

lazyLibraryFunctions: Set<Function> = new Set();

/** Pending class-specific instanceof helpers. */

pendingClassInstanceOf: Set<ClassPrototype> = new Set();

/** Functions potentially involving a virtual call. */

virtualCalls: Set<Function> = new Set();

/** Compiles a {@link Program} to a {@link Module} using the specified options. */

static compile(program: Program): Module {

return new Compiler(program).compile();

}

/** Constructs a new compiler for a {@link Program} using the specified options. */

constructor(program: Program) {

super(program.diagnostics);

this.program = program;

var options = program.options;

var module = Module.create();

this.module = module;

if (options.memoryBase) {

this.memoryOffset = i64_new(options.memoryBase);

module.setLowMemoryUnused(false);

} else {

if (!options.lowMemoryLimit && options.optimizeLevelHint >= 2) {

this.memoryOffset = i64_new(1024);

module.setLowMemoryUnused(true);

} else {

this.memoryOffset = i64_new(8);

module.setLowMemoryUnused(false);

}

}

var featureFlags: FeatureFlags = 0;

if (options.hasFeature(Feature.SIGN_EXTENSION)) featureFlags |= FeatureFlags.SignExt;

if (options.hasFeature(Feature.MUTABLE_GLOBALS)) featureFlags |= FeatureFlags.MutableGloabls;

if (options.hasFeature(Feature.NONTRAPPING_F2I)) featureFlags |= FeatureFlags.NontrappingFPToInt;

if (options.hasFeature(Feature.BULK_MEMORY)) featureFlags |= FeatureFlags.BulkMemory;

if (options.hasFeature(Feature.SIMD)) featureFlags |= FeatureFlags.SIMD128;

if (options.hasFeature(Feature.THREADS)) featureFlags |= FeatureFlags.Atomics;

if (options.hasFeature(Feature.EXCEPTION_HANDLING)) featureFlags |= FeatureFlags.ExceptionHandling;

if (options.hasFeature(Feature.TAIL_CALLS)) featureFlags |= FeatureFlags.TailCall;

if (options.hasFeature(Feature.REFERENCE_TYPES)) featureFlags |= FeatureFlags.ReferenceTypes;

if (options.hasFeature(Feature.MULTI_VALUE)) featureFlags |= FeatureFlags.MultiValue;

module.setFeatures(featureFlags);

}

initializeProgram(): void {

// initialize lookup maps, built-ins, imports, exports, etc.

this.program.initialize(this.options);

}

/** Performs compilation of the underlying {@link Program} to a {@link Module}. */

compile(): Module {

var options = this.options;

var module = this.module;

var program = this.program;

// check and perform this program initialization if it hasn't been done

this.initializeProgram();

// set up the main start function

var startFunctionInstance = program.makeNativeFunction(BuiltinNames.start, new Signature(program, [], Type.void));

startFunctionInstance.internalName = BuiltinNames.start;

var startFunctionBody = new Array<ExpressionRef>();

this.currentFlow = startFunctionInstance.flow;

this.currentBody = startFunctionBody;

// add mutable heap and rtti base dummies

if (options.isWasm64) {

module.addGlobal(BuiltinNames.heap_base, NativeType.I64, true, module.i64(0));

module.addGlobal(BuiltinNames.rtti_base, NativeType.I64, true, module.i64(0));

} else {

module.addGlobal(BuiltinNames.heap_base, NativeType.I32, true, module.i32(0));

module.addGlobal(BuiltinNames.rtti_base, NativeType.I32, true, module.i32(0));

}

// compile entry file(s) while traversing reachable elements

var files = program.filesByName;

// TODO: for (let file of files.values()) {

for (let _values = Map_values(files), i = 0, k = _values.length; i < k; ++i) {

let file = unchecked(_values[i]);

if (file.source.sourceKind == SourceKind.USER_ENTRY) {

this.compileFile(file);

this.compileExports(file);

}

}

// compile the start function if not empty or if explicitly requested

var startIsEmpty = !startFunctionBody.length;

var explicitStart = program.isWasi || options.explicitStart;

if (!startIsEmpty || explicitStart) {

let signature = startFunctionInstance.signature;

if (!startIsEmpty && explicitStart) {

module.addGlobal(BuiltinNames.started, NativeType.I32, true, module.i32(0));

startFunctionBody.unshift(

module.if(

module.global_get(BuiltinNames.started, NativeType.I32),

module.return(),

module.global_set(BuiltinNames.started, module.i32(1))

)

);

}

let funcRef = module.addFunction(

startFunctionInstance.internalName,

signature.nativeParams,

signature.nativeResults,

typesToNativeTypes(startFunctionInstance.additionalLocals),

module.flatten(startFunctionBody)

);

startFunctionInstance.finalize(module, funcRef);

if (!explicitStart) module.setStart(funcRef);

else module.addFunctionExport(startFunctionInstance.internalName, ExportNames.start);

}

// check if the entire program is acyclic

var cyclicClasses = program.findCyclicClasses();

if (cyclicClasses.size) {

if (options.pedantic) {

// TODO: for (let classInstance of cyclicClasses) {

for (let _values = Set_values(cyclicClasses), i = 0, k = _values.length; i < k; ++i) {

let classInstance = unchecked(_values[i]);

this.pedantic(

DiagnosticCode.Type_0_is_cyclic_Module_will_include_deferred_garbage_collection,

classInstance.identifierNode.range, classInstance.internalName

);

}

}

} else {

program.registerConstantInteger("__GC_ALL_ACYCLIC", Type.bool, i64_new(1, 0));

}

// compile lazy library functions

var lazyLibraryFunctions = this.lazyLibraryFunctions;

do {

let functionsToCompile = new Array<Function>();

// TODO: for (let instance of lazyLibraryFunctions) {

for (let _values = Set_values(lazyLibraryFunctions), i = 0, k = _values.length; i < k; ++i) {

let instance = unchecked(_values[i]);

functionsToCompile.push(instance);

}

lazyLibraryFunctions.clear();

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

this.compileFunction(unchecked(functionsToCompile[i]), true);

}

} while (lazyLibraryFunctions.size);

// compile pending class-specific instanceof helpers

// TODO: for (let prototype of this.pendingClassInstanceOf.values()) {

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

let prototype = unchecked(_values[i]);

compileClassInstanceOf(this, prototype);

}

// set up virtual lookup tables

this.setupVirtualLookupTables();

// finalize runtime features

module.removeGlobal(BuiltinNames.rtti_base);

if (this.runtimeFeatures & RuntimeFeatures.RTTI) compileRTTI(this);

if (this.runtimeFeatures & RuntimeFeatures.visitGlobals) compileVisitGlobals(this);

if (this.runtimeFeatures & RuntimeFeatures.visitMembers) compileVisitMembers(this);

// update the heap base pointer

var memoryOffset = this.memoryOffset;

memoryOffset = i64_align(memoryOffset, options.usizeType.byteSize);

var lowMemoryLimit32 = this.options.lowMemoryLimit;

if (lowMemoryLimit32) {

let lowMemoryLimit = i64_new(lowMemoryLimit32 & ~15);

if (i64_gt(memoryOffset, lowMemoryLimit)) {

this.error(

DiagnosticCode.Low_memory_limit_exceeded_by_static_data_0_1,

null, i64_to_string(memoryOffset), i64_to_string(lowMemoryLimit)

);

}

}

this.memoryOffset = memoryOffset;

module.removeGlobal(BuiltinNames.heap_base);

if (this.runtimeFeatures & RuntimeFeatures.HEAP) {

if (options.isWasm64) {

module.addGlobal(

BuiltinNames.heap_base,

NativeType.I64,

false,

module.i64(i64_low(memoryOffset), i64_high(memoryOffset))

);

} else {

module.addGlobal(

BuiltinNames.heap_base,

NativeType.I32,

false,

module.i32(i64_low(memoryOffset))

);

}

}

// set up memory

var isSharedMemory = options.hasFeature(Feature.THREADS) && options.sharedMemory > 0;

module.setMemory(

this.options.memoryBase /* is specified */ || this.memorySegments.length

? i64_low(i64_shr_u(i64_align(memoryOffset, 0x10000), i64_new(16)))

: 0,

isSharedMemory ? options.sharedMemory : Module.UNLIMITED_MEMORY,

this.memorySegments,

options.target,

ExportNames.memory,

isSharedMemory

);

// import memory if requested (default memory is named '0' by Binaryen)

if (options.importMemory) module.addMemoryImport("0", "env", "memory", isSharedMemory);

// set up function table (first elem is blank)

var functionTable = this.functionTable;

var tableBase = this.options.tableBase;

if (!tableBase) tableBase = 1; // leave first elem blank

module.setFunctionTable(tableBase + functionTable.length, Module.UNLIMITED_TABLE, functionTable, module.i32(tableBase));

// import and/or export table if requested (default table is named '0' by Binaryen)

if (options.importTable) {

module.addTableImport("0", "env", "table");

if (options.pedantic && options.willOptimize) {

this.pedantic(

DiagnosticCode.Importing_the_table_disables_some_indirect_call_optimizations,

null

);

}

}

if (options.exportTable) {

module.addTableExport("0", ExportNames.table);

if (options.pedantic && options.willOptimize) {

this.pedantic(

DiagnosticCode.Exporting_the_table_disables_some_indirect_call_optimizations,

null

);

}

}

// set up module exports

// TODO: for (let file of this.program.filesByName.values()) {

for (let _values = Map_values(this.program.filesByName), i = 0, k = _values.length; i < k; ++i) {

let file = unchecked(_values[i]);

if (file.source.sourceKind == SourceKind.USER_ENTRY) this.ensureModuleExports(file);

}

return module;

}

private setupVirtualLookupTables(): void {

// TODO: :-)

var program = this.program;

var virtualCalls = this.virtualCalls;

// Virtual instance methods in the function table are potentially called virtually

var functionTable = this.functionTable;

var elementsByName = program.elementsByName;

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

let instanceName = unchecked(functionTable[i]);

if (elementsByName.has(instanceName)) { // otherwise ~anonymous

let instance = assert(elementsByName.get(instanceName));

if (instance.is(CommonFlags.INSTANCE | CommonFlags.VIRTUAL)) {

assert(instance.kind == ElementKind.FUNCTION);

virtualCalls.add(<Function>instance);

}

}

}

// Inject a virtual lookup table into each function potentially called virtually

// TODO: for (let instance of virtualCalls.values()) {

for (let _values = Set_values(virtualCalls), i = 0, k = _values.length; i < k; ++i) {

let instance = unchecked(_values[i]);

this.warning(

DiagnosticCode.Function_0_is_possibly_called_virtually_which_is_not_yet_supported,

instance.identifierNode.range, instance.internalName

);

}

}

// === Exports ==================================================================================

/** Applies the respective module exports for the specified file. */

private ensureModuleExports(file: File): void {

var exports = file.exports;

if (exports) {

// TODO: for (let [elementName, element] of exports) {

for (let _keys = Map_keys(exports), i = 0, k = _keys.length; i < k; ++i) {

let elementName = unchecked(_keys[i]);

let element = assert(exports.get(elementName));

this.ensureModuleExport(elementName, element);

}

}

var exportsStar = file.exportsStar;

if (exportsStar) {

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

this.ensureModuleExports(exportsStar[i]);

}

}

}

/** Applies the respective module export(s) for the specified element. */

private ensureModuleExport(name: string, element: Element, prefix: string = ""): void {

switch (element.kind) {

// traverse instances

case ElementKind.FUNCTION_PROTOTYPE: {

let functionInstances = (<FunctionPrototype>element).instances;

if (functionInstances) {

// TODO: for (let instance of instances.values()) {

for (let _values = Map_values(functionInstances), i = 0, k = _values.length; i < k; ++i) {

let instance = unchecked(_values[i]);

let instanceName = name;

if (instance.is(CommonFlags.GENERIC)) {

let fullName = instance.internalName;

instanceName += fullName.substring(fullName.lastIndexOf("<"));

}

this.ensureModuleExport(instanceName, instance, prefix);

}

}

break;

}

case ElementKind.CLASS_PROTOTYPE: {

let classInstances = (<ClassPrototype>element).instances;

if (classInstances) {

// TODO: for (let instance of instances.values()) {

for (let _values = Map_values(classInstances), i = 0, k = _values.length; i < k; ++i) {

let instance = unchecked(_values[i]);

let instanceName = name;

if (instance.is(CommonFlags.GENERIC)) {

let fullName = instance.internalName;

instanceName += fullName.substring(fullName.lastIndexOf("<"));

}

this.ensureModuleExport(instanceName, instance, prefix);

}

}

break;

}

case ElementKind.PROPERTY_PROTOTYPE: {

let propertyPrototype = <PropertyPrototype>element;

let getterPrototype = propertyPrototype.getterPrototype;

if (getterPrototype) this.ensureModuleExport(GETTER_PREFIX + name, getterPrototype, prefix);

let setterPrototype = propertyPrototype.setterPrototype;

if (setterPrototype) this.ensureModuleExport(SETTER_PREFIX + name, setterPrototype, prefix);

break;

}

// export concrete elements

case ElementKind.GLOBAL: {

let global = <Global>element;

let isConst = global.is(CommonFlags.CONST) || global.is(CommonFlags.STATIC | CommonFlags.READONLY);

if (!isConst && !this.options.hasFeature(Feature.MUTABLE_GLOBALS)) {

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

global.identifierNode.range

);

} else {

this.module.addGlobalExport(element.internalName, prefix + name);

}

break;

}

case ElementKind.ENUMVALUE: {

let enumValue = <EnumValue>element;

if (!enumValue.isImmutable && !this.options.hasFeature(Feature.MUTABLE_GLOBALS)) {

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

enumValue.identifierNode.range

);

} else {

this.module.addGlobalExport(element.internalName, prefix + name);

}

break;

}

case ElementKind.FUNCTION: {

let functionInstance = <Function>element;

let signature = functionInstance.signature;

if (signature.requiredParameters < signature.parameterTypes.length) {

// utilize trampoline to fill in omitted arguments

functionInstance = this.ensureTrampoline(functionInstance);

this.ensureBuiltinArgumentsLength();

}

if (functionInstance.is(CommonFlags.COMPILED)) this.module.addFunctionExport(functionInstance.internalName, prefix + name);

break;

}

case ElementKind.PROPERTY: {

let propertyInstance = <Property>element;

let getter = propertyInstance.getterInstance;

if (getter) this.ensureModuleExport(GETTER_PREFIX + name, getter, prefix);

let setter = propertyInstance.setterInstance;

if (setter) this.ensureModuleExport(SETTER_PREFIX + name, setter, prefix);

break;

}

case ElementKind.FIELD: {

let fieldInstance = <Field>element;

if (element.is(CommonFlags.COMPILED)) {

let module = this.module;

module.addFunctionExport(fieldInstance.internalGetterName, prefix + GETTER_PREFIX + name);

if (!element.is(CommonFlags.READONLY)) {

module.addFunctionExport(fieldInstance.internalSetterName, prefix + SETTER_PREFIX + name);

}

}

break;

}

case ElementKind.CLASS: {

let classInstance = <Class>element;

// make the class name itself represent its runtime id

if (!classInstance.type.isUnmanaged) {

let module = this.module;

let internalName = classInstance.internalName;

module.addGlobal(internalName, NativeType.I32, false, module.i32(classInstance.id));

module.addGlobalExport(internalName, prefix + name);

}

break;

}

// just traverse members below

case ElementKind.ENUM:

case ElementKind.NAMESPACE:

case ElementKind.TYPEDEFINITION:

case ElementKind.INDEXSIGNATURE: break;

default: assert(false); // unexpected module export

}

// traverse members

var members = element.members;

if (members) {

let subPrefix = prefix + name + (element.kind == ElementKind.CLASS

? INSTANCE_DELIMITER

: STATIC_DELIMITER

);

if (element.kind == ElementKind.NAMESPACE) {

let implicitExport = element.is(CommonFlags.SCOPED);

// TODO: for (let [memberName, member] of members) {

for (let _keys = Map_keys(members), i = 0, k = _keys.length; i < k; ++i) {

let memberName = unchecked(_keys[i]);

let member = assert(members.get(memberName));

if (implicitExport || member.is(CommonFlags.EXPORT)) {

this.ensureModuleExport(memberName, member, subPrefix);

}

}

} else {

// TODO: for (let [memberName, member] of members) {

for (let _keys = Map_keys(members), i = 0, k = _keys.length; i < k; ++i) {

let memberName = unchecked(_keys[i]);

let member = assert(members.get(memberName));

if (!member.is(CommonFlags.PRIVATE)) {

this.ensureModuleExport(memberName, member, subPrefix);

}

}

}

}

}

// === Elements =================================================================================

/** Compiles any element. */

compileElement(element: Element, compileMembers: bool = true): void {

switch (element.kind) {

case ElementKind.GLOBAL: {

this.compileGlobal(<Global>element);

break;

}

case ElementKind.ENUM: {

this.compileEnum(<Enum>element);

break;

}

case ElementKind.FUNCTION_PROTOTYPE: {

if (!element.is(CommonFlags.GENERIC)) {

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

if (instance) this.compileFunction(instance);

}

break;

}

case ElementKind.CLASS_PROTOTYPE: {

if (!element.is(CommonFlags.GENERIC)) {

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

if (instance) this.compileClass(instance);

}

break;

}

case ElementKind.PROPERTY_PROTOTYPE: {

let propertyPrototype = <PropertyPrototype>element;

let getterPrototype = propertyPrototype.getterPrototype;

if (getterPrototype) {

assert(!getterPrototype.is(CommonFlags.GENERIC));

let instance = this.resolver.resolveFunction(getterPrototype, null);

if (instance) this.compileFunction(instance);

}

let setterPrototype = propertyPrototype.setterPrototype;

if (setterPrototype) {

assert(!setterPrototype.is(CommonFlags.GENERIC));

let instance = this.resolver.resolveFunction(setterPrototype, null);

if (instance) this.compileFunction(instance);

}

break;

}

case ElementKind.NAMESPACE:

case ElementKind.TYPEDEFINITION:

case ElementKind.ENUMVALUE:

case ElementKind.INDEXSIGNATURE: break;

default: assert(false);

}

if (compileMembers) {

let members = element.members;

if (members) {

// TODO: for (let element of members.values()) {

for (let _values = Map_values(members), i = 0, k = _values.length; i < k; ++i) {

let element = unchecked(_values[i]);

this.compileElement(element);

}

}

}

}

/** Compiles a file's exports. */

compileExports(file: File): void {

var exports = file.exports;

if (exports) {

// TODO: for (let element of exports.values()) {

for (let _values = Map_values(exports), i = 0, k = _values.length; i < k; ++i) {

let element = unchecked(_values[i]);

this.compileElement(element);

}

}

var exportsStar = file.exportsStar;

if (exportsStar) {

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

let exportStar = unchecked(exportsStar[i]);

this.compileFile(exportStar);

this.compileExports(exportStar);

}

}

}

// files

/** Compiles the file matching the specified path. */

compileFileByPath(normalizedPathWithoutExtension: string, reportNode: Node): void {

var file: File;

var filesByName = this.program.filesByName;

var pathWithIndex: string;

if (filesByName.has(normalizedPathWithoutExtension)) {

file = assert(filesByName.get(normalizedPathWithoutExtension));

} else if (filesByName.has(pathWithIndex = normalizedPathWithoutExtension + INDEX_SUFFIX)) {

file = assert(filesByName.get(pathWithIndex));

} else {

this.error(

DiagnosticCode.File_0_not_found,

reportNode.range, normalizedPathWithoutExtension

);

return;

}

this.compileFile(file);

}

/** Compiles the specified file. */

compileFile(file: File): void {

if (file.is(CommonFlags.COMPILED)) return;

file.set(CommonFlags.COMPILED);

// compile top-level statements within the file's start function

var startFunction = file.startFunction;

var startSignature = startFunction.signature;

var previousBody = this.currentBody;

var startFunctionBody = new Array<ExpressionRef>();

this.currentBody = startFunctionBody;

// compile top-level statements

var previousFlow = this.currentFlow;

var flow = startFunction.flow;

this.currentFlow = flow;

for (let statements = file.source.statements, i = 0, k = statements.length; i < k; ++i) {

this.compileTopLevelStatement(statements[i], startFunctionBody);

}

this.finishAutoreleases(flow, startFunctionBody);

// no need to insert unreachable since last statement should have done that

this.currentFlow = previousFlow;

this.currentBody = previousBody;

// if top-level statements are present, make the per-file start function and call it in start

if (startFunctionBody.length) {

let module = this.module;

let locals = startFunction.localsByIndex;

let numLocals = locals.length;

let varTypes = new Array<NativeType>(numLocals);

for (let i = 0; i < numLocals; ++i) varTypes[i] = locals[i].type.toNativeType();

module.addFunction(

startFunction.internalName,

startSignature.nativeParams,

startSignature.nativeResults,

varTypes,

module.flatten(startFunctionBody)

);

previousBody.push(

module.call(startFunction.internalName, null, NativeType.None)

);

}

}

// === Globals ==================================================================================

/** Compiles a global variable. */

compileGlobal(global: Global): bool {

if (global.is(CommonFlags.COMPILED)) return true;

global.set(CommonFlags.COMPILED);

var module = this.module;

var initExpr: ExpressionRef = 0;

var typeNode = global.typeNode;

var initializerNode = global.initializerNode;

if (!global.is(CommonFlags.RESOLVED)) {

// Resolve type if annotated

if (typeNode) {

let resolvedType = this.resolver.resolveType(typeNode, global.parent); // reports

if (!resolvedType) return false;

if (resolvedType == Type.void) {

this.error(

DiagnosticCode.Type_expected,

typeNode.range

);

return false;

}

global.setType(resolvedType);

// Otherwise infer type from initializer

} else if (initializerNode) {

let previousFlow = this.currentFlow;

if (global.hasDecorator(DecoratorFlags.LAZY)) {

this.currentFlow = global.file.startFunction.flow;

}

initExpr = this.compileExpression(initializerNode, Type.auto, // reports

Constraints.MUST_WRAP | Constraints.WILL_RETAIN | Constraints.PREFER_STATIC

);

this.currentFlow = previousFlow;

if (this.currentType == Type.void) {

this.error(

DiagnosticCode.Type_0_is_not_assignable_to_type_1,

initializerNode.range, this.currentType.toString(), "<auto>"

);

return false;

}

global.setType(this.currentType);

// Error if there's neither a type nor an initializer

} else {

this.error(

DiagnosticCode.Type_expected,

global.identifierNode.range.atEnd

);

return false;

}

}

// Handle ambient builtins like '__heap_base' that need to be resolved but are added explicitly

if (global.is(CommonFlags.AMBIENT) && global.hasDecorator(DecoratorFlags.BUILTIN)) {

if (global.internalName == BuiltinNames.heap_base) this.runtimeFeatures |= RuntimeFeatures.HEAP;

else if (global.internalName == BuiltinNames.rtti_base) this.runtimeFeatures |= RuntimeFeatures.RTTI;

return true;

}