[parser] Error recovery of type parameters on void

Fixes #39958.

Change-Id: I851bef762776f4b68f0fcb645d634019b8b32e81
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/137925
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>

Author: jensjoha

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -8681,6 +8681,16 @@ const MessageCode messageVoidExpression = const MessageCode("VoidExpression",
     analyzerCodes: <String>["USE_OF_VOID_RESULT"],
     message: r"""This expression has type 'void' and can't be used.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeVoidWithTypeParameters = messageVoidWithTypeParameters;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageVoidWithTypeParameters = const MessageCode(
+    "VoidWithTypeParameters",
+    index: 100,
+    message: r"""Type 'void' can't have type parameters.""",
+    tip: r"""Try removing the type parameters.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
     Message Function(

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -1569,6 +1569,11 @@ class ForwardingListener implements Listener {
     listener?.handleVoidKeyword(token);
   }
 
+  @override
+  void handleVoidKeywordWithTypeArguments(Token token) {
+    listener?.handleVoidKeywordWithTypeArguments(token);
+  }
+
   @override
   void logEvent(String name) {
     listener?.logEvent(name);

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -1551,6 +1551,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("VoidKeyword");
   }
 
+  /// The parser saw a void with type arguments (e.g. void<int>).
+  /// This is not valid - an error has already been emitted.
+  void handleVoidKeywordWithTypeArguments(Token token) {
+    logEvent("handleVoidKeywordWithTypeArguments");
+  }
+
   void beginYieldStatement(Token token) {}
 
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {

pkg/_fe_analyzer_shared/lib/src/parser/type_info_impl.dart

@@ -355,14 +355,39 @@ class VoidType implements TypeInfo {
 
   @override
   Token parseType(Token token, Parser parser) {
-    token = token.next;
-    parser.listener.handleVoidKeyword(token);
+    Token voidKeyword = token = token.next;
+    bool hasTypeArguments = false;
+
+    // Recovery: Skip past, but issue problem, if followed by type arguments.
+    if (optional('<', token.next)) {
+      TypeParamOrArgInfo typeParam = computeTypeParamOrArg(token);
+      if (typeParam != noTypeParamOrArg) {
+        hasTypeArguments = true;
+        parser.reportRecoverableError(
+            token.next, codes.messageVoidWithTypeParameters);
+        token = typeParam.parseArguments(token, parser);
+      }
+    }
+    if (hasTypeArguments) {
+      parser.listener.handleVoidKeywordWithTypeArguments(voidKeyword);
+    } else {
+      // Normal case.
+      parser.listener.handleVoidKeyword(voidKeyword);
+    }
     return token;
   }
 
   @override
   Token skipType(Token token) {
-    return token.next;
+    token = token.next;
+    // Recovery: Skip past if followed by type arguments.
+    if (optional('<', token.next)) {
+      TypeParamOrArgInfo typeParam = computeTypeParamOrArg(token);
+      if (typeParam != noTypeParamOrArg) {
+        token = typeParam.skip(token);
+      }
+    }
+    return token;
   }
 }
 

pkg/analyzer/lib/error/error.dart

@@ -656,6 +656,7 @@ const List<ErrorCode> errorCodeValues = [
   ParserErrorCode.VAR_ENUM,
   ParserErrorCode.VAR_RETURN_TYPE,
   ParserErrorCode.VAR_TYPEDEF,
+  ParserErrorCode.VOID_WITH_TYPE_PARAMETERS,
   ParserErrorCode.WITH_BEFORE_EXTENDS,
   ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
   ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP,

pkg/analyzer/lib/src/dart/error/syntactic_errors.dart

@@ -881,6 +881,9 @@ class ParserErrorCode extends ErrorCode {
           correction: "Try removing the keyword 'var', or "
               "replacing it with the name of the return type.");
 
+  static const ParserErrorCode VOID_WITH_TYPE_PARAMETERS =
+      _VOID_WITH_TYPE_PARAMETERS;
+
   /**
    * Initialize a newly created error code to have the given [name]. The message
    * associated with the error will be created from the given [message]

pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart

@@ -107,6 +107,7 @@ final fastaAnalyzerErrorCodes = <ErrorCode>[
   _MULTIPLE_VARIANCE_MODIFIERS,
   _INVALID_USE_OF_COVARIANT_IN_EXTENSION,
   _TYPE_PARAMETER_ON_CONSTRUCTOR,
+  _VOID_WITH_TYPE_PARAMETERS,
 ];
 
 const ParserErrorCode _ABSTRACT_CLASS_MEMBER = ParserErrorCode(
@@ -574,6 +575,10 @@ const ParserErrorCode _VAR_RETURN_TYPE = ParserErrorCode(
     correction:
         "Try removing the keyword 'var', or replacing it with the name of the return type.");
 
+const ParserErrorCode _VOID_WITH_TYPE_PARAMETERS = ParserErrorCode(
+    'VOID_WITH_TYPE_PARAMETERS', r"Type 'void' can't have type parameters.",
+    correction: "Try removing the type parameters.");
+
 const ParserErrorCode _WITH_BEFORE_EXTENDS = ParserErrorCode(
     'WITH_BEFORE_EXTENDS',
     r"The extends clause must be before the with clause.",

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -3443,6 +3443,19 @@ class AstBuilder extends StackListener {
     handleType(voidKeyword, null);
   }
 
+  @override
+  void handleVoidKeywordWithTypeArguments(Token voidKeyword) {
+    assert(optional('void', voidKeyword));
+    debugEvent("VoidKeywordWithTypeArguments");
+    TypeArgumentList arguments = pop();
+
+    // TODO(paulberry): is this sufficient, or do we need to hook the "void"
+    // keyword up to an element?
+    handleIdentifier(voidKeyword, IdentifierContext.typeReference);
+    push(arguments);
+    handleType(voidKeyword, null);
+  }
+
   @override
   dynamic internalProblem(Message message, int charOffset, Uri uri) {
     throw UnsupportedError(message.message);

pkg/analyzer/test/src/diagnostics/test_all.dart

@@ -487,6 +487,7 @@ import 'uri_does_not_exist_test.dart' as uri_does_not_exist;
 import 'uri_with_interpolation_test.dart' as uri_with_interpolation;
 import 'use_of_void_result_test.dart' as use_of_void_result;
 import 'variable_type_mismatch_test.dart' as variable_type_mismatch;
+import 'void_test.dart' as void_test;
 import 'wrong_number_of_parameters_for_operator_test.dart'
     as wrong_number_of_parameters_for_operator;
 import 'wrong_number_of_parameters_for_setter_test.dart'
@@ -834,6 +835,7 @@ main() {
     uri_with_interpolation.main();
     use_of_void_result.main();
     variable_type_mismatch.main();
+    void_test.main();
     wrong_number_of_parameters_for_operator.main();
     wrong_number_of_parameters_for_setter.main();
     wrong_number_of_type_arguments.main();

pkg/analyzer/test/src/diagnostics/void_test.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/src/dart/error/syntactic_errors.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/driver_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(VoidTest);
+  });
+}
+
+@reflectiveTest
+class VoidTest extends DriverResolutionTest {
+  test_void_with_type_parameters() async {
+    await assertErrorsInCode('''
+void<int> f() {}
+''', [
+      error(ParserErrorCode.VOID_WITH_TYPE_PARAMETERS, 4, 1),
+    ]);
+  }
+
+  test_void_with_no_type_parameters() async {
+    await assertErrorsInCode('''
+void f() {}
+''', []);
+  }
+}