Add nullish coalescing

acorn-loose/src/expression.js

@@ -102,7 +102,7 @@ lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
         let rightStart = this.storeCurrentPos()
         node.right = this.parseExprOp(this.parseMaybeUnary(false), rightStart, prec, noIn, indent, line)
       }
-      this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression")
+      this.finishNode(node, /&&|\|\||\?\?/.test(node.operator) ? "LogicalExpression" : "BinaryExpression")
       return this.parseExprOp(node, start, minPrec, noIn, indent, line)
     }
   }

acorn/src/expression.js

@@ -186,11 +186,20 @@ pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
   if (prec != null && (!noIn || this.type !== tt._in)) {
     if (prec > minPrec) {
       let logical = this.type === tt.logicalOR || this.type === tt.logicalAND
+      let coalesce = this.type === tt.coalesce
+      if (coalesce) {
+        // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.
+        // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.
+        prec = tt.logicalAND.binop
+      }
       let op = this.value
       this.next()
       let startPos = this.start, startLoc = this.startLoc
       let right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn)
-      let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical)
+      let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce)
+      if ((logical && this.type === tt.coalesce) || (coalesce && (this.type === tt.logicalOR || this.type === tt.logicalAND))) {
+        this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses")
+      }
       return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
     }
   }

acorn/src/tokenize.js

@@ -289,6 +289,14 @@ pp.readToken_eq_excl = function(code) { // '=!'
   return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1)
 }
 
+pp.readToken_question = function() { // '?'
+  if (this.options.ecmaVersion >= 11) {
+    let next = this.input.charCodeAt(this.pos + 1)
+    if (next === 63) return this.finishOp(tt.coalesce, 2)
+  }
+  return this.finishOp(tt.question, 1)
+}
+
 pp.getTokenFromCode = function(code) {
   switch (code) {
   // The interpretation of a dot depends on whether it is followed
@@ -306,7 +314,6 @@ pp.getTokenFromCode = function(code) {
   case 123: ++this.pos; return this.finishToken(tt.braceL)
   case 125: ++this.pos; return this.finishToken(tt.braceR)
   case 58: ++this.pos; return this.finishToken(tt.colon)
-  case 63: ++this.pos; return this.finishToken(tt.question)
 
   case 96: // '`'
     if (this.options.ecmaVersion < 6) break
@@ -356,6 +363,9 @@ pp.getTokenFromCode = function(code) {
   case 61: case 33: // '=!'
     return this.readToken_eq_excl(code)
 
+  case 63: // '?'
+    return this.readToken_question()
+
   case 126: // '~'
     return this.finishOp(tt.prefix, 1)
   }

acorn/src/tokentype.js

@@ -108,6 +108,7 @@ export const types = {
   star: binop("*", 10),
   slash: binop("/", 10),
   starstar: new TokenType("**", {beforeExpr: true}),
+  coalesce: binop("??", 1),
 
   // Keyword token types.
   _break: kw("break"),

bin/run_test262.js

@@ -10,7 +10,6 @@ const unsupportedFeatures = [
   "class-static-fields-private",
   "class-static-fields-public",
   "class-static-methods-private",
-  "coalesce-expression",
   "numeric-separator-literal",
   "optional-chaining",
   "top-level-await"

test/run.js

@@ -19,6 +19,7 @@
   require("./tests-dynamic-import.js");
   require("./tests-export-all-as-ns-from-source.js");
   require("./tests-import-meta.js");
+  require("./tests-nullish-coalescing.js");
   var acorn = require("../acorn")
   var acorn_loose = require("../acorn-loose")