More tests for ExtractorPattern resolution, report errors.

Change-Id: I800f909a1d58e8bebcbfa30e52f09a16906b1e07
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/263142
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml

@@ -679,6 +679,8 @@ CompileTimeErrorCode.MISSING_DEFAULT_VALUE_FOR_PARAMETER_POSITIONAL:
   status: hasFix
 CompileTimeErrorCode.MISSING_DEFAULT_VALUE_FOR_PARAMETER_WITH_ANNOTATION:
   status: hasFix
+CompileTimeErrorCode.MISSING_EXTRACTOR_PATTERN_GETTER_NAME:
+  status: noFix
 CompileTimeErrorCode.MISSING_REQUIRED_ARGUMENT:
   status: hasFix
 CompileTimeErrorCode.MISSING_VARIABLE_PATTERN:

pkg/analyzer/lib/error/error.dart

@@ -306,6 +306,7 @@ const List<ErrorCode> errorCodeValues = [
   CompileTimeErrorCode.MISSING_DEFAULT_VALUE_FOR_PARAMETER,
   CompileTimeErrorCode.MISSING_DEFAULT_VALUE_FOR_PARAMETER_POSITIONAL,
   CompileTimeErrorCode.MISSING_DEFAULT_VALUE_FOR_PARAMETER_WITH_ANNOTATION,
+  CompileTimeErrorCode.MISSING_EXTRACTOR_PATTERN_GETTER_NAME,
   CompileTimeErrorCode.MISSING_REQUIRED_ARGUMENT,
   CompileTimeErrorCode.MISSING_VARIABLE_PATTERN,
   CompileTimeErrorCode.MIXIN_APPLICATION_CONCRETE_SUPER_INVOKED_MEMBER_TYPE,

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -85,7 +85,7 @@ import 'package:analyzer/src/util/performance/operation_performance.dart';
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 242;
+  static const int DATA_VERSION = 243;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/dart/resolver/extractor_pattern_resolver.dart

@@ -13,6 +13,7 @@ import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/element/generic_inferrer.dart';
 import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_schema.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 class ExtractorPatternResolver {
@@ -35,20 +36,7 @@ class ExtractorPatternResolver {
     );
 
     for (var field in node.fields) {
-      // TODO(scheglov) Report an error.
-      var nameToken =
-          field.fieldName?.name ?? field.pattern.variablePattern!.name;
-      var result = resolverVisitor.typePropertyResolver.resolve(
-        receiver: null,
-        receiverType: inferredType,
-        name: nameToken.lexeme,
-        propertyErrorEntity: nameToken,
-        nameErrorEntity: node,
-      );
-      // TODO(scheglov) Report an error.
-      var getter = result.getter;
-      field.fieldElement = getter;
-      var fieldType = getter?.returnType ?? _typeProvider.dynamicType;
+      var fieldType = _resolveFieldType(inferredType, field);
       field.pattern
           .resolvePattern(resolverVisitor, fieldType, typeInfos, context);
     }
@@ -115,4 +103,58 @@ class ExtractorPatternResolver {
       }
     }).toList();
   }
+
+  DartType _resolveFieldType(
+    DartType inferredType,
+    RecordPatternFieldImpl field,
+  ) {
+    var nameToken = field.fieldName?.name;
+    nameToken ??= field.pattern.variablePattern?.name;
+    if (nameToken == null) {
+      resolverVisitor.errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.MISSING_EXTRACTOR_PATTERN_GETTER_NAME,
+        field,
+      );
+      return _typeProvider.dynamicType;
+    }
+
+    var result = resolverVisitor.typePropertyResolver.resolve(
+      receiver: null,
+      receiverType: inferredType,
+      name: nameToken.lexeme,
+      propertyErrorEntity: nameToken,
+      nameErrorEntity: nameToken,
+    );
+
+    if (result.needsGetterError) {
+      resolverVisitor.errorReporter.reportErrorForToken(
+        CompileTimeErrorCode.UNDEFINED_GETTER,
+        nameToken,
+        [nameToken.lexeme, inferredType],
+      );
+    }
+
+    var getter = result.getter;
+    if (getter != null) {
+      field.fieldElement = getter;
+      if (getter is PropertyAccessorElement) {
+        return getter.returnType;
+      } else {
+        // TODO(scheglov) https://github.com/dart-lang/language/issues/2561
+        resolverVisitor.errorReporter.reportErrorForToken(
+          CompileTimeErrorCode.UNDEFINED_GETTER,
+          nameToken,
+          [nameToken.lexeme, inferredType],
+        );
+        return getter.type;
+      }
+    }
+
+    var recordField = result.recordField;
+    if (recordField != null) {
+      return recordField.type;
+    }
+
+    return _typeProvider.dynamicType;
+  }
 }

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

