/**

* The AssemblyScript compiler.

* @module compiler

*//***/

import {

compileCall as compileBuiltinCall,

compileAllocate,

compileAbort,

compileIterateRoots,

ensureGCHook

} from "./builtins";

import {

DiagnosticCode,

DiagnosticEmitter

} from "./diagnostics";

import {

Module,

MemorySegment,

ExpressionRef,

UnaryOp,

BinaryOp,

NativeType,

FunctionRef,

ExpressionId,

FunctionTypeRef,

GlobalRef,

getExpressionId,

getExpressionType,

getConstValueI32,

getConstValueI64Low,

getConstValueI64High,

getConstValueF32,

getConstValueF64,

getGetLocalIndex,

getBlockChildCount,

getBlockChild,

getBlockName,

needsExplicitUnreachable

} from "./module";

import {

CommonFlags,

PATH_DELIMITER,

INNER_DELIMITER,

INSTANCE_DELIMITER,

STATIC_DELIMITER,

GETTER_PREFIX,

SETTER_PREFIX

} from "./common";

import {

Program,

ClassPrototype,

Class,

Element,

ElementKind,

Enum,

Field,

FunctionPrototype,

Function,

FunctionTarget,

Global,

Local,

Namespace,

EnumValue,

Property,

VariableLikeElement,

FlowFlags,

ConstantValueKind,

Flow,

OperatorKind,

DecoratorFlags

} from "./program";

import {

Resolver, ReportMode

} from "./resolver";

import {

Token,

operatorTokenToString

} from "./tokenizer";

import {

Node,

NodeKind,

TypeNode,

Source,

Range,

DecoratorKind,

Statement,

BlockStatement,

BreakStatement,

ClassDeclaration,

ContinueStatement,

DeclarationStatement,

DoStatement,

EmptyStatement,

EnumDeclaration,

ExportStatement,

ExpressionStatement,

FunctionDeclaration,

ForStatement,

IfStatement,

ImportStatement,

InstanceOfExpression,

InterfaceDeclaration,

NamespaceDeclaration,

ReturnStatement,

SwitchStatement,

ThrowStatement,

TryStatement,

VariableDeclaration,

VariableStatement,

VoidStatement,

WhileStatement,

Expression,

AssertionExpression,

BinaryExpression,

CallExpression,

CommaExpression,

ElementAccessExpression,

FloatLiteralExpression,

FunctionExpression,

IdentifierExpression,

IntegerLiteralExpression,

LiteralExpression,

LiteralKind,

NewExpression,

ObjectLiteralExpression,

ParenthesizedExpression,

PropertyAccessExpression,

TernaryExpression,

ArrayLiteralExpression,

StringLiteralExpression,

UnaryPostfixExpression,

UnaryPrefixExpression,

FieldDeclaration,

nodeIsConstantValue,

isLastStatement,

findDecorator,

getSourceLevelName

} from "./ast";

import {

Type,

TypeKind,

TypeFlags,

Signature,

typesToNativeTypes

} from "./types";

import {

writeI8,

writeI16,

writeI32,

writeI64,

writeF32,

writeF64

} from "./util";

/** Compilation target. */

export enum Target {

/** WebAssembly with 32-bit pointers. */

WASM32,

/** WebAssembly with 64-bit pointers. Experimental and not supported by any runtime yet. */

WASM64

}

/** Compiler options. */

export class Options {

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

target: Target = Target.WASM32;

/** If true, compiles everything instead of just reachable code. */

noTreeShaking: bool = false;

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

noAssert: bool = false;

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

importMemory: bool = false;

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

importTable: bool = false;

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

sourceMap: bool = false;

/** Static memory start offset. */

memoryBase: i32 = 0;

/** Global aliases. */

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

/** Additional features to activate. */

features: Feature = Feature.NONE;

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

}

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

hasFeature(feature: Feature): bool {

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

}

}

/** Indicates specific features to activate. */

