yukigo-mini-parser 0.1.0 → 0.1.2

package/src/grammar.ne

@@ -1,127 +1,132 @@
-@{%
-import { MiniLexer } from "./lexer.js"
-import { 
-    SimpleType, 
-    Assignment, 
-    Variable,
-    ListPrimitive,
-    ListType,
-    ArithmeticBinaryOperation, 
-    SymbolPrimitive, 
-    NumberPrimitive, 
-    ComparisonOperation,
-    BooleanPrimitive, 
-    StringPrimitive, 
-    ParameterizedType,
-    Sequence,
-    UnguardedBody,
-    If,
-    While,
-    VariablePattern,
-    Equation,
-    Procedure,
-    TypeSignature,
-    CharPrimitive,
-    NilPrimitive,
-    Return
-} from "yukigo-ast"
-%}
-
-@preprocessor typescript
-@lexer MiniLexer
-
-program -> statement:+ _ %EOF {% (d) => d[0].flat(Infinity) %}
-
-# Statements
-
-statement -> (assignment | variable_statement | function_statement | return_statement | if_statement | while_statement) _ ";" _ {% (d) => d[0][0] %}
-
-variable_statement -> type __ variable (_ ":=" _ expression):? {% (d) => new Variable(d[2], d[3] ? d[3][3] : new NilPrimitive(null), d[0]) %}
-
-return_statement -> "return" _ expression {% (d) => new Return(d[2]) %}
-
-while_statement -> "while" _ condition _ statement_list {% d => new While(d[2], d[4]) %}
-
-if_statement -> "if" _ condition _ statement_list _ "else" _ statement_list {% d => new If(d[2], d[4], d[8]) %}
-
-condition -> "(" _ expression _ ")" {% (d) => d[2] %}
-
-statement_list -> "{" _ statement:* _ "}" {% d => new Sequence(d[2]) %}
-
-assignment -> variable _ ":=" _ expression {% (d) => new Assignment(d[0], d[4]) %}
-
-## Function rules
-
-function_statement -> type __ variable ("(" _ param_list:? _ ")" _ "{" _ body _ "}") {% (d) => {
-    const paramTypeList = []
-    const patternList = []
-    if(d[3][2]) {
-        for(const [paramType, paramPattern] of d[3][2]) {
-            paramTypeList.push(paramType);
-            patternList.push(paramPattern);
-        }
-    }
-    const signatureType = new ParameterizedType(paramTypeList, d[0], []) 
-
-    const signature = new TypeSignature(d[2], signatureType);
-    const procedure =  new Procedure(d[2], [new Equation(patternList, d[3][8])])
-    return [signature, procedure]
-}%}
-
-param_list -> param (_ "," _ param):* {% d => [d[0], ...d[1].map(x => x[3])] %}
-
-param -> type __ variable {% d => [d[0], new VariablePattern(d[2])] %}
-
-body -> statement:* {% (d) => new UnguardedBody(new Sequence(d[0])) %}
-
-# Expressions
-
-expression -> comparison {% (d) => d[0] %}
-
-comparison ->
-    addition _ comparison_operator _ addition {% (d) => new ComparisonOperation(d[2], d[0], d[4]) %}
-    | addition {% (d) => d[0] %}
-
-addition -> 
-    addition _ "+" _ multiplication {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
-    | addition _ "-" _ multiplication {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
-    | multiplication {% (d) => d[0] %}
-
-multiplication -> 
-    multiplication _ "*" _ primary {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
-    | multiplication _ "/" _ primary {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
-    | primary {% (d) => d[0] %}
-
-primary -> 
-    variable {% (d) => d[0] %}
-    | "(" _ expression _ ")" {% (d) => d[2] %}
-    | primitive {% (d) => d[0] %}
-
-primitive -> 
-    %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
-    | %char {% (d) => new CharPrimitive(d[0].value) %}
-    | %string {% (d) => new StringPrimitive(d[0].value) %}
-    | %bool {% (d) => new BooleanPrimitive(d[0].value) %}
-    | variable {% (d) => d[0] %}
-    | list_primitive {% d => d[0] %}
-
-type -> 
-    variable {% (d) => new SimpleType(d[0].value, []) %}
-    | type "[" "]" {% (d) => new ListType(d[0], []) %}
-
-list_primitive -> "[" _ expression_list _ "]" {% (d) => new ListPrimitive(d[2]) %}
-
-expression_list -> expression _ ("," _ expression _):* {% (d) => ([d[0], ...d[2].map(x => x[2])]) %}
-
-variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
-
-comparison_operator -> 
-    %equal {% d => "Equal" %}
-    | %notEqual {% d => "NotEqual" %}
-    | %lt {% d => "LessThan" %}
-    | %lte {% d => "LessOrEqualThan" %}
-    | %gt {% d => "GreaterThan" %}
-    | %gte {% d => "GreaterOrEqualThan" %}
-
-_ -> %WS:* {% d => null %}
+@{%
+import { MiniLexer } from "./lexer.js"
+import { 
+    SimpleType, 
+    Assignment, 
+    Variable,
+    ListPrimitive,
+    ListType,
+    ArithmeticBinaryOperation, 
+    SymbolPrimitive, 
+    NumberPrimitive, 
+    ComparisonOperation,
+    BooleanPrimitive, 
+    StringPrimitive, 
+    ParameterizedType,
+    Sequence,
+    UnguardedBody,
+    If,
+    While,
+    VariablePattern,
+    Equation,
+    Procedure,
+    TypeSignature,
+    CharPrimitive,
+    NilPrimitive,
+    Return
+} from "yukigo-ast"
+%}
+
+@preprocessor typescript
+@lexer MiniLexer
+
+program -> _ statements _ %EOF {% (d) => d[1].flat(Infinity) %}
+
+statements -> 
+    statement {% (d) => [d[0]] %}
+    | statements _ statement {% (d) => [...d[0], d[2]] %}
+
+# Statements
+
+statement -> (assignment | variable_statement | function_statement | return_statement | if_statement | while_statement) _ ";" {% (d) => d[0][0] %}
+
+variable_statement -> type __ variable (_ ":=" _ expression):? {% (d) => new Variable(d[2], d[3] ? d[3][3] : new NilPrimitive(null), d[0]) %}
+
+return_statement -> "return" _ expression {% (d) => new Return(d[2]) %}
+
+while_statement -> "while" _ condition _ statement_list {% d => new While(d[2], d[4]) %}
+
+if_statement -> "if" _ condition _ statement_list _ "else" _ statement_list {% d => new If(d[2], d[4], d[8]) %}
+
+condition -> "(" _ expression _ ")" {% (d) => d[2] %}
+
+statement_list -> "{" _ body _ "}" {% d => d[2] %}
+body -> 
+    statements {% (d) => new Sequence(d[0].flat(Infinity)) %}
+    | null {% () => new Sequence([]) %}
+
+assignment -> variable _ ":=" _ expression {% (d) => new Assignment(d[0], d[4]) %}
+
+## Function rules
+
+function_statement -> type __ variable ("(" _ param_list:? _ ")" _ statement_list) {% (d) => {
+    const paramTypeList = []
+    const patternList = []
+    if(d[3][2]) {
+        for(const [paramType, paramPattern] of d[3][2]) {
+            paramTypeList.push(paramType);
+            patternList.push(paramPattern);
+        }
+    }
+    const signatureType = new ParameterizedType(paramTypeList, d[0], []) 
+
+    const signature = new TypeSignature(d[2], signatureType);
+    const procedure =  new Procedure(d[2], [new Equation(patternList, new UnguardedBody(d[3][6]))])
+    return [signature, procedure]
+}%}
+
+param_list -> param (_ "," _ param):* {% d => [d[0], ...d[1].map(x => x[3])] %}
+
+param -> type __ variable {% d => [d[0], new VariablePattern(d[2])] %}
+
+
+# Expressions
+
+expression -> comparison {% (d) => d[0] %}
+
+comparison ->
+    addition _ comparison_operator _ addition {% (d) => new ComparisonOperation(d[2], d[0], d[4]) %}
+    | addition {% (d) => d[0] %}
+
+addition -> 
+    addition _ "+" _ multiplication {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
+    | addition _ "-" _ multiplication {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
+    | multiplication {% (d) => d[0] %}
+
+multiplication -> 
+    multiplication _ "*" _ primary {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
+    | multiplication _ "/" _ primary {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
+    | primary {% (d) => d[0] %}
+
+primary -> 
+    "(" _ expression _ ")" {% (d) => d[2] %}
+    | primitive {% (d) => d[0] %}
+
+primitive -> 
+    %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
+    | %char {% (d) => new CharPrimitive(d[0].value) %}
+    | %string {% (d) => new StringPrimitive(d[0].value) %}
+    | %bool {% (d) => new BooleanPrimitive(d[0].value) %}
+    | variable {% (d) => d[0] %}
+    | list_primitive {% d => d[0] %}
+
+type -> 
+    variable {% (d) => new SimpleType(d[0].value, []) %}
+    | type "[" "]" {% (d) => new ListType(d[0], []) %}
+
+list_primitive -> "[" _ expression_list _ "]" {% (d) => new ListPrimitive(d[2]) %}
+
+expression_list -> expression _ ("," _ expression):* {% (d) => ([d[0], ...d[2].map(x => x[2])]) %}
+
+variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
+
+comparison_operator -> 
+    %equal {% d => "Equal" %}
+    | %notEqual {% d => "NotEqual" %}
+    | %lt {% d => "LessThan" %}
+    | %lte {% d => "LessOrEqualThan" %}
+    | %gt {% d => "GreaterThan" %}
+    | %gte {% d => "GreaterOrEqualThan" %}
+
+_ -> %WS:* {% d => null %}
 __ -> %WS:+ {% d => null %}

package/src/grammar.ts

@@ -74,16 +74,16 @@ interface Grammar {
 const grammar: Grammar = {
   Lexer: MiniLexer,
   ParserRules: [
-    {"name": "program$ebnf$1", "symbols": ["statement"]},
-    {"name": "program$ebnf$1", "symbols": ["program$ebnf$1", "statement"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "program", "symbols": ["program$ebnf$1", "_", (MiniLexer.has("EOF") ? {type: "EOF"} : EOF)], "postprocess": (d) => d[0].flat(Infinity)},
+    {"name": "program", "symbols": ["_", "statements", "_", (MiniLexer.has("EOF") ? {type: "EOF"} : EOF)], "postprocess": (d) => d[1].flat(Infinity)},
+    {"name": "statements", "symbols": ["statement"], "postprocess": (d) => [d[0]]},
+    {"name": "statements", "symbols": ["statements", "_", "statement"], "postprocess": (d) => [...d[0], d[2]]},
     {"name": "statement$subexpression$1", "symbols": ["assignment"]},
     {"name": "statement$subexpression$1", "symbols": ["variable_statement"]},
     {"name": "statement$subexpression$1", "symbols": ["function_statement"]},
     {"name": "statement$subexpression$1", "symbols": ["return_statement"]},
     {"name": "statement$subexpression$1", "symbols": ["if_statement"]},
     {"name": "statement$subexpression$1", "symbols": ["while_statement"]},
-    {"name": "statement", "symbols": ["statement$subexpression$1", "_", {"literal":";"}, "_"], "postprocess": (d) => d[0][0]},
+    {"name": "statement", "symbols": ["statement$subexpression$1", "_", {"literal":";"}], "postprocess": (d) => d[0][0]},
     {"name": "variable_statement$ebnf$1$subexpression$1", "symbols": ["_", {"literal":":="}, "_", "expression"]},
     {"name": "variable_statement$ebnf$1", "symbols": ["variable_statement$ebnf$1$subexpression$1"], "postprocess": id},
     {"name": "variable_statement$ebnf$1", "symbols": [], "postprocess": () => null},
@@ -92,13 +92,13 @@ const grammar: Grammar = {
     {"name": "while_statement", "symbols": [{"literal":"while"}, "_", "condition", "_", "statement_list"], "postprocess": d => new While(d[2], d[4])},
     {"name": "if_statement", "symbols": [{"literal":"if"}, "_", "condition", "_", "statement_list", "_", {"literal":"else"}, "_", "statement_list"], "postprocess": d => new If(d[2], d[4], d[8])},
     {"name": "condition", "symbols": [{"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => d[2]},
-    {"name": "statement_list$ebnf$1", "symbols": []},
-    {"name": "statement_list$ebnf$1", "symbols": ["statement_list$ebnf$1", "statement"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "statement_list", "symbols": [{"literal":"{"}, "_", "statement_list$ebnf$1", "_", {"literal":"}"}], "postprocess": d => new Sequence(d[2])},
+    {"name": "statement_list", "symbols": [{"literal":"{"}, "_", "body", "_", {"literal":"}"}], "postprocess": d => d[2]},
+    {"name": "body", "symbols": ["statements"], "postprocess": (d) => new Sequence(d[0].flat(Infinity))},
+    {"name": "body", "symbols": [], "postprocess": () => new Sequence([])},
     {"name": "assignment", "symbols": ["variable", "_", {"literal":":="}, "_", "expression"], "postprocess": (d) => new Assignment(d[0], d[4])},
     {"name": "function_statement$subexpression$1$ebnf$1", "symbols": ["param_list"], "postprocess": id},
     {"name": "function_statement$subexpression$1$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "function_statement$subexpression$1", "symbols": [{"literal":"("}, "_", "function_statement$subexpression$1$ebnf$1", "_", {"literal":")"}, "_", {"literal":"{"}, "_", "body", "_", {"literal":"}"}]},
+    {"name": "function_statement$subexpression$1", "symbols": [{"literal":"("}, "_", "function_statement$subexpression$1$ebnf$1", "_", {"literal":")"}, "_", "statement_list"]},
     {"name": "function_statement", "symbols": ["type", "__", "variable", "function_statement$subexpression$1"], "postprocess":  (d) => {
             const paramTypeList = []
             const patternList = []
@@ -111,7 +111,7 @@ const grammar: Grammar = {
             const signatureType = new ParameterizedType(paramTypeList, d[0], []) 
         
             const signature = new TypeSignature(d[2], signatureType);
-            const procedure =  new Procedure(d[2], [new Equation(patternList, d[3][8])])
+            const procedure =  new Procedure(d[2], [new Equation(patternList, new UnguardedBody(d[3][6]))])
             return [signature, procedure]
         }},
     {"name": "param_list$ebnf$1", "symbols": []},
@@ -119,9 +119,6 @@ const grammar: Grammar = {
     {"name": "param_list$ebnf$1", "symbols": ["param_list$ebnf$1", "param_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
     {"name": "param_list", "symbols": ["param", "param_list$ebnf$1"], "postprocess": d => [d[0], ...d[1].map(x => x[3])]},
     {"name": "param", "symbols": ["type", "__", "variable"], "postprocess": d => [d[0], new VariablePattern(d[2])]},
-    {"name": "body$ebnf$1", "symbols": []},
-    {"name": "body$ebnf$1", "symbols": ["body$ebnf$1", "statement"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "body", "symbols": ["body$ebnf$1"], "postprocess": (d) => new UnguardedBody(new Sequence(d[0]))},
     {"name": "expression", "symbols": ["comparison"], "postprocess": (d) => d[0]},
     {"name": "comparison", "symbols": ["addition", "_", "comparison_operator", "_", "addition"], "postprocess": (d) => new ComparisonOperation(d[2], d[0], d[4])},
     {"name": "comparison", "symbols": ["addition"], "postprocess": (d) => d[0]},
@@ -131,7 +128,6 @@ const grammar: Grammar = {
     {"name": "multiplication", "symbols": ["multiplication", "_", {"literal":"*"}, "_", "primary"], "postprocess": (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4])},
     {"name": "multiplication", "symbols": ["multiplication", "_", {"literal":"/"}, "_", "primary"], "postprocess": (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4])},
     {"name": "multiplication", "symbols": ["primary"], "postprocess": (d) => d[0]},
-    {"name": "primary", "symbols": ["variable"], "postprocess": (d) => d[0]},
     {"name": "primary", "symbols": [{"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => d[2]},
     {"name": "primary", "symbols": ["primitive"], "postprocess": (d) => d[0]},
     {"name": "primitive", "symbols": [(MiniLexer.has("number") ? {type: "number"} : number)], "postprocess": (d) => new NumberPrimitive(Number(d[0].value))},
@@ -144,7 +140,7 @@ const grammar: Grammar = {
     {"name": "type", "symbols": ["type", {"literal":"["}, {"literal":"]"}], "postprocess": (d) => new ListType(d[0], [])},
     {"name": "list_primitive", "symbols": [{"literal":"["}, "_", "expression_list", "_", {"literal":"]"}], "postprocess": (d) => new ListPrimitive(d[2])},
     {"name": "expression_list$ebnf$1", "symbols": []},
-    {"name": "expression_list$ebnf$1$subexpression$1", "symbols": [{"literal":","}, "_", "expression", "_"]},
+    {"name": "expression_list$ebnf$1$subexpression$1", "symbols": [{"literal":","}, "_", "expression"]},
     {"name": "expression_list$ebnf$1", "symbols": ["expression_list$ebnf$1", "expression_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
     {"name": "expression_list", "symbols": ["expression", "_", "expression_list$ebnf$1"], "postprocess": (d) => ([d[0], ...d[2].map(x => x[2])])},
     {"name": "variable", "symbols": [(MiniLexer.has("variable") ? {type: "variable"} : variable)], "postprocess": (d) => new SymbolPrimitive(d[0].value)},

package/src/index.ts

@@ -1,24 +1,39 @@
-import { YukigoParser } from "yukigo-ast";
-import nearley from "nearley";
-import grammar from "./grammar.js";
-
-export class YukigoMiniParser implements YukigoParser {
-  public errors: string[] = [];
-
-  public parse(code: string) {
-    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
-    try {
-      parser.feed(code);
-      parser.finish();
-    } catch (error) {
-      const token = error.token;
-      const message = `Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`;
-      this.errors.push(message)
-    }
-    const results = parser.results
-    if(results.length > 1)
-      throw Error(`Ambiguous grammar. The parser generated ${results.length} ASTs`)
-
-    return results[0]
-  }
-}
+import { AST, Expression, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./grammar.js";
+import { Token } from "moo";
+
+class UnexpectedToken extends Error {
+  constructor(token: Token) {
+    super(
+      `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`
+    );
+  }
+}
+
+export class YukigoMiniParser implements YukigoParser {
+  public errors: string[] = [];
+
+  public parse(code: string): AST {
+    return this.feedParser(code);
+  }
+  public parseExpression(code: string): Expression {
+    return this.feedParser(code);
+  }
+  private feedParser(code: string): any {
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (error) {
+      if ("token" in error) throw new UnexpectedToken(error.token);
+      throw error
+    }
+    const results = parser.results;
+    if (results.length > 1)
+      throw Error(
+        `Ambiguous grammar. The parser generated ${results.length} ASTs`
+      );
+    return results[0];
+  }
+}

package/src/lexer.ts

@@ -1,49 +1,49 @@
-import moo from "moo";
-import { makeLexer } from "moo-ignore";
-
-const keywords = [
-  "return",
-  "if",
-  "else"
-]
-
-export const MiniLexerConfig = {
-  EOF: "*__EOF__*",
-  wildcard: "_",
-  WS: /[ \t]+/,
-  comment: /--.*?$|{-[\s\S]*?-}/,
-  number:
-    /0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d*\.\d+|\d+)(?:[eE][+-]?\d+)?/,
-  char: /'(?:\\['\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^'\\\n\r])?'/,
-  string: /"(?:\\["\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^"\\\n\r])*"/,
-  bool: {
-    match: ["True", "False"],
-  },
-  semicolon: ";",
-  assign: ":=",
-  notEqual: "!=",
-  equal: "==",
-  gte: ">=",
-  gt: ">",
-  lte: "<=",
-  lt: "<",
-  lparen: "(",
-  rparen: ")",
-  lsquare: "[",
-  rsquare: "]",
-  lbracket: "{",
-  rbracket: "}",
-  comma: ",",
-  operator: /\+|\*/,
-  variable: {
-    match: /[a-z_][a-zA-Z0-9_']*/,
-    type: moo.keywords({
-      keyword: keywords,
-    }),
-  },
-  NL: { match: /\r?\n/, lineBreaks: true },
-};
-
-export const MiniLexer = makeLexer(MiniLexerConfig, ["NL", "comment"], {
-  eof: true,
-});
+import moo from "moo";
+import { makeLexer } from "moo-ignore";
+
+const keywords = [
+  "return",
+  "if",
+  "else"
+]
+
+export const MiniLexerConfig = {
+  EOF: "*__EOF__*",
+  wildcard: "_",
+  WS: /[ \t]+/,
+  comment: /--.*?$|{-[\s\S]*?-}/,
+  number:
+    /0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d*\.\d+|\d+)(?:[eE][+-]?\d+)?/,
+  char: /'(?:\\['\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^'\\\n\r])?'/,
+  string: /"(?:\\["\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^"\\\n\r])*"/,
+  bool: {
+    match: ["True", "False"],
+  },
+  semicolon: ";",
+  assign: ":=",
+  notEqual: "!=",
+  equal: "==",
+  gte: ">=",
+  gt: ">",
+  lte: "<=",
+  lt: "<",
+  lparen: "(",
+  rparen: ")",
+  lsquare: "[",
+  rsquare: "]",
+  lbracket: "{",
+  rbracket: "}",
+  comma: ",",
+  operator: /\+|\*/,
+  variable: {
+    match: /[a-z_][a-zA-Z0-9_']*/,
+    type: moo.keywords({
+      keyword: keywords,
+    }),
+  },
+  NL: { match: /\r?\n/, lineBreaks: true },
+};
+
+export const MiniLexer = makeLexer(MiniLexerConfig, ["NL", "comment"], {
+  eof: true,
+});

package/src/parse.ts

@@ -1,18 +1,18 @@
-import { YukigoMiniParser } from "./index.js";
-
-const parser = new YukigoMiniParser()
-
-const code = `int n
-int result
-
-n := 5
-result := 1
-
-while n > 0 do
-    result := result * n
-    n := n - 1
-endwhile
-
-print result # This should print 120`
-
+import { YukigoMiniParser } from "./index.js";
+
+const parser = new YukigoMiniParser()
+
+const code = `int n
+int result
+
+n := 5
+result := 1
+
+while n > 0 do
+    result := result * n
+    n := n - 1
+endwhile
+
+print result # This should print 120`
+
 console.log(parser.parse(code))