remove string.const_, accept string literal in context instead

dcodeIO · dcodeIO · commit 13214ba17cd5 · 2023-04-23T13:06:04.000+02:00
diff --git a/src/builtins.ts b/src/builtins.ts
@@ -715,7 +715,6 @@ export namespace BuiltinNames {
   export const i31_new = "~lib/builtins/i31.new";
   export const i31_get = "~lib/builtins/i31.get";
 
-  export const string_const = "~lib/builtins/string.const_";
   export const string_new_utf8 = "~lib/builtins/string.new_utf8";
   export const string_new_utf8_array = "~lib/builtins/string.new_utf8_array";
   export const string_new_lossy_utf8 = "~lib/builtins/string.new_lossy_utf8";
@@ -10871,33 +10870,6 @@ builtinFunctions.set(BuiltinNames.i32x4_relaxed_dot_i8x16_i7x16_add_s, builtin_i
 
 // === Stringref ==============================================================================
 
-// string.const(str: string) -> stringref
-function builtin_string_const(ctx: BuiltinFunctionContext): ExpressionRef {
-  let compiler = ctx.compiler;
-  let module = compiler.module;
-  if (
-    checkFeatureEnabled(ctx, Feature.Stringref) |
-    checkTypeAbsent(ctx) |
-    checkArgsRequired(ctx, 1)
-  ) return module.unreachable();
-  let operands = ctx.operands;
-  let node = operands[0];
-  if (node.kind == NodeKind.Literal) {
-    let literal = <LiteralExpression>node;
-    if (literal.literalKind == LiteralKind.String) {
-      compiler.currentType = Type.string;
-      return module.string_const((<StringLiteralExpression>literal).value);
-    }
-  }
-  compiler.error(
-    DiagnosticCode.String_literal_expected,
-    node.range
-  );
-  compiler.currentType = Type.string;
-  return module.unreachable();
-}
-builtinFunctions.set(BuiltinNames.string_const, builtin_string_const);
-
 // string.new_utf8(ptr: usize, bytes: i32, immMemory?: i32) -> stringref
 function builtin_string_new_utf8(ctx: BuiltinFunctionContext): ExpressionRef {
   let compiler = ctx.compiler;
diff --git a/src/compiler.ts b/src/compiler.ts
@@ -7923,6 +7923,11 @@ export class Compiler extends DiagnosticEmitter {
       }
       case LiteralKind.String: {
         assert(!implicitlyNegate);
+        // Emit a stringref if context indicates
+        if (contextualType.kind == TypeKind.String) {
+          this.currentType = Type.string;
+          return module.string_const((<StringLiteralExpression>expression).value);
+        }
         return this.compileStringLiteral(<StringLiteralExpression>expression, constraints);
       }
       case LiteralKind.Template: {
diff --git a/std/assembly/builtins.ts b/std/assembly/builtins.ts
@@ -2598,10 +2598,6 @@ export abstract class i31 { // FIXME: usage of 'new' requires a class :(
 
 export namespace string {
 
-  // @ts-ignore: decorator
-  @builtin
-  export declare function const_(str: string): ref_string;
-
   // @ts-ignore: decorator
   @unsafe @builtin
   export declare function new_utf8(ptr: usize, bytes: i32): ref_string;
diff --git a/std/assembly/index.d.ts b/std/assembly/index.d.ts
@@ -64,7 +64,7 @@ declare type ref_i31 = object;
 /** Canonical nullable 31-bit integer reference. */
 declare type i31ref = ref_i31 | null;
 /** Non-nullable string reference. */
-declare type ref_string = object;
+declare type ref_string = string;
 /** Canonical nullable string reference. */
 declare type stringref = ref_string | null;
 /** Non-nullable WTF-8 string view. */
@@ -1669,8 +1669,6 @@ declare abstract class i31 {
 }
 
 declare namespace string {
-  /** Constructs a string reference from a string literal. Temporary! */
-  export function const_(str: string): ref_string;
   /** Creates a new string from memory using a strict UTF-8 decoder, decoding `bytes` bytes starting at `ptr`. */
   export function new_utf8(ptr: usize, bytes: i32): ref_string;
   /** Creates a new string from `array` using a strict UTF-8 decoder, decoding from `start` inclusive to `end` exclusive. */

Original file line number	Diff line number	Diff line change
`@@ -7923,6 +7923,11 @@ export class Compiler extends DiagnosticEmitter {`
`7923`	`7923`	`}`
`7924`	`7924`	`case LiteralKind.String: {`
`7925`	`7925`	`assert(!implicitlyNegate);`
	`7926`	`+ // Emit a stringref if context indicates`
	`7927`	`+ if (contextualType.kind == TypeKind.String) {`
	`7928`	`+ this.currentType = Type.string;`
	`7929`	`+ return module.string_const((<StringLiteralExpression>expression).value);`
	`7930`	`+ }`
`7926`	`7931`	`return this.compileStringLiteral(<StringLiteralExpression>expression, constraints);`
`7927`	`7932`	`}`
`7928`	`7933`	`case LiteralKind.Template: {`