Merge branch 'main' of https://github.com/david518yang/Lang

README.md

@@ -2,6 +2,8 @@
 
 # MODE
 
+[Mode Official Website](https://david518yang.github.io/MODEsite/)
+
 ## Matt Martinez, Owen Sheow, David Yang, Eric Hwang
 
 ## Story/Introduction

src/MODE.ohm

@@ -9,8 +9,8 @@ MODE {
                 | LoopStmt
                 | BreakStmt
                 | ClassDef
-                | return ";"                            --shortreturn
                 | return Exp ";"                        --return
+                | return ";"                            --shortreturn
 
     VarDecl     = auto id "=" Exp ";"                   --inference
                 | Type id "=" Exp ";"                  --type

src/analyzer.js

@@ -189,8 +189,8 @@ export default function analyze(match) {
                 return 'string'
             case 'BoolType':
                 return 'boolean'
-            case 'AnyType':
-                return 'any'
+            // case 'AnyType':
+            //     return 'any'
             case 'ClassType':
                 return type.name
             case 'ArrayType':
@@ -560,6 +560,13 @@ export default function analyze(match) {
                 return core.binary(op, left, right, left.type)
             },
 
+            Factor_negation(unaryOp, exp) {
+                const [op, operand] = [unaryOp.sourceString, exp.rep()]
+                mustHaveNumericType(operand, { at: exp })
+                let type = operand.type
+                return core.negation(op, operand, type)
+            },
+
             Primary_emptyarray(ty, _open, _close) {
                 const type = ty.rep()
                 mustBeAnArrayType(type, { at: ty })

src/core.js

@@ -107,8 +107,8 @@ export function binary(op, left, right, type) {
     return { kind: 'BinaryExpression', op, left, right, type }
 }
 
-export function unary(op, operand, type) {
-    return { kind: 'UnaryExpression', op, operand, type }
+export function negation(op, operand, type) {
+    return { kind: 'NegationExpression', op, operand, type }
 }
 
 export function emptyOptional(baseType) {

src/generator.js

@@ -50,9 +50,9 @@ export default function generate(program) {
       output.push("}")
       output.push("}")
     },
-    StructType(t) {
-      return targetName(t)
-    },
+    // StructType(t) {
+    //   return targetName(t)
+    // },
     Field(f) {
       return targetName(f)
     },
@@ -116,22 +116,15 @@ export default function generate(program) {
       s.body.forEach(gen)
       output.push("}")
     },
-    Conditional(e) {
-      return `((${gen(e.test)}) ? (${gen(e.consequent)}) : (${gen(e.alternate)}))`
-    },
+    // Conditional(e) {
+    //   return `((${gen(e.test)}) ? (${gen(e.consequent)}) : (${gen(e.alternate)}))`
+    // },
     BinaryExpression(e) {
       const op = { "==": "===", "!=": "!==" }[e.op] ?? e.op
       return `(${gen(e.left)} ${op} ${gen(e.right)})`
     },
-    UnaryExpression(e) {
+    NegationExpression(e) {
       const operand = gen(e.operand)
-      if (e.op === "some") {
-        return operand
-      } else if (e.op === "#") {
-        return `${operand}.length`
-      } else if (e.op === "random") {
-        return `((a=>a[~~(Math.random()*a.length)])(${operand}))`
-      }
       return `${e.op}(${operand})`
     },
     SubscriptExpression(e) {

src/optimizer.js

@@ -157,7 +157,7 @@ const optimizers = {
         else if (e.op === ">") return e.left > e.right
       } else if (e.left === 0 && e.op === "+") return e.right
       else if (e.left === 1 && e.op === "*") return e.right
-      else if (e.left === 0 && e.op === "-") return core.unary("-", e.right)
+      else if (e.left === 0 && e.op === "-") return core.negation("-", e.right)
       else if (e.left === 1 && e.op === "**") return 1
       else if (e.left === 0 && ["*", "/"].includes(e.op)) return 0
     } else if ([Number, BigInt].includes(e.right.constructor)) {
@@ -169,7 +169,7 @@ const optimizers = {
     }
     return e
   },
-  UnaryExpression(e) {
+  NegationExpression(e) {
     e.op = optimize(e.op)
     e.operand = optimize(e.operand)
     if (e.operand.constructor === Number) {

test/analyzer.test.js

@@ -130,6 +130,7 @@ const semanticChecks = [
         'type description for array type',
         'int[] arr = [1, 2, 3]; arr = [2, 3, 4];',
     ],
+    ['unary negation', 'auto x = -5;']
 ]
 
 // Programs that are syntactically correct but have semantic errors

test/generator.test.js

@@ -89,14 +89,15 @@ const fixtures = [
   {
     name: "functions",
     source: `
-    auto z = 0.5;
-    func f(x: float, y: bool) {
-      print x;
-      return;
-    }
-    func g(): bool {
-      return false;
-    }
+      auto z = 0.5;
+      func f(x: float, y: bool) {
+        print x;
+        return;
+      }
+      func g(): bool {
+        return false;
+      }
+      f(z, g());
     `,
     expected: dedent`
       let z_1 = 0.5;

test/optimizer.test.js

@@ -18,14 +18,13 @@ const and = (...c) => c.reduce((x, y) => core.binary("&&", x, y))
 const less = (x, y) => core.binary("<", x, y)
 const eq = (x, y) => core.binary("==", x, y)
 const times = (x, y) => core.binary("*", x, y)
-const neg = x => core.unary("-", x)
+const neg = x => core.negation("-", x)
 const array = (...elements) => core.arrayExpression(elements)
 const assign = (v, e) => core.assignment(v, e)
 const emptyArray = core.emptyArray(core.intType)
 const sub = (a, e) => core.subscript(a, e)
 const unwrapElse = (o, e) => core.binary("??", o, e)
 const emptyOptional = core.emptyOptional(core.intType)
-const some = x => core.unary("some", x)
 const program = core.program
 
 const tests = [
@@ -50,7 +49,7 @@ const tests = [
   ["optimizes 0+", core.binary("+", 0, x), x],
   ["optimizes 0-", core.binary("-", 0, x), neg(x)],
   ["optimizes 1*", core.binary("*", 1, x), x],
-  ["folds negation", core.unary("-", 8), -8],
+  ["folds negation", core.negation("-", 8), -8],
   ["optimizes 1**", core.binary("**", 1, x), 1],
   ["optimizes **0", core.binary("**", x, 0), 1],
   ["removes left false from ||", or(false, less(x, 1)), less(x, 1)],
@@ -66,26 +65,27 @@ const tests = [
   ["optimizes in arguments", callIdentity([times(3, 5)]), callIdentity([15])],
   ["optimizes ConstructorCall", core.constructorCall(identity, [times(3, 5)]), core.constructorCall(identity, [15])],
   ["optimizes MemberExpression", core.memberExpression(core.constructorCall(identity, [times(3, 5)]), ".", "f"), core.memberExpression(core.constructorCall(identity, [15]), ".", "f")],
+  ["optimizes assignments return brackets", core.program([assign(x, core.binary("+", x, 1)), returnX]), core.program([assign(x, core.binary("+", x, 1)), returnX])],
   [
     "passes through nonoptimizable constructs",
     ...Array(2).fill([
       core.program([core.shortReturnStatement()]),
       core.variableDeclaration("x", true, "z"),
       core.assignment(x, core.binary("*", x, "z")),
-      core.assignment(x, core.unary("not", x)),
+      core.assignment(x, core.negation("not", x)),
       core.constructorCall(identity, core.memberExpression(x, ".", "f")),
       core.variableDeclaration("q", false, core.emptyArray(core.floatType)),
       core.variableDeclaration("r", false, core.emptyOptional(core.intType)),
       core.whileStatement(true, [core.breakStatement]),
       core.conditional(x, 1, 2),
-      unwrapElse(some(x), 7),
       core.ifStatement(x, [], []),
       core.shortIfStatement(x, []),
       core.forRangeStatement(x, 2, "..", 5, []),
       core.forStatement(x, array(1, 2, 3), []),
     ]),
   ],
   ["optimizes whileStatement", core.whileStatement(true, [returnX]), core.whileStatement(true, [returnX])],
+  ["optimizes shortReturnStatement", core.shortReturnStatement(), core.shortReturnStatement()],  
 ]
 
 describe("The optimizer", () => {