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

pkg/analyzer/test/generated/parser_test.dart

Index: pkg/analyzer/test/generated/parser_test.dart
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index b21fbee49142904bb5f2aa76a4563276d6326050..953a14ab5281e413786105a7b83c3b6849ff1e3e 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -316,6 +316,13 @@ class ComplexParserTest extends ParserTestCase {
     }
   }
 
+  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,
@@ -359,6 +366,27 @@ class C {
         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,
@@ -2399,6 +2427,12 @@ class ParserTestCase extends EngineTestCase {
   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
@@ -2441,6 +2475,9 @@ class ParserTestCase extends EngineTestCase {
     //
     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);
     //
@@ -2574,6 +2611,9 @@ class ParserTestCase extends EngineTestCase {
     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);
@@ -4769,7 +4809,7 @@ class SimpleParserTest extends ParserTestCase {
     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);
   }
 
@@ -4782,6 +4822,15 @@ class SimpleParserTest extends ParserTestCase {
     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");
@@ -4804,7 +4853,7 @@ class SimpleParserTest extends ParserTestCase {
     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);
   }
 
@@ -4817,6 +4866,15 @@ class SimpleParserTest extends ParserTestCase {
     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");
@@ -4839,7 +4897,7 @@ class SimpleParserTest extends ParserTestCase {
   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);
   }
 
@@ -4859,6 +4917,14 @@ class SimpleParserTest extends ParserTestCase {
     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);
@@ -8473,6 +8539,16 @@ void''');
   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);
   }