/**

* @fileoverview The AssemblyScript compiler.

* @license Apache-2.0

*/

import {

BuiltinNames,

BuiltinContext,

builtins,

function_builtins,

compileVisitGlobals,

compileVisitMembers,

compileRTTI,

compileClassInstanceOf

} from "./builtins";

import {

DiagnosticCode,

DiagnosticEmitter

} from "./diagnostics";

import {

Module,

MemorySegment,

ExpressionRef,

UnaryOp,

BinaryOp,

RefIsOp,

TypeRef,

FunctionRef,

ExpressionId,

GlobalRef,

FeatureFlags,

Index,

getExpressionId,

getExpressionType,

getConstValueI32,

getConstValueI64Low,

getConstValueI64High,

getConstValueF32,

getConstValueF64,

getConstValueV128,

getBlockChildCount,

getBlockChildAt,

getBlockName,

needsExplicitUnreachable,

getLocalSetValue,

getGlobalGetName,

isGlobalMutable,

createType,

getSideEffects,

SideEffects,

SwitchBuilder,

ExpressionRunnerFlags,

isConstZero

} from "./module";

import {

CommonFlags,

STATIC_DELIMITER,

INDEX_SUFFIX,

CommonNames,

Feature,

Target,

Runtime,

featureToString

} from "./common";

import {

Program,

ClassPrototype,

Class,

Element,

ElementKind,

DeclaredElement,

Enum,

Field,

FunctionPrototype,

Function,

Global,

Local,

EnumValue,

Property,

VariableLikeElement,

ConstantValueKind,

OperatorKind,

DecoratorFlags,

PropertyPrototype,

IndexSignature,

File,

mangleInternalName

} from "./program";

import {

FlowFlags,

Flow,

LocalFlags,

FieldFlags,

ConditionKind,

findUsedLocals

} from "./flow";

import {

Resolver,

ReportMode

} from "./resolver";

import {

Token,

Range,

operatorTokenToString

} from "./tokenizer";

import {

Node,

NodeKind,

DecoratorKind,

AssertionKind,

SourceKind,

FunctionTypeNode,

DecoratorNode,

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,

TemplateLiteralExpression,

UnaryPostfixExpression,

UnaryPrefixExpression,

CompiledExpression,

TypeNode,

NamedTypeNode,

findDecorator,

isTypeOmitted

} from "./ast";

import {

Type,

TypeKind,

TypeFlags,

Signature,

typesToRefs

} from "./types";

import {

writeI8,

writeI16,

writeI32,

writeI64,

writeF32,

writeF64,

writeV128,

uniqueMap,

isPowerOf2,

v128_zero,

readI32,

isIdentifier

} from "./util";

import {

RtraceMemory

} from "./passes/rtrace";

import {

ShadowStackPass

} from "./passes/shadowstack";

/** Compiler options. */

