Initial support for the NNBD proposal

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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 72 matching lines @@
       new MethodTrampoline(0, (Parser target) => target.parseReturnType()),
   'parseSimpleIdentifier_0': new MethodTrampoline(
       0, (Parser target) => target.parseSimpleIdentifier()),
   'parseStatement_0':
       new MethodTrampoline(0, (Parser target) => target.parseStatement2()),
   'parseStringLiteral_0':
       new MethodTrampoline(0, (Parser target) => target.parseStringLiteral()),
   'parseTypeArgumentList_0': new MethodTrampoline(
       0, (Parser target) => target.parseTypeArgumentList()),
   'parseTypeName_0':
-      new MethodTrampoline(0, (Parser target) => target.parseTypeName()),
+      new MethodTrampoline(0, (Parser target) => target.parseTypeName(false)),
   'parseTypeParameter_0':
       new MethodTrampoline(0, (Parser target) => target.parseTypeParameter()),
   'parseTypeParameterList_0': new MethodTrampoline(
       0, (Parser target) => target.parseTypeParameterList()),
   'parseWithClause_0':
       new MethodTrampoline(0, (Parser target) => target.parseWithClause()),
   'advance_0': new MethodTrampoline(0, (Parser target) => target._advance()),
   'appendScalarValue_5': new MethodTrampoline(
       5,
       (Parser target, arg0, arg1, arg2, arg3, arg4) =>
@@ skipping 572 matching lines @@
    */
   int _errorListenerLock = 0;
 
   /**
    * A flag indicating whether the parser is to parse asserts in the initializer
    * list of a constructor.
    */
   bool _enableAssertInitializer = false;
 
   /**
+   * A flag indicating whether the parser is to parse the non-nullable modifier
+   * in type names.
+   */
+  bool _enableNnbd = false;
+
+  /**
    * A flag indicating whether the parser is to parse the async support.
    */
   bool _parseAsync = true;
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   bool _parseFunctionBodies = true;
 
   /**
@@ skipping 61 matching lines @@
 
   /**
    * Set whether the parser is to parse asserts in the initializer list of a
    * constructor to match the given [enable] flag.
    */
   void set enableAssertInitializer(bool enable) {
     _enableAssertInitializer = enable;
   }
 
   /**
+   * Return `true` if the parser is to parse the non-nullable modifier in type
+   * names.
+   */
+  bool get enableNnbd => _enableNnbd;
+
+  /**
+   * Set whether the parser is to parse the non-nullable modifier in type names
+   * to match the given [enable] flag.
+   */
+  void set enableNnbd(bool enable) {
+    _enableNnbd = enable;
+  }
+
+  /**
    * Return `true` if the current token is the first token of a return type that
    * is followed by an identifier, possibly followed by a list of type
    * parameters, followed by a left-parenthesis. This is used by
    * [_parseTypeAlias] to determine whether or not to parse a return type.
    */
   @deprecated
   bool get hasReturnTypeInTypeAlias {
     Token next = _skipReturnType(_currentToken);
     if (next == null) {
       return false;
@@ skipping 737 matching lines @@
   }
 
   /**
    * Parse the name of a constructor. Return the constructor name that was
    * parsed.
    *
    *     constructorName:
    *         type ('.' identifier)?
    */
   ConstructorName parseConstructorName() {
-    TypeName type = parseTypeName();
+    TypeName type = parseTypeName(false);
     Token period = null;
     SimpleIdentifier name = null;
     if (_matches(TokenType.PERIOD)) {
       period = getAndAdvance();
       name = parseSimpleIdentifier();
     }
     return new ConstructorName(type, period, name);
   }
 
   /**
@@ skipping 95 matching lines @@
    * Parse a class extends clause. Return the class extends clause that was
    * parsed.
    *
    * This method assumes that the current token matches `Keyword.EXTENDS`.
    *
    *     classExtendsClause ::=
    *         'extends' type
    */
   ExtendsClause parseExtendsClause() {
     Token keyword = getAndAdvance();
-    TypeName superclass = parseTypeName();
+    TypeName superclass = parseTypeName(false);
     return new ExtendsClause(keyword, superclass);
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    *     formalParameterList ::=
    *         '(' ')'
    *       | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
@@ skipping 60 matching lines @@
    * Parse an implements clause. Return the implements clause that was parsed.
    *
    * This method assumes that the current token matches `Keyword.IMPLEMENTS`.
    *
    *     implementsClause ::=
    *         'implements' type (',' type)*
    */
   ImplementsClause parseImplementsClause() {
     Token keyword = getAndAdvance();
     List<TypeName> interfaces = <TypeName>[];
-    interfaces.add(parseTypeName());
+    interfaces.add(parseTypeName(false));
     while (_optional(TokenType.COMMA)) {
-      interfaces.add(parseTypeName());
+      interfaces.add(parseTypeName(false));
     }
     return new ImplementsClause(keyword, interfaces);
   }
 
   /**
    * Parse a label. Return the label that was parsed.
    *
    * This method assumes that the current token matches an identifier and that
    * the following token matches `TokenType.COLON`.
    *
@@ skipping 81 matching lines @@
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
+        Token question = null;
+        if (enableNnbd && _matches(TokenType.QUESTION)) {
+          question = getAndAdvance();
+        }
         return new FunctionTypedFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.type,
             new SimpleIdentifier(identifier.token, isDeclaration: true),
             typeParameters,
-            parameters);
+            parameters,
+            question: question);
       } else {
         return new FieldFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.keyword,
             holder.type,
             thisKeyword,
             period,
             identifier,
             typeParameters,
@@ skipping 52 matching lines @@
    * Parse a return type. Return the return type that was parsed.
    *
    *     returnType ::=
    *         'void'
    *       | type
    */
   TypeName parseReturnType() {
     if (_currentToken.keyword == Keyword.VOID) {
       return new TypeName(new SimpleIdentifier(getAndAdvance()), null);
     } else {
-      return parseTypeName();
+      return parseTypeName(false);
     }
   }
 
   /**
    * Parse a simple identifier. Return the simple identifier that was parsed.
    *
    *     identifier ::=
    *         IDENTIFIER
    */
   SimpleIdentifier parseSimpleIdentifier({bool isDeclaration: false}) {
@@ skipping 69 matching lines @@
    * This method assumes that the current token matches `TokenType.LT`.
    *
    *     typeArguments ::=
    *         '<' typeList '>'
    *
    *     typeList ::=
    *         type (',' type)*
    */
   TypeArgumentList parseTypeArgumentList() {
     Token leftBracket = getAndAdvance();
-    List<TypeName> arguments = <TypeName>[parseTypeName()];
+    List<TypeName> arguments = <TypeName>[parseTypeName(false)];
     while (_optional(TokenType.COMMA)) {
-      arguments.add(parseTypeName());
+      arguments.add(parseTypeName(false));
     }
     Token rightBracket = _expectGt();
     return new TypeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
    * Parse a type name. Return the type name that was parsed.
    *
    *     type ::=
    *         qualified typeArguments?
    */
-  TypeName parseTypeName() {
-    TypeName realType = _parseTypeName();
+  TypeName parseTypeName(bool inExpression) {
+    TypeName realType = _parseTypeName(inExpression);
     // If this is followed by a generic method type comment, allow the comment
     // type to replace the real type name.
     // TODO(jmesserly): this feels like a big hammer. Can we restrict it to
     // only work inside generic methods?
     TypeName typeFromComment = _parseOptionalTypeNameComment();
     return typeFromComment ?? realType;
   }
 
   /**
    * Parse a type parameter. Return the type parameter that was parsed.
    *
    *     typeParameter ::=
    *         metadata name ('extends' bound)?
    */
   TypeParameter parseTypeParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matchesKeyword(Keyword.EXTENDS)) {
       Token keyword = getAndAdvance();
-      TypeName bound = parseTypeName();
+      TypeName bound = parseTypeName(false);
       return new TypeParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, name, keyword, bound);
     }
     return new TypeParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, name, null, null);
   }
 
   /**
    * Parse a list of type parameters. Return the list of type parameters that
    * were parsed.
@@ skipping 16 matching lines @@
   /**
    * Parse a with clause. Return the with clause that was parsed.
    *
    * This method assumes that the current token matches `Keyword.WITH`.
    *
    *     withClause ::=
    *         'with' typeName (',' typeName)*
    */
   WithClause parseWithClause() {
     Token withKeyword = getAndAdvance();
-    List<TypeName> types = <TypeName>[parseTypeName()];
+    List<TypeName> types = <TypeName>[parseTypeName(false)];
     while (_optional(TokenType.COMMA)) {
-      types.add(parseTypeName());
+      types.add(parseTypeName(false));
     }
     return new WithClause(withKeyword, types);
   }
 
   /**
+   * Return `true` if the current token could be the question mark in a
+   * condition expression. The current token is assumed to be a question mark.
+   */
+  bool _isConditionalOperator() {
+    void parseFunction(Parser parser) {

[scheglov, 2016/09/16 15:29:38]

The name looks like this function will parse a function :-)

[Brian Wilkerson, 2016/09/16 15:47:35]

Yes it does. :-) I've renamed it to 'parseOperation' in leu of a better name.

+      parser.parseExpressionWithoutCascade();
+    }
+
+    Token token = _skip(_currentToken.next, parseFunction);
+    if (token == null || !_tokenMatches(token, TokenType.COLON)) {
+      return false;
+    }
+    token = _skip(token.next, parseFunction);

[scheglov, 2016/09/16 15:29:38]

Out of curiosity - what is an example when just seeing COLON after an expression
is not enough?

[Brian Wilkerson, 2016/09/16 15:47:35]

I'm concerned about cases like

  if (foo is Bar? && flag ? m1() : m2())

where we need to ensure that the colon isn't part of some other conditional
expression.

I'm not sure, but it might be possible to put together a list of tokens that can
legally follow the '?' when it isn't a conditional expression ('&&', '||', ')',
';', etc.) and reverse the sense of the condition, thus making this require only
a small number of tokens to be looked at, but I need to spend some time with the
grammar to be sure.