export const enum Feature {

/** No additional features. */

NONE = 0,

/** Sign extension operations. */

SIGN_EXTENSION = 1 << 0, // see: https://github.com/WebAssembly/sign-extension-ops

/** Mutable global imports and exports. */

MUTABLE_GLOBAL = 1 << 1 // see: https://github.com/WebAssembly/mutable-global

}

/** Indicates the desired kind of a conversion. */

export const enum ConversionKind {

/** No conversion. */

NONE,

/** Implicit conversion. */

IMPLICIT,

/** Explicit conversion. */

EXPLICIT

}

/** Indicates the desired wrap mode of a conversion. */

export const enum WrapMode {

/** No wrapping. */

NONE,

/** Wrap small integer values. */

WRAP

}

/** Compiler interface. */

export class Compiler extends DiagnosticEmitter {

/** Program reference. */

program: Program;

/** Resolver reference. */

resolver: Resolver;

/** Provided options. */

options: Options;

/** Module instance being compiled. */

module: Module;

/** Current function in compilation. */

currentFunction: Function;

/** Current outer function in compilation, if compiling a function expression. */

currentOuterFunction: Function | null = null;

/** Current inline functions stack. */

currentInlineFunctions: Function[] = [];

/** Current enum in compilation. */

currentEnum: Enum | null = null;

/** Current type in compilation. */

currentType: Type = Type.void;

/** Start function being compiled. */

startFunctionInstance: Function;

/** Start function statements. */

startFunctionBody: 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. */

functionTable: string[] = [ "null" ];

/** Argument count helper global. */

argcVar: GlobalRef = 0;

/** Argument count helper setter. */

argcSet: FunctionRef = 0;

/** Indicates whether the iterateRoots function must be generated. */

needsIterateRoots: bool = false;

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

static compile(program: Program, options: Options | null = null): Module {

return new Compiler(program, options).compile();

}

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

constructor(program: Program, options: Options | null = null) {

super(program.diagnostics);

this.program = program;

this.resolver = program.resolver;

if (!options) options = new Options();

this.options = options;

this.memoryOffset = i64_new(

// leave space for `null`. also functions as a sentinel for erroneous stores at offset 0.

// note that Binaryen's asm.js output utilizes the first 8 bytes for reinterpretations (#1547)

max(options.memoryBase, 8)

);

this.module = Module.create();

}

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

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

program.initialize(options);

// set up the start function

var startFunctionInstance = new Function(program.startFunction, "start", new Signature([], Type.void));

this.startFunctionInstance = startFunctionInstance;

var startFunctionBody = new Array<ExpressionRef>();

this.startFunctionBody = startFunctionBody;

this.currentFunction = startFunctionInstance;

// add a mutable heap base dummy

if (options.isWasm64) {

module.addGlobal(

"HEAP_BASE",

NativeType.I64,

true,

module.createI64(0, 0)

);

} else {

module.addGlobal(

"HEAP_BASE",

NativeType.I32,

false,

module.createI32(0)

);

}

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

var sources = program.sources;

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

if (sources[i].isEntry) this.compileSource(sources[i]);

}

// compile the start function if not empty or called by main

if (startFunctionBody.length || program.mainFunction !== null) {

let signature = startFunctionInstance.signature;

let funcRef = module.addFunction(

startFunctionInstance.internalName,

this.ensureFunctionType(

signature.parameterTypes,

signature.returnType,

signature.thisType

),

typesToNativeTypes(startFunctionInstance.additionalLocals),

module.createBlock(null, startFunctionBody)

);

startFunctionInstance.finalize(module, funcRef);

if (!program.mainFunction) module.setStart(funcRef);

}

// update the heap base pointer

var memoryOffset = this.memoryOffset;

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

this.memoryOffset = memoryOffset;

module.removeGlobal("HEAP_BASE");

if (options.isWasm64) {

module.addGlobal(

"HEAP_BASE",

NativeType.I64,

false,

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

);

} else {

module.addGlobal(

"HEAP_BASE",

NativeType.I32,

false,

module.createI32(i64_low(memoryOffset))

);

}

// determine initial page size

