feat: new asm parser

WIP WIP WIP

src/grammar/ast.ts

@@ -57,17 +57,26 @@ export type AstAsmFunctionDef = {
     name: AstId;
     return: AstType | null;
     params: AstTypedParameter[];
-    instructions: AstAsmInstruction[];
+    expressions: AstAsmExpression[];
     id: number;
     loc: SrcInfo;
 };
 
-export type AstAsmInstruction = string;
 export type AstAsmShuffle = {
     args: AstId[];
     ret: AstNumber[];
 };
 
+export type AstAsmExpression =
+    | AstAsmExpressionList
+    | string;
+
+export type AstAsmExpressionList = {
+    kind: "asm_expr_list";
+    expressions: AstAsmExpression[];
+    loc: SrcInfo;
+};
+
 export type AstFunctionDecl = {
     kind: "function_decl";
     attributes: AstFunctionAttribute[];

src/grammar/compare.ts

@@ -51,7 +51,7 @@ import {
     AstNode,
     AstFuncId,
     AstAsmFunctionDef,
-    AstAsmInstruction,
+    AstAsmExpression,
     AstDestructMapping,
     AstStatementDestruct,
 } from "./ast";
@@ -850,8 +850,8 @@ export class AstComparator {
     }
 
     private compareAsmInstructions(
-        instructions1: AstAsmInstruction[],
-        instructions2: AstAsmInstruction[],
+        instructions1: AstAsmExpression[],
+        instructions2: AstAsmExpression[],
     ): boolean {
         if (instructions1.length !== instructions2.length) {
             return false;

src/grammar/grammar.ohm

@@ -22,7 +22,7 @@ Tact {
     ModuleFunction = FunctionDefinition
                    | AsmFunction
 
-    AsmFunction = "asm" AsmShuffle? FunctionAttribute* fun id Parameters (":" Type)? "{" AsmInstruction* "}"
+    AsmFunction = "asm" AsmShuffle? FunctionAttribute* fun id Parameters (":" Type)? "{" AsmExpression* "}"
 
     ModuleConstant = ConstantDefinition
 
@@ -99,20 +99,62 @@ Tact {
              | external "(" Parameter? ")" "{" Statement* "}" --externalRegular
              | external "(" stringLiteral ")" "{" Statement* "}" --externalComment
 
-    AsmInstruction = "[" &#whiteSpace AsmInstruction* "]" &#whiteSpace --internal
-                   | "{" &#whiteSpace AsmInstruction* "}" &#whiteSpace --list
-                   | "({)" &#whiteSpace AsmInstruction* "(})" &#whiteSpace --listNoStateCheck
-                   | ("abort\"" | ".\"" | "+\"" | "\"") (~"\"" any)* "\"" &#whiteSpace --string
-                   | "'" &#whiteSpace asmInstruction --tick
-                   | "char" &#whiteSpace (~whiteSpace any) &#whiteSpace --char
-                   | ("x{" | "B{") ~#whiteSpace hexDigit* ~#whiteSpace ("_" ~#whiteSpace)? "}" &#whiteSpace --hexLiteral
-                   | "b{" ~#whiteSpace binDigit* ~#whiteSpace "}" &#whiteSpace --binLiteral
-                   | asmInstruction --custom
+    // FIXME: grammar.ts, prettyPrinter.ts, hash.ts, compare.ts
+    AsmExpression = "{" &#whiteSpace AsmExpression* "}" &#whiteSpace --list
+                  | "SETEXITALT:<{" &#whiteSpace AsmExpression* AsmBlockEnd --setExitAlt
+                  | "ATEXITALT:<{" &#whiteSpace  AsmExpression* AsmBlockEnd --atExitAlt
+                  | "ATEXIT:<{" &#whiteSpace     AsmExpression* AsmBlockEnd --atExit
+                  | "PROCINLINE:<{" &#whiteSpace AsmExpression* AsmBlockEnd --procInline
+                  | "PROCREF:<{" &#whiteSpace    AsmExpression* AsmBlockEnd --procRef
+                  | "PROC:<{" &#whiteSpace       AsmExpression* AsmBlockEnd --proc
+                  | "CONT:<{" &#whiteSpace       AsmExpression* AsmBlockEnd --cont
+                  | "WHILEBRK:<{" &#whiteSpace   AsmExpression* AsmDo AsmBlockEnd --whileBrk
+                  | "WHILE:<{" &#whiteSpace      AsmExpression* AsmDo AsmBlockEnd --while
+                  | "UNTILBRK:<{" &#whiteSpace   AsmExpression* AsmBlockEnd --untilBrk
+                  | "UNTIL:<{" &#whiteSpace      AsmExpression* AsmBlockEnd --until
+                  | "AGAINBRK:<{" &#whiteSpace   AsmExpression* AsmBlockEnd --againBrk
+                  | "AGAIN:<{" &#whiteSpace      AsmExpression* AsmBlockEnd --again
+                  | "REPEATBRK:<{" &#whiteSpace  AsmExpression* AsmBlockEnd --repeatBrk
+                  | "REPEAT:<{" &#whiteSpace     AsmExpression* AsmBlockEnd --repeat
+                  | "TRY:<{" &#whiteSpace        AsmExpression* "}>CATCH<{" &#whiteSpace AsmExpression* AsmBlockEnd --tryCatch
+                  | "IFNOTJMP:<{" &#whiteSpace   AsmExpression* AsmElse AsmBlockEnd --ifNotJmpWithElse
+                  | "IFNOTJMP:<{" &#whiteSpace   AsmExpression* AsmBlockEnd --ifNotJmp
+                  | "IFNOT:<{" &#whiteSpace      AsmExpression* AsmElse AsmBlockEnd --ifNotWithElse
+                  | "IFNOT:<{" &#whiteSpace      AsmExpression* AsmBlockEnd --ifNot
+                  | "IFJMP:<{" &#whiteSpace      AsmExpression* AsmElse AsmBlockEnd --ifJmpWithElse
+                  | "IFJMP:<{" &#whiteSpace      AsmExpression* AsmBlockEnd --ifJmp
+                  | AsmPrimitive
+                  | "IF:<{" &#whiteSpace         AsmExpression* AsmElse AsmBlockEnd --ifWithElse
+                  | "IF:<{" &#whiteSpace         AsmExpression* AsmBlockEnd --if
+                  | AsmPrimitive
+
+    // Common parts, not standalone instructions or words
+    AsmElse = "}>ELSE<{" &#whiteSpace AsmExpression* --block
+            | "}>ELSE:" &#whiteSpace AsmExpression* --colon
+    AsmDo = "}>DO<{" &#whiteSpace AsmExpression* --block
+          | "}>DO:" &#whiteSpace AsmExpression* --colon
+    // TODO(grammar.ts): check that --cont version matches the prefix
+    AsmBlockEnd = "}>" #asmWord &#whiteSpace --cont
+                | "}>" &#whiteSpace --base
+
+    // Various instructions not forming a block
+    // TODO(grammar.ts): perform checks for inner contents of the string
+    AsmPrimitive = "\"" (~"\"" any)* "\"" &#whiteSpace --string
+                 | ("x{" | "B{") ~#whiteSpace hexDigit* ~#whiteSpace ("_" ~#whiteSpace)? "}" &#whiteSpace --hexLiteral
+                 | "b{" ~#whiteSpace binDigit* ~#whiteSpace "}" &#whiteSpace --binLiteral
+                 // TODO(grammar.ts): limit up to 15
+                 | "c" #(digit digit?) &#whiteSpace --controlRegister
+                 // TODO(grammar.ts): limit up to 15
+                 | "s" #(digit digit?) &#whiteSpace --stackRegister
+                 // TODO(grammar.ts): limit up to 255
+                 | digit #(digit digit?)? &#whiteSpace "s()" &#whiteSpace --stackRegister255
+                 | digit+ &#whiteSpace --number
+                 | asmInstruction --custom
 
     // Instructions exclude some begin and end words to ensure correct parse
-    asmInstruction = ~(("[" | "]" | "{" | "}" | "({)" | "(})") ~asmWord) asmWord
+    asmInstruction = ~(("{" | "}") ~asmWord) asmWord
 
-    // A chunk of non-whitespace characters forms a word in Fift
+    // A chunk of non-whitespace characters forms a word
     asmWord = (~whiteSpace any)+
 
     Statement = StatementLet

src/grammar/grammar.spec.ts

@@ -1,5 +1,5 @@
 import { parse } from "./grammar";
-import { AstModule, SrcInfo, __DANGER_resetNodeId } from "./ast";
+import { SrcInfo, __DANGER_resetNodeId } from "./ast";
 import { loadCases } from "../utils/loadCases";
 
 expect.addSnapshotSerializer({
@@ -12,20 +12,6 @@ describe("grammar", () => {
         __DANGER_resetNodeId();
     });
 
-    // Test parsing of known Fift projects, wrapped in asm functions of Tact
-    for (const r of loadCases(__dirname + "/test-asm/")) {
-        it("should parse " + r.name, () => {
-            const parsed: AstModule | undefined = parse(
-                r.code,
-                "<unknown>",
-                "user",
-            );
-
-            // Don't produce snapshots
-            expect(parsed).toBeDefined();
-        });
-    }
-
     for (const r of loadCases(__dirname + "/test/")) {
         it("should parse " + r.name, () => {
             expect(parse(r.code, "<unknown>", "user")).toMatchSnapshot();

src/grammar/grammar.ts

@@ -344,7 +344,7 @@ semantics.addOperation<AstNode>("astOfItem", {
         _optColon,
         optReturnType,
         _lbrace,
-        asmInstructions,
+        asmExpressions,
         _rbrace,
     ) {
         const shuffle = optAsmShuffle.children[0]?.astsOfAsmShuffle() ?? {
@@ -363,8 +363,8 @@ semantics.addOperation<AstNode>("astOfItem", {
             name: funId.astOfExpression(),
             return: unwrapOptNode(optReturnType, (t) => t.astOfType()),
             params: funParameters.astsOfList(),
-            instructions: asmInstructions.children.map((s) =>
-                s.astOfAsmInstruction(),
+            expressions: asmExpressions.children.map((s) =>
+                s.astOfAsmExpression(),
             ),
             loc: createRef(this),
         });
@@ -502,11 +502,19 @@ semantics.addOperation<AstNode>("astOfItem", {
     },
 });
 
-// Beginnings of the possible future AST for Fift-asm
-semantics.addOperation<string>("astOfAsmInstruction", {
+// TVM instructions
+semantics.addOperation<string>("astOfAsmExpression", {
     asmInstruction(word) {
+        // TODO: make a node here!
         return word.sourceString;
     },
+    AsmExpression(expression) {
+        return expression.astOfAsmExpression();
+    },
+    AsmExpression_list(_lbrace, _ws1, _arg2, _rbrace, _ws2) {
+        // TODO: make a node here!
+        return '';
+    },
     AsmInstruction(instruction) {
         return instruction.astOfAsmInstruction();
     },

src/grammar/hash.ts

@@ -23,7 +23,7 @@ import {
     AstFieldDecl,
     AstNode,
     AstAsmFunctionDef,
-    AstAsmInstruction,
+    AstAsmExpression,
 } from "./ast";
 import { createHash } from "crypto";
 import { throwInternalCompilerError } from "../errors";
@@ -312,7 +312,7 @@ export class AstHasher {
         return hashedStatements.join("|");
     }
 
-    private hashInstructions(instructions: AstAsmInstruction[]): string {
+    private hashInstructions(instructions: AstAsmExpression[]): string {
         return instructions.join("|");
     }