Fix parsing ambiguity

Author: nicklockwood

ShapeScript/Lexer.swift

@@ -16,7 +16,27 @@ public func tokenize(_ input: String) throws -> [Token] {
     var spaceBefore = true
     _ = characters.skipWhitespaceAndComments()
     while let token = try characters.readToken(spaceBefore: spaceBefore) {
-        if token.type != .linebreak || tokens.last?.type != .linebreak {
+        switch (tokens.last?.type, token.type) {
+        case (.linebreak?, .linebreak):
+            break // Skip duplicate linebreak
+        case (.identifier?, .lparen) where spaceBefore && tokens.count > 1:
+            switch tokens[tokens.count - 2].type {
+            case .infix, .prefix:
+                // Insert parens for disambiguation
+                let identifier = tokens.removeLast()
+                let range = identifier.range
+                let lRange = range.lowerBound ..< range.lowerBound
+                let rRange = range.upperBound ..< range.upperBound
+                tokens += [
+                    Token(type: .lparen, range: lRange),
+                    identifier,
+                    Token(type: .rparen, range: rRange),
+                    token,
+                ]
+            default:
+                tokens.append(token)
+            }
+        default:
             tokens.append(token)
         }
         spaceBefore = characters.skipWhitespaceAndComments()
@@ -40,7 +60,7 @@ public func tokenize(_ input: String) throws -> [Token] {
     return tokens
 }
 
-/// Note: only includes keywords that start a command, not joining words
+// Note: only includes keywords that start a command, not joining words
 public enum Keyword: String, CaseIterable {
     case define
     case `for`

ShapeScriptTests/InterpreterTests.swift

@@ -2237,6 +2237,34 @@ class InterpreterTests: XCTestCase {
         XCTAssertEqual(delegate.log, [2])
     }
 
+    func testFunctionAmbiguity() {
+        let program = "print -cos(pi) + sin(pi)"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [-cos(Double.pi) + sin(.pi)])
+    }
+
+    func testFunctionAmbiguity2() {
+        let program = """
+        define a 1
+        define b 2
+        print -a (pi) + b (pi)
+        """
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [-1, Double.pi + 2, Double.pi])
+    }
+
+    func testFunctionAmbiguity3() {
+        let program = """
+        define a 1
+        print -a (pi)
+        """
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [-1, Double.pi])
+    }
+
     // MARK: Numeric comparison
 
     func testGT() {

ShapeScriptTests/LexerTests.swift

@@ -76,6 +76,25 @@ class LexerTests: XCTestCase {
         }
     }
 
+    func testInsertPhantomParensForDisambiguation() {
+        let input = "-a (b)"
+        let tokens: [TokenType] = [
+            .prefix(.minus), .lparen, .identifier("a"), .rparen,
+            .lparen, .identifier("b"), .rparen, .eof,
+        ]
+        XCTAssertEqual(try tokenize(input).map { $0.type }, tokens)
+    }
+
+    func testInsertPhantomParensForDisambiguation2() {
+        let input = "a + b (c)"
+        let tokens: [TokenType] = [
+            .identifier("a"), .infix(.plus),
+            .lparen, .identifier("b"), .rparen,
+            .lparen, .identifier("c"), .rparen, .eof,
+        ]
+        XCTAssertEqual(try tokenize(input).map { $0.type }, tokens)
+    }
+
     // MARK: numbers
 
     func testZero() {