var numPages = this.memorySegments.length

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

: 0;

module.setMemory(

numPages,

this.options.isWasm64

? Module.MAX_MEMORY_WASM64

: Module.MAX_MEMORY_WASM32,

this.memorySegments,

options.target,

"memory"

);

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

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

// set up function table

var functionTable = this.functionTable;

module.setFunctionTable(functionTable.length, 0xffffffff, functionTable);

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

module.addFunction("null", this.ensureFunctionType(null, Type.void), null, module.createBlock(null, []));

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

if (options.importTable) module.addTableImport("0", "env", "table");

// set up module exports

for (let [name, moduleExport] of program.moduleLevelExports) {

this.makeModuleExport(name, moduleExport.element);

}

// set up gc

if (this.needsIterateRoots) compileIterateRoots(this);

return module;

}

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

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

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

for (let member of members.values()) {

if (!member.is(CommonFlags.EXPORT)) continue;

this.makeModuleExport(member.simpleName, member, subPrefix);

}

} else {

for (let member of members.values()) {

if (member.is(CommonFlags.PRIVATE)) continue;

this.makeModuleExport(member.simpleName, member, subPrefix);

}

}

}

switch (element.kind) {

// export global

case ElementKind.GLOBAL: {

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

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

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

if (declaration) {

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

declaration.name.range

);

}

} else {

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

}

break;

}

case ElementKind.ENUMVALUE: {

if (!assert(element.parent).is(CommonFlags.CONST) && !this.options.hasFeature(Feature.MUTABLE_GLOBAL)) {

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

if (declaration) {

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

declaration.name.range

);

}

} else {

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

}

break;

}

// export function

case ElementKind.FUNCTION: {

let instance = <Function>element;

let signature = instance.signature;

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

// utilize trampoline to fill in omitted arguments

instance = this.ensureTrampoline(instance);

this.ensureArgcSet();

}

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

break;

}

// export getter and setter

case ElementKind.PROPERTY: {

let getter = assert((<Property>element).getterPrototype);

this.makeModuleExport(GETTER_PREFIX + name, getter, prefix);

let setter = (<Property>element).setterPrototype;

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

break;

}

// export a getter and a setter

case ElementKind.FIELD: {

let module = this.module;

let type = (<Field>element).type;

let nativeType = type.toNativeType();

let offset = (<Field>element).memoryOffset;

let usizeType = this.options.usizeType;

let nativeSizeType = this.options.nativeSizeType;

// make a getter

let getterName = prefix + GETTER_PREFIX + name;

module.addFunction(

getterName,

this.ensureFunctionType(null, type, usizeType),

null,

module.createLoad(

type.byteSize,

type.is(TypeFlags.SIGNED),

module.createGetLocal(0, nativeSizeType),

nativeType,

offset

)

);

module.addFunctionExport(getterName, getterName);

// make a setter

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

let setterName = prefix + SETTER_PREFIX + name;

module.addFunction(

setterName,

this.ensureFunctionType([ type ], Type.void, usizeType),

null,

module.createStore(

type.byteSize,

module.createGetLocal(0, nativeSizeType),

module.createGetLocal(1, nativeType),

nativeType,

offset

)

);

module.addFunctionExport(setterName, setterName);

}

break;

}

// skip prototype and export instances

case ElementKind.FUNCTION_PROTOTYPE: {

for (let instance of (<FunctionPrototype>element).instances.values()) {

let instanceName = name;

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

let fullName = instance.internalName;

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

}

this.makeModuleExport(instanceName, instance, prefix);

}

break;

}

case ElementKind.CLASS_PROTOTYPE: {

for (let instance of (<ClassPrototype>element).instances.values()) {

let instanceName = name;

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

let fullName = instance.internalName;

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

}

let ctor = instance.constructorInstance;

if (ctor) this.makeModuleExport(instanceName + INSTANCE_DELIMITER + ctor.simpleName, ctor, prefix);

this.makeModuleExport(instanceName, instance, prefix);

}

break;

}

// all possible members already handled above