export class Options {

constructor() { /* as internref */ }

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

target: Target = Target.WASM32;

/** Runtime type. Defaults to Incremental GC. */

runtime: Runtime = Runtime.Incremental;

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

noAssert: bool = false;

/** It true, exports the memory to the embedder. */

exportMemory: bool = true;

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

importMemory: bool = false;

/** Initial memory size, in pages. */

initialMemory: u32 = 0;

/** Maximum memory size, in pages. */

maximumMemory: u32 = 0;

/** If true, memory is declared as shared. */

sharedMemory: bool = false;

/** If true, imported memory is zero filled. */

zeroFilledMemory: bool = false;

/** 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 given, exports the start function instead of calling it implicitly. */

exportStart: string | null = null;

/** Static memory start offset. */

memoryBase: u32 = 0;

/** Static table start offset. */

tableBase: u32 = 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

| Feature.SIGN_EXTENSION

| Feature.NONTRAPPING_F2I

| Feature.BULK_MEMORY;

/** 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: u32 = 0;

/** If true, exports the runtime helpers. */

exportRuntime: bool = false;

/** Stack size in bytes, if using a stack. */

stackSize: i32 = 0;

/** Semantic major bundle version from root package.json */

bundleMajorVersion: i32 = 0;

/** Semantic minor bundle version from root package.json */

bundleMinorVersion: i32 = 0;

/** Semantic patch bundle version from root package.json */

bundlePatchVersion: 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;

/** Hinted basename. */

basenameHint: string = "output";

/** 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 size type reference matching the target. */

get sizeTypeRef(): TypeRef {

return this.target == Target.WASM64 ? TypeRef.I64 : TypeRef.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 static data is preferred. */

PREFER_STATIC = 1 << 4,

/** Indicates that the value will become `this` of a property access or instance call. */

IS_THIS = 1 << 5

}

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

export const enum RuntimeFeatures {

NONE = 0,

/** Requires data setup. */

DATA = 1 << 0,

/** Requires a stack. */

STACK = 1 << 1,

/** Requires heap setup. */

HEAP = 1 << 2,

/** Requires runtime type information setup. */

RTTI = 1 << 3,

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

visitGlobals = 1 << 4,

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

visitMembers = 1 << 5,

/** Requires the setArgumentsLength export. */

setArgumentsLength = 1 << 6

}

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

export namespace ExportNames {

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

}

/** Functions to export if `--exportRuntime` is set. */

const runtimeFunctions = [ "__new", "__pin", "__unpin", "__collect" ];

/** Globals to export if `--exportRuntime` is set. */

const runtimeGlobals = [ "__rtti_base" ];

/** 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: Function[] = [];

/** Arguments length helper global. */

builtinArgumentsLength: GlobalRef = 0;

/** Requires runtime features. */

runtimeFeatures: RuntimeFeatures = RuntimeFeatures.NONE;

/** Current inline functions stack. */

inlineStack: Function[] = [];

/** Lazily compiled functions. */

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

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

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

/** Virtually called stubs that may have overloads. */

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

/** Elements currently undergoing compilation. */

pendingElements: Set<Element> = new Set();

/** Elements, that are module exports, already processed */

doneModuleExports: Set<Element> = new Set();

/** Shadow stack reference. */

shadowStack!: ShadowStackPass;

/** Whether the module has custom function exports. */

hasCustomFunctionExports: bool = false;

/** 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(options.stackSize > 0, options.sizeTypeRef);

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

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

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

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

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;

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

if (options.hasFeature(Feature.MEMORY64)) featureFlags |= FeatureFlags.Memory64;

if (options.hasFeature(Feature.FUNCTION_REFERENCES)) featureFlags |= FeatureFlags.FunctionReferences;

if (options.hasFeature(Feature.RELAXED_SIMD)) featureFlags |= FeatureFlags.RelaxedSIMD;

if (options.hasFeature(Feature.EXTENDED_CONST)) featureFlags |= FeatureFlags.ExtendedConst;

module.setFeatures(featureFlags);

// set up the main start function

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

startFunctionInstance.internalName = BuiltinNames.start;

this.currentFlow = startFunctionInstance.flow;

this.currentBody = new Array<ExpressionRef>();

this.shadowStack = new ShadowStackPass(this);

}

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

var resolver = this.resolver;

var hasShadowStack = options.stackSize > 0; // implies runtime=incremental

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

this.program.initialize();

// obtain the main start function

var startFunctionInstance = this.currentFlow.actualFunction;

assert(startFunctionInstance.internalName == BuiltinNames.start);

var startFunctionBody = this.currentBody;

assert(startFunctionBody.length == 0);

// add mutable data, heap and rtti offset dummies

if (options.isWasm64) {

module.addGlobal(BuiltinNames.data_end, TypeRef.I64, true, module.i64(0));

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

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

} else {

module.addGlobal(BuiltinNames.data_end, TypeRef.I32, true, module.i32(0));

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

module.addGlobal(BuiltinNames.rtti_base, TypeRef.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.compileModuleExports(file);

}

}

// compile and export runtime if requested

if (this.options.exportRuntime) {

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

let name = runtimeFunctions[i];

let instance = program.requireFunction(name);

if (this.compileFunction(instance) && !module.hasExport(name)) {

module.addFunctionExport(instance.internalName, name);

}

}

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

let name = runtimeGlobals[i];

let instance = program.requireGlobal(name);

if (this.compileGlobal(instance) && !module.hasExport(name)) {

module.addGlobalExport(instance.internalName, name);

}

}

}

// compile lazy functions

var lazyFunctions = this.lazyFunctions;

do {

let functionsToCompile = new Array<Function>();

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

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

let instance = unchecked(_values[i]);

functionsToCompile.push(instance);

}

lazyFunctions.clear();

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

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

}

} while (lazyFunctions.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 stubs

var functionTable = this.functionTable;

var virtualStubs = this.virtualStubs;

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

let instance = functionTable[i];

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

assert(instance.is(CommonFlags.INSTANCE));

functionTable[i] = this.ensureVirtualStub(instance); // includes varargs stub

} else if (instance.signature.requiredParameters < instance.signature.parameterTypes.length) {

functionTable[i] = this.ensureVarargsStub(instance);

}

}

var virtualStubsSeen = new Set<Function>();

do {

// virtual stubs and overloads have cross-dependencies on each other, in that compiling

// either may discover the respective other. do this in a loop until no more are found.

resolver.discoveredOverload = false;

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

let instance = unchecked(_values[i]);

let overloadInstances = resolver.resolveOverloads(instance);

if (overloadInstances) {

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

this.compileFunction(overloadInstances[i]);

}

}

virtualStubsSeen.add(instance);

}

} while (virtualStubs.size > virtualStubsSeen.size || resolver.discoveredOverload);

virtualStubsSeen.clear();

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

this.finalizeVirtualStub(_values[i]);

}

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

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

// finalize data

module.removeGlobal(BuiltinNames.data_end);

if ((this.runtimeFeatures & RuntimeFeatures.DATA) != 0 || hasShadowStack) {

if (options.isWasm64) {

module.addGlobal(BuiltinNames.data_end, TypeRef.I64, false,

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

);

} else {

module.addGlobal(BuiltinNames.data_end, TypeRef.I32, false,

module.i32(i64_low(memoryOffset))

);

}

}

// finalize stack (grows down from __heap_base to __data_end)

module.removeGlobal(BuiltinNames.stack_pointer);

if ((this.runtimeFeatures & RuntimeFeatures.STACK) != 0 || hasShadowStack) {

memoryOffset = i64_align(

i64_add(memoryOffset, i64_new(options.stackSize)),

options.usizeType.byteSize

);

if (options.isWasm64) {

module.addGlobal(BuiltinNames.stack_pointer, TypeRef.I64, true,

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

);

} else {

module.addGlobal(BuiltinNames.stack_pointer, TypeRef.I32, true,

module.i32(i64_low(memoryOffset))

);

}

}

// finalize heap

module.removeGlobal(BuiltinNames.heap_base);

if ((this.runtimeFeatures & RuntimeFeatures.HEAP) != 0 || hasShadowStack) {

if (options.isWasm64) {

module.addGlobal(BuiltinNames.heap_base, TypeRef.I64, false,

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

);

} else {

module.addGlobal(BuiltinNames.heap_base, TypeRef.I32, false,

module.i32(i64_low(memoryOffset))

);

}

}

this.memoryOffset = memoryOffset;

// check that we didn't exceed lowMemoryLimit already

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)

);

}

}

// set up memory

var initialPages: u32 = 0;

if (this.options.memoryBase /* is specified */ || this.memorySegments.length) {

initialPages = u32(i64_low(i64_shr_u(i64_align(memoryOffset, 0x10000), i64_new(16))));

}

