Scanner/parser support for DEP 9 (null-aware operators).

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 676 matching lines @@
   }
 
   @override
   AstNode visitCompilationUnit(CompilationUnit node) {
     throw new InsufficientContextException();
   }
 
   @override
   AstNode visitConditionalExpression(ConditionalExpression node) {
     if (identical(_oldNode, node.condition)) {
-      return _parser.parseLogicalOrExpression();
+      return _parser.parseIfNullExpression();
     } else if (identical(_oldNode, node.thenExpression)) {
       return _parser.parseExpressionWithoutCascade();
     } else if (identical(_oldNode, node.elseExpression)) {
       return _parser.parseExpressionWithoutCascade();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitConstructorDeclaration(ConstructorDeclaration node) {
@@ skipping 2000 matching lines @@
     }
     return new CompilationUnit(
         firstToken, scriptTag, directives, declarations, _currentToken);
   }
 
   /**
    * Parse a conditional expression. Return the conditional expression that was
    * parsed.
    *
    *     conditionalExpression ::=
-   *         logicalOrExpression ('?' expressionWithoutCascade ':' expressionWithoutCascade)?
+   *         ifNullExpression ('?' expressionWithoutCascade ':' expressionWithoutCascade)?
    */
   Expression parseConditionalExpression() {
-    Expression condition = parseLogicalOrExpression();
+    Expression condition = parseIfNullExpression();
     if (!_matches(TokenType.QUESTION)) {
       return condition;
     }
     Token question = getAndAdvance();
     Expression thenExpression = parseExpressionWithoutCascade();
     Token colon = _expect(TokenType.COLON);
     Expression elseExpression = parseExpressionWithoutCascade();
     return new ConditionalExpression(
         condition, question, thenExpression, colon, elseExpression);
   }
@@ skipping 306 matching lines @@
    */
   FunctionExpression parseFunctionExpression() {
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         _parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
     return new FunctionExpression(parameters, body);
   }
 
   /**
+   * Parse an if-null expression.  Return the if-null expression that was
+   * parsed.
+   *
+   *     ifNullExpression ::= logicalOrExpression ('??' logicalOrExpression)*
+   */
+  Expression parseIfNullExpression() {
+    Expression expression = parseLogicalOrExpression();
+    while (_matches(TokenType.QUESTION_QUESTION)) {
+      Token operator = getAndAdvance();
+      expression = new BinaryExpression(
+          expression, operator, parseLogicalOrExpression());
+    }
+    return expression;
+  }
+
+  /**
    * Parse an implements clause. Return the implements clause that was parsed.
    *
    *     implementsClause ::=
    *         'implements' type (',' type)*
    */
   ImplementsClause parseImplementsClause() {
     Token keyword = _expectKeyword(Keyword.IMPLEMENTS);
     List<TypeName> interfaces = new List<TypeName>();
     interfaces.add(parseTypeName());
     while (_optional(TokenType.COMMA)) {
@@ skipping 1213 matching lines @@
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         return new IndexExpression.forTarget(
             prefix, leftBracket, index, rightBracket);
       } finally {
         _inInitializer = wasInInitializer;
       }
-    } else if (_matches(TokenType.PERIOD)) {
-      Token period = getAndAdvance();
-      return new PropertyAccess(prefix, period, parseSimpleIdentifier());
+    } else if (_matches(TokenType.PERIOD) || _matches(TokenType.QUESTION_PERIOD)) {
+      Token operator = getAndAdvance();
+      return new PropertyAccess(prefix, operator, parseSimpleIdentifier());
     } else {
       if (!optional) {
         // Report the missing selector.
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
       }
       return prefix;
     }
   }
 
@@ skipping 2414 matching lines @@
    *       | primary selector*
    *
    *     selector ::=
    *         assignableSelector
    *       | argumentList
    */
   Expression _parsePostfixExpression() {
     Expression operand = _parseAssignableExpression(true);
     if (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
         _matches(TokenType.PERIOD) ||
+        _matches(TokenType.QUESTION_PERIOD) ||
         _matches(TokenType.OPEN_PAREN)) {
       do {
         if (_matches(TokenType.OPEN_PAREN)) {
           ArgumentList argumentList = parseArgumentList();
           if (operand is PropertyAccess) {
             PropertyAccess access = operand as PropertyAccess;
             operand = new MethodInvocation(access.target, access.operator,
                 access.propertyName, argumentList);
           } else {
             operand = new FunctionExpressionInvocation(operand, argumentList);
           }
         } else {
           operand = _parseAssignableSelector(operand, true);
         }
       } while (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
           _matches(TokenType.PERIOD) ||
+          _matches(TokenType.QUESTION_PERIOD) ||
           _matches(TokenType.OPEN_PAREN));
       return operand;
     }
     if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
     _ensureAssignable(operand);
     Token operator = getAndAdvance();
     return new PostfixExpression(operand, operator);
   }
@@ skipping 3844 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }