Issue 62382. Fixes for reporting member conflicts in extension types.

scheglov · Commit Queue · commit 4b6664fea702 · 2026-01-27T07:23:01.000-08:00
Bug: #62382 Change-Id: I7989b4172d135cea06c0d52aca58162ffc03cdcc Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/475540 Reviewed-by: Paul Berry <paulberry@google.com> Reviewed-by: Brian Wilkerson <brianwilkerson@google.com> Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
diff --git a/pkg/analyzer/api.txt b/pkg/analyzer/api.txt
@@ -4007,6 +4007,7 @@ package:analyzer/dart/element/element.dart:
     forSetter (getter: Name)
     hashCode (getter: int)
     isPublic (getter: bool)
+    isSetter (getter: bool)
     libraryUri (getter: Uri?)
     name (getter: String)
     == (method: bool Function(Object))
diff --git a/pkg/analyzer/lib/src/dart/element/extensions.dart b/pkg/analyzer/lib/src/dart/element/extensions.dart
@@ -10,6 +10,7 @@ import 'package:analyzer/source/source.dart';
 import 'package:analyzer/source/source_range.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/diagnostic/diagnostic_message.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:meta/meta_meta.dart';
 
@@ -202,6 +203,24 @@ extension InterfaceTypeExtension on InterfaceType {
   }
 }
 
