Added support for binary addition

Author: b-temirov

hkmc2/shared/src/main/scala/hkmc2/codegen/Lowering.scala

@@ -455,7 +455,11 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
               )(true, false)))
           else
             subTerm_nonTail(arg2): ar2 =>
-              k(Call(Value.Ref(sym).withLocOf(ref), Arg(N, ar1) :: Arg(N, ar2) :: Nil)(true, false))
+              val targetPath =
+                if config.target == CompilationTarget.Wasm && sym.nme == "+"
+                then Value.Ref(State.wasmSymbol).selN(Tree.Ident("plus_impl"))
+                else Value.Ref(sym).withLocOf(ref)
+              k(Call(targetPath, Arg(N, ar1) :: Arg(N, ar2) :: Nil)(true, false))
       case _ => fail:
         ErrorReport(
           msg"Unexpected arguments for builtin symbol '${sym.nme}'" -> arg.toLoc :: Nil, S(arg),
@@ -484,7 +488,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       case t if t.resolvedSym.isDefined && (t.resolvedSym.get is ctx.builtins.js.try_catch) =>
         conclude(Value.Ref(State.runtimeSymbol).selN(Tree.Ident("try_catch")))
       case t if t.resolvedSym.exists(_ is ctx.builtins.wasm.plus_impl) =>
-        conclude(Value.Ref(State.runtimeSymbol).selN(Tree.Ident("plus_impl")))
+        conclude(Value.Ref(State.wasmSymbol).selN(Tree.Ident("plus_impl")))
       case t if t.resolvedSym.exists(_ is ctx.builtins.Int31) =>
         conclude(Value.Ref(State.runtimeSymbol).selN(Tree.Ident("Int31")))
       case t if t.resolvedSym.isDefined && (t.resolvedSym.get is ctx.builtins.debug.printStack) =>

hkmc2/shared/src/main/scala/hkmc2/codegen/wasm/text/WatBuilder.scala

@@ -156,42 +156,19 @@ class WatBuilder(using TraceLogger, State) extends CodeBuilder:
           ref.func(funcIdx, RefType(ctx.getFuncInfo_!(l).typeIdx, nullable = false))
         case N => getVar(l, r.toLoc)
 
+    case c @ Call(fun, lhs :: rhs :: Nil) if isWasmIntrinsic(fun, "plus_impl") =>
+      compilePlusIntrinsic(lhs, rhs)
+
     case Call(Value.Ref(l: BuiltinSymbol), lhs :: rhs :: Nil) if !l.functionLike =>
       if l.binary then
         l.nme match
           case "+" =>
-            // TODO(Derppening): Refactor to lower to `Call(plus_impl, ...)`
-            def castOperand(expr: Expr, opSide: Str): Expr =
-              expr.resultType match
-                case S(RefType(HeapType.Any, _)) => `if`(
-                    ref.test(expr, RefType.i31ref),
-                    ifTrue = castOperand(ref.cast(expr, RefType.i31ref), opSide),
-                    ifFalse = S(unreachable),
-                    resultTypes = Seq(Result(I32Type))
-                  )
-                case S(RefType(HeapType.I31, _)) => i31.get(expr, true)
-                case S(I32Type) => expr
-                case ty =>
-                  errExpr(
-                    Ls(
-                      msg"WatBuilder::result for binary builtin symbol '${l.nme.toString}' ($opSide.type=${ty.fold("(none)")(_.toWat.mkString())}) not implemented yet" -> r.toLoc
-                    ),
-                    extraInfo = S(r.toString)
-                  )
-
-            val lhsOp = castOperand(operand(lhs), "lhs")
-            val rhsOp = castOperand(operand(rhs), "rhs")
-
-            (lhsOp.resultType, rhsOp.resultType) match
-              case (S(I32Type), S(I32Type)) =>
-                ref.i31(i32.add(lhsOp, rhsOp))
-              case (lhsType, rhsType) =>
-                errExpr(
-                  Ls(
-                    msg"WatBuilder::result for binary builtin symbol '${l.nme.toString}' for (${lhsType.fold("(none)")(_.toWat.mkString())}, ${rhsType.fold("(none)")(_.toWat.mkString())}) not implemented yet" -> r.toLoc
-                  ),
-                  extraInfo = S(r.toString)
-                )
+            errExpr(
+              Ls(
+                msg"WatBuilder::result encountered builtin '+' which should be lowered to wasm.plus_impl" -> r.toLoc
+              ),
+              extraInfo = S(r.toString)
+            )
           case lNme =>
             errExpr(
               Ls(
@@ -287,6 +264,25 @@ class WatBuilder(using TraceLogger, State) extends CodeBuilder:
       )
   end result
 
+  private def isWasmIntrinsic(path: Path, name: Str): Bool = path match
+    case Select(Value.Ref(sym), ident) =>
+      (sym eq State.wasmSymbol) && ident.name == name
+    case _ => false
+
+  private def compilePlusIntrinsic(lhs: Arg, rhs: Arg)(using
+      Ctx,
+      Raise,
+      Scope
+  ): Expr =
+    val lhsCast = ref.cast(operand(lhs), RefType.i31ref)
+    val rhsCast = ref.cast(operand(rhs), RefType.i31ref)
+    ref.i31(
+      i32.add(
+        i31.get(lhsCast, true),
+        i31.get(rhsCast, true)
+      )
+    )
+
   def returningTerm(t: Block)(using Ctx, Raise, Scope): Expr = t match
     case _: HandleBlock =>
       errExpr(

hkmc2/shared/src/test/mlscript/wasm/Basics.mls

@@ -72,24 +72,12 @@ foo() + foo()
 //│               (ref.func $foo)))
 //│           (ref.i31
 //│             (i32.add
-//│               (if (result i32)
-//│                 (ref.test (ref null i31)
-//│                   (local.get $tmp))
-//│                 (then
-//│                   (i31.get_s
-//│                     (ref.cast (ref null i31)
-//│                       (local.get $tmp))))
-//│                 (else
-//│                   (unreachable)))
-//│               (if (result i32)
-//│                 (ref.test (ref null i31)
-//│                   (local.get $tmp1))
-//│                 (then
-//│                   (i31.get_s
-//│                     (ref.cast (ref null i31)
-//│                       (local.get $tmp1))))
-//│                 (else
-//│                   (unreachable)))))))))
+//│               (i31.get_s
+//│                 (ref.cast (ref null i31)
+//│                   (local.get $tmp)))
+//│               (i31.get_s
+//│                 (ref.cast (ref null i31)
+//│                   (local.get $tmp1)))))))))
 //│   (export "entry" (func $entry))
 //│   (elem declare func $entry))
 //│ Wasm result:

hkmc2/shared/src/test/mlscript/wasm/BuiltinOperators.mls

@@ -0,0 +1,25 @@
+
+:global
+:wasm
+:wat
+
+1 + 3
+//│ Wat:
+//│ (module
+//│   (type (func (result (ref null any))))
+//│   (func $entry (type 0) (result (ref null any))
+//│     (ref.i31
+//│       (i32.add
+//│         (i31.get_s
+//│           (ref.cast (ref null i31)
+//│             (ref.i31
+//│               (i32.const 1))))
+//│         (i31.get_s
+//│           (ref.cast (ref null i31)
+//│             (ref.i31
+//│               (i32.const 3)))))))
+//│   (export "entry" (func $entry))
+//│   (elem declare func $entry))
+//│ Wasm result:
+//│ = 4
+//│