small improvements

src/index.ts

@@ -11,8 +11,7 @@ import { exec } from "child_process";
 
 const input = `
 function main() = (
-  print("\\3AAA\\n");
+  1 + 2 * 3;
-  print("meow\\n");
 );
 `;
 

src/lower.ts

@@ -114,7 +114,9 @@ export function lower(ast: Ast): wasm.Module {
 
   const HEAP_ALIGN = 0x08;
   cx.reservedHeapMemoryStart =
-    (mod.datas[0].init.length + (HEAP_ALIGN - 1)) & ~(HEAP_ALIGN - 1);
+    mod.datas.length > 0
+      ? (mod.datas[0].init.length + (HEAP_ALIGN - 1)) & ~(HEAP_ALIGN - 1)
+      : 0;
 
   addRt(cx, ast);
 

src/parser.ts

@@ -18,6 +18,7 @@ import {
   TypeDef,
   UNARY_KINDS,
   UnaryKind,
+  binaryExprPrecedenceClass,
   foldAst,
   superFoldExpr,
 } from "./ast";
@@ -507,23 +508,42 @@ function unexpectedToken(token: Token): never {
 function validateAst(ast: Ast) {
   const validator: Folder = {
     ...DEFAULT_FOLDER,
-    expr(value: Expr): Expr {
+    expr(expr: Expr): Expr {
-      if (value.kind === "block") {
+      if (expr.kind === "block") {
-        value.exprs.forEach((expr) => {
+        expr.exprs.forEach((inner) => {
-          if (expr.kind === "let") {
+          if (inner.kind === "let") {
-            this.expr(expr.rhs);
+            this.expr(inner.rhs);
-            if (expr.type) {
+            if (inner.type) {
-              this.type(expr.type);
+              this.type(inner.type);
             }
           } else {
-            this.expr(expr);
+            this.expr(inner);
           }
         });
-        return value;
+        return expr;
-      } else if (value.kind === "let") {
+      } else if (expr.kind === "let") {
-        throw new CompilerError("let is only allowed in blocks", value.span);
+        throw new CompilerError("let is only allowed in blocks", expr.span);
+      } else if (expr.kind === "binary") {
+        const checkPrecedence = (inner: Expr, side: string) => {
+          if (inner.kind === "binary") {
+            const ourClass = binaryExprPrecedenceClass(expr.binaryKind);
+            const innerClass = binaryExprPrecedenceClass(inner.binaryKind);
+
+            if (ourClass !== innerClass) {
+              throw new CompilerError(
+                `mixing operators without parentheses is not allowed. ${side} is ${inner.binaryKind}, which is different from ${expr.binaryKind}`,
+                expr.span
+              );
+            }
+          }
+        };
+
+        checkPrecedence(expr.lhs, "left");
+        checkPrecedence(expr.rhs, "right");
+
+        return superFoldExpr(expr, this);
       } else {
-        return superFoldExpr(value, this);
+        return superFoldExpr(expr, this);
       }
     },
   };

src/typeck.ts

@@ -641,23 +641,6 @@ export function checkBody(
 }
 
 function checkBinary(expr: Expr & ExprBinary): Expr {
-  const checkPrecedence = (inner: Expr, side: string) => {
-    if (inner.kind === "binary") {
-      const ourClass = binaryExprPrecedenceClass(expr.binaryKind);
-      const innerClass = binaryExprPrecedenceClass(inner.binaryKind);
-
-      if (ourClass !== innerClass) {
-        throw new CompilerError(
-          `mixing operators without parentheses is not allowed. ${side} is ${inner.binaryKind}, which is different from ${expr.binaryKind}`,
-          expr.span
-        );
-      }
-    }
-  };
-
-  checkPrecedence(expr.lhs, "left");
-  checkPrecedence(expr.rhs, "right");
-
   let lhsTy = expr.lhs.ty!;
   let rhsTy = expr.rhs.ty!;