Merge branch 'main' into opt-zero-init

Author: KKiiim

NOTICE

@@ -61,6 +61,7 @@ under the licensing terms detailed in LICENSE:
 * Jonas Minnberg <[email protected]>
 * Kam Chehresa <[email protected]>
 * Rui Jin <[email protected]>
+* Mopsgamer <[email protected]>
 
 Portions of this software are derived from third-party works licensed under
 the following terms:

bin/asinit.js

@@ -100,7 +100,7 @@ if (/^(\.\.[/\\])*node_modules[/\\]assemblyscript[/\\]/.test(tsconfigBase)) {
 }
 const entryFile = path.join(assemblyDir, "index.ts");
 const buildDir = path.join(projectDir, "build");
-const testsDir = path.join(projectDir, "tests");
+const testsDir = path.join(projectDir, "test");
 const gitignoreFile = path.join(buildDir, ".gitignore");
 const packageFile = path.join(projectDir, "package.json");
 
@@ -358,7 +358,7 @@ function ensurePackageJson() {
         "asbuild:debug": buildDebug,
         "asbuild:release": buildRelease,
         "asbuild": buildAll,
-        "test": "node tests",
+        "test": "node --test",
         "start": "npx serve ."
       },
       "devDependencies": {
@@ -390,7 +390,7 @@ function ensurePackageJson() {
       updated = true;
     }
     if (!scripts["test"] || scripts["test"] == npmDefaultTest) {
-      scripts["test"] = "node tests";
+      scripts["test"] = "node --test";
       pkg["scripts"] = scripts;
       updated = true;
     }
@@ -416,7 +416,7 @@ function ensurePackageJson() {
 }
 
 function ensureTestsDirectory() {
-  console.log("- Making sure that the 'tests' directory exists...");
+  console.log("- Making sure that the 'test' directory exists...");
   if (!fs.existsSync(testsDir)) {
     fs.mkdirSync(testsDir);
     console.log(stdoutColors.green("  Created: ") + testsDir);
@@ -427,13 +427,16 @@ function ensureTestsDirectory() {
 }
 
 function ensureTestsIndexJs() {
-  console.log("- Making sure that 'tests/index.js' exists...");
+  console.log("- Making sure that 'test/index.js' exists...");
   if (!fs.existsSync(testsIndexFile)) {
     fs.writeFileSync(testsIndexFile, [
-      "import assert from \"assert\";",
+      "import assert from \"node:assert/strict\";",
+      "import { it } from \"node:test\";",
       "import { add } from \"../build/debug.js\";",
-      "assert.strictEqual(add(1, 2), 3);",
-      "console.log(\"ok\");"
+      "",
+      "it(\"add\", () => {",
+      "  assert.equal(add(1, 2), 3);",
+      "});"
     ].join("\n") + "\n");
     console.log(stdoutColors.green("  Created: ") + testsIndexFile);
   } else {

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

@@ -1523,6 +1523,49 @@ export class Compiler extends DiagnosticEmitter {
     return true;
   }
 
+  private ensureEnumToString(enumElement: Enum, reportNode: Node): string | null {
+    if (enumElement.toStringFunctionName) return enumElement.toStringFunctionName;
+    
+    if (!this.compileEnum(enumElement)) return null;
+    if (enumElement.is(CommonFlags.Const)) {
+      this.errorRelated(
+        DiagnosticCode.A_const_enum_member_can_only_be_accessed_using_a_string_literal,
+        reportNode.range, enumElement.identifierNode.range
+      );
+      return null;
+    }
+
+    let members = enumElement.members;
+    if (!members) return null;
+
+    let module = this.module;
+    const isInline = enumElement.hasDecorator(DecoratorFlags.Inline);
+
+    const functionName = `${enumElement.internalName}#${CommonNames.EnumToString}`;
+    enumElement.toStringFunctionName = functionName;
+
+    let exprs = new Array<ExpressionRef>();
+    // when the values are the same, TS returns the last enum value name that appears
+    for (let _keys = Map_keys(members), _values = Map_values(members), i = 1, k = _keys.length; i <= k; ++i) {
+      let enumValueName = unchecked(_keys[k - i]);
+      let member = unchecked(_values[k - i]);
+      if (member.kind != ElementKind.EnumValue) continue;
+      let enumValue = <EnumValue>member;
+      const enumValueExpr = isInline
+        ? module.i32(i64_low(enumValue.constantIntegerValue))
+        : module.global_get(enumValue.internalName, TypeRef.I32);
+      let expr = module.if(
+        module.binary(BinaryOp.EqI32, enumValueExpr, module.local_get(0, TypeRef.I32)),
+        module.return(this.ensureStaticString(enumValueName))
+      );
+      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. */
@@ -7093,7 +7136,17 @@ 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 elementExpr = this.compileExpression(expression.elementExpression, Type.i32, Constraints.ConvImplicit);
+      const toStringFunctionName = this.ensureEnumToString(<Enum>targetElement, expression);
+      this.currentType = this.program.stringInstance.type;
+      if (toStringFunctionName == null) return module.unreachable();
+      return module.call(toStringFunctionName, [ elementExpr ], TypeRef.I32);
+    }
+
+    let targetType = resolver.resolveExpression(targetExpression, this.currentFlow);
     if (targetType) {
       let classReference = targetType.getClassOrWrapper(this.program);
       if (classReference) {

src/diagnosticMessages.json

@@ -174,6 +174,7 @@
   "Type '{0}' has no property '{1}'.": 2460,
   "The '{0}' operator cannot be applied to type '{1}'.": 2469,
   "In 'const' enum declarations member initializer must be constant expression.": 2474,
+  "A const enum member can only be accessed using a string literal.": 2476,
   "Export declaration conflicts with exported declaration of '{0}'.": 2484,
   "'{0}' is referenced directly or indirectly in its own base expression.": 2506,
   "Cannot create an instance of an abstract class.": 2511,

src/program.ts

@@ -3449,7 +3449,7 @@ export class Namespace extends DeclaredElement {
 
 /** An enum. */
 export class Enum extends TypedElement {
-
+  toStringFunctionName: string | null = null;
   /** Constructs a new enum. */
   constructor(
     /** Simple name. */

tests/compiler/enum-to-string-error.json

@@ -0,0 +1,7 @@
+{
+  "asc_flags": [],
+  "stderr": [
+    "TS2476: A const enum member can only be accessed using a string literal.",
+    "EOF"
+  ]
+}

tests/compiler/enum-to-string-error.ts

@@ -0,0 +1,9 @@
+const enum CE {
+  CE0,
+  CE1,
+  CE2,
+}
+
+assert(CE[CE.CE0] === "CE0");
+
+ERROR("EOF");