case ElementKind.ENUM:

case ElementKind.CLASS:

case ElementKind.NAMESPACE: break;

default: assert(false);

}

}

// sources

/** Compiles a source by looking it up by path first. */

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

var source = this.program.lookupSourceByPath(normalizedPathWithoutExtension);

if (source) this.compileSource(source);

else {

this.error(

DiagnosticCode.File_0_not_found,

reportNode.range, normalizedPathWithoutExtension

);

}

}

/** Compiles a source. */

compileSource(source: Source): void {

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

source.set(CommonFlags.COMPILED);

// compile top-level statements

var noTreeShaking = this.options.noTreeShaking;

var isEntry = source.isEntry;

var startFunctionInstance = this.startFunctionInstance;

var startFunctionBody = this.startFunctionBody;

var statements = source.statements;

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

let statement = statements[i];

switch (statement.kind) {

case NodeKind.CLASSDECLARATION: {

if (

(noTreeShaking || (isEntry && statement.is(CommonFlags.EXPORT))) &&

!(<ClassDeclaration>statement).isGeneric

) {

this.compileClassDeclaration(<ClassDeclaration>statement, [], null);

}

break;

}

case NodeKind.INTERFACEDECLARATION: break;

case NodeKind.ENUMDECLARATION: {

if (noTreeShaking || (isEntry && statement.is(CommonFlags.EXPORT))) {

this.compileEnumDeclaration(<EnumDeclaration>statement);

}

break;

}

case NodeKind.FUNCTIONDECLARATION: {

if (

(noTreeShaking || (isEntry && statement.is(CommonFlags.EXPORT))) &&

!(<FunctionDeclaration>statement).isGeneric

) {

this.compileFunctionDeclaration(<FunctionDeclaration>statement, []);

}

break;

}

case NodeKind.IMPORT: {

this.compileSourceByPath(

(<ImportStatement>statement).normalizedPath,

(<ImportStatement>statement).path

);

break;

}

case NodeKind.NAMESPACEDECLARATION: {

if (noTreeShaking || (isEntry && statement.is(CommonFlags.EXPORT))) {

this.compileNamespaceDeclaration(<NamespaceDeclaration>statement);

}

break;

}

case NodeKind.VARIABLE: { // global, always compiled as initializers might have side effects

let variableInit = this.compileVariableStatement(<VariableStatement>statement);

if (variableInit) startFunctionBody.push(variableInit);

break;

}

case NodeKind.EXPORT: {

if ((<ExportStatement>statement).normalizedPath != null) {

this.compileSourceByPath(

<string>(<ExportStatement>statement).normalizedPath,

<StringLiteralExpression>(<ExportStatement>statement).path

);

}

if (noTreeShaking || isEntry) {

this.compileExportStatement(<ExportStatement>statement);

}

break;

}

default: { // otherwise a top-level statement that is part of the start function's body

let previousFunction = this.currentFunction;

this.currentFunction = startFunctionInstance;

startFunctionBody.push(this.compileStatement(statement));

this.currentFunction = previousFunction;

break;

}

}

}

}

// globals

compileGlobalDeclaration(declaration: VariableDeclaration): Global | null {

// look up the initialized program element

var element = assert(this.program.elementsLookup.get(declaration.fileLevelInternalName));

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

if (!this.compileGlobal(<Global>element)) return null; // reports

return <Global>element;

}

compileGlobal(global: Global): bool {

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

global.set(CommonFlags.COMPILED);

var module = this.module;

var declaration = global.declaration;

var initExpr: ExpressionRef = 0;

if (global.type == Type.void) { // type is void if not yet resolved or not annotated

if (declaration) {

// resolve now if annotated

if (declaration.type) {

let resolvedType = this.resolver.resolveType(declaration.type); // reports

if (!resolvedType) return false;

if (resolvedType == Type.void) {

this.error(

DiagnosticCode.Type_expected,

declaration.type.range

);

return false;

}

global.type = resolvedType;

// infer from initializer if not annotated

} else if (declaration.initializer) { // infer type using void/NONE for literal inference

initExpr = this.compileExpressionRetainType( // reports

declaration.initializer,

Type.void,

WrapMode.WRAP

);

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

this.error(

DiagnosticCode.Type_0_is_not_assignable_to_type_1,

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

);

return false;

}

global.type = this.currentType;

// must either be annotated or have an initializer

} else {

this.error(

DiagnosticCode.Type_expected,

declaration.name.range.atEnd

);

return false;

}

} else {

assert(false); // must have a declaration if 'void' (and thus resolved later on)

}

}

// ambient builtins like 'HEAP_BASE' need to be resolved but are added explicitly

if (global.is(CommonFlags.AMBIENT) && global.hasDecorator(DecoratorFlags.BUILTIN)) return true;

var nativeType = global.type.toNativeType();

var isDeclaredConstant = global.is(CommonFlags.CONST) || global.is(CommonFlags.STATIC | CommonFlags.READONLY);

// handle imports

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

// constant global

if (isDeclaredConstant || this.options.hasFeature(Feature.MUTABLE_GLOBAL)) {

global.set(CommonFlags.MODULE_IMPORT);

if (declaration) {

mangleImportName(global, declaration);

} else {

mangleImportName_moduleName = "env";

mangleImportName_elementName = global.simpleName;

}

module.addGlobalImport(

global.internalName,

mangleImportName_moduleName,

mangleImportName_elementName,

nativeType

);

global.set(CommonFlags.COMPILED);

return true;

// importing mutable globals is not supported in the MVP

} else {

this.error(

DiagnosticCode.Operation_not_supported,

assert(declaration).range

);

}

return false;

}

// the MVP does not yet support initializer expressions other than constant values (and constant

// get_globals), hence such initializations must be performed in the start function for now.

var initializeInStart = false;

// evaluate initializer if present

if (declaration !== null && declaration.initializer !== null) {

if (!initExpr) {

initExpr = this.compileExpression(

declaration.initializer,

global.type,

ConversionKind.IMPLICIT,

WrapMode.WRAP

);

}

if (getExpressionId(initExpr) != ExpressionId.Const) {

if (isDeclaredConstant) {

initExpr = module.precomputeExpression(initExpr);

if (getExpressionId(initExpr) != ExpressionId.Const) {

this.warning(

DiagnosticCode.Compiling_constant_with_non_constant_initializer_as_mutable,

declaration.range

);

initializeInStart = true;

}

} else {

initializeInStart = true;

}

}

// explicitly inline if annotated

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

if (!initializeInStart) { // reported above

assert(getExpressionId(initExpr) == ExpressionId.Const);

let exprType = getExpressionType(initExpr);

switch (exprType) {

case NativeType.I32: {

global.constantValueKind = ConstantValueKind.INTEGER;

global.constantIntegerValue = i64_new(getConstValueI32(initExpr), 0);

break;

}

case NativeType.I64: {

global.constantValueKind = ConstantValueKind.INTEGER;

global.constantIntegerValue = i64_new(

getConstValueI64Low(initExpr),

getConstValueI64High(initExpr)

);

break;

}

case NativeType.F32: {

global.constantValueKind = ConstantValueKind.FLOAT;

global.constantFloatValue = getConstValueF32(initExpr);

break;

}

case NativeType.F64: {

global.constantValueKind = ConstantValueKind.FLOAT;

global.constantFloatValue = getConstValueF64(initExpr);

break;

}

default: {

assert(false);

return false;

}

}

global.set(CommonFlags.INLINED); // inline the value from now on

}

}

// initialize to zero if there's no initializer

} else {

initExpr = global.type.toNativeZero(module);

}

var internalName = global.internalName;

if (initializeInStart) { // initialize to mutable zero and set the actual value in start

module.addGlobal(internalName, nativeType, true, global.type.toNativeZero(module));

this.startFunctionBody.push(module.createSetGlobal(internalName, initExpr));

} else { // compile normally

module.addGlobal(internalName, nativeType, !isDeclaredConstant, initExpr);

}