+    return token != null;
+  }
+
+  /**
    * Advance to the next token in the token stream.
    */
   void _advance() {
     _currentToken = _currentToken.next;
   }
 
   /**
    * Append the character equivalent of the given [scalarValue] to the given
    * [builder]. Use the [startIndex] and [endIndex] to report an error, and
    * don't append anything to the builder, if the scalar value is invalid. The
@@ skipping 1416 matching lines @@
    *     mixinApplication ::=
    *         type withClause implementsClause? ';'
    */
   ClassTypeAlias _parseClassTypeAliasAfterName(
       CommentAndMetadata commentAndMetadata,
       Token abstractKeyword,
       Token classKeyword,
       SimpleIdentifier className,
       TypeParameterList typeParameters) {
     Token equals = _expect(TokenType.EQ);
-    TypeName superclass = parseTypeName();
+    TypeName superclass = parseTypeName(false);
     WithClause withClause = null;
     if (_matchesKeyword(Keyword.WITH)) {
       withClause = parseWithClause();
     } else {
       _reportErrorForCurrentToken(
           ParserErrorCode.EXPECTED_TOKEN, [Keyword.WITH.syntax]);
     }
     ImplementsClause implementsClause = null;
     if (_matchesKeyword(Keyword.IMPLEMENTS)) {
       implementsClause = parseImplementsClause();
@@ skipping 1052 matching lines @@
    *       | 'var'
    *       | type
    */
   FinalConstVarOrType _parseFinalConstVarOrType(bool optional) {
     Token keywordToken = null;
     TypeName type = null;
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.FINAL || keyword == Keyword.CONST) {
       keywordToken = getAndAdvance();
       if (_isTypedIdentifier(_currentToken)) {
-        type = parseTypeName();
+        type = parseTypeName(false);
       } else {
         // Support `final/*=T*/ x;`
         type = _parseOptionalTypeNameComment();
       }
     } else if (keyword == Keyword.VAR) {
       keywordToken = getAndAdvance();
       // Support `var/*=T*/ x;`
       type = _parseOptionalTypeNameComment();
       if (type != null) {
         // Clear the keyword to prevent an error.
@@ skipping 1616 matching lines @@
    */
   TypeArgumentList _parseOptionalTypeArguments() {
     if (_matches(TokenType.LT) || _injectGenericCommentTypeList()) {
       return parseTypeArgumentList();
     }
     return null;
   }
 
   TypeName _parseOptionalTypeNameComment() {
     if (_injectGenericCommentTypeAssign()) {
-      return _parseTypeName();
+      return _parseTypeName(false);
     }
     return null;
   }
 
   /**
    * Parse a part directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the part or part-of directive that
    * was parsed.
    *
    * This method assumes that the current token matches `Keyword.PART`.
@@ skipping 317 matching lines @@
         _currentToken.next.type.isRelationalOperator) {
       Expression expression = new SuperExpression(getAndAdvance());
       Token operator = getAndAdvance();
       return new BinaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     Expression expression = parseBitwiseOrExpression();
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.AS) {
       Token asOperator = getAndAdvance();
-      return new AsExpression(expression, asOperator, parseTypeName());
+      return new AsExpression(expression, asOperator, parseTypeName(true));
     } else if (keyword == Keyword.IS) {
       Token isOperator = getAndAdvance();
       Token notOperator = null;
       if (_matches(TokenType.BANG)) {
         notOperator = getAndAdvance();
       }
       return new IsExpression(
-          expression, isOperator, notOperator, parseTypeName());
+          expression, isOperator, notOperator, parseTypeName(true));
     } else if (_currentToken.type.isRelationalOperator) {
       Token operator = getAndAdvance();
       return new BinaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     return expression;
   }
 
   /**
    * Parse a rethrow expression. Return the rethrow expression that was parsed.
@@ skipping 418 matching lines @@
   Statement _parseTryStatement() {
     Token tryKeyword = getAndAdvance();
     Block body = _parseBlockChecked();
     List<CatchClause> catchClauses = <CatchClause>[];
     Block finallyClause = null;
     while (_matchesString(_ON) || _matchesKeyword(Keyword.CATCH)) {
       Token onKeyword = null;
       TypeName exceptionType = null;
       if (_matchesString(_ON)) {
         onKeyword = getAndAdvance();
-        exceptionType = parseTypeName();
+        exceptionType = parseTypeName(false);
       }
       Token catchKeyword = null;
       Token leftParenthesis = null;
       SimpleIdentifier exceptionParameter = null;
       Token comma = null;
       SimpleIdentifier stackTraceParameter = null;
       Token rightParenthesis = null;
       if (_matchesKeyword(Keyword.CATCH)) {
         catchKeyword = getAndAdvance();
         leftParenthesis = _expect(TokenType.OPEN_PAREN);
@@ skipping 69 matching lines @@
         TypeAlias typeAlias =
             _parseClassTypeAlias(commentAndMetadata, null, keyword);
         _reportErrorForToken(
             ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
         return typeAlias;
       }
     }
     return _parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
-  TypeName _parseTypeName() {
+  TypeName _parseTypeName(bool inExpression) {
     Identifier typeName;
     if (_matchesIdentifier()) {
       typeName = _parsePrefixedIdentifierUnchecked();
     } else if (_matchesKeyword(Keyword.VAR)) {
       _reportErrorForCurrentToken(ParserErrorCode.VAR_AS_TYPE_NAME);
       typeName = new SimpleIdentifier(getAndAdvance());
     } else {
       typeName = _createSyntheticIdentifier();
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TYPE_NAME);
     }
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
-    return new TypeName(typeName, typeArguments);
+    Token question = null;
+    if (enableNnbd && _matches(TokenType.QUESTION)) {
+      if (!inExpression || !_isConditionalOperator()) {
+        question = getAndAdvance();
+      }
+    }
+    return new TypeName(typeName, typeArguments, question: question);
   }
 
   /**
+   * Execute the given [parseFunction] in a temporary parser whose current token
+   * has been set to the given [startToken]. If the parse does not generate any
+   * errors or exceptions, then return the token following the matching portion
+   * of the token stream. Otherwise, return `null`.
+   *
+   * Note: This is an extremely inefficient way of testing whether the tokens in
+   * the token stream match a given production. It should not be used for
+   * production code.
+   */
+  Token _skip(Token startToken, parseFunction(Parser parser)) {
+    // TODO(brianwilkerson) We need to create a copy of the token stream from
+    // the current token onward so that token re-writes don't change the
+    // behavior of the current parser.
+    BooleanErrorListener listener = new BooleanErrorListener();
+    Parser parser = new Parser(_source, listener);
+    parser._currentToken = startToken;
+    parser._enableAssertInitializer = _enableAssertInitializer;
+    parser._enableNnbd = _enableNnbd;
+    parser._inAsync = _inAsync;
+    parser._inGenerator = _inGenerator;
+    parser._inInitializer = _inInitializer;
+    parser._inLoop = _inLoop;
+    parser._inSwitch = _inSwitch;
+    parser._parseAsync = _parseAsync;
+    parser._parseFunctionBodies = _parseFunctionBodies;
+    try {
+      parseFunction(parser);
+    } catch (exception) {
+      return null;
+    }
+    if (listener.errorReported) {
+      return null;
+    }
+    return parser._currentToken;
+  }
+
+  /**
    * Parse a type name. Return the type name that was parsed.
    *
    * This method assumes that the current token is an identifier.
    *
    *     type ::=
    *         qualified typeArguments?
    */
   TypeName _parseTypeNameAfterIdentifier() {
     Identifier typeName = _parsePrefixedIdentifierUnchecked();
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
@@ skipping 1963 matching lines @@
    */
   const ParserErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }