add optional chaining

Author: mysticatea

acorn-loose/src/expression.js

@@ -159,24 +159,33 @@ lp.parseExprSubscripts = function() {
 }
 
 lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
+  const optionalSupported = this.options.ecmaVersion >= 11
+  let optionalChained = false
   for (;;) {
     if (this.curLineStart !== line && this.curIndent <= startIndent && this.tokenStartsLine()) {
       if (this.tok.type === tt.dot && this.curIndent === startIndent)
         --startIndent
       else
-        return base
+        break
     }
 
     let maybeAsyncArrow = base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon()
+    let optional = optionalSupported && this.eat(tt.questionDot)
+    if (optional) {
+      optionalChained = true
+    }
 
-    if (this.eat(tt.dot)) {
+    if ((optional && this.tok.type !== tt.parenL && this.tok.type !== tt.bracketL && this.tok.type !== tt.backQuote) || this.eat(tt.dot)) {
       let node = this.startNodeAt(start)
       node.object = base
       if (this.curLineStart !== line && this.curIndent <= startIndent && this.tokenStartsLine())
         node.property = this.dummyIdent()
       else
         node.property = this.parsePropertyAccessor() || this.dummyIdent()
       node.computed = false
+      if (optionalSupported) {
+        node.optional = optional
+      }
       base = this.finishNode(node, "MemberExpression")
     } else if (this.tok.type === tt.bracketL) {
       this.pushCx()
@@ -185,6 +194,9 @@ lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
       node.object = base
       node.property = this.parseExpression()
       node.computed = true
+      if (optionalSupported) {
+        node.optional = optional
+      }
       this.popCx()
       this.expect(tt.bracketR)
       base = this.finishNode(node, "MemberExpression")
@@ -195,16 +207,26 @@ lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
       let node = this.startNodeAt(start)
       node.callee = base
       node.arguments = exprList
+      if (optionalSupported) {
+        node.optional = optional
+      }
       base = this.finishNode(node, "CallExpression")
     } else if (this.tok.type === tt.backQuote) {
       let node = this.startNodeAt(start)
       node.tag = base
       node.quasi = this.parseTemplate()
       base = this.finishNode(node, "TaggedTemplateExpression")
     } else {
-      return base
+      break
     }
   }
+
+  if (optionalChained) {
+    const chainNode = this.startNodeAt(start)
+    chainNode.expression = base
+    base = this.finishNode(chainNode, "ChainExpression")
+  }
+  return base
 }
 
 lp.parseExprAtom = function() {

acorn-walk/src/index.js

@@ -192,7 +192,7 @@ base.Program = base.BlockStatement = (node, st, c) => {
 }
 base.Statement = skipThrough
 base.EmptyStatement = ignore
-base.ExpressionStatement = base.ParenthesizedExpression =
+base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
   (node, st, c) => c(node.expression, st, "Expression")
 base.IfStatement = (node, st, c) => {
   c(node.test, st, "Expression")

acorn/src/expression.js

@@ -273,29 +273,47 @@ pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
   let maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
       this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 &&
       this.potentialArrowAt === base.start
+  let optionalChained = false
+
   while (true) {
-    let element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow)
-    if (element === base || element.type === "ArrowFunctionExpression") return element
+    let element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained)
+
+    if (element.optional) optionalChained = true
+    if (element === base || element.type === "ArrowFunctionExpression") {
+      if (optionalChained) {
+        const chainNode = this.startNodeAt(startPos, startLoc)
+        chainNode.expression = element
+        element = this.finishNode(chainNode, "ChainExpression")
+      }
+      return element
+    }
+
     base = element
   }
 }
 
-pp.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
+pp.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained) {
+  let optional = this.options.ecmaVersion >= 11 && this.eat(tt.questionDot)
+  if (noCalls && optional) this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions")
+
   let computed = this.eat(tt.bracketL)
-  if (computed || this.eat(tt.dot)) {
+  if (computed || (optional && this.type !== tt.parenL && this.type !== tt.backQuote) || this.eat(tt.dot)) {
     let node = this.startNodeAt(startPos, startLoc)
     node.object = base
     node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never")
     node.computed = !!computed
     if (computed) this.expect(tt.bracketR)
+    if (this.options.ecmaVersion >= 11) {
+      node.optional = optional
+    }
     base = this.finishNode(node, "MemberExpression")
   } else if (!noCalls && this.eat(tt.parenL)) {
     let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos
     this.yieldPos = 0
     this.awaitPos = 0
     this.awaitIdentPos = 0
     let exprList = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors)
-    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
+    if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
       this.checkPatternErrors(refDestructuringErrors, false)
       this.checkYieldAwaitInDefaultParams()
       if (this.awaitIdentPos > 0)
@@ -312,8 +330,14 @@ pp.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow)
     let node = this.startNodeAt(startPos, startLoc)
     node.callee = base
     node.arguments = exprList
+    if (this.options.ecmaVersion >= 11) {
+      node.optional = optional
+    }
     base = this.finishNode(node, "CallExpression")
   } else if (this.type === tt.backQuote) {
+    if (optional || optionalChained) {
+      this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions")
+    }
     let node = this.startNodeAt(startPos, startLoc)
     node.tag = base
     node.quasi = this.parseTemplate({isTagged: true})

acorn/src/lval.js

@@ -73,6 +73,10 @@ pp.toAssignable = function(node, isBinding, refDestructuringErrors) {
       this.toAssignable(node.expression, isBinding, refDestructuringErrors)
       break
 
+    case "ChainExpression":
+      this.raiseRecoverable(node.start, "Optional chaining cannot appear in left-hand side")
+      break
+
     case "MemberExpression":
       if (!isBinding) break
 
@@ -201,6 +205,10 @@ pp.checkLVal = function(expr, bindingType = BIND_NONE, checkClashes) {
     if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) this.declareName(expr.name, bindingType, expr.start)
     break
 
+  case "ChainExpression":
+    this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side")
+    break
+
   case "MemberExpression":
     if (bindingType) this.raiseRecoverable(expr.start, "Binding member expression")
     break

acorn/src/tokenize.js

@@ -292,6 +292,10 @@ pp.readToken_eq_excl = function(code) { // '=!'
 pp.readToken_question = function() { // '?'
   if (this.options.ecmaVersion >= 11) {
     let next = this.input.charCodeAt(this.pos + 1)
+    if (next === 46) {
+      let next2 = this.input.charCodeAt(this.pos + 2)
+      if (next2 < 48 || next2 > 57) return this.finishOp(tt.questionDot, 2)
+    }
     if (next === 63) return this.finishOp(tt.coalesce, 2)
   }
   return this.finishOp(tt.question, 1)

acorn/src/tokentype.js

@@ -70,6 +70,7 @@ export const types = {
   colon: new TokenType(":", beforeExpr),
   dot: new TokenType("."),
   question: new TokenType("?", beforeExpr),
+  questionDot: new TokenType("?."),
   arrow: new TokenType("=>", beforeExpr),
   template: new TokenType("template"),
   invalidTemplate: new TokenType("invalidTemplate"),

bin/run_test262.js

@@ -11,7 +11,6 @@ const unsupportedFeatures = [
   "class-static-fields-public",
   "class-static-methods-private",
   "numeric-separator-literal",
-  "optional-chaining",
 ];
 
 run(

test/run.js

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