Fix error recovery for : super.<keyword>() / : this.<keyword>()

Previously, if a keyword was used in place of a constructor name in a
constructor initializer list, it caused an analyzer crash, because as
part of error recovery, the AST builder would try to create a
SuperConstructorInvocation or a RedirectingConstructorInvocation using
a null argument list.  This CL fixes the problem by creating a
synthetic argument list.  It re-uses logic that previously existed for
creating a synthetic argument list.

To avoid a crash happening later in analysis, it was also necessary to
modify the AST cloner so that when it encounters the `(` and `)`
tokens in the synthetic argument list, it is able to clone them even
though they are not in the token stream.  (Note that this is not an
ideal solution; I would have rather inserted the `(` and `)` into the
token stream, but with the current parser architecture there's no good
way to do this without the parser then trying to interpret those
tokens).

Change-Id: Ibbdcdd956d80c16d427ba1ba7a9cd7ce374e941b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/201282
Reviewed-by: Samuel Rawlins <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/ast/utilities.dart

@@ -92,7 +92,7 @@ class AstCloner implements AstVisitor<AstNode> {
       if (_lastClonedOffset <= token.offset) {
         _cloneTokens(_nextToClone ?? token, token.offset);
       }
-      return _clonedTokens[token]!;
+      return _clonedTokens[token] ?? _cloneSyntheticToken(token);
     } else {
       return token;
     }
@@ -1090,6 +1090,15 @@ class AstCloner implements AstVisitor<AstNode> {
           cloneNode(node.expression),
           cloneToken(node.semicolon));
 
+  /// Clones a synthetic token that isn't linked up to the rest of the token
+  /// list.
+  Token _cloneSyntheticToken(Token token) {
+    assert(token.isSynthetic);
+    assert(token.next == null);
+    assert(token.previous == null);
+    return token.copy();
+  }
+
   /// Clone all token starting from the given [token] up to a token that has
   /// offset greater then [stopAfter], and put mapping from originals to clones
   /// into [_clonedTokens].

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

@@ -485,15 +485,15 @@ class AstBuilder extends StackListener {
       // This error is also reported in the body builder
       handleRecoverableError(messageInvalidSuperInInitializer,
           target.superKeyword, target.superKeyword);
-      return ast.superConstructorInvocation(
-          target.superKeyword, null, null, argumentList!);
+      return ast.superConstructorInvocation(target.superKeyword, null, null,
+          argumentList ?? _syntheticArgumentList(target.superKeyword));
     } else if (target is ThisExpression) {
       // TODO(danrubel): Consider generating this error in the parser
       // This error is also reported in the body builder
       handleRecoverableError(messageInvalidThisInInitializer,
           target.thisKeyword, target.thisKeyword);
-      return ast.redirectingConstructorInvocation(
-          target.thisKeyword, null, null, argumentList!);
+      return ast.redirectingConstructorInvocation(target.thisKeyword, null,
+          null, argumentList ?? _syntheticArgumentList(target.thisKeyword));
     }
     return null;
   }
@@ -3537,14 +3537,8 @@ class AstBuilder extends StackListener {
       // TODO(paulberry): once we have visitor support for constructor
       // tear-offs, fall through and return a FunctionReference instead since
       // that should lead to better quality error recovery.
-      var syntheticOffset = typeArguments.rightBracket.end;
-      push(ast.functionExpressionInvocation(
-          receiver,
-          typeArguments,
-          ast.argumentList(
-              SyntheticToken(TokenType.OPEN_PAREN, syntheticOffset),
-              [],
-              SyntheticToken(TokenType.CLOSE_PAREN, syntheticOffset))));
+      push(ast.functionExpressionInvocation(receiver, typeArguments,
+          _syntheticArgumentList(typeArguments.rightBracket)));
       return;
     }
     push(ast.functionReference(
@@ -3871,6 +3865,14 @@ class AstBuilder extends StackListener {
     return ast.variableDeclaration(name, equals, initializer);
   }
 
+  ArgumentList _syntheticArgumentList(Token precedingToken) {
+    int syntheticOffset = precedingToken.end;
+    return ast.argumentList(
+        SyntheticToken(TokenType.OPEN_PAREN, syntheticOffset),
+        [],
+        SyntheticToken(TokenType.CLOSE_PAREN, syntheticOffset));
+  }
+
   SimpleIdentifier _tmpSimpleIdentifier() {
     return ast.simpleIdentifier(
       StringToken(TokenType.STRING, '__tmp', -1),

pkg/analyzer/test/generated/simple_parser_test.dart

@@ -117,6 +117,33 @@ class C<@Foo.bar(const [], const [1], const{"":r""}, 0xFF + 2, .3, 4.5) T> {}
     expect(metadata.name.name, 'Foo.bar');
   }
 
+  void test_classDeclaration_invalid_super() {
+    parseCompilationUnit('''
+class C {
+  C() : super.const();
+}
+''', errors: [
+      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 18, 5),
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 24, 5),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 24, 5),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 29, 1),
+    ]);
+  }
+
+  void test_classDeclaration_invalid_this() {
+    parseCompilationUnit('''
+class C {
+  C() : this.const();
+}
+''', errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 18, 4),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 23, 5),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 23, 5),
+      expectedError(ParserErrorCode.CONST_METHOD, 23, 5),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 28, 1),
+    ]);
+  }
+
   void test_method_name_notNull_37733() {
     // https://github.com/dart-lang/sdk/issues/37733
     var unit = parseCompilationUnit(r'class C { f(<T>()); }', errors: [

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

@@ -0,0 +1,30 @@
+// Copyright (c) 2021, 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/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InvalidSuperInInitializerTest);
+  });
+}
+
+@reflectiveTest
+class InvalidSuperInInitializerTest extends PubPackageResolutionTest {
+  test_constructor_name_is_keyword() async {
+    await assertErrorsInCode('''
+class C {
+  C() : super.const();
+}
+''', [
+      error(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 18, 5),
+      error(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 24, 5),
+      error(ParserErrorCode.MISSING_IDENTIFIER, 24, 5),
+      error(ParserErrorCode.MISSING_IDENTIFIER, 29, 1),
+    ]);
+  }
+}

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

@@ -334,6 +334,7 @@ import 'invalid_required_optional_positional_param_test.dart'
 import 'invalid_required_positional_param_test.dart'
     as invalid_required_positional_param;
 import 'invalid_sealed_annotation_test.dart' as invalid_sealed_annotation;
+import 'invalid_super_in_initializer_test.dart' as invalid_super_in_initializer;
 import 'invalid_super_invocation_test.dart' as invalid_super_invocation;
 import 'invalid_type_argument_in_const_list_test.dart'
     as invalid_type_argument_in_const_list;
@@ -918,6 +919,7 @@ main() {
     invalid_required_optional_positional_param.main();
     invalid_required_positional_param.main();
     invalid_sealed_annotation.main();
+    invalid_super_in_initializer.main();
     invalid_super_invocation.main();
     invalid_type_argument_in_const_list.main();
     invalid_type_argument_in_const_map.main();