@@ -2723,6 +2723,16 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
     uniqueName: 'MISSING_DEFAULT_VALUE_FOR_PARAMETER_WITH_ANNOTATION',
   );
 
+  static const CompileTimeErrorCode MISSING_EXTRACTOR_PATTERN_GETTER_NAME =
+      CompileTimeErrorCode(
+    'MISSING_EXTRACTOR_PATTERN_GETTER_NAME',
+    "The getter name is not specified explicitly, and the pattern is not a "
+        "variable.",
+    correctionMessage:
+        "Try specifying the getter name explicitly, or using a variable "
+        "pattern.",
+  );
+
   ///  Parameters:
   ///  0: the name of the parameter
   static const CompileTimeErrorCode MISSING_REQUIRED_ARGUMENT =

pkg/analyzer/messages.yaml

@@ -8344,6 +8344,9 @@ CompileTimeErrorCode:
     correctionMessage: "Try removing the '@'."
     hasPublishedDocs: true
     comment: No parameters.
+  MISSING_EXTRACTOR_PATTERN_GETTER_NAME:
+    problemMessage: The getter name is not specified explicitly, and the pattern is not a variable.
+    correctionMessage: Try specifying the getter name explicitly, or using a variable pattern.
   MISSING_REQUIRED_ARGUMENT:
     problemMessage: "The named parameter '{0}' is required, but there's no corresponding argument."
     correctionMessage: Try adding the required argument.

pkg/analyzer/test/src/dart/resolution/extractor_pattern_test.dart

@@ -2,6 +2,7 @@
 // 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/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'context_collection_resolution.dart';