if (options.initialMemory) {

if (options.initialMemory < initialPages) {

this.error(

DiagnosticCode.Module_requires_at_least_0_pages_of_initial_memory,

null,

initialPages.toString()

);

} else {

initialPages = options.initialMemory;

}

}

var maximumPages = Module.UNLIMITED_MEMORY;

if (options.maximumMemory) {

if (options.maximumMemory < initialPages) {

this.error(

DiagnosticCode.Module_requires_at_least_0_pages_of_maximum_memory,

null,

initialPages.toString()

);

} else {

maximumPages = options.maximumMemory;

}

}

var isSharedMemory = false;

if (options.sharedMemory) {

isSharedMemory = true;

if (!options.maximumMemory) {

this.error(

DiagnosticCode.Shared_memory_requires_maximum_memory_to_be_defined,

null

);

isSharedMemory = false;

}

if (!options.hasFeature(Feature.THREADS)) {

this.error(

DiagnosticCode.Shared_memory_requires_feature_threads_to_be_enabled,

null

);

isSharedMemory = false;

}

}

module.setMemory(

initialPages,

maximumPages,

this.memorySegments,

options.target,

options.exportMemory ? ExportNames.memory : null,

isSharedMemory

);

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

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

// 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 function table (first elem is blank)

var tableBase = this.options.tableBase;

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

var functionTableNames = new Array<string>(functionTable.length);

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

functionTableNames[i] = functionTable[i].internalName;

}

var tableSize = tableBase + functionTable.length;

module.addFunctionTable(

"0",

tableSize,

// use fixed size for non-imported and non-exported tables

options.importTable || options.exportTable ? Module.UNLIMITED_TABLE : tableSize,

functionTableNames,

module.i32(tableBase)

);

// expose the arguments length helper if there are varargs exports

if (this.runtimeFeatures & RuntimeFeatures.setArgumentsLength) {

module.addFunction(BuiltinNames.setArgumentsLength, TypeRef.I32, TypeRef.None, null,

module.global_set(this.ensureArgumentsLength(), module.local_get(0, TypeRef.I32))

);

module.addFunctionExport(BuiltinNames.setArgumentsLength, ExportNames.setArgumentsLength);

}

// NOTE: no more element compiles from here. may go to the start function!

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

var startIsEmpty = !startFunctionBody.length;

var exportStart = options.exportStart;

