Syntax: correct compose-op parsing

nois-lang · Nov 25, 2024 · b488915 · b488915
1 parent 36e94c7
commit b488915
Show file tree

Hide file tree

Showing 4 changed files with 43 additions and 9 deletions.
diff --git a/nois.bnf b/nois.bnf
@@ -68,7 +68,7 @@ statement             ::= var-def | fn-def | trait-def | impl-def | type-def | r
 
     postfix-op        ::= compose-op | call-op | unwrap-op | bind-op | await-op
                       ;                                                                                                                                                                                                                                                                                                
-      compose-op      ::= PERIOD sub-expr
+      compose-op      ::= PERIOD (identifier call-op | identifier | block)
                       ;
       call-op         ::= O-PAREN (arg (COMMA arg)*)? COMMA? C-PAREN
                       ;

diff --git a/src/ast/expr.ts b/src/ast/expr.ts
@@ -96,8 +96,7 @@ export const buildSubExpr = (node: ParseNode, ctx: Context): UnaryExpr | Operand
     const operand = buildOperand(nodes[0], ctx)
     const ops = nodes.slice(1).map(n => buildPostfixOp(n, ctx))
     let expr: Expr = { kind: 'operand-expr', parseNode: operand.parseNode, operand }
-    // fold a list of ops into left-associative unary-exprs
-    for (const op of ops.toReversed()) {
+    for (const op of ops) {
         expr = {
             kind: 'unary-expr',
             parseNode: { kind: 'expr', nodes: [expr.parseNode, op.parseNode].filter(n => !!n) },

diff --git a/src/ast/op.ts b/src/ast/op.ts
@@ -1,7 +1,9 @@
 import { ParseNode, filterNonAstNodes } from '../parser'
 import { Context } from '../scope'
-import { Expr, buildSubExpr } from './expr'
+import { Expr } from './expr'
 import { Arg, AstNode, AstNodeKind, BaseAstNode, buildArg } from './index'
+import { buildIdentifier } from './operand'
+import { buildBlock } from './statement'
 
 export type PostfixOp = ComposeOp | CallOp | UnwrapOp | BindOp | AwaitOp
 
@@ -120,8 +122,29 @@ export type ComposeOp = BaseAstNode & {
 }
 
 export const buildComposeOp = (node: ParseNode, ctx: Context): ComposeOp => {
-    const expr = buildSubExpr(filterNonAstNodes(node)[0], ctx)
-    return { kind: 'compose-op', parseNode: node, operand: expr }
+    const nodes = filterNonAstNodes(node)
+    let i = 0
+    let expr: Expr | undefined
+    if (nodes.at(i)?.kind === 'identifier') {
+        const id = buildIdentifier(nodes[i++], ctx)
+        const idExpr: Expr = { kind: 'operand-expr', parseNode: id.parseNode, operand: id }
+        if (nodes.at(i)?.kind === 'call-op') {
+            const op = buildCallOp(nodes[i++], ctx)
+            expr = {
+                kind: 'unary-expr',
+                parseNode: { kind: 'expr', nodes: [id, op].map(n => n.parseNode!) },
+                operand: idExpr,
+                op
+            }
+        } else {
+            expr = idExpr
+        }
+    }
+    if (nodes.at(i)?.kind === 'block') {
+        const block = buildBlock(nodes[i++], ctx)
+        expr = { kind: 'operand-expr', parseNode: block.parseNode, operand: block }
+    }
+    return { kind: 'compose-op', parseNode: node, operand: expr! }
 }
 
 export type CallOp = BaseAstNode & {

diff --git a/src/parser/fns/op.ts b/src/parser/fns/op.ts
@@ -1,7 +1,8 @@
 import { nameLikeTokens } from '.'
 import { Parser } from '..'
 import { syntaxError } from '../../error'
-import { parseExpr, parseSubExpr } from './expr'
+import { parseExpr, parseIdentifier } from './expr'
+import { parseBlock } from './statement'
 
 /**
  * infix-op ::= add-op | sub-op | mult-op | div-op | exp-op | mod-op | eq-op | ne-op | ge-op | le-op | gt-op
@@ -111,12 +112,23 @@ export const parsePostfixOp = (parser: Parser): void => {
 }
 
 /*
- * compose-op ::= PERIOD sub-expr
+ * compose-op ::= PERIOD (identifier call-op | identifier | block)
  */
 export const parseComposeOp = (parser: Parser): void => {
     const mark = parser.open()
     parser.expect('period')
-    parseSubExpr(parser)
+
+    if (parser.at('name')) {
+        parseIdentifier(parser)
+        if (parser.at('o-paren')) {
+            parseCallOp(parser)
+        }
+    } else if (parser.at('o-brace')) {
+        parseBlock(parser)
+    } else {
+        parser.advanceWithError(syntaxError(parser, 'expected infix operator'), mark)
+    }
+
     parser.close(mark, 'compose-op')
 }