@@ -118,7 +119,7 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_hasName_constant() async {
+  test_notGeneric_hasName_constant() async {
     await assertNoErrorsInCode(r'''
 abstract class A {
   int get foo;
@@ -155,7 +156,7 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_hasName_extensionGetter() async {
+  test_notGeneric_hasName_extensionGetter() async {
     await assertNoErrorsInCode(r'''
 abstract class A {}
 
@@ -194,7 +195,162 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_hasName_variable_untyped() async {
+  test_notGeneric_hasName_extensionGetter_functionType() async {
+    await assertNoErrorsInCode(r'''
+typedef A = void Function();
+
+extension E on A {
+  int get foo => 0;
+}
+
+void f(x) {
+  switch (x) {
+    case A(foo: var y):
+      break;
+  }
+}
+''');
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@typeAlias::A
+      staticType: null
+    type: void Function()
+      alias: self::@typeAlias::A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        name: foo
+        colon: :
+      pattern: VariablePattern
+        keyword: var
+        name: y
+        declaredElement: hasImplicitType y@119
+          type: int
+      fieldElement: self::@extension::E::@getter::foo
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_hasName_method() async {
+    await assertErrorsInCode(r'''
+abstract class A {
+  void foo();
+}
+
+void f(x) {
+  switch (x) {
+    case A(foo: var y):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_GETTER, 74, 3),
+    ]);
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@class::A
+      staticType: null
+    type: A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        name: foo
+        colon: :
+      pattern: VariablePattern
+        keyword: var
+        name: y
+        declaredElement: hasImplicitType y@83
+          type: void Function()
+      fieldElement: self::@class::A::@method::foo
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_hasName_recordField_named() async {
+    await assertNoErrorsInCode(r'''
+typedef A = ({int foo});
+
+void f(x) {
+  switch (x) {
+    case A(foo: var y):
+      break;
+  }
+}
+''');
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@typeAlias::A
+      staticType: null
+    type: ({int foo})
+      alias: self::@typeAlias::A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        name: foo
+        colon: :
+      pattern: VariablePattern
+        keyword: var
+        name: y
+        declaredElement: hasImplicitType y@73
+          type: int
+      fieldElement: <null>
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_hasName_recordField_positional() async {
+    await assertNoErrorsInCode(r'''
+typedef A = (int foo,);
+
+void f(x) {
+  switch (x) {
+    case A($0: var y):
+      break;
+  }
+}
+''');
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@typeAlias::A
+      staticType: null
+    type: (int)
+      alias: self::@typeAlias::A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        name: $0
+        colon: :
+      pattern: VariablePattern
+        keyword: var
+        name: y
+        declaredElement: hasImplicitType y@71
+          type: int
+      fieldElement: <null>
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_hasName_variable_untyped() async {
     await assertNoErrorsInCode(r'''
 abstract class A {
   int get foo;
@@ -232,7 +388,45 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_noName_variable() async {
+  test_notGeneric_noName_constant() async {
+    await assertErrorsInCode(r'''
+abstract class A {
+  int get foo;
+}
+
+void f(x) {
+  switch (x) {
+    case A(: 0):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.MISSING_EXTRACTOR_PATTERN_GETTER_NAME, 75, 3),
+    ]);
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@class::A
+      staticType: null
+    type: A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        colon: :
+      pattern: ConstantPattern
+        expression: IntegerLiteral
+          literal: 0
+          staticType: int
+      fieldElement: <null>
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_noName_variable() async {
     await assertNoErrorsInCode(r'''
 abstract class A {
   int get foo;
@@ -269,7 +463,7 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_noName_variable_nullCheck() async {
+  test_notGeneric_noName_variable_nullCheck() async {
     await assertNoErrorsInCode(r'''
 abstract class A {
   int? get foo;
@@ -308,7 +502,7 @@ ExtractorPattern
 ''');
   }
 
-  test_notGeneric_noTypeArguments_noName_variable_parenthesis() async {
+  test_notGeneric_noName_variable_parenthesis() async {
     await assertNoErrorsInCode(r'''
 abstract class A {
   int get foo;
@@ -345,6 +539,80 @@ ExtractorPattern
         rightParenthesis: )
       fieldElement: self::@class::A::@getter::foo
   rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_unresolved_hasName() async {
+    await assertErrorsInCode(r'''
+abstract class A {}
+
+void f(x) {
+  switch (x) {
+    case A(foo: 0):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_GETTER, 59, 3),
+    ]);
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@class::A
+      staticType: null
+    type: A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        name: foo
+        colon: :
+      pattern: ConstantPattern
+        expression: IntegerLiteral
+          literal: 0
+          staticType: int
+      fieldElement: <null>
+  rightParenthesis: )
+''');
+  }
+
+  test_notGeneric_unresolved_noName() async {
+    await assertErrorsInCode(r'''
+abstract class A {}
+
+void f(x) {
+  switch (x) {
+    case A(: var foo):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_GETTER, 65, 3),
+    ]);
+    final node = findNode.switchPatternCase('case').pattern;
+    assertResolvedNodeText(node, r'''
+ExtractorPattern
+  type: NamedType
+    name: SimpleIdentifier
+      token: A
+      staticElement: self::@class::A
+      staticType: null
+    type: A
+  leftParenthesis: (
+  fields
+    RecordPatternField
+      fieldName: RecordPatternFieldName
+        colon: :
+      pattern: VariablePattern
+        keyword: var
+        name: foo
+        declaredElement: hasImplicitType foo@65
+          type: dynamic
+      fieldElement: <null>
+  rightParenthesis: )
 ''');
   }
 }

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

@@ -14,7 +14,7 @@ main() {
 }
 
 @reflectiveTest
-class WrongNumberOfTypeArgumentsTest extends PubPackageResolutionTest {
+class WrongNumberOfTypeArgumentsTest extends PatternsResolutionTest {
   test_class_tooFew() async {
     await assertErrorsInCode(r'''
 class A<E, F> {}
@@ -93,6 +93,40 @@ dynamic<int> v;
     ]);
   }
 
+  test_extractorPattern_tooFew() async {
+    await assertErrorsInCode(r'''
+abstract class A<T, U> {
+  int get foo;
+}
+
+void f(x) {
+  switch (x) {
+    case A<int>(foo: 0):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 79, 6),
+    ]);
+  }
+
+  test_extractorPattern_tooMany() async {
+    await assertErrorsInCode(r'''
+abstract class A {
+  int get foo;
+}
+
+void f(x) {
+  switch (x) {
+    case A<int>(foo: 0):
+      break;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 73, 6),
+    ]);
+  }
+
   test_functionReference_tooFew() async {
     await assertErrorsInCode('''
 f() {