Add some errors related to nnbd

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 2732 matching lines @@
    * parsed.
    *
    * This method assumes that the current token matches `Keyword.EXTENDS`.
    *
    *     classExtendsClause ::=
    *         'extends' type
    */
   ExtendsClause parseExtendsClause() {
     Token keyword = getAndAdvance();
     TypeName superclass = parseTypeName(false);
+    _mustNotBeNullable(superclass, ParserErrorCode.NULLABLE_TYPE_IN_EXTENDS);
     return new ExtendsClause(keyword, superclass);
   }
 
   /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration.
    * The [optional] is `true` if the keyword and type are optional. Return the
    * 'final', 'const', 'var' or type that was parsed.
    *
    *     finalConstVarOrType ::=
    *         'final' type?
@@ skipping 591 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(false));
-    while (_optional(TokenType.COMMA)) {
-      interfaces.add(parseTypeName(false));
-    }
+    do {
+      TypeName typeName = parseTypeName(false);
+      _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_IMPLEMENTS);
+      interfaces.add(typeName);
+    } while (_optional(TokenType.COMMA));
     return new ImplementsClause(keyword, interfaces);
   }
 
   /**
    * Parse an import directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the import directive that was parsed.
    *
    * This method assumes that the current token matches `Keyword.IMPORT`.
    *
    *     importDirective ::=
@@ skipping 1542 matching lines @@
 
   /**
    * 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 (_matches(TokenType.QUESTION)) {
+      _reportErrorForCurrentToken(ParserErrorCode.NULLABLE_TYPE_PARAMETER);
+      _advance();
+    }
     if (_matchesKeyword(Keyword.EXTENDS)) {
       Token keyword = getAndAdvance();
       TypeName bound = parseTypeName(false);
       return new TypeParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, name, keyword, bound);
     }
     return new TypeParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, name, null, null);
   }
 
@@ skipping 213 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(false)];
-    while (_optional(TokenType.COMMA)) {
-      types.add(parseTypeName(false));
-    }
+    List<TypeName> types = <TypeName>[];
+    do {
+      TypeName typeName = parseTypeName(false);
+      _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_WITH);
+      types.add(typeName);
+    } while (_optional(TokenType.COMMA));
     return new WithClause(withKeyword, types);
   }
 
   /**
    * Parse a yield statement. Return the yield statement that was parsed.
    *
    * This method assumes that the current token matches [Keyword.YIELD].
    *
    *     yieldStatement ::=
    *         'yield' '*'? expression ';'
@@ skipping 770 matching lines @@
       _tokenMatchesKeyword(_currentToken, keyword);
 
   /**
    * Return `true` if the current token matches the given [identifier].
    */
   bool _matchesString(String identifier) =>
       _currentToken.type == TokenType.IDENTIFIER &&
       _currentToken.lexeme == identifier;
 
   /**
+   * Report an error with the given [errorCode] if the given [typeName] has been
+   * marked as nullable.
+   */
+  void _mustNotBeNullable(TypeName typeName, ParserErrorCode errorCode) {
+    if (typeName.question != null) {
+      _reportErrorForToken(errorCode, typeName.question);
+    }
+  }
+
+  /**
    * If the current token has the given [type], then advance to the next token
    * and return `true`. Otherwise, return `false` without advancing. This method
    * should not be invoked with an argument value of [TokenType.GT].
    */
   bool _optional(TokenType type) {
     if (_currentToken.type == type) {
       _advance();
       return true;
     }
     return false;
@@ skipping 2649 matching lines @@
           "Enclose the URI in either single or double quotes.");
 
   static const ParserErrorCode NON_USER_DEFINABLE_OPERATOR =
       const ParserErrorCode('NON_USER_DEFINABLE_OPERATOR',
           "The operator '{0}' is not user definable");
 
   static const ParserErrorCode NORMAL_BEFORE_OPTIONAL_PARAMETERS =
       const ParserErrorCode('NORMAL_BEFORE_OPTIONAL_PARAMETERS',
           "Normal parameters must occur before optional parameters");
 
+  static const ParserErrorCode NULLABLE_TYPE_IN_EXTENDS = const ParserErrorCode(
+      'NULLABLE_TYPE_IN_EXTENDS',
+      "A nullable type cannot be used in an extends clause",
+      "Remove the '?' from the type name");
+
+  static const ParserErrorCode NULLABLE_TYPE_IN_IMPLEMENTS =
+      const ParserErrorCode(
+          'NULLABLE_TYPE_IN_IMPLEMENTS',
+          "A nullable type cannot be used in an implements clause",
+          "Remove the '?' from the type name");
+
+  static const ParserErrorCode NULLABLE_TYPE_IN_WITH = const ParserErrorCode(
+      'NULLABLE_TYPE_IN_WITH',
+      "A nullable type cannot be used in an with clause",

[scheglov, 2016/09/22 20:30:43]

"a with"?

[Brian Wilkerson, 2016/09/22 20:43:13]

Done

+      "Remove the '?' from the type name");
+
+  static const ParserErrorCode NULLABLE_TYPE_PARAMETER = const ParserErrorCode(
+      'NULLABLE_TYPE_PARAMETER',
+      "Type parameters cannot be nullable",
+      "Remove the '?' from the type name");
+
   static const ParserErrorCode POSITIONAL_AFTER_NAMED_ARGUMENT =
       const ParserErrorCode('POSITIONAL_AFTER_NAMED_ARGUMENT',
           "Positional arguments must occur before named arguments");
 
   static const ParserErrorCode POSITIONAL_PARAMETER_OUTSIDE_GROUP =
       const ParserErrorCode('POSITIONAL_PARAMETER_OUTSIDE_GROUP',
           "Positional parameters must be enclosed in square brackets ('[' and ']')");
 
   static const ParserErrorCode REDIRECTING_CONSTRUCTOR_WITH_BODY =
       const ParserErrorCode('REDIRECTING_CONSTRUCTOR_WITH_BODY',
@@ skipping 112 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;
 }