if (program.isWasi && !exportStart) {

// Try to do the right thing for WASI. If the module has custom function

// exports it is likely a reactor, otherwise it is likely a command.

exportStart = this.hasCustomFunctionExports ? "_initialize" : "_start";

}

if (!startIsEmpty || exportStart != null) {

let signature = startFunctionInstance.signature;

if (!startIsEmpty && exportStart != null) {

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

startFunctionBody.unshift(

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

);

startFunctionBody.unshift(

module.if(

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

module.return()

)

);

}

let funcRef = module.addFunction(

startFunctionInstance.internalName,

signature.paramRefs,

signature.resultRefs,

typesToRefs(startFunctionInstance.additionalLocals),

module.flatten(startFunctionBody)

);

startFunctionInstance.finalize(module, funcRef);

if (exportStart == null) module.setStart(funcRef);

else {

if (!isIdentifier(exportStart) || module.hasExport(exportStart)) {

this.error(

DiagnosticCode.Start_function_name_0_is_invalid_or_conflicts_with_another_export,

this.program.nativeRange, exportStart

);

} else {

module.addFunctionExport(startFunctionInstance.internalName, exportStart);

}

}

}

// Run custom passes

if (hasShadowStack) {

this.shadowStack.walkModule();

}

if (program.lookup("ASC_RTRACE") != null) {

new RtraceMemory(this).walkModule();

}

return module;

}

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

/** Compiles the respective module exports for the specified entry file. */

private compileModuleExports(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.compileModuleExport(elementName, element);

}

}

var exportsStar = file.exportsStar;

if (exportsStar) {

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

this.compileModuleExports(exportsStar[i]);

}

}

}

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

private compileModuleExport(name: string, element: DeclaredElement, prefix: string = ""): void {

var module = this.module;

switch (element.kind) {

case ElementKind.FUNCTION_PROTOTYPE: {

// obtain the default instance

let functionPrototype = <FunctionPrototype>element;

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

let functionInstance = this.resolver.resolveFunction(functionPrototype, null);

if (functionInstance) {

this.compileModuleExport(name, functionInstance, prefix);

}

return;

}

break;

}

case ElementKind.FUNCTION: {

let functionInstance = <Function>element;

if (!functionInstance.hasDecorator(DecoratorFlags.BUILTIN)) {

let signature = functionInstance.signature;

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

// utilize varargs stub to fill in omitted arguments

functionInstance = this.ensureVarargsStub(functionInstance);

this.runtimeFeatures |= RuntimeFeatures.setArgumentsLength;

}

this.compileFunction(functionInstance);

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

let exportName = prefix + name;

if (!module.hasExport(exportName)) {

module.addFunctionExport(functionInstance.internalName, exportName);

this.hasCustomFunctionExports = true;

if (signature.hasManagedOperands) {

this.shadowStack.noteExport(exportName, signature.getManagedOperandIndices());

}

}

return;

}

}

break;

}

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.warning(

DiagnosticCode.Feature_0_is_not_enabled,

global.identifierNode.range, "mutable-globals"

);

return;

}

this.compileGlobal(global);

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

let exportName = prefix + name;

if (!module.hasExport(exportName)) {

module.addGlobalExport(element.internalName, exportName);

}

return;

}

break;

}

case ElementKind.ENUM: {

this.compileEnum(<Enum>element);

let members = element.members;

if (members) {

let subPrefix = prefix + name + STATIC_DELIMITER;

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.compileModuleExport(memberName, member, subPrefix);

}

}

}

return;

}

case ElementKind.ENUMVALUE: {

let enumValue = <EnumValue>element;

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

this.error(

DiagnosticCode.Feature_0_is_not_enabled,

enumValue.identifierNode.range, "mutable-globals"

);

return;

}

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

let exportName = prefix + name;

if (!module.hasExport(exportName)) {

module.addGlobalExport(element.internalName, exportName);

}

return;

}

break;

}

}

this.warning(

DiagnosticCode.Only_variables_functions_and_enums_become_WebAssembly_module_exports,

element.identifierNode.range

);

}

// === 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 functionInstance = this.resolver.resolveFunction(<FunctionPrototype>element, null);

if (functionInstance) this.compileFunction(functionInstance);

}

break;

}

case ElementKind.CLASS_PROTOTYPE: {

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

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

if (classInstance) this.compileClass(classInstance);

}

break;

}

case ElementKind.PROPERTY_PROTOTYPE: {

let propertyInstance = this.resolver.resolveProperty(<PropertyPrototype>element);

if (propertyInstance) this.compileProperty(propertyInstance);

break;

}

case ElementKind.INTERFACE_PROTOTYPE:

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);

}

}

}

}

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