compiling more infix exprs

src/compiler/compiler-babel.test.ts

@@ -43,6 +43,39 @@ describe("intrinsics", () => {
     expect(out).toMatchInlineSnapshot(`"const Main$x = 1 * 2;"`);
   });
 
+  test("strings concat", () => {
+    const out = compileSrc(`let x = "a" ++ "b"`);
+    expect(out).toMatchInlineSnapshot(`
+      "const Main$x = "a" + "b";"
+    `);
+  });
+
+  test("boolean negation", () => {
+    const out = compileSrc(`let x = fn b { !b }`);
+
+    expect(out).toMatchInlineSnapshot(`"const Main$x = b => !b;"`);
+  });
+
+  test("infix &&", () => {
+    const out = compileSrc(`let x = fn a, b { a && b }`);
+
+    expect(out).toMatchInlineSnapshot(`"const Main$x = (a, b) => a && b;"`);
+  });
+
+  test("infix ||", () => {
+    const out = compileSrc(`let x = fn a, b { a || b }`);
+
+    expect(out).toMatchInlineSnapshot(`"const Main$x = (a, b) => a || b;"`);
+  });
+
+  test("boolean negation and && prec", () => {
+    const out = compileSrc(`let x = fn t, f { !(t && f)}`);
+
+    expect(out).toMatchInlineSnapshot(`
+      "const Main$x = (t, f) => !(t && f);"
+    `);
+  });
+
   test("compile == of ints", () => {
     const out = compileSrc(`pub let x = 1 == 2`);
     expect(out).toMatchInlineSnapshot(`"const Main$x = 1 === 2;"`);

src/compiler/compiler-babel.ts

@@ -49,6 +49,26 @@ class Compiler {
               right: this.compileExpr(src.args[1]!),
             };
           }
+
+          const infixLogicalName = toJsInfixLogical(src.caller.name);
+          if (infixLogicalName !== undefined) {
+            return {
+              type: "LogicalExpression",
+              operator: infixLogicalName,
+              left: this.compileExpr(src.args[0]!),
+              right: this.compileExpr(src.args[1]!),
+            };
+          }
+
+          const prefixName = toJsPrefix(src.caller.name);
+          if (prefixName !== undefined) {
+            return {
+              type: "UnaryExpression",
+              operator: prefixName,
+              argument: this.compileExpr(src.args[0]!),
+              prefix: true,
+            };
+          }
         }
 
         return {
@@ -334,6 +354,18 @@ function compileConst(ast: ConstLiteral): t.Expression {
   }
 }
 
+function toJsPrefix(
+  kestrelCaller: string,
+): t.UnaryExpression["operator"] | undefined {
+  switch (kestrelCaller) {
+    case "!":
+      return kestrelCaller;
+
+    default:
+      return undefined;
+  }
+}
+
 function toJsInfix(
   kestrelCaller: string,
 ): BinaryExpression["operator"] | undefined {
@@ -342,6 +374,9 @@ function toJsInfix(
     case "*":
       return kestrelCaller;
 
+    case "++":
+      return "+";
+
     case "==":
       return "===";
 
@@ -350,6 +385,19 @@ function toJsInfix(
   }
 }
 
+function toJsInfixLogical(
+  kestrelCaller: string,
+): t.LogicalExpression["operator"] | undefined {
+  switch (kestrelCaller) {
+    case "&&":
+    case "||":
+      return kestrelCaller;
+
+    default:
+      return undefined;
+  }
+}
+
 function sanitizeNamespace(ns: string): string {
   return ns?.replace(/\//g, "$");
 }