Member and destructured assignment and rest operator

README.md

@@ -20,10 +20,12 @@ Liszt compiles to JavaScript, so it can be used both for browser-based applicati
 
 The type checker implementation owes a great deal to Jake Donham's [Reconstructing TypeScript](https://jaked.org/blog/2021-09-07-Reconstructing-TypeScript-part-0) series.
 
-## Syntax
+## The language
 
 Comments start with a semicolon and continue to the end of the line.
 
+### Literals
+
 There are literals for Integer, Float, String, Boolean, Symbol, Object, Tuple, Vector, and Nil types.
 
 ```ruby
@@ -40,15 +42,19 @@ nil
 
 Note that both Integer and Float are subtypes of Number, so they can be mixed together in most operations (need to fix this).
 
+### Declaring bindings
+
 Declare variables with `var` and constants with `const`. Note that if you reassign a variable the new value must be of the same type as the one it was declared with.
 
 ```ruby
 var changeMe = "I can be changed!"
 const cantChangeMe = "Try to change me and it will throw an error"
 
-changeMe = 42 ;=> Type error!
+cantChangeMe = 42 ;=> Type error!
 ```
 
+### Defining functions
+
 Define functions with the `def` keyword and end the body with `end`. Note that we strongly recommend using type annotations with the function parameters, though a return type annotation is not necessary. If you don't annotate the function parameters, they will be typed as Any which basically turns off the type checker.
 
 ```ruby
@@ -59,6 +65,8 @@ end
 
 If you want to annotate the return type you can do that too; sometimes it's a big help to the type checker (especially with recursive functions).
 
+Note that the if operation is an expression, not a statement, and it MUST have an else branch.
+
 ```ruby
 def fib(n: integer): integer
     if n == 0
@@ -74,6 +82,8 @@ You can also just assign a lambda to a variable (though a lambda must use an exp
 const inc: (x: integer) => integer = (x) => x + 1
 ```
 
+### Generic functions
+
 You can use type variables in your function definitions for parametric polymorphism. Type variables start with a single quote character.
 
 ```ruby
@@ -82,6 +92,8 @@ def id(x: 'a)
 end
 ```
 
+### Iteration
+
 Iterate over vectors with for statements.
 
 ```ruby
@@ -94,6 +106,36 @@ end
 sum == 55  ;=> true
 ```
 
