Optional chaining

lib/Common/ConfigFlagsList.h

@@ -673,6 +673,7 @@ PHASE(All)
 #define DEFAULT_CONFIG_ESArrayFindFromLast     (true)
 #define DEFAULT_CONFIG_ESPromiseAny            (true)
 #define DEFAULT_CONFIG_ESNullishCoalescingOperator (true)
+#define DEFAULT_CONFIG_ESOptionalChaining      (true)
 #define DEFAULT_CONFIG_ESGlobalThis            (true)
 
 // Jitting generators has not been tested on ARM
@@ -1199,6 +1200,9 @@ FLAGR(Boolean, ESNumericSeparator, "Enable Numeric Separator flag", DEFAULT_CONF
 // ES Nullish coalescing operator support (??)
 FLAGR(Boolean, ESNullishCoalescingOperator, "Enable nullish coalescing operator", DEFAULT_CONFIG_ESNullishCoalescingOperator)
 
+// ES Optional chaining operator support (?.)
+FLAGR(Boolean, ESOptionalChaining, "Enable optional chaining operator", DEFAULT_CONFIG_ESOptionalChaining)
+
 // ES Hashbang support for interpreter directive syntax
 FLAGR(Boolean, ESHashbang, "Enable Hashbang syntax", DEFAULT_CONFIG_ESHashbang)
 

lib/Parser/Parse.cpp

@@ -309,6 +309,7 @@ LPCWSTR Parser::GetTokenString(tokens token)
     case tkLParen: return _u("(");
     case tkLBrack: return _u("[");
     case tkDot: return _u(".");
+    case tkOptChain: return _u("?.");
 
     default:
         return _u("unknown token");
@@ -894,13 +895,13 @@ ParseNodeUni * Parser::CreateUniNode(OpCode nop, ParseNodePtr pnode1, charcount_
 }
 
 // Create ParseNodeBin
-ParseNodeBin * Parser::StaticCreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ArenaAllocator* alloc, charcount_t ichMin, charcount_t ichLim)
+ParseNodeBin * Parser::StaticCreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ArenaAllocator* alloc, charcount_t ichMin, charcount_t ichLim, bool isNullPropagating)
 {
     DebugOnly(VerifyNodeSize(nop, sizeof(ParseNodeBin)));
-    return Anew(alloc, ParseNodeBin, nop, ichMin, ichLim, pnode1, pnode2);
+    return Anew(alloc, ParseNodeBin, nop, ichMin, ichLim, pnode1, pnode2, isNullPropagating);
 }
 
-ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2)
+ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, bool isNullPropagating)
 {
     Assert(!this->m_deferringAST);
     charcount_t ichMin;
@@ -937,15 +938,15 @@ ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodeP
         }
     }
 
-    return CreateBinNode(nop, pnode1, pnode2, ichMin, ichLim);
+    return CreateBinNode(nop, pnode1, pnode2, ichMin, ichLim, isNullPropagating);
 }
 
 
 ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1,
-    ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim)
+    ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim, bool isNullPropagating)
 {
     Assert(!this->m_deferringAST);
-    ParseNodeBin * pnode = StaticCreateBinNode(nop, pnode1, pnode2, &m_nodeAllocator, ichMin, ichLim);
+    ParseNodeBin * pnode = StaticCreateBinNode(nop, pnode1, pnode2, &m_nodeAllocator, ichMin, ichLim, isNullPropagating);
     AddAstSize(sizeof(ParseNodeBin));
     return pnode;
 }
@@ -3909,6 +3910,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
         *pfIsDotOrIndex = false;
     }
 