return true;

}

// enums

compileEnumDeclaration(declaration: EnumDeclaration): Enum | null {

var element = assert(this.program.elementsLookup.get(declaration.fileLevelInternalName));

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

if (!this.compileEnum(<Enum>element)) return null;

return <Enum>element;

}

compileEnum(element: Enum): bool {

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

element.set(CommonFlags.COMPILED);

var module = this.module;

this.currentEnum = element;

var previousValue: EnumValue | null = null;

var previousValueIsMut = false;

if (element.members) {

for (let member of element.members.values()) {

if (member.kind != ElementKind.ENUMVALUE) continue; // happens if an enum is also a namespace

let initInStart = false;

let val = <EnumValue>member;

let valueDeclaration = val.declaration;

val.set(CommonFlags.COMPILED);

let initExpr: ExpressionRef;

if (valueDeclaration.value) {

initExpr = this.compileExpression(

<Expression>valueDeclaration.value,

Type.i32,

ConversionKind.IMPLICIT,

WrapMode.NONE

);

if (getExpressionId(initExpr) != ExpressionId.Const) {

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

initExpr = module.precomputeExpression(initExpr);

if (getExpressionId(initExpr) != ExpressionId.Const) {

this.error(

DiagnosticCode.In_const_enum_declarations_member_initializer_must_be_constant_expression,

valueDeclaration.value.range

);

initInStart = true;

}

} else {

initInStart = true;

}

}

} else if (previousValue == null) {

initExpr = module.createI32(0);

} else {

if (previousValueIsMut) {

this.error(

DiagnosticCode.Enum_member_must_have_initializer,

valueDeclaration.range

);

}

initExpr = module.createBinary(BinaryOp.AddI32,

module.createGetGlobal(previousValue.internalName, NativeType.I32),

module.createI32(1)

);

initExpr = module.precomputeExpression(initExpr);

if (getExpressionId(initExpr) != ExpressionId.Const) {

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

this.error(

DiagnosticCode.In_const_enum_declarations_member_initializer_must_be_constant_expression,

valueDeclaration.range

);

}

initInStart = true;

}

}

if (initInStart) {

module.addGlobal(val.internalName, NativeType.I32, true, module.createI32(0));

this.startFunctionBody.push(module.createSetGlobal(val.internalName, initExpr));

previousValueIsMut = true;

} else {

module.addGlobal(val.internalName, NativeType.I32, !element.is(CommonFlags.CONST), initExpr);

previousValueIsMut = false;

}

previousValue = <EnumValue>val;

}

}

this.currentEnum = null;

return true;

}

// functions

/** Compiles a top-level function given its declaration. */

compileFunctionDeclaration(

declaration: FunctionDeclaration,

typeArguments: TypeNode[],

contextualTypeArguments: Map<string,Type> | null = null

): Function | null {

var element = assert(this.program.elementsLookup.get(declaration.fileLevelInternalName));

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

return this.compileFunctionUsingTypeArguments( // reports

<FunctionPrototype>element,

typeArguments,

contextualTypeArguments,

null, // no outer scope (is top level)

(<FunctionPrototype>element).declaration.name

);

}

/** Resolves the specified type arguments prior to compiling the resulting function instance. */

compileFunctionUsingTypeArguments(

prototype: FunctionPrototype,

typeArguments: TypeNode[],

contextualTypeArguments: Map<string,Type> | null,

outerScope: Flow | null,

reportNode: Node

): Function | null {

var instance = this.resolver.resolveFunctionInclTypeArguments(

prototype,

typeArguments,

contextualTypeArguments,

reportNode

);

if (!instance) return null;

instance.outerScope = outerScope;

if (!this.compileFunction(instance)) return null; // reports

return instance;

}

/** Either reuses or creates the function type matching the specified signature. */

ensureFunctionType(

parameterTypes: Type[] | null,

returnType: Type,

thisType: Type | null = null

): FunctionTypeRef {

var numParameters = parameterTypes ? parameterTypes.length : 0;