+### Constants are really constant
+
+In JavaScript, you can reassign properties of an object (or indices of an array) even if the object is declared with `const`, like so:
+
+```js
+const obj = { greeting: "Hello" };
+obj.greeting = "Hi!";
+
+const arr = [1, 2, 3];
+arr[2] = 5;
+```
+
+Trying to do that with a Liszt object or vector will cause a type error at compile time, so this
+
+```ruby
+const obj = { greeting: "Hello" };
+obj.greeting = "Hi!"
+```
+
+or this
+
+```ruby
+const v = vec[1, 2, 3]
+v[2] = 5
+```
+
+will throw an error. You can always reassign properties or indices of objects that are declared with `var` though.
+
+### Creating types
+
 You can also create your own types as aliases for built-in types, tuple types, and object types.
 
 ```ruby

src/emitter/Emitter.ts

@@ -3,6 +3,7 @@ import { ASTNode } from "../syntax/parser/ast/ASTNode";
 import { CallExpression } from "../syntax/parser/ast/CallExpression";
 import { VariableDeclaration } from "../syntax/parser/ast/VariableDeclaration";
 import { BoundAssignmentExpression } from "../typechecker/bound/BoundAssignmentExpression";
+import { BoundASTNode } from "../typechecker/bound/BoundASTNode";
 import { BoundBinaryOperation } from "../typechecker/bound/BoundBinaryOperation";
 import { BoundBlock } from "../typechecker/bound/BoundBlock";
 import { BoundBooleanLiteral } from "../typechecker/bound/BoundBooleanLiteral";
@@ -19,6 +20,7 @@ import { BoundMemberExpression } from "../typechecker/bound/BoundMemberExpressio
 import { BoundNilLiteral } from "../typechecker/bound/BoundNilLiteral";
 import { BoundNodes } from "../typechecker/bound/BoundNodes";
 import { BoundObjectLiteral } from "../typechecker/bound/BoundObjectLiteral";
+import { BoundObjectPattern } from "../typechecker/bound/BoundObjectPattern";
 import { BoundParenthesizedExpression } from "../typechecker/bound/BoundParenthesizedExpression";
 import { BoundProgramNode } from "../typechecker/bound/BoundProgramNode";
 import { BoundReturnStatement } from "../typechecker/bound/BoundReturnStatement";
@@ -27,6 +29,7 @@ import { BoundStringLiteral } from "../typechecker/bound/BoundStringLiteral";
 import { BoundSymbolLiteral } from "../typechecker/bound/BoundSymbolLiteral";
 import { BoundTree } from "../typechecker/bound/BoundTree";
 import { BoundTuple } from "../typechecker/bound/BoundTuple";
+import { BoundTuplePattern } from "../typechecker/bound/BoundTuplePattern";
 import { BoundUnaryOperation } from "../typechecker/bound/BoundUnaryOperation";
 import { BoundVariableDeclaration } from "../typechecker/bound/BoundVariableDeclaration";
 import { BoundVector } from "../typechecker/bound/BoundVector";
@@ -44,7 +47,7 @@ export class Emitter {
     return this.emitNode(program);
   }
 
-  private emitNode(node: ASTNode): string {
+  private emitNode(node: BoundASTNode): string {
     switch (node.kind) {
       case BoundNodes.BoundProgramNode:
         return this.emitProgram(node as BoundProgramNode);
@@ -101,6 +104,10 @@ export class Emitter {
         return this.emitSliceExpression(node as BoundSliceExpression);
       case BoundNodes.BoundForStatement:
         return this.emitForStatement(node as BoundForStatement);
+      case BoundNodes.BoundTuplePattern:
+        return this.emitTuplePattern(node as BoundTuplePattern);
+      case BoundNodes.BoundObjectPattern:
+        return this.emitObjectPattern(node as BoundObjectPattern);
       default:
         throw new Error(`Unknown bound node type ${node.kind}`);
     }
@@ -182,7 +189,7 @@ export class Emitter {
     return code;
   }
 
-  private emitCallExpression(node: CallExpression): string {
+  private emitCallExpression(node: BoundCallExpression): string {
     let code = `${this.emitNode(node.func)}`;
     code += `(${node.args.map((arg) => this.emitNode(arg)).join(", ")})`;
     return code;
@@ -191,15 +198,15 @@ export class Emitter {
   private emitAssignment(node: BoundAssignmentExpression): string {
     return `${this.emitNode(node.left)} ${node.operator} ${this.emitNode(
       node.right
-    )}`;
+    )};\n`;
   }
 
   private emitVariableDeclaration(node: BoundVariableDeclaration): string {
     if (node.constant) {
-      return `const ${this.emitNode(node.assignment)};\n`;
+      return `const ${this.emitNode(node.assignment)}`;
     }
 
-    return `let ${this.emitNode(node.assignment)};\n`;
+    return `let ${this.emitNode(node.assignment)}`;
   }
 
   private emitFunctionDeclaration(node: BoundFunctionDeclaration): string {
@@ -218,7 +225,7 @@ export class Emitter {
         // this case is redundant, but I'm putting it here for emphasis
         if (expr.kind === BoundNodes.BoundReturnStatement) {
           return this.emitNode(expr);
-        } else if (i === a.length - 1 && node.statement) {
+        } else if (i === a.length - 1 && !node.statement) {
           return `return ${this.emitNode(expr)};`;
         }
         return this.emitNode(expr);
@@ -297,4 +304,33 @@ export class Emitter {
 
     return code;
   }
+
+  private emitTuplePattern(node: BoundTuplePattern): string {
+    return `[${node.names
+      .map((n, i, a) => {
+        if (node.rest && i === a.length - 1) {
+          return `...${(n as BoundIdentifier).name}`;
+        } else if (n instanceof BoundTuplePattern) {
+          return this.emitTuplePattern(n);
+        } else if (n instanceof BoundObjectPattern) {
+          return this.emitObjectPattern(n);
+        }
+
+        return n.name;
+      })
+      .join(", ")}]`;
+  }
+
+  private emitObjectPattern(node: BoundObjectPattern): string {
+    return `{${node.names
+      .map((n, i, a) => {
+        if (node.rest && i === a.length - 1) {
+          return `...${(n as BoundIdentifier).name}`;
+        }
+        // handle cases with nested tuple and object properties
+
+        return (n as BoundIdentifier).name;
+      })
+      .join(", ")}}`;
+  }
 }

src/syntax/lexer/TokenNames.ts

@@ -25,6 +25,11 @@ export enum TokenNames {
   Mod = "Mod",
   Exp = "Exp",
   Equals = "Equals",
+  PlusEquals = "PlusEquals",
+  MinusEquals = "MinusEquals",
+  TimesEquals = "TimesEquals",
+  DivEquals = "DivEquals",
+  ModEquals = "ModEquals",
   FatArrow = "FatArrow",
   As = "As",
   And = "And",

src/syntax/lexer/helpers.ts

@@ -80,6 +80,11 @@ export type kw = keyof typeof KEYWORDS;
 
 export const OPERATORS = {
   "=": TokenNames.Equals,
+  "+=": TokenNames.PlusEquals,
+  "-=": TokenNames.MinusEquals,
+  "*=": TokenNames.TimesEquals,
+  "/=": TokenNames.DivEquals,
+  "%=": TokenNames.ModEquals,
   "=>": TokenNames.FatArrow,
   "+": TokenNames.Plus,
   "-": TokenNames.Minus,

src/syntax/parser/LHVParser.ts

@@ -1,6 +1,10 @@
 import { LexResult } from "../lexer/LexResult";
 import { ASTNode } from "./ast/ASTNode";
+import { DestructuringLHV } from "./ast/DestructuringLHV";
 import { Identifier } from "./ast/Identifier";
+import { ObjectPattern } from "./ast/ObjectPattern";
+import { SetLiteral } from "./ast/SetLiteral";
+import { SpreadOperation } from "./ast/SpreadOperation";
 import { SyntaxNodes } from "./ast/SyntaxNodes";
 import { Tuple } from "./ast/Tuple";
 import { TuplePattern } from "./ast/TuplePattern";
@@ -20,24 +24,98 @@ export class LHVParser extends BaseParser {
       return expr;
     }
 
+    if (expr.kind === SyntaxNodes.SliceExpression) {
+      return expr;
+    }
+
     if (expr.kind === SyntaxNodes.Tuple) {
       return this.parseTuplePattern(expr as Tuple);
     }
 
+    if (expr.kind === SyntaxNodes.SetLiteral) {
+      return this.parseObjectPattern(expr as SetLiteral);
+    }
+
+    if (expr.kind === SyntaxNodes.SpreadOperation) {
+      return this.parseSpreadOperation(expr as SpreadOperation);
+    }
+
     throw new Error(`Invalid left side expression type ${expr.kind}`);
   }
 
+  private parseObjectPattern(expr: SetLiteral) {
+    let names: DestructuringLHV[] = [];
+    let rest = false;
+    for (let member of expr.members) {
+      if (rest) {
+        throw new Error("No left hand values allowed after rest parameter");
+      }
+
+      if (
+        ![
+          SyntaxNodes.Identifier,
+          SyntaxNodes.SpreadOperation,
+          SyntaxNodes.Tuple,
+          SyntaxNodes.SetLiteral,
+        ].includes(member.kind)
+      ) {
+        throw new Error(
+          `Object pattern assignment requires valid assignment parameter; ${member.kind} given`
+        );
+      }
+
+      if (member.kind === SyntaxNodes.SpreadOperation) {
+        rest = true;
+      }
+
+      let name = this.parseLHV(member) as DestructuringLHV;
+
+      names.push(name);
+    }
+
+    return ObjectPattern.new(names, rest, expr.start, expr.end);
+  }
+
+  private parseSpreadOperation(expr: SpreadOperation) {
+    if (expr.expression.kind !== SyntaxNodes.Identifier) {
+      throw new Error(
+        `Rest parameter in left hand assignment value must be a valid identifier; ${expr.kind} given`
+      );
+    }
+
+    return expr;
+  }
+
   private parseTuplePattern(expr: Tuple) {
-    let names: Identifier[] = [];
+    let names: DestructuringLHV[] = [];
+    let rest = false;
     for (let value of expr.values) {
-      if (value.kind !== SyntaxNodes.Identifier) {
+      if (rest) {
+        throw new Error(`No left hand values allowed after rest parameter`);
+      }
+
+      if (
+        ![
+          SyntaxNodes.Identifier,
+          SyntaxNodes.SpreadOperation,
+          SyntaxNodes.Tuple,
+          SyntaxNodes.SetLiteral,
+        ].includes(value.kind)
+      ) {
         throw new Error(
-          `Tuple pattern assignment expects valid identifiers; ${expr} given`
+          `Tuple pattern assignment requires valid assignment parameter; ${expr} given`
         );
       }
-      names.push(value as Identifier);
+
+      if (value.kind === SyntaxNodes.SpreadOperation) {
+        rest = true;
+      }
+
+      let name = this.parseLHV(value) as DestructuringLHV;
+
+      names.push(name);
     }
 
-    return TuplePattern.new(names, expr.start, expr.end);
+    return TuplePattern.new(names, rest, expr.start, expr.end);
   }
 }