/**

* The AssemblyScript compiler.

* @module compiler

*//***/

import {

BuiltinSymbols,

compileCall as compileBuiltinCall,

compileAbort,

compileVisitGlobals,

compileVisitMembers,

compileRTTI,

} 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,

getBlockChildCount,

getBlockChild,

getBlockName,

getLocalGetIndex,

isLocalTee,

getLocalSetIndex,

FeatureFlags,

needsExplicitUnreachable,

getLocalSetValue

} from "./module";

import {

CommonFlags,

INSTANCE_DELIMITER,

STATIC_DELIMITER,

GETTER_PREFIX,

SETTER_PREFIX,

CommonSymbols,

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,

findUsedLocals

} from "./flow";

import {

Resolver, ReportMode

} from "./resolver";

import {

Token,

operatorTokenToString

} from "./tokenizer";

import {

Node,

NodeKind,

NamedTypeNode,

Range,

DecoratorKind,

AssertionKind,

Statement,

BlockStatement,

BreakStatement,

ClassDeclaration,

ContinueStatement,

DeclarationStatement,

DoStatement,

EmptyStatement,

EnumDeclaration,

ExportStatement,

ExpressionStatement,

FieldDeclaration,

ForStatement,

FunctionDeclaration,

IfStatement,

ImportStatement,

InstanceOfExpression,

InterfaceDeclaration,

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,

nodeIsConstantValue,

findDecorator,

isTypeOmitted,

ExportDefaultStatement,

SourceKind

} 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, 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;

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

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

}

}

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

}

/** Compiler interface. */

export class Compiler extends DiagnosticEmitter {

/** Program reference. */

program: Program;

/** Resolver reference. */

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

/** Provided options. */

options: Options;

/** Module instance being compiled. */

module: Module;

/** Current control flow. */

currentFlow: Flow;

/** Current inline functions stack. */

currentInlineFunctions: Function[] = [];

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

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

/** Argument count helper global. */

argcVar: GlobalRef = 0;

/** Argument count helper setter. */

argcSet: FunctionRef = 0;

/** Requires runtime features. */

runtimeFeatures: RuntimeFeatures = RuntimeFeatures.NONE;

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

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

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

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

var featureFlags: BinaryenFeatureFlags = 0;

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

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

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

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

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

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

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

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

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

this.module.setFeatures(featureFlags);

}

/** 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 main start function

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

startFunctionInstance.internalName = "start";

var startFunctionBody = new Array<ExpressionRef>();

this.currentFlow = startFunctionInstance.flow;

this.currentBody = startFunctionBody;

// add a mutable heap and rtti base dummies

if (options.isWasm64) {

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

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

} else {

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

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

}

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

var files = program.filesByName;

for (let file of files.values()) {

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

this.compileFile(file);

this.compileExports(file);

}

}

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

var startIsEmpty = !startFunctionBody.length;

var explicitStart = options.explicitStart;

if (!startIsEmpty || explicitStart) {

let signature = startFunctionInstance.signature;

if (!startIsEmpty && explicitStart) {

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

startFunctionBody.unshift(

module.if(

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

module.return(),

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

)

);

}

let funcRef = module.addFunction(

startFunctionInstance.internalName,

this.ensureFunctionType(

signature.parameterTypes,

signature.returnType,

signature.thisType

),

typesToNativeTypes(startFunctionInstance.additionalLocals),

module.block(null, startFunctionBody)

);

startFunctionInstance.finalize(module, funcRef);

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

else module.addFunctionExport(startFunctionInstance.internalName, "__start");

}

// compile runtime features

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

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

module.removeGlobal(BuiltinSymbols.rtti_base);

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

// update the heap base pointer

var memoryOffset = this.memoryOffset;

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

this.memoryOffset = memoryOffset;

module.removeGlobal(BuiltinSymbols.heap_base);

if (this.runtimeFeatures & RuntimeFeatures.HEAP) {

if (options.isWasm64) {

module.addGlobal(

BuiltinSymbols.heap_base,

NativeType.I64,

false,

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

);

} else {

module.addGlobal(

BuiltinSymbols.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)))

: 0,

isSharedMemory ? options.sharedMemory : Module.UNLIMITED_MEMORY,

this.memorySegments,

options.target,

"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

var functionTable = this.functionTable;

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

module.addFunction("null", this.ensureFunctionType(null, Type.void), null, module.block(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 file of this.program.filesByName.values()) {

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

}

return module;

}

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

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

private ensureModuleExports(file: File): void {

var members = file.exports;

if (members) for (let [name, member] of members) this.ensureModuleExport(name, member);

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 instances = (<FunctionPrototype>element).instances;

if (instances) {

for (let instance of instances.values()) {

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 instances = (<ClassPrototype>element).instances;

if (instances) {

for (let instance of instances.values()) {

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 getter = (<PropertyPrototype>element).getterPrototype;

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

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

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

break;

}

// export concrete elements

case ElementKind.GLOBAL: {

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

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

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

(<Global>element).identifierNode.range

);

} else {

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

}

break;

}

case ElementKind.ENUMVALUE: {

if (!(<EnumValue>element).isImmutable && !this.options.hasFeature(Feature.MUTABLE_GLOBALS)) {

this.error(

DiagnosticCode.Cannot_export_a_mutable_global,

(<EnumValue>element).identifierNode.range

);

} else {

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

}

break;

}

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;

}

case ElementKind.PROPERTY: {

let getter = (<Property>element).getterInstance;

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

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

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

break;

}

case ElementKind.FIELD: {

this.ensureModuleFieldGetter(prefix + GETTER_PREFIX + name, <Field>element);

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

this.ensureModuleFieldSetter(prefix + SETTER_PREFIX + name, <Field>element);

}

break;

}

case ElementKind.CLASS: {

// make the class name itself represent its runtime id

if (!(<Class>element).type.isUnmanaged) {

let module = this.module;

let internalName = (<Class>element).internalName;

module.addGlobal(internalName, NativeType.I32, false, module.i32((<Class>element).id));

module.addGlobalExport(internalName, prefix + name);

}

break;

}

// just traverse members below

case ElementKind.ENUM:

case ElementKind.NAMESPACE:

case ElementKind.FILE:

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

element.kind == ElementKind.FILE

) {

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

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

this.ensureModuleExport(member.name, member, subPrefix);

}

} else {

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

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

this.ensureModuleExport(member.name, member, subPrefix);

}

}

}

}

/** Makes a function to get the value of a field of an exported class. */

private ensureModuleFieldGetter(name: string, field: Field): void {

var type = field.type;

var module = this.module;

var usizeType = this.options.usizeType;

var loadExpr = module.load(type.byteSize, type.is(TypeFlags.SIGNED),

module.local_get(0, usizeType.toNativeType()),

type.toNativeType(), field.memoryOffset

);

// a user-defined getter would return a retained value, so:

if (type.isManaged) loadExpr = this.makeRetain(loadExpr);

module.addFunction(

name,

this.ensureFunctionType(null, type, usizeType),

null,

loadExpr

);

module.addFunctionExport(name, name);

}

/** Makes a function to set the value of a field of an exported class. */

private ensureModuleFieldSetter(name: string, field: Field): void {

var type = field.type;

var module = this.module;

var nativeType = type.toNativeType();

var usizeType = this.options.usizeType;

var nativeSizeType = usizeType.toNativeType();

var valueExpr = module.local_get(1, nativeType);

if (type.isManaged) {

valueExpr = this.makeRetainRelease(

module.load(type.byteSize, false, // oldRef

module.local_get(0, nativeSizeType),

nativeType, field.memoryOffset

),

valueExpr // newRef

);

}

module.addFunction(

name,

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

null,

module.store(

type.byteSize,

module.local_get(0, nativeSizeType),

valueExpr,

nativeType,

field.memoryOffset

)

);

module.addFunctionExport(name, name);

}

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

this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, []);

}

break;

}

case ElementKind.CLASS_PROTOTYPE: {

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

this.compileClassUsingTypeArguments(<ClassPrototype>element, []);

}

break;

}

case ElementKind.PROPERTY_PROTOTYPE: {

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

if (getterPrototype) {

this.compileFunctionUsingTypeArguments(getterPrototype, []);

}

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

if (setterPrototype) {

this.compileFunctionUsingTypeArguments(setterPrototype, []);

}

break;

}

case ElementKind.NAMESPACE:

case ElementKind.TYPEDEFINITION:

case ElementKind.ENUMVALUE:

case ElementKind.INDEXSIGNATURE: break;

default: assert(false, ElementKind[element.kind]);

}

if (compileMembers) this.compileMembers(element);

}

/** Compiles an element's members. */

compileMembers(element: Element): void {

var members = element.members;

if (members) for (let element of members.values()) this.compileElement(element);

}

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

compileExports(file: File): void {

var exports = file.exports;

if (exports) for (let element of exports.values()) this.compileElement(element);

var exportsStar = file.exportsStar;

if (exportsStar) {

for (let exportStar of exportsStar) {

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 = filesByName.get(normalizedPathWithoutExtension)!;

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

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

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,

this.ensureFunctionType(startFunction.signature.parameterTypes, startFunction.signature.returnType),

varTypes,

startFunctionBody.length > 1

? module.block(null, startFunctionBody)

: startFunctionBody[0]

);

previousBody.push(

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

);

}

}

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

compileGlobal(global: Global): bool {

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

global.set(CommonFlags.COMPILED);

var module = this.module;

var initExpr: ExpressionRef = 0;

var initAutoreleaseSkipped: bool = false;

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

);

if (this.skippedAutoreleases.has(initExpr)) initAutoreleaseSkipped = true;

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 == BuiltinSymbols.heap_base) this.runtimeFeatures |= RuntimeFeatures.HEAP;

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

return true;

}

var type = global.type;

var nativeType = type.toNativeType();

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

var isDeclaredInline = global.hasDecorator(DecoratorFlags.INLINE);

// Handle imports

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

// Constant global or mutable globals enabled

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

global.set(CommonFlags.MODULE_IMPORT);

mangleImportName(global, global.declaration);

module.addGlobalImport(

global.internalName,

mangleImportName_moduleName,

mangleImportName_elementName,

nativeType,

!isDeclaredConstant

);

global.set(CommonFlags.COMPILED);

return true;

// Importing mutable globals is not supported in the MVP

} else {

this.error(

DiagnosticCode.Feature_0_is_not_enabled,

global.declaration.range, "mutable-globals"

);

}

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 (initializerNode) {

if (!initExpr) {

let previousFlow = this.currentFlow;

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

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

}

initExpr = this.compileExpression(initializerNode, type,

Constraints.CONV_IMPLICIT | Constraints.MUST_WRAP | Constraints.WILL_RETAIN | Constraints.PREFER_STATIC

);

if (this.skippedAutoreleases.has(initExpr)) initAutoreleaseSkipped = true;

this.currentFlow = previousFlow;

}

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

if (isDeclaredConstant) {

initExpr = module.precomputeExpression(initExpr);

if (getExpressionId(initExpr) != ExpressionId.Const) initializeInStart = true;

} else {

initializeInStart = true;

}

}

// Explicitly inline if annotated

if (isDeclaredInline) {

if (initializeInStart) {

this.warning(

DiagnosticCode.Mutable_value_cannot_be_inlined,

initializerNode.range

);

} else {

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 = type.toNativeZero(module);

}

var internalName = global.internalName;

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

if (isDeclaredInline) {

this.error(

DiagnosticCode.Decorator_0_is_not_valid_here,

assert(findDecorator(DecoratorKind.INLINE, global.decoratorNodes)).range, "inline"

);

}

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

if (type.isManaged && !initAutoreleaseSkipped) initExpr = this.makeRetain(initExpr);

this.currentBody.push(

module.global_set(internalName, initExpr)

);

} else if (!isDeclaredInline) { // compile normally

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

}

return true;

}

// === Enums ====================================================================================

compileEnum(element: Enum): bool {

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

element.set(CommonFlags.COMPILED);

var module = this.module;

var previousParent = this.currentParent;

this.currentParent = element;

var previousValue: EnumValue | null = null;

var previousValueIsMut = false;

var isInline = element.is(CommonFlags.CONST) || element.hasDecorator(DecoratorFlags.INLINE);

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;