mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-04-25 15:12:12 +00:00
Search parent namespaces when resolving identifiers
This commit is contained in:
dcodeIO
parent
ba61a5e414
commit
eccac129ad
388
src/compiler.ts
388
src/compiler.ts
@ -183,8 +183,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
|
||||
/** Compiles a {@link Program} to a {@link Module} using the specified options. */
|
||||
static compile(program: Program, options: Options | null = null): Module {
|
||||
const compiler: Compiler = new Compiler(program, options);
|
||||
return compiler.compile();
|
||||
return new Compiler(program, options).compile();
|
||||
}
|
||||
|
||||
/** Constructs a new compiler for a {@link Program} using the specified options. */
|
||||
@ -203,23 +202,20 @@ export class Compiler extends DiagnosticEmitter {
|
||||
|
||||
/** Performs compilation of the underlying {@link Program} to a {@link Module}. */
|
||||
compile(): Module {
|
||||
const program: Program = this.program;
|
||||
|
||||
// initialize lookup maps, built-ins, imports, exports, etc.
|
||||
program.initialize(this.options.target);
|
||||
this.program.initialize(this.options.target);
|
||||
|
||||
// compile entry file (exactly one, usually)
|
||||
const sources: Source[] = program.sources;
|
||||
let i: i32, k: i32 = sources.length;
|
||||
for (i = 0; i < k; ++i) {
|
||||
const source: Source = sources[i];
|
||||
if (source.isEntry)
|
||||
this.compileSource(source);
|
||||
}
|
||||
const sources: Source[] = this.program.sources;
|
||||
let i: i32, k = sources.length;
|
||||
for (i = 0; i < k; ++i)
|
||||
if (sources[i].isEntry)
|
||||
this.compileSource(sources[i]);
|
||||
|
||||
// make start function if not empty
|
||||
if (this.startFunctionBody.length) {
|
||||
let typeRef: FunctionTypeRef = this.module.getFunctionTypeBySignature(NativeType.None, []);
|
||||
let typeRef = this.module.getFunctionTypeBySignature(NativeType.None, []);
|
||||
if (!typeRef)
|
||||
typeRef = this.module.addFunctionType("v", NativeType.None, []);
|
||||
this.module.setStart(
|
||||
@ -231,14 +227,14 @@ export class Compiler extends DiagnosticEmitter {
|
||||
|
||||
// set up memory
|
||||
if (!this.options.noMemory) {
|
||||
const initial: U64 = this.memoryOffset.clone();
|
||||
const initial = this.memoryOffset.clone();
|
||||
if (this.options.target == Target.WASM64)
|
||||
this.module.addGlobal("HEAP_BASE", NativeType.I64, false, this.module.createI64(initial.lo, initial.hi));
|
||||
else
|
||||
this.module.addGlobal("HEAP_BASE", NativeType.I32, false, this.module.createI32(initial.lo));
|
||||
|
||||
// determine initial page size
|
||||
const initialOverlaps: U64 = initial.clone();
|
||||
const initialOverlaps = initial.clone();
|
||||
initialOverlaps.and32(0xffff);
|
||||
if (!initialOverlaps.isZero) {
|
||||
initial.or32(0xffff);
|
||||
@ -253,8 +249,8 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// sources
|
||||
|
||||
compileSourceByPath(normalizedPath: string, reportNode: Node): void {
|
||||
for (let i: i32 = 0, k: i32 = this.program.sources.length; i < k; ++i) {
|
||||
const importedSource: Source = this.program.sources[i];
|
||||
for (let i = 0, k = this.program.sources.length; i < k; ++i) {
|
||||
const importedSource = this.program.sources[i];
|
||||
if (importedSource.normalizedPath == normalizedPath) {
|
||||
this.compileSource(importedSource);
|
||||
return;
|
||||
@ -268,24 +264,23 @@ export class Compiler extends DiagnosticEmitter {
|
||||
return;
|
||||
this.files.add(source.normalizedPath);
|
||||
|
||||
const isEntry: bool = source.isEntry;
|
||||
const noTreeShaking: bool = this.options.noTreeShaking;
|
||||
for (let i: i32 = 0, k: i32 = source.statements.length; i < k; ++i) {
|
||||
const noTreeShaking = this.options.noTreeShaking;
|
||||
for (let i = 0, k = source.statements.length; i < k; ++i) {
|
||||
const statement: Statement = source.statements[i];
|
||||
switch (statement.kind) {
|
||||
|
||||
case NodeKind.CLASS:
|
||||
if ((noTreeShaking || isEntry && hasModifier(ModifierKind.EXPORT, (<ClassDeclaration>statement).modifiers)) && !(<ClassDeclaration>statement).typeParameters.length)
|
||||
if ((noTreeShaking || source.isEntry && hasModifier(ModifierKind.EXPORT, (<ClassDeclaration>statement).modifiers)) && !(<ClassDeclaration>statement).typeParameters.length)
|
||||
this.compileClassDeclaration(<ClassDeclaration>statement, []);
|
||||
break;
|
||||
|
||||
case NodeKind.ENUM:
|
||||
if (noTreeShaking || isEntry && hasModifier(ModifierKind.EXPORT, (<EnumDeclaration>statement).modifiers))
|
||||
if (noTreeShaking || source.isEntry && hasModifier(ModifierKind.EXPORT, (<EnumDeclaration>statement).modifiers))
|
||||
this.compileEnumDeclaration(<EnumDeclaration>statement);
|
||||
break;
|
||||
|
||||
case NodeKind.FUNCTION:
|
||||
if ((noTreeShaking || isEntry && hasModifier(ModifierKind.EXPORT, (<FunctionDeclaration>statement).modifiers)) && !(<FunctionDeclaration>statement).typeParameters.length)
|
||||
if ((noTreeShaking || source.isEntry && hasModifier(ModifierKind.EXPORT, (<FunctionDeclaration>statement).modifiers)) && !(<FunctionDeclaration>statement).typeParameters.length)
|
||||
this.compileFunctionDeclaration(<FunctionDeclaration>statement, []);
|
||||
break;
|
||||
|
||||
@ -294,28 +289,29 @@ export class Compiler extends DiagnosticEmitter {
|
||||
break;
|
||||
|
||||
case NodeKind.NAMESPACE:
|
||||
if (noTreeShaking || isEntry && hasModifier(ModifierKind.EXPORT, (<NamespaceDeclaration>statement).modifiers))
|
||||
if (noTreeShaking || source.isEntry && hasModifier(ModifierKind.EXPORT, (<NamespaceDeclaration>statement).modifiers))
|
||||
this.compileNamespaceDeclaration(<NamespaceDeclaration>statement);
|
||||
break;
|
||||
|
||||
case NodeKind.VARIABLE:
|
||||
if (noTreeShaking || isEntry && hasModifier(ModifierKind.EXPORT, (<VariableStatement>statement).modifiers))
|
||||
if (noTreeShaking || source.isEntry && hasModifier(ModifierKind.EXPORT, (<VariableStatement>statement).modifiers))
|
||||
this.compileVariableStatement(<VariableStatement>statement);
|
||||
break;
|
||||
|
||||
case NodeKind.EXPORT:
|
||||
if ((<ExportStatement>statement).normalizedPath != null)
|
||||
this.compileSourceByPath(<string>(<ExportStatement>statement).normalizedPath, <StringLiteralExpression>(<ExportStatement>statement).path);
|
||||
if (noTreeShaking || isEntry)
|
||||
if (noTreeShaking || source.isEntry)
|
||||
this.compileExportStatement(<ExportStatement>statement);
|
||||
break;
|
||||
|
||||
// otherwise a top-level statement that is part of the start function's body
|
||||
default: {
|
||||
const previousFunction: Function = this.currentFunction;
|
||||
const previousFunction = this.currentFunction;
|
||||
this.currentFunction = this.startFunction;
|
||||
const expr: ExpressionRef = this.compileStatement(statement);
|
||||
if (!this.module.noEmit) this.startFunctionBody.push(expr);
|
||||
const expr = this.compileStatement(statement);
|
||||
if (!this.module.noEmit)
|
||||
this.startFunctionBody.push(expr);
|
||||
this.currentFunction = previousFunction;
|
||||
break;
|
||||
}
|
||||
@ -326,7 +322,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// globals
|
||||
|
||||
compileGlobalDeclaration(declaration: VariableDeclaration, isConst: bool): Global | null {
|
||||
const element: Element | null = <Element | null>this.program.elements.get(declaration.internalName);
|
||||
const element = this.program.elements.get(declaration.internalName);
|
||||
if (!element || element.kind != ElementKind.GLOBAL)
|
||||
throw new Error("global expected");
|
||||
if (!this.compileGlobal(<Global>element)) // reports
|
||||
@ -344,7 +340,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
if (global.isCompiled || (global.isBuiltIn && compileBuiltinGetConstant(this, global)))
|
||||
return true;
|
||||
|
||||
const declaration: VariableLikeDeclarationStatement | null = global.declaration;
|
||||
const declaration = global.declaration;
|
||||
let initExpr: ExpressionRef = 0;
|
||||
|
||||
if (!global.type) { // infer type
|
||||
@ -366,8 +362,8 @@ export class Compiler extends DiagnosticEmitter {
|
||||
throw new Error("declaration expected");
|
||||
}
|
||||
|
||||
const nativeType: NativeType = global.type.toNativeType();
|
||||
let initializeInStart: bool = false;
|
||||
const nativeType = global.type.toNativeType();
|
||||
let initializeInStart = false;
|
||||
|
||||
if (global.hasConstantValue) {
|
||||
if (global.type.isLongInteger)
|
||||
@ -378,7 +374,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
initExpr = this.module.createF64(global.constantFloatValue);
|
||||
else if (global.type.isSmallInteger) {
|
||||
if (global.type.isSignedInteger) {
|
||||
const shift: i32 = global.type.smallIntegerShift;
|
||||
const shift = global.type.smallIntegerShift;
|
||||
initExpr = this.module.createI32(global.constantIntegerValue ? global.constantIntegerValue.toI32() << shift >> shift : 0);
|
||||
} else
|
||||
initExpr = this.module.createI32(global.constantIntegerValue ? global.constantIntegerValue.toI32() & global.type.smallIntegerMask: 0);
|
||||
@ -403,10 +399,10 @@ export class Compiler extends DiagnosticEmitter {
|
||||
} else
|
||||
throw new Error("declaration expected");
|
||||
|
||||
const internalName: string = global.internalName;
|
||||
const internalName = global.internalName;
|
||||
if (initializeInStart) {
|
||||
this.module.addGlobal(internalName, nativeType, true, global.type.toNativeZero(this.module));
|
||||
const setExpr: ExpressionRef = this.module.createSetGlobal(internalName, initExpr);
|
||||
const setExpr = this.module.createSetGlobal(internalName, initExpr);
|
||||
if (!this.module.noEmit)
|
||||
this.startFunctionBody.push(setExpr);
|
||||
} else {
|
||||
@ -439,7 +435,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// enums
|
||||
|
||||
compileEnumDeclaration(declaration: EnumDeclaration): void {
|
||||
const element: Element | null = <Element | null>this.program.elements.get(declaration.internalName);
|
||||
const element = this.program.elements.get(declaration.internalName);
|
||||
if (!element || element.kind != ElementKind.ENUM)
|
||||
throw new Error("enum expected");
|
||||
this.compileEnum(<Enum>element);
|
||||
@ -454,13 +450,13 @@ export class Compiler extends DiagnosticEmitter {
|
||||
for (let [key, member] of element.members) {
|
||||
if (member.kind != ElementKind.ENUMVALUE)
|
||||
continue;
|
||||
const val: EnumValue = <EnumValue>member;
|
||||
const val = <EnumValue>member;
|
||||
if (val.hasConstantValue) {
|
||||
this.module.addGlobal(val.internalName, NativeType.I32, false, this.module.createI32(val.constantValue));
|
||||
} else if (val.declaration) {
|
||||
const declaration: EnumValueDeclaration = val.declaration;
|
||||
const declaration = val.declaration;
|
||||
let initExpr: ExpressionRef;
|
||||
let initInStart: bool = false;
|
||||
let initInStart = false;
|
||||
if (declaration.value) {
|
||||
initExpr = this.compileExpression(<Expression>declaration.value, Type.i32);
|
||||
if (!this.module.noEmit && _BinaryenExpressionGetId(initExpr) != ExpressionId.Const) {
|
||||
@ -487,7 +483,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
if (initInStart) {
|
||||
this.module.addGlobal(val.internalName, NativeType.I32, true, this.module.createI32(0));
|
||||
const setExpr: ExpressionRef = this.module.createSetGlobal(val.internalName, initExpr);
|
||||
const setExpr = this.module.createSetGlobal(val.internalName, initExpr);
|
||||
if (!this.module.noEmit)
|
||||
this.startFunctionBody.push(setExpr);
|
||||
} else {
|
||||
@ -510,11 +506,11 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// functions
|
||||
|
||||
compileFunctionDeclaration(declaration: FunctionDeclaration, typeArguments: TypeNode[], contextualTypeArguments: Map<string,Type> | null = null, alternativeReportNode: Node | null = null): void {
|
||||
const internalName: string = declaration.internalName;
|
||||
const element: Element | null = <Element | null>this.program.elements.get(internalName);
|
||||
const internalName = declaration.internalName;
|
||||
const element = this.program.elements.get(internalName);
|
||||
if (!element || element.kind != ElementKind.FUNCTION_PROTOTYPE)
|
||||
throw new Error("unexpected missing function");
|
||||
const instance: Function | null = this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, typeArguments, contextualTypeArguments, alternativeReportNode);
|
||||
throw new Error("function expected");
|
||||
const instance = this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, typeArguments, contextualTypeArguments, alternativeReportNode); // reports
|
||||
if (!instance)
|
||||
return;
|
||||
if (isModuleExport(instance, declaration))
|
||||
@ -522,7 +518,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileFunctionUsingTypeArguments(prototype: FunctionPrototype, typeArguments: TypeNode[], contextualTypeArguments: Map<string,Type> | null = null, alternativeReportNode: Node | null = null): Function | null {
|
||||
const instance: Function | null = prototype.resolveInclTypeArguments(typeArguments, contextualTypeArguments, alternativeReportNode); // reports
|
||||
const instance = prototype.resolveInclTypeArguments(typeArguments, contextualTypeArguments, alternativeReportNode); // reports
|
||||
if (!instance)
|
||||
return null;
|
||||
return this.compileFunction(instance) ? instance : null;
|
||||
@ -532,7 +528,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
if (instance.isCompiled)
|
||||
return true;
|
||||
|
||||
const declaration: FunctionDeclaration | null = instance.prototype.declaration;
|
||||
const declaration = instance.prototype.declaration;
|
||||
if (!declaration)
|
||||
throw new Error("declaration expected"); // built-ins are not compiled here
|
||||
|
||||
@ -552,59 +548,43 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// compile statements
|
||||
let stmts: ExpressionRef[] | null = null;
|
||||
if (!instance.isDeclared) {
|
||||
const previousFunction: Function = this.currentFunction;
|
||||
const previousFunction = this.currentFunction;
|
||||
this.currentFunction = instance;
|
||||
stmts = this.compileStatements(<Statement[]>declaration.statements);
|
||||
this.currentFunction = previousFunction;
|
||||
}
|
||||
|
||||
// create the function type
|
||||
let k: i32 = instance.parameters.length;
|
||||
const nativeResultType: NativeType = instance.returnType.toNativeType();
|
||||
const nativeParamTypes: NativeType[] = new Array(k);
|
||||
const signatureNameParts: string[] = new Array(k + 1);
|
||||
for (let i: i32 = 0; i < k; ++i) {
|
||||
let k = instance.parameters.length;
|
||||
const nativeResultType = instance.returnType.toNativeType();
|
||||
const nativeParamTypes = new Array<NativeType>(k);
|
||||
const signatureNameParts = new Array<string>(k + 1);
|
||||
for (let i = 0; i < k; ++i) {
|
||||
nativeParamTypes[i] = instance.parameters[i].type.toNativeType();
|
||||
signatureNameParts[i] = instance.parameters[i].type.toSignatureName();
|
||||
}
|
||||
signatureNameParts[k] = instance.returnType.toSignatureName();
|
||||
let typeRef: FunctionTypeRef = this.module.getFunctionTypeBySignature(nativeResultType, nativeParamTypes);
|
||||
let typeRef = this.module.getFunctionTypeBySignature(nativeResultType, nativeParamTypes);
|
||||
if (!typeRef)
|
||||
typeRef = this.module.addFunctionType(signatureNameParts.join(""), nativeResultType, nativeParamTypes);
|
||||
|
||||
// create the function
|
||||
const internalName: string = instance.internalName;
|
||||
if (instance.isDeclared) { // TODO: use parent namespace as externalModuleName, if applicable
|
||||
this.module.addFunctionImport(internalName, "env", declaration.name.name, typeRef);
|
||||
this.module.addFunctionImport(instance.internalName, "env", declaration.name.name, typeRef);
|
||||
} else {
|
||||
this.module.addFunction(internalName, typeRef, typesToNativeTypes(instance.additionalLocals), this.module.createBlock(null, <ExpressionRef[]>stmts, NativeType.None));
|
||||
this.module.addFunction(instance.internalName, typeRef, typesToNativeTypes(instance.additionalLocals), this.module.createBlock(null, <ExpressionRef[]>stmts, NativeType.None));
|
||||
}
|
||||
instance.finalize();
|
||||
return true;
|
||||
}
|
||||
|
||||
// compilePropertyUsingTypeArguments(prototype: PropertyPrototype, contextualTypeArguments: Map<string,Type> | null = null, alternativeReportNode: Node | null = null): Function | null {
|
||||
// let getter: Function | null = null;
|
||||
// let setter: Function | null = null;
|
||||
// if (prototype.getterPrototype) {
|
||||
// getter = prototype.getterPrototype.resolve([], contextualTypeArguments); // reports
|
||||
// if (prototype.setterPrototype)
|
||||
// setter = prototype.setterPrototype.resolve([], contextualTypeArguments); // reports
|
||||
// }
|
||||
|
||||
// }
|
||||
|
||||
// compileProperty(instance: Property): bool {
|
||||
|
||||
// }
|
||||
|
||||
// namespaces
|
||||
|
||||
compileNamespaceDeclaration(declaration: NamespaceDeclaration): void {
|
||||
const members: Statement[] = declaration.members;
|
||||
const noTreeShaking: bool = this.options.noTreeShaking;
|
||||
for (let i: i32 = 0, k: i32 = members.length; i < k; ++i) {
|
||||
const member: Statement = members[i];
|
||||
const members = declaration.members;
|
||||
const noTreeShaking = this.options.noTreeShaking;
|
||||
for (let i = 0, k = members.length; i < k; ++i) {
|
||||
const member = members[i];
|
||||
switch (member.kind) {
|
||||
|
||||
case NodeKind.CLASS:
|
||||
@ -638,7 +618,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Error("unexpected namespace member");
|
||||
throw new Error("namespace member expected");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -647,7 +627,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
if (!ns.members)
|
||||
return;
|
||||
|
||||
const noTreeShaking: bool = this.options.noTreeShaking;
|
||||
const noTreeShaking = this.options.noTreeShaking;
|
||||
for (let [name, element] of ns.members) {
|
||||
switch (element.kind) {
|
||||
|
||||
@ -679,11 +659,11 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// exports
|
||||
|
||||
compileExportStatement(statement: ExportStatement): void {
|
||||
const members: ExportMember[] = statement.members;
|
||||
for (let i: i32 = 0, k: i32 = members.length; i < k; ++i) {
|
||||
const member: ExportMember = members[i];
|
||||
const internalExportName: string = statement.range.source.internalPath + PATH_DELIMITER + member.externalIdentifier.name;
|
||||
const element: Element | null = <Element | null>this.program.exports.get(internalExportName);
|
||||
const members = statement.members;
|
||||
for (let i = 0, k = members.length; i < k; ++i) {
|
||||
const member = members[i];
|
||||
const internalExportName = statement.range.source.internalPath + PATH_DELIMITER + member.externalIdentifier.name;
|
||||
const element = this.program.exports.get(internalExportName);
|
||||
if (!element) // reported in Program#initialize
|
||||
continue;
|
||||
switch (element.kind) {
|
||||
@ -699,7 +679,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
|
||||
case ElementKind.FUNCTION_PROTOTYPE:
|
||||
if (!(<FunctionPrototype>element).isGeneric) {
|
||||
const functionInstance: Function | null = this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, []);
|
||||
const functionInstance = this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, []);
|
||||
if (functionInstance && statement.range.source.isEntry)
|
||||
this.module.addFunctionExport(functionInstance.internalName, member.externalIdentifier.name);
|
||||
}
|
||||
@ -724,15 +704,15 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// classes
|
||||
|
||||
compileClassDeclaration(declaration: ClassDeclaration, typeArguments: TypeNode[], contextualTypeArguments: Map<string,Type> | null = null, alternativeReportNode: Node | null = null): void {
|
||||
const internalName: string = declaration.internalName;
|
||||
const element: Element | null = <Element | null>this.program.elements.get(internalName);
|
||||
const internalName = declaration.internalName;
|
||||
const element = this.program.elements.get(internalName);
|
||||
if (!element || element.kind != ElementKind.CLASS_PROTOTYPE)
|
||||
throw new Error("unexpected missing class");
|
||||
throw new Error("class expected");
|
||||
this.compileClassUsingTypeArguments(<ClassPrototype>element, typeArguments, contextualTypeArguments, alternativeReportNode);
|
||||
}
|
||||
|
||||
compileClassUsingTypeArguments(prototype: ClassPrototype, typeArguments: TypeNode[], contextualTypeArguments: Map<string,Type> | null = null, alternativeReportNode: Node | null = null): void {
|
||||
const instance: Class | null = prototype.resolveInclTypeArguments(typeArguments, contextualTypeArguments, alternativeReportNode);
|
||||
const instance = prototype.resolveInclTypeArguments(typeArguments, contextualTypeArguments, alternativeReportNode);
|
||||
if (!instance)
|
||||
return;
|
||||
this.compileClass(instance);
|
||||
@ -754,7 +734,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
this.memoryOffset.or32(7);
|
||||
this.memoryOffset.add32(1);
|
||||
}
|
||||
const segment: MemorySegment = MemorySegment.create(buffer, this.memoryOffset.clone());
|
||||
const segment = MemorySegment.create(buffer, this.memoryOffset.clone());
|
||||
this.memorySegments.push(segment);
|
||||
this.memoryOffset.add32(buffer.length);
|
||||
return segment;
|
||||
@ -801,31 +781,32 @@ export class Compiler extends DiagnosticEmitter {
|
||||
case NodeKind.TRY:
|
||||
return this.compileTryStatement(<TryStatement>statement);
|
||||
|
||||
case NodeKind.TYPEDECLARATION:
|
||||
if (this.currentFunction == this.startFunction)
|
||||
return this.module.createNop();
|
||||
break; // must be top-level; function bodies are not initialized
|
||||
|
||||
case NodeKind.VARIABLE:
|
||||
return this.compileVariableStatement(<VariableStatement>statement);
|
||||
|
||||
case NodeKind.WHILE:
|
||||
return this.compileWhileStatement(<WhileStatement>statement);
|
||||
|
||||
case NodeKind.TYPEDECLARATION:
|
||||
if (this.currentFunction == this.startFunction)
|
||||
return this.module.createNop();
|
||||
// fall-through: must be top-level; function bodies are not initialized
|
||||
|
||||
default:
|
||||
throw new Error("statement expected");
|
||||
}
|
||||
this.error(DiagnosticCode.Operation_not_supported, statement.range);
|
||||
throw new Error("unexpected statement kind");
|
||||
}
|
||||
|
||||
compileStatements(statements: Statement[]): ExpressionRef[] {
|
||||
let i: i32 = 0, k: i32 = statements.length;
|
||||
const stmts: ExpressionRef[] = new Array(k);
|
||||
for (; i < k; ++i)
|
||||
const k = statements.length;
|
||||
const stmts = new Array<ExpressionRef>(k);
|
||||
for (let i = 0; i < k; ++i)
|
||||
stmts[i] = this.compileStatement(statements[i]);
|
||||
return stmts; // array of 0-es in noEmit-mode
|
||||
}
|
||||
|
||||
compileBlockStatement(statement: BlockStatement): ExpressionRef {
|
||||
const statements: Statement[] = statement.statements;
|
||||
const statements = statement.statements;
|
||||
if (statements.length == 0)
|
||||
return this.module.createNop();
|
||||
if (statements.length == 1)
|
||||
@ -838,9 +819,10 @@ export class Compiler extends DiagnosticEmitter {
|
||||
this.error(DiagnosticCode.Operation_not_supported, statement.label.range);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
const context: string | null = this.currentFunction.breakContext;
|
||||
const context = this.currentFunction.breakContext;
|
||||
if (context != null)
|
||||
return this.module.createBreak("break|" + (<string>context));
|
||||
|
||||
this.error(DiagnosticCode.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement, statement.range);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
@ -850,20 +832,21 @@ export class Compiler extends DiagnosticEmitter {
|
||||
this.error(DiagnosticCode.Operation_not_supported, statement.label.range);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
const context: string | null = this.currentFunction.breakContext;
|
||||
const context = this.currentFunction.breakContext;
|
||||
if (context != null && !this.disallowContinue)
|
||||
return this.module.createBreak("continue|" + (<string>context));
|
||||
|
||||
this.error(DiagnosticCode.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement, statement.range);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
|
||||
compileDoStatement(statement: DoStatement): ExpressionRef {
|
||||
const label: string = this.currentFunction.enterBreakContext();
|
||||
const condition: ExpressionRef = this.compileExpression(statement.condition, Type.i32);
|
||||
const body: ExpressionRef = this.compileStatement(statement.statement);
|
||||
const label = this.currentFunction.enterBreakContext();
|
||||
const condition = this.compileExpression(statement.condition, Type.i32);
|
||||
const body = this.compileStatement(statement.statement);
|
||||
this.currentFunction.leaveBreakContext();
|
||||
const breakLabel: string = "break|" + label;
|
||||
const continueLabel: string = "continue|" + label;
|
||||
const breakLabel = "break|" + label;
|
||||
const continueLabel = "continue|" + label;
|
||||
return this.module.createBlock(breakLabel, [
|
||||
this.module.createLoop(continueLabel,
|
||||
this.module.createBlock(null, [
|
||||
@ -878,7 +861,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileExpressionStatement(statement: ExpressionStatement): ExpressionRef {
|
||||
let expr: ExpressionRef = this.compileExpression(statement.expression, Type.void, ConversionKind.NONE);
|
||||
let expr = this.compileExpression(statement.expression, Type.void, ConversionKind.NONE);
|
||||
if (this.currentType != Type.void) {
|
||||
expr = this.module.createDrop(expr);
|
||||
this.currentType = Type.void;
|
||||
@ -887,18 +870,18 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileForStatement(statement: ForStatement): ExpressionRef {
|
||||
const context: string = this.currentFunction.enterBreakContext();
|
||||
const variableWasLocal: bool = this.variableIsLocal;
|
||||
const context = this.currentFunction.enterBreakContext();
|
||||
const variableWasLocal = this.variableIsLocal;
|
||||
if (this.currentFunction == this.startFunction)
|
||||
this.variableIsLocal = true;
|
||||
const initializer: ExpressionRef = statement.initializer ? this.compileStatement(<Statement>statement.initializer) : this.module.createNop();
|
||||
const initializer = statement.initializer ? this.compileStatement(<Statement>statement.initializer) : this.module.createNop();
|
||||
this.variableIsLocal = variableWasLocal;
|
||||
const condition: ExpressionRef = statement.condition ? this.compileExpression(<Expression>statement.condition, Type.i32) : this.module.createI32(1);
|
||||
const incrementor: ExpressionRef = statement.incrementor ? this.compileExpression(<Expression>statement.incrementor, Type.void) : this.module.createNop();
|
||||
const body: ExpressionRef = this.compileStatement(statement.statement);
|
||||
const condition = statement.condition ? this.compileExpression(<Expression>statement.condition, Type.i32) : this.module.createI32(1);
|
||||
const incrementor = statement.incrementor ? this.compileExpression(<Expression>statement.incrementor, Type.void) : this.module.createNop();
|
||||
const body = this.compileStatement(statement.statement);
|
||||
this.currentFunction.leaveBreakContext();
|
||||
const continueLabel: string = "continue|" + context;
|
||||
const breakLabel: string = "break|" + context;
|
||||
const continueLabel = "continue|" + context;
|
||||
const breakLabel = "break|" + context;
|
||||
return this.module.createBlock(breakLabel, [
|
||||
initializer,
|
||||
this.module.createLoop(continueLabel, this.module.createBlock(null, [
|
||||
@ -912,38 +895,38 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileIfStatement(statement: IfStatement): ExpressionRef {
|
||||
const condition: ExpressionRef = this.compileExpression(statement.condition, Type.i32);
|
||||
const ifTrue: ExpressionRef = this.compileStatement(statement.ifTrue);
|
||||
const ifFalse: ExpressionRef = statement.ifFalse ? this.compileStatement(<Statement>statement.ifFalse) : 0;
|
||||
const condition = this.compileExpression(statement.condition, Type.i32);
|
||||
const ifTrue = this.compileStatement(statement.ifTrue);
|
||||
const ifFalse = statement.ifFalse ? this.compileStatement(<Statement>statement.ifFalse) : <ExpressionRef>0;
|
||||
return this.module.createIf(condition, ifTrue, ifFalse);
|
||||
}
|
||||
|
||||
compileReturnStatement(statement: ReturnStatement): ExpressionRef {
|
||||
if (this.currentFunction) {
|
||||
const expression: ExpressionRef = statement.value ? this.compileExpression(<Expression>statement.value, this.currentFunction.returnType) : 0;
|
||||
const expression = statement.value ? this.compileExpression(<Expression>statement.value, this.currentFunction.returnType) : <ExpressionRef>0;
|
||||
return this.module.createReturn(expression);
|
||||
}
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
|
||||
compileSwitchStatement(statement: SwitchStatement): ExpressionRef {
|
||||
const context: string = this.currentFunction.enterBreakContext();
|
||||
const previousDisallowContinue: bool = this.disallowContinue;
|
||||
const context = this.currentFunction.enterBreakContext();
|
||||
const previousDisallowContinue = this.disallowContinue;
|
||||
this.disallowContinue = true;
|
||||
|
||||
// introduce a local for evaluating the condition (exactly once)
|
||||
const tempLocal: Local = this.currentFunction.getTempLocal(Type.i32);
|
||||
let i: i32, k: i32 = statement.cases.length;
|
||||
const tempLocal = this.currentFunction.getTempLocal(Type.i32);
|
||||
let i: i32, k = statement.cases.length;
|
||||
|
||||
// prepend initializer to inner block
|
||||
const breaks: ExpressionRef[] = new Array(1 + k);
|
||||
const breaks = new Array<ExpressionRef>(1 + k);
|
||||
breaks[0] = this.module.createSetLocal(tempLocal.index, this.compileExpression(statement.condition, Type.i32)); // initializer
|
||||
|
||||
// make one br_if per (possibly dynamic) labeled case (binaryen optimizes to br_table where possible)
|
||||
let breakIndex: i32 = 1;
|
||||
let defaultIndex: i32 = -1;
|
||||
let breakIndex = 1;
|
||||
let defaultIndex = -1;
|
||||
for (i = 0; i < k; ++i) {
|
||||
const case_: SwitchCase = statement.cases[i];
|
||||
const case_ = statement.cases[i];
|
||||
if (case_.label) {
|
||||
breaks[breakIndex++] = this.module.createBreak("case" + i.toString(10) + "|" + context,
|
||||
this.module.createBinary(BinaryOp.EqI32,
|
||||
@ -964,16 +947,14 @@ export class Compiler extends DiagnosticEmitter {
|
||||
) + "|" + context);
|
||||
|
||||
// nest blocks in order
|
||||
let currentBlock: ExpressionRef = this.module.createBlock("case0|" + context, breaks, NativeType.None);
|
||||
let currentBlock = this.module.createBlock("case0|" + context, breaks, NativeType.None);
|
||||
for (i = 0; i < k; ++i) {
|
||||
const case_: SwitchCase = statement.cases[i];
|
||||
const nextLabel: string = i == k - 1
|
||||
? "break|" + context
|
||||
: "case" + (i + 1).toString(10) + "|" + context;
|
||||
const l: i32 = case_.statements.length;
|
||||
const body: ExpressionRef[] = new Array(1 + l);
|
||||
const case_ = statement.cases[i];
|
||||
const nextLabel = i == k - 1 ? "break|" + context : "case" + (i + 1).toString(10) + "|" + context;
|
||||
const l = case_.statements.length;
|
||||
const body = new Array<ExpressionRef>(1 + l);
|
||||
body[0] = currentBlock;
|
||||
for (let j: i32 = 0; j < l; ++j)
|
||||
for (let j = 0; j < l; ++j)
|
||||
body[j + 1] = this.compileStatement(case_.statements[j]);
|
||||
currentBlock = this.module.createBlock(nextLabel, body, NativeType.None);
|
||||
}
|
||||
@ -994,20 +975,20 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileVariableStatement(statement: VariableStatement): ExpressionRef {
|
||||
const declarations: VariableDeclaration[] = statement.declarations;
|
||||
const declarations = statement.declarations;
|
||||
|
||||
// top-level variables become globals
|
||||
if (this.currentFunction == this.startFunction && !this.variableIsLocal) {
|
||||
const isConst: bool = hasModifier(ModifierKind.CONST, statement.modifiers);
|
||||
for (let i: i32 = 0, k: i32 = declarations.length; i < k; ++i)
|
||||
const isConst = hasModifier(ModifierKind.CONST, statement.modifiers);
|
||||
for (let i = 0, k = declarations.length; i < k; ++i)
|
||||
this.compileGlobalDeclaration(declarations[i], isConst);
|
||||
return this.module.createNop();
|
||||
}
|
||||
// other variables become locals
|
||||
const initializers: ExpressionRef[] = new Array();
|
||||
for (let i: i32 = 0, k = declarations.length; i < k; ++i) {
|
||||
const declaration: VariableDeclaration = declarations[i];
|
||||
const name: string = declaration.name.name;
|
||||
const initializers = new Array<ExpressionRef>();
|
||||
for (let i = 0, k = declarations.length; i < k; ++i) {
|
||||
const declaration = declarations[i];
|
||||
const name = declaration.name.name;
|
||||
let type: Type | null = null;
|
||||
let init: ExpressionRef = 0;
|
||||
if (declaration.type) {
|
||||
@ -1036,11 +1017,11 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileWhileStatement(statement: WhileStatement): ExpressionRef {
|
||||
const label: string = this.currentFunction.enterBreakContext();
|
||||
const condition: ExpressionRef = this.compileExpression(statement.condition, Type.i32);
|
||||
const breakLabel: string = "break|" + label;
|
||||
const continueLabel: string = "continue|" + label;
|
||||
const body: ExpressionRef = this.compileStatement(statement.statement);
|
||||
const label = this.currentFunction.enterBreakContext();
|
||||
const condition = this.compileExpression(statement.condition, Type.i32);
|
||||
const breakLabel = "break|" + label;
|
||||
const continueLabel = "continue|" + label;
|
||||
const body = this.compileStatement(statement.statement);
|
||||
this.currentFunction.leaveBreakContext();
|
||||
return this.module.createBlock(breakLabel, [
|
||||
this.module.createLoop(continueLabel,
|
||||
@ -1113,7 +1094,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Error("unexpected expression kind");
|
||||
throw new Error("expression expected");
|
||||
}
|
||||
|
||||
if (conversionKind != ConversionKind.NONE && this.currentType != contextualType) {
|
||||
@ -1124,18 +1105,17 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
precomputeExpression(expression: Expression, contextualType: Type, conversionKind: ConversionKind = ConversionKind.IMPLICIT): ExpressionRef {
|
||||
const expr: ExpressionRef = this.compileExpression(expression, contextualType, conversionKind);
|
||||
return this.precomputeExpressionRef(expr);
|
||||
return this.precomputeExpressionRef(this.compileExpression(expression, contextualType, conversionKind));
|
||||
}
|
||||
|
||||
precomputeExpressionRef(expr: ExpressionRef): ExpressionRef {
|
||||
const nativeType: NativeType = this.currentType.toNativeType();
|
||||
let typeRef: FunctionTypeRef = this.module.getFunctionTypeBySignature(nativeType, []);
|
||||
const nativeType = this.currentType.toNativeType();
|
||||
let typeRef = this.module.getFunctionTypeBySignature(nativeType, []);
|
||||
if (!typeRef)
|
||||
typeRef = this.module.addFunctionType(this.currentType.toSignatureName(), nativeType, []);
|
||||
const funcRef: FunctionRef = this.module.addFunction("__precompute", typeRef, [], expr);
|
||||
const funcRef = this.module.addFunction("__precompute", typeRef, [], expr);
|
||||
this.module.runPasses([ "precompute" ], funcRef);
|
||||
const ret: ExpressionRef = _BinaryenFunctionGetBody(funcRef);
|
||||
const ret = _BinaryenFunctionGetBody(funcRef);
|
||||
this.module.removeFunction("__precompute");
|
||||
// TODO: also remove the function type somehow if no longer used or make the C-API accept
|
||||
// a `null` typeRef, using an implicit type.
|
||||
@ -1156,11 +1136,11 @@ export class Compiler extends DiagnosticEmitter {
|
||||
if (toType.kind == TypeKind.VOID)
|
||||
return this.module.createDrop(expr);
|
||||
|
||||
const fromFloat: bool = fromType.isAnyFloat;
|
||||
const toFloat: bool = toType.isAnyFloat;
|
||||
const fromFloat = fromType.isAnyFloat;
|
||||
const toFloat = toType.isAnyFloat;
|
||||
|
||||
const mod: Module = this.module;
|
||||
let losesInformation: bool = false;
|
||||
const mod = this.module;
|
||||
let losesInformation = false;
|
||||
|
||||
if (fromFloat) {
|
||||
|
||||
@ -1306,7 +1286,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileAssertionExpression(expression: AssertionExpression, contextualType: Type): ExpressionRef {
|
||||
const toType: Type | null = this.program.resolveType(expression.toType, this.currentFunction.contextualTypeArguments); // reports
|
||||
const toType = this.program.resolveType(expression.toType, this.currentFunction.contextualTypeArguments); // reports
|
||||
if (!toType)
|
||||
return this.module.createUnreachable();
|
||||
return this.compileExpression(expression.expression, toType, ConversionKind.EXPLICIT);
|
||||
@ -1669,16 +1649,16 @@ export class Compiler extends DiagnosticEmitter {
|
||||
break;
|
||||
|
||||
case ElementKind.PROPERTY:
|
||||
const setterPrototype: FunctionPrototype | null = (<Property>element).setterPrototype;
|
||||
const setterPrototype = (<Property>element).setterPrototype;
|
||||
if (setterPrototype) {
|
||||
const setterInstance: Function | null = setterPrototype.resolve(); // reports
|
||||
const setterInstance = setterPrototype.resolve(); // reports
|
||||
if (setterInstance) {
|
||||
if (contextualType == Type.void) { // just set if dropped anyway
|
||||
return this.compileCall(setterInstance, [ valueExpression ], expression);
|
||||
} else { // otherwise do a set followed by a get
|
||||
const getterPrototype: FunctionPrototype | null = (<Property>element).getterPrototype;
|
||||
const getterPrototype = (<Property>element).getterPrototype;
|
||||
if (getterPrototype) {
|
||||
const getterInstance: Function | null = getterPrototype.resolve(); // reports
|
||||
const getterInstance = getterPrototype.resolve(); // reports
|
||||
if (getterInstance) {
|
||||
return this.module.createBlock(null, [
|
||||
this.compileCall(setterInstance, [ valueExpression ], expression),
|
||||
@ -1749,7 +1729,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
return this.module.createSetGlobal((<Global>element).internalName, valueWithCorrectType);
|
||||
}
|
||||
|
||||
// TODO: fields, setters
|
||||
// TODO: fields, (setters)
|
||||
|
||||
throw new Error("not implemented");
|
||||
}
|
||||
@ -1774,24 +1754,24 @@ export class Compiler extends DiagnosticEmitter {
|
||||
return this.module.createUnreachable();
|
||||
|
||||
if (element.kind == ElementKind.FUNCTION_PROTOTYPE) {
|
||||
const functionPrototype: FunctionPrototype = <FunctionPrototype>element;
|
||||
const functionPrototype = <FunctionPrototype>element;
|
||||
let functionInstance: Function | null = null;
|
||||
if (functionPrototype.isBuiltIn) {
|
||||
const k: i32 = expression.typeArguments.length;
|
||||
const resolvedTypeArguments: Type[] = new Array(k);
|
||||
const k = expression.typeArguments.length;
|
||||
const resolvedTypeArguments = new Array<Type>(k);
|
||||
sb.length = 0;
|
||||
for (let i: i32 = 0; i < k; ++i) {
|
||||
let resolvedType: Type | null = this.program.resolveType(expression.typeArguments[i], this.currentFunction.contextualTypeArguments, true); // reports
|
||||
for (let i = 0; i < k; ++i) {
|
||||
let resolvedType = this.program.resolveType(expression.typeArguments[i], this.currentFunction.contextualTypeArguments, true); // reports
|
||||
if (!resolvedType)
|
||||
return this.module.createUnreachable();
|
||||
resolvedTypeArguments[i] = resolvedType;
|
||||
sb.push(resolvedType.toString());
|
||||
}
|
||||
|
||||
functionInstance = <Function | null>functionPrototype.instances.get(sb.join(","));
|
||||
functionInstance = functionPrototype.instances.get(sb.join(","));
|
||||
if (!functionInstance) {
|
||||
this.currentType = contextualType;
|
||||
let expr: ExpressionRef = compileBuiltinCall(this, functionPrototype, resolvedTypeArguments, expression.arguments, expression);
|
||||
let expr = compileBuiltinCall(this, functionPrototype, resolvedTypeArguments, expression.arguments, expression);
|
||||
if (!expr) {
|
||||
this.error(DiagnosticCode.Operation_not_supported, expression.range);
|
||||
return this.module.createUnreachable();
|
||||
@ -1814,9 +1794,9 @@ export class Compiler extends DiagnosticEmitter {
|
||||
compileCall(functionInstance: Function, argumentExpressions: Expression[], reportNode: Node): ExpressionRef {
|
||||
|
||||
// validate and compile arguments
|
||||
const parameters: Parameter[] = functionInstance.parameters;
|
||||
const parameterCount: i32 = parameters.length;
|
||||
const argumentCount: i32 = argumentExpressions.length;
|
||||
const parameters = functionInstance.parameters;
|
||||
const parameterCount = parameters.length;
|
||||
const argumentCount = argumentExpressions.length;
|
||||
if (argumentExpressions.length > parameterCount) { // too many arguments
|
||||
this.error(DiagnosticCode.Expected_0_arguments_but_got_1, reportNode.range,
|
||||
(functionInstance.isInstance ? parameterCount - 1 : parameterCount).toString(10),
|
||||
@ -1824,12 +1804,12 @@ export class Compiler extends DiagnosticEmitter {
|
||||
);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
const operands: ExpressionRef[] = new Array(parameterCount);
|
||||
for (let i: i32 = 0; i < parameterCount; ++i) {
|
||||
const operands = new Array<ExpressionRef>(parameterCount);
|
||||
for (let i = 0; i < parameterCount; ++i) {
|
||||
if (argumentExpressions.length > i) {
|
||||
operands[i] = this.compileExpression(argumentExpressions[i], parameters[i].type);
|
||||
} else {
|
||||
const initializer: Expression | null = parameters[i].initializer;
|
||||
const initializer = parameters[i].initializer;
|
||||
if (initializer) { // omitted, uses initializer
|
||||
// FIXME: here, the initializer is compiled in the caller's scope.
|
||||
// a solution could be to use a stub for each possible overload, calling the
|
||||
@ -1859,7 +1839,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileElementAccessExpression(expression: ElementAccessExpression, contextualType: Type): ExpressionRef {
|
||||
const element: Element | null = this.program.resolveElement(expression.expression, this.currentFunction); // reports
|
||||
const element = this.program.resolveElement(expression.expression, this.currentFunction); // reports
|
||||
if (!element)
|
||||
return this.module.createUnreachable();
|
||||
throw new Error("not implemented");
|
||||
@ -1900,7 +1880,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
|
||||
const element: Element | null = this.program.resolveElement(expression, this.currentFunction); // reports
|
||||
const element = this.program.resolveElement(expression, this.currentFunction); // reports
|
||||
if (!element)
|
||||
return this.module.createUnreachable();
|
||||
|
||||
@ -1915,9 +1895,10 @@ export class Compiler extends DiagnosticEmitter {
|
||||
if (element.isBuiltIn)
|
||||
return compileBuiltinGetConstant(this, <Global>element);
|
||||
|
||||
const global: Global = <Global>element;
|
||||
const global = <Global>element;
|
||||
if (!this.compileGlobal(global)) // reports
|
||||
return this.module.createUnreachable();
|
||||
assert(global.type != null);
|
||||
this.currentType = <Type>global.type;
|
||||
if (global.hasConstantValue) {
|
||||
if (global.type == Type.f32)
|
||||
@ -1929,19 +1910,11 @@ export class Compiler extends DiagnosticEmitter {
|
||||
else if ((<Type>global.type).isAnyInteger)
|
||||
return this.module.createI32((<I64>global.constantIntegerValue).lo);
|
||||
else
|
||||
throw new Error("unexpected global type");
|
||||
throw new Error("concrete type expected");
|
||||
} else
|
||||
return this.module.createGetGlobal((<Global>element).internalName, this.currentType.toNativeType());
|
||||
}
|
||||
|
||||
// field
|
||||
// if (element.kind == ElementKind.FIELD)
|
||||
// throw new Error("not implemented");
|
||||
|
||||
// getter
|
||||
if (element.kind == ElementKind.FUNCTION_PROTOTYPE && (<FunctionPrototype>element).isGetter)
|
||||
throw new Error("not implemented");
|
||||
|
||||
this.error(DiagnosticCode.Operation_not_supported, expression.range);
|
||||
return this.module.createUnreachable();
|
||||
}
|
||||
@ -1951,7 +1924,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
// case LiteralKind.ARRAY:
|
||||
|
||||
case LiteralKind.FLOAT: {
|
||||
const floatValue: f64 = (<FloatLiteralExpression>expression).value;
|
||||
const floatValue = (<FloatLiteralExpression>expression).value;
|
||||
if (contextualType == Type.f32)
|
||||
return this.module.createF32(<f32>floatValue);
|
||||
this.currentType = Type.f64;
|
||||
@ -1959,7 +1932,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
case LiteralKind.INTEGER: {
|
||||
const intValue: I64 = (<IntegerLiteralExpression>expression).value;
|
||||
const intValue = (<IntegerLiteralExpression>expression).value;
|
||||
if (contextualType == Type.bool && (intValue.isZero || intValue.isOne))
|
||||
return this.module.createI32(intValue.isZero ? 0 : 1);
|
||||
if (contextualType == Type.f64)
|
||||
@ -1995,8 +1968,8 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compilePropertyAccessExpression(propertyAccess: PropertyAccessExpression, contextualType: Type): ExpressionRef {
|
||||
const expression: Expression = propertyAccess.expression;
|
||||
const propertyName: string = propertyAccess.property.name;
|
||||
const expression = propertyAccess.expression;
|
||||
const propertyName = propertyAccess.property.name;
|
||||
|
||||
// the lhs expression is either 'this', 'super', an identifier or another property access
|
||||
let target: Element | null;
|
||||
@ -2027,7 +2000,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Error("unexpected expression kind");
|
||||
throw new Error("lhs expression expected");
|
||||
}
|
||||
if (!target)
|
||||
return this.module.createUnreachable();
|
||||
@ -2088,6 +2061,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
case ElementKind.GLOBAL:
|
||||
if (!this.compileGlobal(<Global>element))
|
||||
return this.module.createUnreachable();
|
||||
assert((<Global>element).type != null);
|
||||
this.currentType = <Type>(<Global>element).type;
|
||||
if ((<Global>element).hasConstantValue)
|
||||
return this.currentType== Type.f32 ? this.module.createF32((<Global>element).constantFloatValue)
|
||||
@ -2098,9 +2072,9 @@ export class Compiler extends DiagnosticEmitter {
|
||||
return this.module.createGetGlobal((<Global>element).internalName, this.currentType.toNativeType());
|
||||
|
||||
case ElementKind.PROPERTY: // getter
|
||||
const getterPrototype: FunctionPrototype | null = (<Property>element).getterPrototype;
|
||||
const getterPrototype = (<Property>element).getterPrototype;
|
||||
if (getterPrototype) {
|
||||
const getterInstance: Function | null = getterPrototype.resolve([], this.currentFunction.contextualTypeArguments);
|
||||
const getterInstance = getterPrototype.resolve([], this.currentFunction.contextualTypeArguments);
|
||||
if (getterInstance) {
|
||||
return this.compileCall(getterInstance, [], propertyAccess);
|
||||
} else {
|
||||
@ -2116,20 +2090,20 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileTernaryExpression(expression: TernaryExpression, contextualType: Type): ExpressionRef {
|
||||
const condition: ExpressionRef = this.compileExpression(expression.condition, Type.i32);
|
||||
const ifThen: ExpressionRef = this.compileExpression(expression.ifThen, contextualType);
|
||||
const ifElse: ExpressionRef = this.compileExpression(expression.ifElse, contextualType);
|
||||
const condition = this.compileExpression(expression.condition, Type.i32);
|
||||
const ifThen = this.compileExpression(expression.ifThen, contextualType);
|
||||
const ifElse = this.compileExpression(expression.ifElse, contextualType);
|
||||
return this.module.createIf(condition, ifThen, ifElse);
|
||||
}
|
||||
|
||||
compileUnaryPostfixExpression(expression: UnaryPostfixExpression, contextualType: Type): ExpressionRef {
|
||||
const operator: Token = expression.operator;
|
||||
const operator = expression.operator;
|
||||
|
||||
// make a getter for the expression (also obtains the type)
|
||||
const getValue: ExpressionRef = this.compileExpression(expression.operand, contextualType, contextualType == Type.void ? ConversionKind.NONE : ConversionKind.IMPLICIT);
|
||||
const getValue = this.compileExpression(expression.operand, contextualType, contextualType == Type.void ? ConversionKind.NONE : ConversionKind.IMPLICIT);
|
||||
|
||||
// use a temp local for the intermediate value
|
||||
const tempLocal: Local = this.currentFunction.getTempLocal(this.currentType);
|
||||
const tempLocal = this.currentFunction.getTempLocal(this.currentType);
|
||||
|
||||
let op: BinaryOp;
|
||||
let nativeType: NativeType;
|
||||
@ -2157,7 +2131,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
// make a setter that sets the new value (temp value +/- 1)
|
||||
const setValue: ExpressionRef = this.compileAssignmentWithValue(expression.operand,
|
||||
const setValue = this.compileAssignmentWithValue(expression.operand,
|
||||
this.module.createBinary(op,
|
||||
this.module.createGetLocal(tempLocal.index, nativeType),
|
||||
nativeOne
|
||||
@ -2176,7 +2150,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
compileUnaryPrefixExpression(expression: UnaryPrefixExpression, contextualType: Type): ExpressionRef {
|
||||
const operandExpression: Expression = expression.operand;
|
||||
const operandExpression = expression.operand;
|
||||
|
||||
let operand: ExpressionRef;
|
||||
let op: UnaryOp;
|
||||
@ -2241,7 +2215,7 @@ export class Compiler extends DiagnosticEmitter {
|
||||
: this.module.createBinary(BinaryOp.XorI32, operand, this.module.createI32(-1));
|
||||
|
||||
default:
|
||||
throw new Error("not implemented");
|
||||
throw new Error("unary operator expected");
|
||||
}
|
||||
return this.module.createUnary(op, operand);
|
||||
}
|
||||
@ -2254,7 +2228,7 @@ function isModuleExport(element: Element, declaration: DeclarationStatement): bo
|
||||
return false;
|
||||
if (declaration.range.source.isEntry)
|
||||
return true;
|
||||
let parentNode: Node | null = declaration.parent;
|
||||
let parentNode = declaration.parent;
|
||||
if (!parentNode)
|
||||
return false;
|
||||
if (parentNode.kind == NodeKind.VARIABLE)
|
||||
@ -2262,7 +2236,7 @@ function isModuleExport(element: Element, declaration: DeclarationStatement): bo
|
||||
return false;
|
||||
if (parentNode.kind != NodeKind.NAMESPACE && parentNode.kind != NodeKind.CLASS)
|
||||
return false;
|
||||
let parent: Element | null = element.program.elements.get((<DeclarationStatement>parentNode).internalName);
|
||||
let parent = element.program.elements.get((<DeclarationStatement>parentNode).internalName);
|
||||
if (!parent)
|
||||
return false;
|
||||
return isModuleExport(parent, <DeclarationStatement>parentNode);
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
// internal naming scheme
|
||||
|
||||
export const PATH_DELIMITER: string = "/";
|
||||
export const PARENT_SUBST: string = "..";
|
||||
export const GETTER_PREFIX: string = "get_";
|
||||
export const SETTER_PREFIX: string = "set_";
|
||||
export const INSTANCE_DELIMITER: string = "#";
|
||||
export const STATIC_DELIMITER: string = ".";
|
||||
export const PATH_DELIMITER = "/";
|
||||
export const PARENT_SUBST = "..";
|
||||
export const GETTER_PREFIX = "get:";
|
||||
export const SETTER_PREFIX = "set:";
|
||||
export const INSTANCE_DELIMITER = "#";
|
||||
export const STATIC_DELIMITER = ".";
|
||||
|
||||
@ -250,6 +250,7 @@ export class Program extends DiagnosticEmitter {
|
||||
return;
|
||||
}
|
||||
const prototype = new ClassPrototype(this, declaration.name.name, internalName, declaration);
|
||||
prototype.namespace = namespace;
|
||||
this.elements.set(internalName, prototype);
|
||||
|
||||
// add program-level alias if annotated as @global
|
||||
@ -433,6 +434,7 @@ export class Program extends DiagnosticEmitter {
|
||||
return;
|
||||
}
|
||||
const enm = new Enum(this, internalName, declaration);
|
||||
enm.namespace = namespace;
|
||||
this.elements.set(internalName, enm);
|
||||
|
||||
if (namespace) {
|
||||
@ -558,6 +560,7 @@ export class Program extends DiagnosticEmitter {
|
||||
return;
|
||||
}
|
||||
const prototype = new FunctionPrototype(this, declaration.name.name, internalName, declaration, null);
|
||||
prototype.namespace = namespace;
|
||||
this.elements.set(internalName, prototype);
|
||||
|
||||
if (hasDecorator("global", declaration.decorators)) {
|
||||
@ -648,12 +651,12 @@ export class Program extends DiagnosticEmitter {
|
||||
|
||||
private initializeInterface(declaration: InterfaceDeclaration, namespace: Element | null = null): void {
|
||||
const internalName = declaration.internalName;
|
||||
const prototype = new InterfacePrototype(this, declaration.name.name, internalName, declaration);
|
||||
|
||||
if (this.elements.has(internalName)) {
|
||||
this.error(DiagnosticCode.Duplicate_identifier_0, declaration.name.range, internalName);
|
||||
return;
|
||||
}
|
||||
const prototype = new InterfacePrototype(this, declaration.name.name, internalName, declaration);
|
||||
prototype.namespace = namespace;
|
||||
this.elements.set(internalName, prototype);
|
||||
|
||||
if (namespace) {
|
||||
@ -697,6 +700,7 @@ export class Program extends DiagnosticEmitter {
|
||||
let namespace = this.elements.get(internalName);
|
||||
if (!namespace) {
|
||||
namespace = new Namespace(this, internalName, declaration);
|
||||
namespace.namespace = parentNamespace;
|
||||
this.elements.set(internalName, namespace);
|
||||
}
|
||||
|
||||
@ -757,6 +761,7 @@ export class Program extends DiagnosticEmitter {
|
||||
|
||||
private initializeType(declaration: TypeDeclaration, namespace: Element | null = null): void {
|
||||
// type aliases are program globals
|
||||
// TODO: what about namespaced types?
|
||||
const name = declaration.name.name;
|
||||
if (this.types.has(name) || this.typeAliases.has(name)) {
|
||||
this.error(DiagnosticCode.Duplicate_identifier_0, declaration.name.range, name);
|
||||
@ -776,6 +781,7 @@ export class Program extends DiagnosticEmitter {
|
||||
}
|
||||
|
||||
const global = new Global(this, internalName, declaration, null);
|
||||
global.namespace = namespace;
|
||||
this.elements.set(internalName, global);
|
||||
|
||||
if (hasDecorator("global", declaration.decorators)) {
|
||||
@ -868,17 +874,32 @@ export class Program extends DiagnosticEmitter {
|
||||
return typeArguments;
|
||||
}
|
||||
|
||||
/** Resolves an identifier to the element is refers to. */
|
||||
/** Resolves an identifier to the element it refers to. */
|
||||
resolveIdentifier(identifier: IdentifierExpression, contextualFunction: Function): Element | null {
|
||||
const name = identifier.name;
|
||||
const local = contextualFunction.locals.get(name);
|
||||
if (local)
|
||||
return local;
|
||||
|
||||
let element: Element | null;
|
||||
let namespace: Element | null;
|
||||
|
||||
// search parent namespaces if applicable
|
||||
if (contextualFunction && (namespace = contextualFunction.prototype.namespace)) {
|
||||
do {
|
||||
if (element = this.elements.get(namespace.internalName + STATIC_DELIMITER + name))
|
||||
return element;
|
||||
} while (namespace = namespace.namespace);
|
||||
}
|
||||
|
||||
// search current file
|
||||
if (element = this.elements.get(identifier.range.source.internalPath + PATH_DELIMITER + name))
|
||||
return element;
|
||||
|
||||
// search global scope
|
||||
if (element = this.elements.get(name))
|
||||
return element;
|
||||
|
||||
this.error(DiagnosticCode.Cannot_find_name_0, identifier.range, name);
|
||||
return null;
|
||||
}
|
||||
@ -1026,6 +1047,8 @@ export abstract class Element {
|
||||
flags: ElementFlags = ElementFlags.NONE;
|
||||
/** Namespaced member elements. */
|
||||
members: Map<string,Element> | null = null;
|
||||
/** Parent namespace, if applicable. */
|
||||
namespace: Element | null = null;
|
||||
|
||||
/** Constructs a new element, linking it to its containing {@link Program}. */
|
||||
protected constructor(program: Program, internalName: string) {
|
||||
@ -1081,6 +1104,7 @@ export abstract class Element {
|
||||
/** A namespace. */
|
||||
export class Namespace extends Element {
|
||||
|
||||
// All elements have namespace semantics. This is an explicitly declared one.
|
||||
kind = ElementKind.NAMESPACE;
|
||||
|
||||
/** Declaration reference. */
|
||||
|
||||
@ -6,36 +6,36 @@
|
||||
(memory $0 1)
|
||||
(export "memory" (memory $0))
|
||||
(start $start)
|
||||
(func $getter-setter/Foo.get_bar (; 0 ;) (type $i) (result i32)
|
||||
(func $getter-setter/Foo.get:bar (; 0 ;) (type $i) (result i32)
|
||||
(get_global $getter-setter/Foo._bar)
|
||||
)
|
||||
(func $getter-setter/Foo.set_bar (; 1 ;) (type $iv) (param $0 i32)
|
||||
(func $getter-setter/Foo.set:bar (; 1 ;) (type $iv) (param $0 i32)
|
||||
(set_global $getter-setter/Foo._bar
|
||||
(get_local $0)
|
||||
)
|
||||
)
|
||||
(func $start (; 2 ;) (type $v)
|
||||
(if
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
(unreachable)
|
||||
)
|
||||
(call $getter-setter/Foo.set_bar
|
||||
(call $getter-setter/Foo.set:bar
|
||||
(i32.const 1)
|
||||
)
|
||||
(if
|
||||
(i32.ne
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
(i32.const 1)
|
||||
)
|
||||
(unreachable)
|
||||
)
|
||||
(if
|
||||
(block (result i32)
|
||||
(call $getter-setter/Foo.set_bar
|
||||
(call $getter-setter/Foo.set:bar
|
||||
(i32.const 2)
|
||||
)
|
||||
(i32.ne
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
(i32.const 2)
|
||||
)
|
||||
)
|
||||
|
||||
@ -7,12 +7,12 @@
|
||||
(memory $0 1)
|
||||
(export "memory" (memory $0))
|
||||
(start $start)
|
||||
(func $getter-setter/Foo.get_bar (; 0 ;) (type $i) (result i32)
|
||||
(func $getter-setter/Foo.get:bar (; 0 ;) (type $i) (result i32)
|
||||
(return
|
||||
(get_global $getter-setter/Foo._bar)
|
||||
)
|
||||
)
|
||||
(func $getter-setter/Foo.set_bar (; 1 ;) (type $iv) (param $0 i32)
|
||||
(func $getter-setter/Foo.set:bar (; 1 ;) (type $iv) (param $0 i32)
|
||||
(set_global $getter-setter/Foo._bar
|
||||
(get_local $0)
|
||||
)
|
||||
@ -21,19 +21,19 @@
|
||||
(if
|
||||
(i32.eqz
|
||||
(i32.eq
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
(i32.const 0)
|
||||
)
|
||||
)
|
||||
(unreachable)
|
||||
)
|
||||
(call $getter-setter/Foo.set_bar
|
||||
(call $getter-setter/Foo.set:bar
|
||||
(i32.const 1)
|
||||
)
|
||||
(if
|
||||
(i32.eqz
|
||||
(i32.eq
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
(i32.const 1)
|
||||
)
|
||||
)
|
||||
@ -43,10 +43,10 @@
|
||||
(i32.eqz
|
||||
(i32.eq
|
||||
(block (result i32)
|
||||
(call $getter-setter/Foo.set_bar
|
||||
(call $getter-setter/Foo.set:bar
|
||||
(i32.const 2)
|
||||
)
|
||||
(call $getter-setter/Foo.get_bar)
|
||||
(call $getter-setter/Foo.get:bar)
|
||||
)
|
||||
(i32.const 2)
|
||||
)
|
||||
|
||||
@ -1,11 +1,17 @@
|
||||
(module
|
||||
(type $i (func (result i32)))
|
||||
(type $v (func))
|
||||
(global $namespace/Outer.Inner.aVar (mut i32) (i32.const 0))
|
||||
(memory $0 1)
|
||||
(export "test" (func $namespace/test))
|
||||
(export "memory" (memory $0))
|
||||
(func $namespace/test (; 0 ;) (type $v)
|
||||
(block $__inlined_func$namespace/Outer.Inner.aFunc
|
||||
(nop)
|
||||
(start $start)
|
||||
(func $start (; 0 ;) (type $v)
|
||||
(drop
|
||||
(block (result i32)
|
||||
(block $__inlined_func$namespace/Outer.Inner.aFunc (result i32)
|
||||
(get_global $namespace/Outer.Inner.aVar)
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
@ -1,12 +1,16 @@
|
||||
(module
|
||||
(type $i (func (result i32)))
|
||||
(type $v (func))
|
||||
(global $namespace/Outer.Inner.aVar (mut i32) (i32.const 0))
|
||||
(memory $0 1)
|
||||
(export "test" (func $namespace/test))
|
||||
(export "memory" (memory $0))
|
||||
(func $namespace/Outer.Inner.aFunc (; 0 ;) (type $v)
|
||||
(nop)
|
||||
(start $start)
|
||||
(func $namespace/Outer.Inner.aFunc (; 0 ;) (type $i) (result i32)
|
||||
(get_global $namespace/Outer.Inner.aVar)
|
||||
)
|
||||
(func $namespace/test (; 1 ;) (type $v)
|
||||
(func $start (; 1 ;) (type $v)
|
||||
(drop
|
||||
(call $namespace/Outer.Inner.aFunc)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
@ -1,13 +1,11 @@
|
||||
namespace Outer {
|
||||
export namespace Inner {
|
||||
export let aVar: i32;
|
||||
export function aFunc(): void {}
|
||||
export let aVar: i32 = 0;
|
||||
export function aFunc(): i32 { return aVar; }
|
||||
export enum anEnum { ONE = 1, TWO = 2 }
|
||||
}
|
||||
}
|
||||
|
||||
export function test(): void {
|
||||
Outer.Inner.aVar;
|
||||
Outer.Inner.aFunc();
|
||||
Outer.Inner.anEnum.ONE;
|
||||
}
|
||||
|
||||
@ -1,19 +1,25 @@
|
||||
(module
|
||||
(type $i (func (result i32)))
|
||||
(type $v (func))
|
||||
(global $namespace/Outer.Inner.aVar (mut i32) (i32.const 0))
|
||||
(global $namespace/Outer.Inner.anEnum.ONE i32 (i32.const 1))
|
||||
(global $namespace/Outer.Inner.anEnum.TWO i32 (i32.const 2))
|
||||
(global $HEAP_BASE i32 (i32.const 4))
|
||||
(memory $0 1)
|
||||
(export "test" (func $namespace/test))
|
||||
(export "memory" (memory $0))
|
||||
(func $namespace/Outer.Inner.aFunc (; 0 ;) (type $v)
|
||||
(start $start)
|
||||
(func $namespace/Outer.Inner.aFunc (; 0 ;) (type $i) (result i32)
|
||||
(return
|
||||
(get_global $namespace/Outer.Inner.aVar)
|
||||
)
|
||||
(func $namespace/test (; 1 ;) (type $v)
|
||||
)
|
||||
(func $start (; 1 ;) (type $v)
|
||||
(drop
|
||||
(get_global $namespace/Outer.Inner.aVar)
|
||||
)
|
||||
(drop
|
||||
(call $namespace/Outer.Inner.aFunc)
|
||||
)
|
||||
(drop
|
||||
(get_global $namespace/Outer.Inner.anEnum.ONE)
|
||||
)
|
||||
@ -70,7 +76,6 @@
|
||||
GLOBAL: namespace/Outer.Inner.aVar
|
||||
FUNCTION_PROTOTYPE: namespace/Outer.Inner.aFunc
|
||||
ENUM: namespace/Outer.Inner.anEnum
|
||||
FUNCTION_PROTOTYPE: namespace/test
|
||||
[program.exports]
|
||||
FUNCTION_PROTOTYPE: namespace/test
|
||||
|
||||
;)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user