wip

Author: HerrCai0907

src/common.ts

@@ -194,6 +194,8 @@ export namespace CommonNames {
   export const ASC_VERSION_MAJOR = "ASC_VERSION_MAJOR";
   export const ASC_VERSION_MINOR = "ASC_VERSION_MINOR";
   export const ASC_VERSION_PATCH = "ASC_VERSION_PATCH";
+  // enums
+  export const EnumToString = "__enum_to_string";
   // classes
   export const I8 = "I8";
   export const I16 = "I16";

src/compiler.ts

@@ -1522,6 +1522,58 @@ export class Compiler extends DiagnosticEmitter {
     return true;
   }
 
+  private ensureEnumToString(enumElement: Enum): string | null {
+    if (!this.compileEnum(enumElement)) return null;
+    let members = enumElement.members;
+    if (!members) return null; // TODO
+
+    let module = this.module;
+    const functionName = `${enumElement.internalName}#${CommonNames.EnumToString}`;
+    const isInline = enumElement.is(CommonFlags.Const) || enumElement.hasDecorator(DecoratorFlags.Inline);
+    let _keys = Map_keys(members), _values = Map_values(members);
+    if (isInline) {
+      let valueToNames: Map<i32, string> = new Map();
+      for (let i = 0, k = _keys.length; i < k; ++i) {
+        let name = unchecked(_keys[i]);
+        let member = unchecked(_values[i]);
+        if (member.kind != ElementKind.EnumValue) continue;
+        let enumValue = <EnumValue>member;
+        valueToNames.set(i64_low(enumValue.constantIntegerValue), name);
+      }
+      let exprs = new Array<ExpressionRef>();
+      for (let [value, names] of valueToNames) {
+        let expr = module.if(
+          module.binary(BinaryOp.EqI32, module.i32(value), module.local_get(0, TypeRef.I32)),
+          module.return(this.ensureStaticString(names))
+        );
+        exprs.push(expr);
+      }
+      exprs.push(module.unreachable());
+      module.addFunction(functionName, TypeRef.I32, TypeRef.I32, null, module.block(null, exprs, TypeRef.I32));
+      return functionName;
+    } else {
+      let internalNameToNames: Map<string, string> = new Map();
+      for (let i = 0, k = _keys.length; i < k; ++i) {
+        let name = unchecked(_keys[i]);
+        let member = unchecked(_values[i]);
+        if (member.kind != ElementKind.EnumValue) continue;
+        let enumValue = <EnumValue>member;
+        internalNameToNames.set(enumValue.internalName, name);
+      }
+      let exprs = new Array<ExpressionRef>();
+      for (let [internalName, names] of internalNameToNames) {
+        let expr = module.if(
+          module.binary(BinaryOp.EqI32, module.global_get(internalName, TypeRef.I32), module.local_get(0, TypeRef.I32)),
+          module.return(this.ensureStaticString(names))
+        );
+        exprs.push(expr);
+      }
+      exprs.push(module.unreachable());
+      module.addFunction(functionName, TypeRef.I32, TypeRef.I32, null, module.block(null, exprs, TypeRef.I32));
+      return functionName;
+    }
+  }
+
   // === Functions ================================================================================
 
   /** Compiles a priorly resolved function. */
@@ -7092,7 +7144,16 @@ export class Compiler extends DiagnosticEmitter {
   ): ExpressionRef {
     let module = this.module;
     let targetExpression = expression.expression;
-    let targetType = this.resolver.resolveExpression(targetExpression, this.currentFlow); // reports
+    let resolver = this.resolver;
+    let targetElement = resolver.lookupExpression(targetExpression, this.currentFlow, Type.auto, ReportMode.Swallow);
+    if (targetElement && targetElement.kind == ElementKind.Enum) {
+      const toStringFunctionName = this.ensureEnumToString(<Enum>targetElement);
+      if (toStringFunctionName == null) return module.unreachable();
+      const elementExpr = this.compileExpression(expression.elementExpression, Type.i32, Constraints.ConvImplicit);
+      return module.call(toStringFunctionName, [ elementExpr ], TypeRef.I32);
+    }
+
+    let targetType = resolver.resolveExpression(targetExpression, this.currentFlow);
     if (targetType) {
       let classReference = targetType.getClassOrWrapper(this.program);
       if (classReference) {