Switch on null-aware operators by default in analyzer.

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/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 341 matching lines @@
       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);
   }
@@ skipping 29 matching lines @@
   }
 
   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);
   }
@@ skipping 894 matching lines @@
   void test_invalidInterpolationIdentifier_startWithDigit() {
     parse4("parseStringLiteral", "'\$1'", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_invalidOperator() {
     parse3("parseClassMember", <Object>["C"], "void operator ===(x) {}",
         [ParserErrorCode.INVALID_OPERATOR]);
   }
 
   void test_invalidOperatorAfterSuper_assignableExpression() {
-    _enableNullAwareOperators = true;
     parse3('parseAssignableExpression', <Object>[false], 'super?.v',
         [ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
   void test_invalidOperatorAfterSuper_primaryExpression() {
-    _enableNullAwareOperators = true;
     parse4('parsePrimaryExpression', 'super?.v',
         [ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
   void test_invalidOperatorForSuper() {
     parse4("parseUnaryExpression", "++super",
         [ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
   void test_invalidStarAfterAsync() {
@@ skipping 1221 matching lines @@
    */
   static bool parseFunctionBodies = true;
 
   /**
    * A flag indicating whether generic method support should be enabled for a
    * specific test.
    */
   bool enableGenericMethods = false;
 
   /**
-   * 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.parseGenericMethods = enableGenericMethods;
     parser.parseFunctionBodies = parseFunctionBodies;
     Object result =
         invokeParserMethodImpl(parser, methodName, objects, tokenStream);
@@ skipping 114 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);
     parser.parseGenericMethods = enableGenericMethods;
     Expression expression = parser.parseExpression(token);
     expect(expression, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
@@ skipping 2282 matching lines @@
   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");
@@ skipping 39 matching lines @@
   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");
@@ skipping 30 matching lines @@
 
   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);
@@ skipping 3850 matching lines @@
   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.typeArguments, isNull);
     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.typeArguments, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
     enableGenericMethods = true;
-    _enableNullAwareOperators = true;
     MethodInvocation expression = parse4('parsePostfixExpression', 'a?.m<E>()');
     expect(expression.target, isNotNull);
     expect(expression.operator.type, TokenType.QUESTION_PERIOD);
     expect(expression.methodName, isNotNull);
     expect(expression.typeArguments, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
     enableGenericMethods = true;
@@ skipping 1591 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;
   }
 }