Fix parsing of infix expressions beginning with an object literal

Author: mkantor

src/end-to-end.test.ts

@@ -320,6 +320,11 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   [`b atom.append c atom.prepend a`, either.makeRight('abc')],
   [`(b atom.append c) atom.prepend a`, either.makeRight('abc')],
   [`a atom.append (c atom.prepend b)`, either.makeRight('abc')],
+  [
+    `{ a: "it works!" } object.lookup a`,
+    either.makeRight({ tag: 'some', value: 'it works!' }),
+  ],
+  [`{ a: :identity }.a(1) + 1`, either.makeRight('2')],
   [
     `1
       + 2

src/language/parsing/expression.ts

@@ -253,16 +253,13 @@ const infixOperator = sequence([
 ])
 
 const compactExpression: Parser<Molecule | Atom> = oneOf([
-  // (a => :b).c(d)
+  // (a)
   // (1 + 1)
+  // (a => :b)(c)
+  // ({ a: 1 } |> :identity).a
   map(
     sequence([
-      surroundedByParentheses(
-        oneOf([
-          lazy(() => precededByAtomThenTrivia),
-          lazy(() => precededByColonThenAtom),
-        ]),
-      ),
+      surroundedByParentheses(lazy(() => expression)),
       compactTrailingIndexesAndArguments,
     ]),
     ([expression, trailingIndexesAndArguments]) =>
@@ -275,18 +272,7 @@ const compactExpression: Parser<Molecule | Atom> = oneOf([
   // :a.b(1).c
   // :f(x)
   // :a.b(1)(2)
-  map(
-    sequence([
-      colon,
-      atomRequiringDotQuotation,
-      compactTrailingIndexesAndArguments,
-    ]),
-    ([_colon, key, trailingIndexesAndArguments]) =>
-      trailingIndexesAndArgumentsToExpression(
-        { 0: '@lookup', key },
-        trailingIndexesAndArguments,
-      ),
-  ),
+  lazy(() => precededByColonThenAtom),
   // {}
   lazy(() => precededByOpeningBrace),
   // 1
@@ -423,53 +409,13 @@ const precededByAtomThenTrivia = map(
 // :a.b(1).c
 // :f(x)
 // :a.b(1)(2)
-// :a b.c :z
-// :a b.c z
-// :f(g) + b
-// :a + :b + :c + :d
 const precededByColonThenAtom = map(
-  sequence([
-    colon,
-    atomRequiringDotQuotation,
-    trailingIndexesAndArguments,
-    zeroOrMore(
-      map(
-        // See note in `trailingInfixTokens` about newlines.
-        oneOf([
-          sequence([
-            trivia,
-            infixOperator,
-            triviaExceptNewlines,
-            compactExpression,
-          ]),
-          sequence([
-            triviaExceptNewlines,
-            infixOperator,
-            trivia,
-            compactExpression,
-          ]),
-        ]),
-        ([_trivia1, operator, _trivia2, operand]) =>
-          [operator, operand] as const,
-      ),
-    ),
-  ]),
-  ([_colon, key, trailingIndexesAndArguments, infixOperationTokens]) => {
-    const initialExpression = trailingIndexesAndArgumentsToExpression(
+  sequence([colon, atomRequiringDotQuotation, trailingIndexesAndArguments]),
+  ([_colon, key, trailingIndexesAndArguments]) =>
+    trailingIndexesAndArgumentsToExpression(
       { 0: '@lookup', key },
       trailingIndexesAndArguments,
-    )
-    const [firstToken, ...additionalTokens] = infixOperationTokens
-    if (firstToken === undefined) {
-      return initialExpression
-    } else {
-      return infixTokensToExpression([
-        initialExpression,
-        ...firstToken,
-        ...additionalTokens.flat(),
-      ])
-    }
-  },
+    ),
 )
 
 // (1 + 1)
@@ -479,36 +425,21 @@ const precededByColonThenAtom = map(
 // (1 + 1).b
 // (:x => x)(1)
 // (:f >> :g)(1)
-// (1 + 1) - (1 + 1)
-const precededByOpeningParenthesis = oneOf([
-  map(
-    sequence([
-      surroundedByParentheses(lazy(() => expression)),
-      trailingInfixTokens,
-    ]),
-    ([initialExpression, trailingInfixTokens]) =>
-      infixTokensToExpression([
-        initialExpression,
-        ...trailingInfixTokens.flat(),
-      ]),
-  ),
-  map(
-    sequence([
-      surroundedByParentheses(lazy(() => expression)),
+const precededByOpeningParenthesis = map(
+  sequence([
+    surroundedByParentheses(lazy(() => expression)),
+    trailingIndexesAndArguments,
+  ]),
+  ([expression, trailingIndexesAndArguments]) =>
+    trailingIndexesAndArgumentsToExpression(
+      expression,
       trailingIndexesAndArguments,
-    ]),
-    ([expression, trailingIndexesAndArguments]) =>
-      trailingIndexesAndArgumentsToExpression(
-        expression,
-        trailingIndexesAndArguments,
-      ),
-  ),
-])
+    ),
+)
 
 // {}
 // { a: b }
 // { 1, 2, 3 }
-// {a::f}.a(1) + 1
 const precededByOpeningBrace = map(
   sequence([sugarFreeMolecule, trailingIndexesAndArguments]),
   ([expression, trailingIndexesAndArguments]) =>
@@ -518,10 +449,25 @@ const precededByOpeningBrace = map(
     ),
 )
 
-export const expression: Parser<Atom | Molecule> = oneOf([
-  precededByOpeningParenthesis,
-  precededByOpeningBrace,
-  precededByColonThenAtom,
-  precededByAtomThenTrivia,
-  atom,
-])
+export const expression: Parser<Atom | Molecule> = map(
+  sequence([
+    oneOf([
+      precededByOpeningParenthesis,
+      precededByOpeningBrace,
+      precededByColonThenAtom,
+      precededByAtomThenTrivia,
+      atom,
+    ]),
+    optional(trailingInfixTokens),
+  ]),
+  ([initialExpression, trailingInfixTokens]) => {
+    if (trailingInfixTokens === undefined) {
+      return initialExpression
+    } else {
+      return infixTokensToExpression([
+        initialExpression,
+        ...trailingInfixTokens.flat(),
+      ])
+    }
+  },
+)