+extension InternalExecutableElementExtension on InternalExecutableElement {
+  /// Return a diagnostic message pointing at the first fragment.
+  DiagnosticMessageImpl diagnosticMessage({
+    required String message,
+    String? url,
+  }) {
+    var baseElement = nonSynthetic.baseElement as ElementImpl;
+    var location = baseElement.firstFragmentLocation;
+    return DiagnosticMessageImpl(
+      filePath: location.libraryFragment!.source.fullName,
+      message: message,
+      offset: location.nameOffset ?? -1,
+      length: location.name?.length ?? 0,
+      url: url,
+    );
+  }
+}
+
 extension LibraryExtension2 on LibraryElement? {
   bool get hasWildcardVariablesFeatureEnabled =>
       this?.featureSet.isEnabled(Feature.wildcard_variables) ?? false;
diff --git a/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart b/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart
@@ -30,6 +30,33 @@ class Conflict {
   Conflict({required this.name});
 }
 
+/// The extension type inherits a method and a setter with the same name,
+/// and does not preclude them.
+class ExtensionTypeConflictingInheritedMethodAndSetterConflict
+    extends Conflict {
+  final InternalMethodElement method;
+  final InternalSetterElement setter;
+
+  ExtensionTypeConflictingInheritedMethodAndSetterConflict({
+    required super.name,
+    required this.method,
+    required this.setter,
+  });
+}
+
+/// The extension type has a static member that conflicts with an inherited
+/// instance member.
+class ExtensionTypeConflictingStaticAndInstanceConflict extends Conflict {
+  final InternalExecutableElement declared;
+  final InternalExecutableElement inherited;
+
+  ExtensionTypeConflictingStaticAndInstanceConflict({
+    required super.name,
+    required this.declared,
+    required this.inherited,
+  });
+}
+
 /// Failure because of a getter and a method from direct superinterfaces.
 class GetterMethodConflict extends Conflict {
   final InternalExecutableElement getter;
@@ -840,6 +867,87 @@ class InheritanceManager3 {
       implemented[name] = combinedSignature;
     }
 
+    // Check for conflicting static and instance members.
+    for (var member in [
+      ...element.methods,
+      ...element.getters,
+      ...element.setters,
+    ]) {
+      if (!member.isStatic) {
+        continue;
+      }
+
+      var getterName = Name.forElement(member)?.forGetter;
+      if (getterName == null) {
+        continue;
+      }
+
+      if (redeclared[getterName]?.firstOrNull case var inherited?) {
+        conflicts.add(
+          ExtensionTypeConflictingStaticAndInstanceConflict(
+            name: getterName,
+            declared: member,
+            inherited: inherited,
+          ),
+        );
+        continue;
+      }
+
+      var setterName = getterName.forSetter;
+      if (redeclared[setterName]?.firstOrNull case var inherited?) {
+        conflicts.add(
+          ExtensionTypeConflictingStaticAndInstanceConflict(
+            name: setterName,
+            declared: member,
+            inherited: inherited,
+          ),
+        );
+      }
+    }
+
+    // Inherited method and setter with the same name.
+    for (var redeclaredEntry in redeclared.entries) {
+      var methodName = redeclaredEntry.key;
+      if (methodName.isSetter) {
+        continue;
+      }
+
+      // We are looking for a conflict between an inherited method and an
+      // inherited setter. If either is precluded by a declaration in the
+      // extension type, there is no conflict.
+      var setterName = methodName.forSetter;
+      if (precludedNames.contains(methodName) ||
+          precludedMethods.contains(methodName) ||
+          precludedNames.contains(setterName) ||
+          precludedSetters.contains(setterName)) {
+        continue;
+      }
+
+      // Choose any method.
+      var methodCandidates = redeclaredEntry.value
+          .whereType<InternalMethodElement>();
+      var method = methodCandidates.firstOrNull;
+      if (method == null) {
+        continue;
+      }
+
+      // Choose any corresponding setter.
+      var setterCandidates = redeclared[setterName]
+          ?.whereType<InternalSetterElement>();
+      var setter = setterCandidates?.firstOrNull;
+      if (setter == null) {
+        continue;
+      }
+
+      conflicts.add(
+        ExtensionTypeConflictingInheritedMethodAndSetterConflict(
+          name: methodName,
+          method: method,
+          setter: setter,
+        ),
+      );
+    }
+
     var uniqueRedeclared = <Name, List<InternalExecutableElement>>{};
     for (var entry in redeclared.entries) {
       var name = entry.key;
@@ -1357,7 +1465,7 @@ class Name {
   Name._internal(this.libraryUri, this.name, this.isPublic, this.hashCode);
 
   Name get forGetter {
-    if (name.endsWith('=')) {
+    if (isSetter) {
       var getterName = name.substring(0, name.length - 1);
       return Name(libraryUri, getterName);
     } else {
@@ -1366,13 +1474,18 @@ class Name {
   }
 
   Name get forSetter {
-    if (name.endsWith('=')) {
+    if (isSetter) {
       return this;
     } else {
       return Name(libraryUri, '$name=');
     }
   }
 
+  bool get isSetter {
+    return name.endsWith('=') &&
+        !const {'[]=', '==', '<=', '>='}.contains(name);
+  }
+
   @override
   bool operator ==(Object other) {
     return other is Name &&
diff --git a/pkg/analyzer/lib/src/error/redeclare_verifier.dart b/pkg/analyzer/lib/src/error/redeclare_verifier.dart
@@ -2,9 +2,10 @@
 // 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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/diagnostic/diagnostic.dart' as diag;
 import 'package:analyzer/src/error/listener.dart';
 
@@ -16,12 +17,14 @@ class RedeclareVerifier extends RecursiveAstVisitor<void> {
   final DiagnosticReporter _errorReporter;
 
   /// The current extension type.
-  InterfaceElement? _currentExtensionType;
+  ExtensionTypeElementImpl? _currentExtensionType;
 
   RedeclareVerifier(this._errorReporter);
 
   @override
-  void visitExtensionTypeDeclaration(ExtensionTypeDeclaration node) {
+  void visitExtensionTypeDeclaration(
+    covariant ExtensionTypeDeclarationImpl node,
+  ) {
     _currentExtensionType = node.declaredFragment!.element;
     super.visitExtensionTypeDeclaration(node);
     _currentExtensionType = null;
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -2354,6 +2354,70 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     }
 
     Uri libraryUri = _currentLibrary.uri;
+
+    if (enclosingClass is ExtensionTypeElementImpl) {
+      var conflicts = _inheritanceManager
+          .getInterface(enclosingClass)
+          .conflicts;
+      for (var conflict in conflicts) {
+        switch (conflict) {
+          case ExtensionTypeConflictingStaticAndInstanceConflict():
+            var declared = conflict.declared;
+            if (declared.firstFragment.libraryFragment != _currentUnit) {
+              continue;
+            }
+            diagnosticReporter.report(
+              diag.conflictingStaticAndInstance
+                  .withArguments(
+                    className: enclosingClass.displayName,
+                    memberName: declared.displayName,
+                    conflictingClassName:
+                        conflict.inherited.enclosingElement!.displayName,
+                  )
+                  .atSourceRange(declared.diagnosticRange(_currentUnit.source)),
+            );
+          case ExtensionTypeConflictingInheritedMethodAndSetterConflict():
+            if (fragment.isAugmentation) {
+              continue;
+            }
+            var method = conflict.method;
+            var setter = conflict.setter;
+            diagnosticReporter.report(
+              diag.conflictingInheritedMethodAndSetter
+                  .withArguments(
+                    enclosingElementKind: enclosingClass.kind.displayName,
+                    enclosingElementName: enclosingClass.displayName,
+                    memberName: conflict.name.name,
+                  )
+                  .withContextMessages([
+                    method.diagnosticMessage(
+                      message: formatList(
+                        "The method is inherited from the {0} '{1}'.",
+                        [
+                          method.enclosingElement!.kind.displayName,
+                          method.enclosingElement!.name,
+                        ],
+                      ),
+                    ),
+                    setter.diagnosticMessage(
+                      message: formatList(
+                        "The setter is inherited from the {0} '{1}'.",
+                        [
+                          setter.enclosingElement.kind.displayName,
+                          setter.enclosingElement.name,
+                        ],
+                      ),
+                    ),
+                  ])
+                  .atSourceRange(
+                    enclosingClass.diagnosticRange(_currentUnit.source),
+                  ),
+            );
+        }
+      }
+      return;
+    }
+
     var conflictingDeclaredNames = <String>{};
 
     // method declared in the enclosing class vs. inherited getter/setter
@@ -2400,11 +2464,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
         }
       }
 
-      // Extension type methods preclude accessors.
-      if (enclosingClass is ExtensionTypeElementImpl) {
-        continue;
-      }
-
       void reportFieldConflict(InternalPropertyAccessorElement inherited) {
         diagnosticReporter.report(
           diag.conflictingMethodAndField
@@ -2458,10 +2517,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
         );
         conflictingDeclaredNames.add(name);
       } else if (inherited is InternalMethodElement) {
-        // Extension type accessors preclude inherited accessors/methods.
-        if (enclosingClass is ExtensionTypeElementImpl) {
-          continue;
-        }
         diagnosticReporter.report(
           diag.conflictingFieldAndMethod
               .withArguments(
@@ -2488,7 +2543,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
         }
         var setterName = methodName.forSetter;
         var setter = inherited[setterName];
-        if (setter is InternalPropertyAccessorElement) {
+        if (setter is InternalSetterElement) {
           diagnosticReporter.report(
             diag.conflictingInheritedMethodAndSetter
                 .withArguments(
@@ -2497,33 +2552,23 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
                   memberName: methodName.name,
                 )
                 .withContextMessages([
-                  DiagnosticMessageImpl(
-                    filePath:
-                        method.firstFragment.libraryFragment.source.fullName,
+                  method.diagnosticMessage(
                     message: formatList(
                       "The method is inherited from the {0} '{1}'.",
                       [
                         method.enclosingElement!.kind.displayName,
                         method.enclosingElement!.name,
                       ],
                     ),
-                    offset: method.firstFragment.nameOffset!,
-                    length: method.firstFragment.name!.length,
-                    url: null,
                   ),
-                  DiagnosticMessageImpl(
-                    filePath:
-                        setter.firstFragment.libraryFragment.source.fullName,
+                  setter.diagnosticMessage(
                     message: formatList(
                       "The setter is inherited from the {0} '{1}'.",
                       [
                         setter.enclosingElement.kind.displayName,
                         setter.enclosingElement.name,
                       ],
                     ),
-                    offset: setter.firstFragment.nameOffset!,
-                    length: setter.firstFragment.name!.length,
-                    url: null,
                   ),
                 ])
                 .atSourceRange(
diff --git a/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart b/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
@@ -13,6 +13,7 @@ import 'package:collection/collection.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import '../../../util/diff.dart';
 import '../../../util/element_printer.dart';
 import '../../summary/elements_base.dart';
 import '../resolution/context_collection_resolution.dart';
@@ -3104,9 +3105,9 @@ class _InheritanceManager3Base2 extends ElementsBaseTest {
   void assertInterfaceText(InterfaceElementImpl element, String expected) {
     var actual = _interfaceText(element);
     if (actual != expected) {
-      print('-------- Actual --------');
-      print('$actual------------------------');
       NodeTextExpectationsCollector.add(actual);
+      printPrettyDiff(expected, actual);
+      fail('See the difference above.');
     }
     expect(actual, expected);
   }
diff --git a/pkg/analyzer/test/src/diagnostics/conflicting_inherited_method_and_setter_test.dart b/pkg/analyzer/test/src/diagnostics/conflicting_inherited_method_and_setter_test.dart
