@intend-it/parser 1.2.1 → 1.3.0

package/README.md

@@ -105,6 +105,7 @@ interface IntentDeclaration {
 |---------|--------|---------|
 | **Intents** | `intent Name(params) -> Type { ... }` | `intent Add(a: number, b: number) -> number` |
 | **Steps** | `step "instruction"` | `step "Validate the input"` |
+| **Direct Calls** | `Intent(args)` | `Log(msg) => const res` |
 | **Result Variables** | `=> const x` or `=> let x` | `step "Calculate" => const result` |
 | **Invariants** | `invariant "rule"` | `invariant "Input must be positive"` |
 | **Ensures** | `ensure expression` | `ensure result is defined` |

package/dist/index.js

@@ -9185,7 +9185,12 @@ var Equals = createToken({ name: "Equals", pattern: /===/ });
 var GreaterThan = createToken({ name: "GreaterThan", pattern: />/ });
 var LessThan = createToken({ name: "LessThan", pattern: /</ });
 var Dot = createToken({ name: "Dot", pattern: /\./ });
-var StringLiteral = createToken({ name: "StringLiteral", pattern: /"(:?[^\\"\n\r]+|\\(:?[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/ });
+var StringLiteral = createToken({
+  name: "StringLiteral",
+  pattern: /"(?:[^"\\]|\\.)*"/,
+  line_breaks: true
+});
+var NumberLiteral = createToken({ name: "NumberLiteral", pattern: /-?\d+(\.\d+)?/ });
 var Identifier = createToken({ name: "Identifier", pattern: /[a-zA-Z_]\w*/ });
 var WhiteSpace = createToken({
   name: "WhiteSpace",
@@ -9227,6 +9232,7 @@ var allTokens = [
   Colon,
   Dot,
   StringLiteral,
+  NumberLiteral,
   Identifier
 ];
 
@@ -9318,7 +9324,8 @@ class IntendParser extends CstParser {
       { ALT: () => this.SUBRULE(this.invariantStatement) },
       { ALT: () => this.SUBRULE(this.stepStatement) },
       { ALT: () => this.SUBRULE(this.ensureStatement) },
-      { ALT: () => this.SUBRULE(this.returnStatement) }
+      { ALT: () => this.SUBRULE(this.returnStatement) },
+      { ALT: () => this.SUBRULE(this.callStatement) }
     ]);
   });
   invariantStatement = this.RULE("invariantStatement", () => {
@@ -9369,6 +9376,39 @@ class IntendParser extends CstParser {
       this.CONSUME(Semicolon);
     });
   });
+  callStatement = this.RULE("callStatement", () => {
+    this.CONSUME(Identifier, { LABEL: "IntentName" });
+    this.CONSUME(LParen);
+    this.OPTION(() => {
+      this.SUBRULE(this.callArguments);
+    });
+    this.CONSUME(RParen);
+    this.OPTION2(() => {
+      this.CONSUME(FatArrow);
+      this.OR([
+        { ALT: () => this.CONSUME(Const) },
+        { ALT: () => this.CONSUME(Let) }
+      ]);
+      this.CONSUME2(Identifier, { LABEL: "ResultVar" });
+    });
+    this.OPTION3(() => {
+      this.CONSUME(Semicolon);
+    });
+  });
+  callArguments = this.RULE("callArguments", () => {
+    this.SUBRULE(this.value);
+    this.MANY(() => {
+      this.CONSUME(Comma);
+      this.SUBRULE2(this.value);
+    });
+  });
+  value = this.RULE("value", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(StringLiteral) },
+      { ALT: () => this.CONSUME(NumberLiteral) },
+      { ALT: () => this.CONSUME(Identifier) }
+    ]);
+  });
 }
 
 // src/ast/visitor.ts
@@ -9438,7 +9478,7 @@ class IntendASTVisitor extends BaseIntendVisitor {
         const result = this.visit(stmt);
         if (result.type === "Invariant") {
           invariants.push(result);
-        } else if (result.type === "Step") {
+        } else if (result.type === "Step" || result.type === "Call") {
           steps.push(result);
         } else if (result.type === "Ensure") {
           ensures.push(result);
@@ -9458,6 +9498,8 @@ class IntendASTVisitor extends BaseIntendVisitor {
       return this.visit(ctx.ensureStatement);
     } else if (ctx.returnStatement) {
       return this.visit(ctx.returnStatement);
+    } else if (ctx.callStatement) {
+      return this.visit(ctx.callStatement);
     }
     throw new Error("Unknown statement type");
   }
@@ -9494,6 +9536,47 @@ class IntendASTVisitor extends BaseIntendVisitor {
       identifier: ctx.Identifier[0].image
     };
   }
+  callStatement(ctx) {
+    const intent = ctx.IntentName[0].image;
+    const args = ctx.callArguments ? this.visit(ctx.callArguments) : [];
+    let resultVariable;
+    let variableKind;
+    if (ctx.ResultVar) {
+      resultVariable = ctx.ResultVar[0].image;
+      variableKind = ctx.Let && ctx.Let.length > 0 ? "let" : "const";
+    }
+    return {
+      type: "Call",
+      intent,
+      args,
+      resultVariable,
+      variableKind
+    };
+  }
+  callArguments(ctx) {
+    if (!ctx.value)
+      return [];
+    return ctx.value.map((v) => this.visit(v));
+  }
+  value(ctx) {
+    if (ctx.StringLiteral) {
+      return {
+        type: "String",
+        value: this.unquoteString(ctx.StringLiteral[0].image)
+      };
+    } else if (ctx.NumberLiteral) {
+      return {
+        type: "Number",
+        value: ctx.NumberLiteral[0].image
+      };
+    } else if (ctx.Identifier) {
+      return {
+        type: "Identifier",
+        value: ctx.Identifier[0].image
+      };
+    }
+    throw new Error("Unknown value type");
+  }
   ensureStatement(ctx) {
     const tokens = [
       ...ctx.Identifier || [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intend-it/parser",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Parser for the Intend programming language",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",