+    bool isOptionalChain = false;
     for (;;)
     {
         uint16 spreadArgCount = 0;
@@ -3918,8 +3920,14 @@ ParseNodePtr Parser::ParsePostfixOperators(
         {
             AutoMarkInParsingArgs autoMarkInParsingArgs(this);
 
+            bool isNullPropagating = tkOptChain == this->GetScanner()->GetPrevious();
             if (fInNew)
             {
+                if (isNullPropagating)
+                {
+                    Error(ERRInvalidOptChainInNew);
+                }
+
                 ParseNodePtr pnodeArgs = ParseArgList<buildAST>(&callOfConstants, &spreadArgCount, &count);
                 if (buildAST)
                 {
@@ -3972,6 +3980,11 @@ ParseNodePtr Parser::ParsePostfixOperators(
                     // Detect super()
                     if (this->NodeIsSuperName(pnode))
                     {
+                        if (isNullPropagating)
+                        {
+                            Error(ERRInvalidOptChainInSuper);
+                        }
+
                         pnode = CreateSuperCallNode(pnode->AsParseNodeSpecialName(), pnodeArgs);
                         Assert(pnode);
 
@@ -4006,6 +4019,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
                     pnode->AsParseNodeCall()->isApplyCall = false;
                     pnode->AsParseNodeCall()->isEvalCall = fCallIsEval;
                     pnode->AsParseNodeCall()->hasDestructuring = m_hasDestructuringPattern;
+                    pnode->AsParseNodeCall()->isNullPropagating = isNullPropagating;
                     Assert(!m_hasDestructuringPattern || count > 0);
                     pnode->AsParseNodeCall()->argCount = count;
                     pnode->ichLim = this->GetScanner()->IchLimTok();
@@ -4041,7 +4055,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
             }
             if (pfCanAssign)
             {
-                *pfCanAssign = fCanAssignToCallResult && 
+                *pfCanAssign = !isOptionalChain && fCanAssignToCallResult &&
                                (m_sourceContextInfo ?
                                 !PHASE_ON_RAW(Js::EarlyErrorOnAssignToCallPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId) :
                                 !PHASE_ON1(Js::EarlyErrorOnAssignToCallPhase));
@@ -4054,6 +4068,8 @@ ParseNodePtr Parser::ParsePostfixOperators(
         }
         case tkLBrack:
         {
+            bool isNullPropagating = tkOptChain == this->GetScanner()->GetPrevious();
+
             this->GetScanner()->Scan();
             IdentToken tok;
             ParseNodePtr pnodeExpr = ParseExpr<buildAST>(0, FALSE, TRUE, FALSE, nullptr, nullptr, nullptr, &tok);
@@ -4062,12 +4078,17 @@ ParseNodePtr Parser::ParsePostfixOperators(
                 AnalysisAssert(pnodeExpr);
                 if (pnode && pnode->nop == knopName && pnode->AsParseNodeName()->IsSpecialName() && pnode->AsParseNodeSpecialName()->isSuper)
                 {
+                    if (isNullPropagating)
+                    {
+                        Error(ERRInvalidOptChainInSuper);
+                    }
+
                     pnode = CreateSuperReferenceNode(knopIndex, pnode->AsParseNodeSpecialName(), pnodeExpr);
                     pnode->AsParseNodeSuperReference()->pnodeThis = ReferenceSpecialName(wellKnownPropertyPids._this, pnode->ichMin, pnode->ichLim, true);
                 }
                 else
                 {
-                    pnode = CreateBinNode(knopIndex, pnode, pnodeExpr);
+                    pnode = CreateBinNode(knopIndex, pnode, pnodeExpr, isNullPropagating);
                 }
 
                 AnalysisAssert(pnode);
@@ -4081,7 +4102,8 @@ ParseNodePtr Parser::ParsePostfixOperators(
             ChkCurTok(tkRBrack, ERRnoRbrack);
             if (pfCanAssign)
             {
-                *pfCanAssign = TRUE;
+                // optional assignment not permitted
+                *pfCanAssign = !isOptionalChain;
             }
             if (pfIsDotOrIndex)
             {
@@ -4163,17 +4185,41 @@ ParseNodePtr Parser::ParsePostfixOperators(
             }
         }
         break;
-
+
+        case tkOptChain:
         case tkDot:
         {
             ParseNodePtr name = nullptr;
             OpCode opCode = knopDot;
 
+            // We don't use separate knops for optional-chains
+            // Instead mark nodes as null-propagating
+            bool isNullPropagating = tkOptChain == m_token.tk;
+            if (isNullPropagating)
+            {
+                isOptionalChain = true;
+            }
+
             this->GetScanner()->Scan();
             if (!m_token.IsIdentifier())
             {
-                //allow reserved words in ES5 mode
-                if (!(m_token.IsReservedWord()))
+                if (isNullPropagating)
+                {
+                    // We don't need an identifier for an Index `?.[` or Call `?.(`
+                    switch (m_token.tk)
+                    {
+                    case tkLParen:
+                    case tkLBrack:
+                        // Continue to parse function or index (loop)
+                        // Check previous token to check for null-propagation
+                        continue;
+
+                    case tkStrTmplBasic:
+                    case tkStrTmplBegin:
+                        Error(ERRInvalidOptChainWithTaggedTemplate);
+                    }
+                }
+                else if (!(m_token.IsReservedWord())) //allow reserved words in ES5 mode
                 {
                     IdentifierExpectedError(m_token);
                 }
@@ -4200,12 +4246,17 @@ ParseNodePtr Parser::ParsePostfixOperators(
                 }
                 if (pnode && pnode->nop == knopName && pnode->AsParseNodeName()->IsSpecialName() && pnode->AsParseNodeSpecialName()->isSuper)
                 {
+                    if (isNullPropagating)
+                    {
+                        Error(ERRInvalidOptChainInSuper);
+                    }
+
                     pnode = CreateSuperReferenceNode(opCode, pnode->AsParseNodeSpecialName(), name);
                     pnode->AsParseNodeSuperReference()->pnodeThis = ReferenceSpecialName(wellKnownPropertyPids._this, pnode->ichMin, pnode->ichLim, true);
                 }
                 else
                 {
-                    pnode = CreateBinNode(opCode, pnode, name);
+                    pnode = CreateBinNode(opCode, pnode, name, isNullPropagating);
                 }
             }
             else
@@ -4216,7 +4267,8 @@ ParseNodePtr Parser::ParsePostfixOperators(
 
             if (pfCanAssign)
             {
-                *pfCanAssign = TRUE;
+                // optional assignment not permitted
+                *pfCanAssign = !isOptionalChain;
             }
             if (pfIsDotOrIndex)
             {
@@ -4230,6 +4282,11 @@ ParseNodePtr Parser::ParsePostfixOperators(
         case tkStrTmplBasic:
         case tkStrTmplBegin:
         {
+            if (isOptionalChain)
+            {
+                Error(ERRInvalidOptChainWithTaggedTemplate);
+            }
+
             ParseNode* templateNode = nullptr;
             if (pnode != nullptr)
             {
@@ -4258,6 +4315,11 @@ ParseNodePtr Parser::ParsePostfixOperators(
             break;
         }
         default:
+            if (buildAST && isOptionalChain)
+            {
+                // Wrap the whole expression as an optional-chain
+                return CreateUniNode(knopOptChain, pnode);
+            }
             return pnode;
         }
     }

lib/Parser/Parse.h

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #pragma once
@@ -371,16 +372,16 @@ class Parser
         return Anew(alloc, typename OpCodeTrait<nop>::ParseNodeType, nop, ichMin, ichLim);        
     }
 
-    static ParseNodeBin * StaticCreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ArenaAllocator* alloc, charcount_t ichMin = 0, charcount_t ichLim = 0);
+    static ParseNodeBin * StaticCreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ArenaAllocator* alloc, charcount_t ichMin = 0, charcount_t ichLim = 0, bool isNullPropagating = false);
     static ParseNodeBlock * StaticCreateBlockNode(ArenaAllocator* alloc, charcount_t ichMin = 0, charcount_t ichLim = 0, int blockId = -1, PnodeBlockType blockType = PnodeBlockType::Regular);
     static ParseNodeVar * StaticCreateTempNode(ParseNode* initExpr, ArenaAllocator* alloc);
     static ParseNodeUni * StaticCreateTempRef(ParseNode* tempNode, ArenaAllocator* alloc);
 
 private:    
     ParseNodeUni * CreateUniNode(OpCode nop, ParseNodePtr pnodeOp);
     ParseNodeUni * CreateUniNode(OpCode nop, ParseNodePtr pnode1, charcount_t ichMin, charcount_t ichLim);
-    ParseNodeBin * CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2);
-    ParseNodeBin * CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim);
+    ParseNodeBin * CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, bool isNullPropagating = false);
+    ParseNodeBin * CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim, bool isNullPropagating = false);
     ParseNodeTri * CreateTriNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ParseNodePtr pnode3);
     ParseNodeTri * CreateTriNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ParseNodePtr pnode3, charcount_t ichMin, charcount_t ichLim);
     ParseNodeBlock * CreateBlockNode(PnodeBlockType blockType = PnodeBlockType::Regular);

lib/Parser/Scan.cpp

@@ -1781,6 +1781,17 @@ tokens Scanner<EncodingPolicy>::ScanCore(bool identifyKwds)
                 token = tkCoalesce;
                 break;
             }
+            else if (m_scriptContext->GetConfig()->IsESOptionalChainingEnabled() && this->PeekFirst(p, last) == '.')
+            {
+                // `a?.3:0` is actually a ternary operator containing the number `0.3`
+                bool isTernary = CharTypes::_C_DIG == this->charClassifier->GetCharType(this->PeekFirst(p + 1, last));
+                if (isTernary)
+                    break;
+
+                p++;
+                token = tkOptChain;
+                break;
+            }
             break;
 
         case '{': Assert(chType == _C_LC);  token = tkLCurly; break;

lib/Parser/kwd-lsc.h

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #ifndef KEYWORD
@@ -174,6 +175,7 @@ TOK_DCL(tkEllipsis      , No, knopNone   ,Spr, knopEllipsis ) // ...
 TOK_DCL(tkLParen        , No, knopNone   , No, knopNone   ) // (
 TOK_DCL(tkLBrack        , No, knopNone   , No, knopNone   ) // [
 TOK_DCL(tkDot           , No, knopNone   , No, knopNone   ) // .
+TOK_DCL(tkOptChain      , No, knopNone   , No, knopNone   ) // ?.
 
 // String template tokens
 TOK_DCL(tkStrTmplBasic  , No, knopNone   , No, knopNone   ) // `...`

lib/Parser/perrors.h

@@ -120,7 +120,11 @@ LSC_ERROR_MSG(1102, ERRInvalidAsgTarget, "Invalid left-hand side in assignment."
 LSC_ERROR_MSG(1103, ERRMissingFrom, "Expected 'from' after import or export clause.")
 
 // 1104 ERRsyntaxEOF
-// 1105-1199 available for future use
+
+LSC_ERROR_MSG(1105, ERRInvalidOptChainInNew, "Invalid optional chain in new expression.")
+LSC_ERROR_MSG(1106, ERRInvalidOptChainInSuper, "Invalid optional chain in call to 'super'.")
+LSC_ERROR_MSG(1107, ERRInvalidOptChainWithTaggedTemplate, "Invalid tagged template in optional chain.")
+// 1108-1199 available for future use
 
 // Generic errors intended to be re-usable
 LSC_ERROR_MSG(1200, ERRKeywordAfter, "Unexpected keyword '%s' after '%s'")

lib/Parser/ptlist.h

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 /*****************************************************************************/
@@ -80,6 +81,7 @@ PTNODE(knopGe         , ">="               , OP(Ge)   , Bin         , fnopBin|fn
 PTNODE(knopGt         , ">"                , OP(Gt)   , Bin         , fnopBin|fnopRel       , "GreaterThanOper"                )
 PTNODE(knopCall       , "()"               , Nop      , Call        , fnopNone              , "CallExpr"                       )
 PTNODE(knopDot        , "."                , Nop      , Bin         , fnopBin               , "DotOper"                        )
+PTNODE(knopOptChain   , "?."               , Nop      , Uni         , fnopUni               , "OptChain"                       )
 PTNODE(knopAsg        , "="                , Nop      , Bin         , fnopBin|fnopAsg       , "AssignmentOper"                 )
 PTNODE(knopInstOf     , "instanceof"       , IsInst   , Bin         , fnopBin|fnopRel       , "InstanceOfExpr"                 )
 PTNODE(knopIn         , "in"               , IsIn     , Bin         , fnopBin|fnopRel       , "InOper"                         )

lib/Parser/ptree.cpp

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #include "ParserPch.h"
@@ -301,7 +302,7 @@ ParseNodeUni::ParseNodeUni(OpCode nop, charcount_t ichMin, charcount_t ichLim, P
     this->pnode1 = pnode1;
 }
 
-ParseNodeBin::ParseNodeBin(OpCode nop, charcount_t ichMin, charcount_t ichLim, ParseNode * pnode1, ParseNode * pnode2)
+ParseNodeBin::ParseNodeBin(OpCode nop, charcount_t ichMin, charcount_t ichLim, ParseNode * pnode1, ParseNode * pnode2, bool isNullPropagating)
     : ParseNode(nop, ichMin, ichLim)
 {
     // Member name is either a string or a computed name
@@ -313,6 +314,7 @@ ParseNodeBin::ParseNodeBin(OpCode nop, charcount_t ichMin, charcount_t ichLim, P
 
     this->pnode1 = pnode1;
     this->pnode2 = pnode2;
+    this->isNullPropagating = isNullPropagating;
 
     // Statically detect if the add is a concat
     if (!PHASE_OFF1(Js::ByteCodeConcatExprOptPhase))
@@ -495,6 +497,7 @@ ParseNodeCall::ParseNodeCall(OpCode nop, charcount_t ichMin, charcount_t ichLim,
     this->isEvalCall = false;
     this->isSuperCall = false;
     this->hasDestructuring = false;
+    this->isNullPropagating = false;
 }
 
 ParseNodeStmt::ParseNodeStmt(OpCode nop, charcount_t ichMin, charcount_t ichLim)

lib/Parser/ptree.h

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #pragma once
@@ -277,10 +278,11 @@ class ParseNodeUni : public ParseNode
 class ParseNodeBin : public ParseNode
 {
 public:
-    ParseNodeBin(OpCode nop, charcount_t ichMin, charcount_t ichLim, ParseNode * pnode1, ParseNode * pnode2);
+    ParseNodeBin(OpCode nop, charcount_t ichMin, charcount_t ichLim, ParseNode * pnode1, ParseNode * pnode2, bool isNullPropagating = false);
 
     ParseNodePtr pnode1;
     ParseNodePtr pnode2;
+    bool isNullPropagating;
 
     DISABLE_SELF_CAST(ParseNodeBin);
 };
@@ -791,6 +793,7 @@ class ParseNodeCall : public ParseNode
     BYTE isEvalCall : 1;
     BYTE isSuperCall : 1;
     BYTE hasDestructuring : 1;
+    bool isNullPropagating;
 
     DISABLE_SELF_CAST(ParseNodeCall);
 };