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

pkg/analyzer/test/generated/parser_test.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.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/incremental_scanner.dart';
@@ skipping 298 matching lines @@
           (obj) => obj is AssignmentExpression, AssignmentExpression, section);
       Expression lhs = (section as AssignmentExpression).leftHandSide;
       EngineTestCase.assertInstanceOf(
           (obj) => obj is IndexExpression, IndexExpression, lhs);
       IndexExpression index = lhs as IndexExpression;
       expect(index.isCascaded, isTrue);
       expect(index.realTarget, same(target));
     }
   }
 
+  void test_conditionalExpression_precedence_ifNullExpression() {
+    _enableNullAwareOperators = true;
+    ConditionalExpression expression = parseExpression('a ?? b ? y : z');
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
+        BinaryExpression, expression.condition);
+  }
+
   void test_conditionalExpression_precedence_logicalOrExpression() {
     ConditionalExpression expression = parseExpression("a | b ? y : z");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.condition);
   }
 
   void test_constructor_initializer_withParenthesizedExpression() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   C() :
@@ skipping 23 matching lines @@
         (obj) => obj is IsExpression, IsExpression, expression.rightOperand);
   }
 
   void test_equalityExpression_super() {
     BinaryExpression expression = parseExpression("super == y != z",
         [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
 
+  void test_ifNullExpression() {
+    _enableNullAwareOperators = true;
+    BinaryExpression expression = parseExpression('x ?? y ?? z');
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
+        BinaryExpression, expression.leftOperand);
+  }
+
+  void test_ifNullExpression_precedence_logicalOr_left() {
+    _enableNullAwareOperators = true;
+    BinaryExpression expression = parseExpression('x || y ?? z');
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
+        BinaryExpression, expression.leftOperand);
+  }
+
+  void test_ifNullExpression_precendce_logicalOr_right() {
+    _enableNullAwareOperators = true;
+    BinaryExpression expression = parseExpression('x ?? y || z');
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
+        BinaryExpression, expression.rightOperand);
+  }
+
   void test_logicalAndExpression() {
     BinaryExpression expression = parseExpression("x && y && z");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_left() {
     BinaryExpression expression = parseExpression("x | y < z");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
@@ skipping 2020 matching lines @@
    * An empty list of objects used as arguments to zero-argument methods.
    */
   static const List<Object> _EMPTY_ARGUMENTS = const <Object>[];
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   static bool parseFunctionBodies = true;
 
   /**
+   * If non-null, this value is used to override the default value of
+   * [Scanner.enableNullAwareOperators] before scanning.
+   */
+  bool _enableNullAwareOperators;
+
+  /**
    * Return a CommentAndMetadata object with the given values that can be used for testing.
    *
    * @param comment the comment to be wrapped in the object
    * @param annotations the annotations to be wrapped in the object
    * @return a CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata commentAndMetadata(Comment comment,
       [List<Annotation> annotations]) {
     return new CommentAndMetadata(comment, annotations);
   }
@@ skipping 22 matching lines @@
    * @throws AssertionFailedError if the result is `null` or the errors produced while
    *           scanning and parsing the source do not match the expected errors
    */
   Object invokeParserMethod(String methodName, List<Object> objects,
       String source, GatheringErrorListener listener) {
     //
     // Scan the source.
     //
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
+    if (_enableNullAwareOperators != null) {
+      scanner.enableNullAwareOperators = _enableNullAwareOperators;
+    }
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     //
     // Parse the source.
     //
     Parser parser = createParser(listener);
     parser.parseFunctionBodies = parseFunctionBodies;
     Object result =
         invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     //
@@ skipping 113 matching lines @@
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
+    if (_enableNullAwareOperators != null) {
+      scanner.enableNullAwareOperators = _enableNullAwareOperators;
+    }
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = createParser(listener);
     Expression expression = parser.parseExpression(token);
     expect(expression, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
   @override
@@ skipping 2175 matching lines @@
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "(x).y");
     expect(propertyAccess.target, isNotNull);
-    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_index() {
     IndexExpression expression =
         parse("parseAssignableExpression", <Object>[false], "(x)[y]");
     expect(expression.target, isNotNull);
     expect(expression.leftBracket, isNotNull);
     expect(expression.index, isNotNull);
     expect(expression.rightBracket, isNotNull);
   }
 
+  void test_parseAssignableExpression_expression_question_dot() {
+    _enableNullAwareOperators = true;
+    PropertyAccess propertyAccess =
+        parse("parseAssignableExpression", <Object>[false], "(x)?.y");
+    expect(propertyAccess.target, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
   void test_parseAssignableExpression_identifier() {
     SimpleIdentifier identifier =
         parse("parseAssignableExpression", <Object>[false], "x");
     expect(identifier, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "x.y");
     expect(propertyAccess.target, isNotNull);
-    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.PERIOD);

[Brian Wilkerson, 2015/03/27 22:56:37]

I generally prefer to leave in the explicit tests for null values
("expect(propertyAccess.operator, isNotNull);") because I find it easier to
debug problems, but it's your call (and might not be as true with unittest as it
was with JUnit).

[Paul Berry, 2015/03/28 02:25:09]

Done.

     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_index() {
     IndexExpression expression =
         parse("parseAssignableExpression", <Object>[false], "x[y]");
     expect(expression.target, isNotNull);
     expect(expression.leftBracket, isNotNull);
     expect(expression.index, isNotNull);
     expect(expression.rightBracket, isNotNull);
   }
 
+  void test_parseAssignableExpression_identifier_question_dot() {
+    _enableNullAwareOperators = true;
+    PropertyAccess propertyAccess =
+        parse("parseAssignableExpression", <Object>[false], "x?.y");
+    expect(propertyAccess.target, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
   void test_parseAssignableExpression_super_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "super.y");
     EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression,
         SuperExpression, propertyAccess.target);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_super_index() {
     IndexExpression expression =
         parse("parseAssignableExpression", <Object>[false], "super[y]");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SuperExpression, SuperExpression, expression.target);
     expect(expression.leftBracket, isNotNull);
     expect(expression.index, isNotNull);
     expect(expression.rightBracket, isNotNull);
   }
 
   void test_parseAssignableSelector_dot() {
     PropertyAccess selector =
         parse("parseAssignableSelector", <Object>[null, true], ".x");
-    expect(selector.operator, isNotNull);
+    expect(selector.operator.type, TokenType.PERIOD);
     expect(selector.propertyName, isNotNull);
   }
 
   void test_parseAssignableSelector_index() {
     IndexExpression selector =
         parse("parseAssignableSelector", <Object>[null, true], "[x]");
     expect(selector.leftBracket, isNotNull);
     expect(selector.index, isNotNull);
     expect(selector.rightBracket, isNotNull);
   }
 
   void test_parseAssignableSelector_none() {
     SimpleIdentifier selector = parse("parseAssignableSelector", <Object>[
       new SimpleIdentifier(null),
       true
     ], ";");
     expect(selector, isNotNull);
   }
 
+  void test_parseAssignableSelector_question_dot() {
+    _enableNullAwareOperators = true;
+    PropertyAccess selector =
+        parse("parseAssignableSelector", <Object>[null, true], "?.x");
+    expect(selector.operator.type, TokenType.QUESTION_PERIOD);
+    expect(selector.propertyName, isNotNull);
+  }
+
   void test_parseAwaitExpression() {
     AwaitExpression expression = parse4("parseAwaitExpression", "await x;");
     expect(expression.awaitKeyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseAwaitExpression_asStatement_inAsync() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "m() async { await x; }");
     FunctionBody body = method.body;
@@ skipping 3594 matching lines @@
 
   void test_parsePostfixExpression_none_indexExpression() {
     IndexExpression expression = parse4("parsePostfixExpression", "a[0]");
     expect(expression.target, isNotNull);
     expect(expression.index, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation() {
     MethodInvocation expression = parse4("parsePostfixExpression", "a.m()");
     expect(expression.target, isNotNull);
+    expect(expression.operator.type, TokenType.PERIOD);
     expect(expression.methodName, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
+
+  void test_parsePostfixExpression_none_methodInvocation_question_dot() {
+    _enableNullAwareOperators = true;
+    MethodInvocation expression = parse4('parsePostfixExpression', 'a?.m()');
+    expect(expression.target, isNotNull);
+    expect(expression.operator.type, TokenType.QUESTION_PERIOD);
+    expect(expression.methodName, isNotNull);
+    expect(expression.argumentList, isNotNull);
+  }
 
   void test_parsePostfixExpression_none_propertyAccess() {
     PrefixedIdentifier expression = parse4("parsePostfixExpression", "a.b");
     expect(expression.prefix, isNotNull);
     expect(expression.identifier, isNotNull);
   }
 
   void test_parsePrefixedIdentifier_noPrefix() {
     String lexeme = "bar";
     SimpleIdentifier identifier = parse4("parsePrefixedIdentifier", lexeme);
@@ skipping 1450 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }