fix: #3501 parse % as unary only when not followed by a term (#3505)

Author: gwhitney

src/expression/parse.js

@@ -1050,16 +1050,9 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
         // explicit operators
         name = state.token
         fn = operators[name]
-
         getTokenSkipNewline(state)
-
-        if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-          // This % cannot be interpreted as a modulus, and it wasn't handled by parseUnaryPostfix
-          throw createSyntaxError(state, 'Unexpected operator %')
-        } else {
-          last = parseImplicitMultiplication(state)
-          node = new OperatorNode(name, fn, [node, last])
-        }
+        last = parseImplicitMultiplication(state)
+        node = new OperatorNode(name, fn, [node, last])
       } else {
         break
       }
@@ -1167,13 +1160,19 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
     if (state.token === '%') {
       const previousState = Object.assign({}, state)
       getTokenSkipNewline(state)
-
-      if (state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-        // This is unary postfix %, then treat that as /100
-        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true)
-      } else {
-        // Not a match, so rewind
+      // We need to decide if this is a unary percentage % or binary modulo %
+      // So we attempt to parse a unary expression at this point.
+      // If it fails, then the only possibility is that this is a unary percentage.
+      // If it succeeds, then we presume that this must be binary modulo, since the
+      // only things that parseUnary can handle are _higher_ precedence than unary %.
+      try {
+        parseUnary(state)
+        // Not sure if we could somehow use the result of that parseUnary? Without
+        // further analysis/testing, safer just to discard and let the parse proceed
         Object.assign(state, previousState)
+      } catch {
+        // Not seeing a term at this point, so was a unary %
+        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true)
       }
     }
 

test/unit-tests/expression/parse.test.js

@@ -1374,35 +1374,40 @@ describe('parse', function () {
     it('should parse % with multiplication', function () {
       approxEqual(parseAndEval('100*50%'), 50)
       approxEqual(parseAndEval('50%*100'), 50)
-      assert.throws(function () { parseAndEval('50%(*100)') }, /Value expected/)
+      assert.throws(function () { parseAndEval('50%(*100)') }, SyntaxError)
     })
 
     it('should parse % with division', function () {
       approxEqual(parseAndEval('100/50%'), 200) // should be treated as 100/(50%)
       approxEqual(parseAndEval('100/50%*2'), 400) // should be treated as (100/(50%))×2
       approxEqual(parseAndEval('50%/100'), 0.005)
       approxEqual(parseAndEval('50%(13)'), 11) // should be treated as 50 % (13)
-      assert.throws(function () { parseAndEval('50%(/100)') }, /Value expected/)
+      assert.throws(function () { parseAndEval('50%(/100)') }, SyntaxError)
     })
 
     it('should parse unary % before division, binary % with division', function () {
       approxEqual(parseAndEval('10/200%%3'), 2) // should be treated as (10/(200%))%3
     })
 
     it('should reject repeated unary percentage operators', function () {
-      assert.throws(function () { math.parse('17%%') }, /Unexpected operator %/)
-      assert.throws(function () { math.parse('17%%*5') }, /Unexpected operator %/)
-      assert.throws(function () { math.parse('10/200%%%3') }, /Unexpected operator %/)
+      assert.throws(function () { math.parse('17%%') }, SyntaxError)
+      assert.throws(function () { math.parse('17%%*5') }, SyntaxError)
+      assert.throws(function () { math.parse('10/200%%%3') }, SyntaxError)
     })
 
     it('should parse unary % with addition', function () {
       approxEqual(parseAndEval('100+3%'), 103)
-      approxEqual(parseAndEval('3%+100'), 100.03)
+      assert.strictEqual(parseAndEval('3%+100'), 3) // treat as 3 mod 100
     })
 
     it('should parse unary % with subtraction', function () {
       approxEqual(parseAndEval('100-3%'), 97)
-      approxEqual(parseAndEval('3%-100'), -99.97)
+      assert.strictEqual(parseAndEval('3%-100'), -97) // treat as 3 mod -100
+    })
+
+    it('should parse binary % with bitwise negation', function () {
+      assert.strictEqual(parseAndEval('11%~1'), -1) // equivalent to 11 mod -2
+      assert.strictEqual(parseAndEval('11%~-3'), 1) // equivalent to 11 mod 2
     })
 
     it('should parse operator mod', function () {