diff --git a/pkg/analyzer/lib/src/dart/element/extensions.dart b/pkg/analyzer/lib/src/dart/element/extensions.dart
index 725ef73..4ab7e2a3 100644
--- a/pkg/analyzer/lib/src/dart/element/extensions.dart
+++ b/pkg/analyzer/lib/src/dart/element/extensions.dart
@@ -104,6 +104,12 @@
   bool get isEnumConstructor {
     return this is ConstructorElement && enclosingElement2 is EnumElementImpl;
   }
+
+  /// Whether the enclosing element is the class `Object`.
+  bool get isObjectMember {
+    final enclosing = enclosingElement2;
+    return enclosing is ClassElement && enclosing.isDartCoreObject;
+  }
 }
 
 extension ExecutableElementExtensionQuestion on ExecutableElement? {
diff --git a/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart b/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart
index b4d417a..be92357 100644
--- a/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart
+++ b/pkg/analyzer/lib/src/dart/element/inheritance_manager3.dart
@@ -17,9 +17,9 @@
   final List<ExecutableElement> candidates;
 
   CandidatesConflict({
-    required Name name,
+    required super.name,
     required this.candidates,
-  }) : super(name);
+  });
 }
 
 /// Failure to find a valid signature from superinterfaces.
@@ -27,7 +27,9 @@
   /// The name for which we failed to find a valid signature.
   final Name name;
 
-  Conflict(this.name);
+  Conflict({
+    required this.name,
+  });
 }
 
 /// Failure because of a getter and a method from direct superinterfaces.
@@ -36,10 +38,10 @@
   final ExecutableElement method;
 
   GetterMethodConflict({
-    required Name name,
+    required super.name,
     required this.getter,
     required this.method,
-  }) : super(name);
+  });
 }
 
 /// Manages knowledge about interface types and their members.
@@ -160,7 +162,7 @@
   Map<Name, ExecutableElement> getInheritedConcreteMap2(
       InterfaceElement element) {
     var interface = getInterface(element);
-    return interface._superImplemented.last;
+    return interface.superImplemented.last;
   }
 
   /// Return the mapping from names to most specific signatures of members
@@ -189,13 +191,13 @@
   /// corresponding name will not be included.
   Map<Name, ExecutableElement> getInheritedMap2(InterfaceElement element) {
     var interface = getInterface(element);
-    var inheritedMap = interface._inheritedMap;
+    var inheritedMap = interface.inheritedMap;
     if (inheritedMap == null) {
-      inheritedMap = interface._inheritedMap = {};
+      inheritedMap = interface.inheritedMap = {};
       _findMostSpecificFromNamedCandidates(
         element,
         inheritedMap,
-        interface._overridden,
+        interface.overridden,
         doTopMerge: false,
       );
     }
@@ -216,7 +218,9 @@
     }
 
     try {
-      if (element is MixinElement) {
+      if (element is ExtensionTypeElement) {
+        result = _getInterfaceExtensionType(element);
+      } else if (element is MixinElement) {
         result = _getInterfaceMixin(element);
       } else {
         result = _getInterfaceClass(element);
@@ -272,7 +276,10 @@
   }) {
     var interface = getInterface(element);
     if (forSuper) {
-      var superImplemented = interface._superImplemented;
+      if (element is ExtensionTypeElement) {
+        return null;
+      }
+      var superImplemented = interface.superImplemented;
       if (forMixinIndex >= 0) {
         return superImplemented[forMixinIndex][name];
       }
@@ -302,7 +309,7 @@
   /// if no members would be overridden.
   List<ExecutableElement>? getOverridden2(InterfaceElement element, Name name) {
     var interface = getInterface(element);
-    return interface._overridden[name];
+    return interface.overridden[name];
   }
 
   /// Remove interfaces for classes defined in specified libraries.
@@ -608,12 +615,12 @@
     var noSuchMethodForwarders = <Name>{};
     if (element is ClassElement && element.isAbstract) {
       if (superTypeInterface != null) {
-        noSuchMethodForwarders = superTypeInterface._noSuchMethodForwarders;
+        noSuchMethodForwarders = superTypeInterface.noSuchMethodForwarders;
       }
     } else {
       var noSuchMethod = implemented[_noSuchMethodName];
       if (noSuchMethod != null && !_isDeclaredInObject(noSuchMethod)) {
-        var superForwarders = superTypeInterface?._noSuchMethodForwarders;
+        var superForwarders = superTypeInterface?.noSuchMethodForwarders;
         for (var entry in interface.entries) {
           var name = entry.key;
           if (!implemented.containsKey(name) ||
@@ -649,6 +656,126 @@
     );
   }
 
+  /// See https://github.com/dart-lang/language
+  ///   blob/main/accepted/future-releases/extension-types/feature-specification.md
+  ///   #static-analysis-of-an-extension-type-member-invocation
+  ///
+  /// We handle "has an extension type member" and "has a non-extension type
+  /// member" portions, considering redeclaration and conflicts.
+  Interface _getInterfaceExtensionType(ExtensionTypeElement element) {
+    final augmented = element.augmentedOfDeclaration;
+
+    // Add instance members implemented by the element itself.
+    final declared = <Name, ExecutableElement>{};
+    _addImplemented(declared, element, augmented);
+
+    // These declared members take precedence over "inherited" ones.
+    final implemented = Map.of(declared);
+
+    // Prepare candidates for inheritance.
+    final extensionCandidates = <Name, List<ExecutableElement>>{};
+    final notExtensionCandidates = <Name, List<ExecutableElement>>{};
+    for (final interface in augmented.interfaces) {
+      for (final entry in getInterface(interface.element).map.entries) {
+        final name = entry.key;
+        if (interface.element is ExtensionTypeElement) {
+          (extensionCandidates[name] ??= []).add(entry.value);
+        } else {
+          (notExtensionCandidates[name] ??= []).add(entry.value);
+        }
+      }
+    }
+
+    final overridden = <Name, List<ExecutableElement>>{};
+    final conflicts = <Conflict>[];
+
+    // Add extension type members.
+    for (final entry in extensionCandidates.entries) {
+      final name = entry.key;
+      final candidates = entry.value;
+      overridden[name] = candidates;
+
+      // Stop if redeclared.
+      if (implemented.containsKey(name)) {
+        continue;
+      }
+
+      // The inherited member must be unique.
+      ExecutableElement? uniqueElement;
+      for (final candidate in candidates) {
+        if (uniqueElement == null) {
+          uniqueElement = candidate;
+        } else if (uniqueElement.declaration != candidate.declaration) {
+          uniqueElement = null;
+          break;
+        }
+      }
+
+      if (uniqueElement != null) {
+        implemented[name] = uniqueElement;
+      } else {
+        conflicts.add(
+          NotUniqueExtensionMemberConflict(
+            name: name,
+            candidates: candidates,
+          ),
+        );
+      }
+    }
+
+    // Add non-extension type members.
+    for (final entry in notExtensionCandidates.entries) {
+      final name = entry.key;
+      final candidates = entry.value;
+      (overridden[name] ??= []).addAll(candidates);
+
+      // Stop if redeclared.
+      if (implemented.containsKey(name)) {
+        continue;
+      }
+
+      final combinedSignature = combineSignatures(
+        targetClass: element,
+        candidates: candidates,
+        doTopMerge: true,
+        name: name,
+      );
+
+      if (combinedSignature != null) {
+        implemented[name] = combinedSignature;
+      } else {
+        conflicts.add(
+          CandidatesConflict(
+            name: name,
+            candidates: candidates,
+          ),
+        );
+      }
+    }
+
+    // Ensure unique overridden elements.
+    final overridden2 = <Name, List<ExecutableElement>>{};
+    for (final entry in overridden.entries) {
+      final name = entry.key;
+      final elements = entry.value;
+      if (elements.length == 1) {
+        overridden2[name] = elements;
+      } else {
+        overridden2[name] = elements.toSet().toFixedList();
+      }
+    }
+
+    return Interface._(
+      implemented,
+      declared,
+      implemented,
+      const {},
+      overridden2,
+      const [],
+      conflicts.toFixedList(),
+    );
+  }
+
   Interface _getInterfaceMixin(MixinElement element) {
     final augmented = element.augmentedOfDeclaration;
     var classLibrary = element.library;
@@ -941,17 +1068,17 @@
   final Map<Name, ExecutableElement> implemented;
 
   /// The set of names that are `noSuchMethod` forwarders in [implemented].
-  final Set<Name> _noSuchMethodForwarders;
+  final Set<Name> noSuchMethodForwarders;
 
   /// The map of names to their signatures from the mixins, superclasses,
   /// or interfaces.
-  final Map<Name, List<ExecutableElement>> _overridden;
+  final Map<Name, List<ExecutableElement>> overridden;
 
   /// Each item of this list maps names to their concrete implementations.
   /// The first item of the list is the nominal superclass, next the nominal
   /// superclass plus the first mixin, etc. So, for the class like
   /// `class C extends S with M1, M2`, we get `[S, S&M1, S&M1&M2]`.
-  final List<Map<Name, ExecutableElement>> _superImplemented;
+  final List<Map<Name, ExecutableElement>> superImplemented;
 
   /// The list of conflicts between superinterfaces - the nominal superclass,
   /// mixins, and interfaces.  Does not include conflicts with the declared
@@ -960,21 +1087,21 @@
 
   /// The map of names to the most specific signatures from the mixins,
   /// superclasses, or interfaces.
-  Map<Name, ExecutableElement>? _inheritedMap;
+  Map<Name, ExecutableElement>? inheritedMap;
 
   Interface._(
     this.map,
     this.declared,
     this.implemented,
-    this._noSuchMethodForwarders,
-    this._overridden,
-    this._superImplemented,
+    this.noSuchMethodForwarders,
+    this.overridden,
+    this.superImplemented,
     this.conflicts,
   );
 
   /// Return `true` if the [name] is implemented in the supertype.
   bool isSuperImplemented(Name name) {
-    return _superImplemented.last.containsKey(name);
+    return superImplemented.last.containsKey(name);
   }
 }
 
@@ -1022,6 +1149,16 @@
   String toString() => libraryUri != null ? '$libraryUri::$name' : name;
 }
 
+/// Failure because of not unique extension type member.
+class NotUniqueExtensionMemberConflict extends Conflict {
+  final List<ExecutableElement> candidates;
+
+  NotUniqueExtensionMemberConflict({
+    required super.name,
+    required this.candidates,
+  });
+}
+
 class _ParameterDesc {
   final int? index;
   final String? name;
diff --git a/pkg/analyzer/lib/src/fasta/ast_builder.dart b/pkg/analyzer/lib/src/fasta/ast_builder.dart
index 75ad09a..ab09464 100644
--- a/pkg/analyzer/lib/src/fasta/ast_builder.dart
+++ b/pkg/analyzer/lib/src/fasta/ast_builder.dart
@@ -341,6 +341,9 @@
 
   @override
   void beginExtensionTypeDeclaration(Token extensionKeyword, Token name) {
+    assert(optional('extension', extensionKeyword));
+    assert(_classLikeBuilder == null);
+
     final typeParameters = pop() as TypeParameterListImpl?;
     final metadata = pop() as List<AnnotationImpl>?;
     final comment = _findComment(metadata, extensionKeyword);
@@ -1669,6 +1672,8 @@
         implementsClause: implementsClause,
       ),
     );
+
+    _classLikeBuilder = null;
   }
 
   @override
diff --git a/pkg/analyzer/lib/src/summary2/types_builder.dart b/pkg/analyzer/lib/src/summary2/types_builder.dart
index d344889..0f0f555 100644
--- a/pkg/analyzer/lib/src/summary2/types_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/types_builder.dart
@@ -262,17 +262,21 @@
     final element = node.declaredElement!;
     final typeSystem = element.library.typeSystem;
 
-    final interfaces = node.implementsClause?.interfaces
+    final type = node.representation.fieldType.typeOrThrow;
+    element.representation.type = type;
+
+    var interfaces = node.implementsClause?.interfaces
         .map((e) => e.type)
         .whereType<InterfaceType>()
         .where(typeSystem.isValidExtensionTypeSuperinterface)
         .toFixedList();
-    if (interfaces != null) {
-      element.interfaces = interfaces;
+    if (interfaces == null || interfaces.isEmpty) {
+      final superInterface = typeSystem.isNonNullable(type)
+          ? typeSystem.objectNone
+          : typeSystem.objectQuestion;
+      interfaces = [superInterface];
     }
-
-    final type = node.representation.fieldType.typeOrThrow;
-    element.representation.type = type;
+    element.interfaces = interfaces;
 
     final primaryConstructor = element.constructors.first;
     final primaryFormalParameter = primaryConstructor.parameters.first;
diff --git a/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart b/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
index ab961fa..b8d6c7e 100644
--- a/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
+++ b/pkg/analyzer/test/src/dart/element/inheritance_manager3_test.dart
@@ -5,16 +5,24 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/extensions.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
+import 'package:collection/collection.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import '../../../util/element_printer.dart';
+import '../../../util/tree_string_sink.dart';
+import '../../summary/elements_base.dart';
 import '../resolution/context_collection_resolution.dart';
+import '../resolution/node_text_expectations.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(InheritanceManager3Test);
     defineReflectiveTests(InheritanceManager3WithoutNullSafetyTest);
+    defineReflectiveTests(InheritanceManager3Test_ExtensionType);
   });
 }
 
@@ -401,6 +409,585 @@
 }
 
 @reflectiveTest
+class InheritanceManager3Test_ExtensionType extends ElementsBaseTest {
+  final printerConfiguration = _InstancePrinterConfiguration();
+
+  @override
+  bool get keepLinkingLibraries => true;
+
+  void assertInterfaceText(InterfaceElementImpl element, String expected) {
+    final actual = _interfaceText(element);
+    if (actual != expected) {
+      print('-------- Actual --------');
+      print('$actual------------------------');
+      NodeTextExpectationsCollector.add(actual);
+    }
+    expect(actual, expected);
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+    printerConfiguration.withoutIdenticalImplemented = true;
+  }
+
+  test_declareGetter() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  int get foo => 0;
+}
+''');
+
+    final element = library.extensionType('A');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::A::@getter::foo
+  it: self::@extensionType::A::@getter::it
+declared
+  foo: self::@extensionType::A::@getter::foo
+  it: self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_declareMethod() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('A');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::A::@method::foo
+  it: self::@extensionType::A::@getter::it
+declared
+  foo: self::@extensionType::A::@method::foo
+  it: self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_declareMethod_implementClass_method2_wouldConflict() async {
+    final library = await buildLibrary(r'''
+class A {
+  int foo() => 0;
+}
+
+class B {
+  String foo() => '0';
+}
+
+extension type C(Object it) implements A, B {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+    self::@class::B::@method::foo
+''');
+  }
+
+  test_declareMethod_implementClass_noOverride() async {
+    final library = await buildLibrary(r'''
+class A {}
+
+class B extends A {
+  void foo() {}
+}
+
+extension type C(B it) implements A {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+''');
+  }
+
+  test_declareMethod_implementClass_override() async {
+    final library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+
+class B extends A {
+  void bar() {}
+}
+
+extension type C(B it) implements A {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+''');
+  }
+
+  test_declareMethod_implementClass_override_getter() async {
+    final library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+
+class B extends A {
+  void bar() {}
+}
+
+extension type C(B it) implements A {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  foo: self::@extensionType::C::@method::foo
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@getter::foo
+''');
+  }
+
+  test_declareMethod_implementExtensionType_method2_wouldConflict() async {
+    final library = await buildLibrary(r'''
+extension type A1(int it) {
+  void foo() {}
+}
+
+extension type A2(int it) {
+  void foo() {}
+}
+
+extension type B(int it) implements A1, A2 {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('B');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+declared
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+overridden
+  foo
+    self::@extensionType::A1::@method::foo
+    self::@extensionType::A2::@method::foo
+  it
+    self::@extensionType::A1::@getter::it
+    self::@extensionType::A2::@getter::it
+''');
+  }
+
+  test_declareMethod_implementExtensionType_override() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  void foo() {}
+}
+
+extension type B(int it) implements A {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('B');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+declared
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+overridden
+  foo
+    self::@extensionType::A::@method::foo
+  it
+    self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_declareMethod_implementExtensionType_override_getter() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  int get foo => 0;
+}
+
+extension type B(int it) implements A {
+  void foo() {}
+}
+''');
+
+    final element = library.extensionType('B');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+declared
+  foo: self::@extensionType::B::@method::foo
+  it: self::@extensionType::B::@getter::it
+overridden
+  foo
+    self::@extensionType::A::@getter::foo
+  it
+    self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_declareMethod_static() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  static void foo() {}
+}
+''');
+
+    final element = library.extensionType('A');
+    assertInterfaceText(element, r'''
+map
+  it: self::@extensionType::A::@getter::it
+declared
+  it: self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_noDeclaration_implementClass_implementExtensionType() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  void foo() {}
+}
+
+class B {
+  void foo() {}
+}
+
+class C extends B {}
+
+extension type D(C it) implements B, A {}
+''');
+
+    final element = library.extensionType('D');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::A::@method::foo
+  it: self::@extensionType::D::@getter::it
+declared
+  it: self::@extensionType::D::@getter::it
+overridden
+  foo
+    self::@extensionType::A::@method::foo
+    self::@class::B::@method::foo
+  it
+    self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_noDeclaration_implementClass_method() async {
+    final library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+
+class B extends A {}
+
+extension type C(B it) implements A {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@class::A::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+''');
+  }
+
+  test_noDeclaration_implementClass_method2_hasConflict() async {
+    final library = await buildLibrary(r'''
+class A {
+  int foo() => 0;
+}
+
+class B {
+  String foo() => '0';
+}
+
+extension type C(Object it) implements A, B {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+    self::@class::B::@method::foo
+conflicts
+  CandidatesConflict
+    self::@class::A::@method::foo
+    self::@class::B::@method::foo
+''');
+  }
+
+  test_noDeclaration_implementClass_method2_noConflict() async {
+    final library = await buildLibrary(r'''
+class A {
+  int foo() => 0;
+}
+
+class B {
+  num foo() => 0;
+}
+
+extension type C(Object it) implements A, B {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@class::A::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+    self::@class::B::@method::foo
+''');
+  }
+
+  test_noDeclaration_implementClass_method2_noConflict2() async {
+    final library = await buildLibrary(r'''
+class A {
+  int foo() => 0;
+}
+
+class B1 extends A {}
+
+class B2 extends A {}
+
+extension type C(Object it) implements B1, B2 {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@class::A::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@class::A::@method::foo
+''');
+  }
+
+  test_noDeclaration_implementClass_setter() async {
+    final library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+
+class B extends A {}
+
+extension type C(B it) implements A {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo=: self::@class::A::@setter::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo=
+    self::@class::A::@setter::foo
+''');
+  }
+
+  test_noDeclaration_implementExtensionType_method() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  void foo() {}
+}
+
+extension type B(int it) implements A {}
+''');
+
+    final element = library.extensionType('B');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::A::@method::foo
+  it: self::@extensionType::B::@getter::it
+declared
+  it: self::@extensionType::B::@getter::it
+overridden
+  foo
+    self::@extensionType::A::@method::foo
+  it
+    self::@extensionType::A::@getter::it
+''');
+  }
+
+  test_noDeclaration_implementExtensionType_method2_hasConflict() async {
+    final library = await buildLibrary(r'''
+extension type A1(int it) {
+  void foo() {}
+}
+
+extension type A2(int it) {
+  void foo() {}
+}
+
+extension type B(int it) implements A1, A2 {}
+''');
+
+    final element = library.extensionType('B');
+    assertInterfaceText(element, r'''
+map
+  it: self::@extensionType::B::@getter::it
+declared
+  it: self::@extensionType::B::@getter::it
+overridden
+  foo
+    self::@extensionType::A1::@method::foo
+    self::@extensionType::A2::@method::foo
+  it
+    self::@extensionType::A1::@getter::it
+    self::@extensionType::A2::@getter::it
+conflicts
+  NotUniqueExtensionMemberConflict
+    self::@extensionType::A1::@method::foo
+    self::@extensionType::A2::@method::foo
+''');
+  }
+
+  test_noDeclaration_implementExtensionType_method2_noConflict() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {
+  void foo() {}
+}
+
+extension type B1(int it) implements A {}
+
+extension type B2(int it) implements A {}
+
+extension type C(int it) implements B1, B2 {}
+''');
+
+    final element = library.extensionType('C');
+    assertInterfaceText(element, r'''
+map
+  foo: self::@extensionType::A::@method::foo
+  it: self::@extensionType::C::@getter::it
+declared
+  it: self::@extensionType::C::@getter::it
+overridden
+  foo
+    self::@extensionType::A::@method::foo
+  it
+    self::@extensionType::B1::@getter::it
+    self::@extensionType::B2::@getter::it
+''');
+  }
+
+  test_withObjectMembers() async {
+    final library = await buildLibrary(r'''
+extension type A(int it) {}
+''');
+
+    final element = library.extensionType('A');
+    printerConfiguration.withObjectMembers = true;
+    assertInterfaceText(element, r'''
+map
+  ==: dart:core::@class::Object::@method::==
+  hashCode: dart:core::@class::Object::@getter::hashCode
+  it: self::@extensionType::A::@getter::it
+  noSuchMethod: dart:core::@class::Object::@method::noSuchMethod
+  runtimeType: dart:core::@class::Object::@getter::runtimeType
+  toString: dart:core::@class::Object::@method::toString
+declared
+  it: self::@extensionType::A::@getter::it
+overridden
+  ==
+    dart:core::@class::Object::@method::==
+  hashCode
+    dart:core::@class::Object::@getter::hashCode
+  noSuchMethod
+    dart:core::@class::Object::@method::noSuchMethod
+  runtimeType
+    dart:core::@class::Object::@getter::runtimeType
+  toString
+    dart:core::@class::Object::@method::toString
+''');
+  }
+
+  String _interfaceText(InterfaceElementImpl element) {
+    final library = element.library;
+    final inheritance = library.session.inheritanceManager;
+    final interface = inheritance.getInterface(element);
+
+    final buffer = StringBuffer();
+    final sink = TreeStringSink(
+      sink: buffer,
+      indent: '',
+    );
+    final elementPrinter = ElementPrinter(
+      sink: sink,
+      configuration: ElementPrinterConfiguration(),
+      selfUriStr: '${library.source.uri}',
+    );
+
+    _InterfacePrinter(
+      sink: sink,
+      elementPrinter: elementPrinter,
+      configuration: printerConfiguration,
+    ).write(interface);
+
+    return buffer.toString();
+  }
+}
+
+@reflectiveTest
 class InheritanceManager3WithoutNullSafetyTest
     extends _InheritanceManager3Base {
   test_getInherited_closestSuper() async {
@@ -1626,3 +2213,140 @@
     expect(actual, expected);
   }
 }
+
+class _InstancePrinterConfiguration {
+  bool withObjectMembers = false;
+  bool withoutIdenticalImplemented = false;
+}
+
+class _InterfacePrinter {
+  final TreeStringSink _sink;
+  final ElementPrinter _elementPrinter;
+  final _InstancePrinterConfiguration _configuration;
+
+  _InterfacePrinter({
+    required TreeStringSink sink,
+    required ElementPrinter elementPrinter,
+    required _InstancePrinterConfiguration configuration,
+  })  : _sink = sink,
+        _elementPrinter = elementPrinter,
+        _configuration = configuration;
+
+  void write(Interface interface) {
+    _writeNameToMap('map', interface.map);
+    _writeNameToMap('declared', interface.declared);
+
+    if (_configuration.withoutIdenticalImplemented) {
+      expect(interface.implemented, same(interface.map));
+    } else {
+      _writeNameToMap('implemented', interface.implemented);
+    }
+
+    _writeNameToListMap('overridden', interface.overridden);
+    _writeListOfMaps('superImplemented', interface.superImplemented);
+    _writeNameToMap('inheritedMap', interface.inheritedMap ?? {});
+    _writeConflicts(interface.conflicts);
+  }
+
+  String _nameObjStr(Name nameObj) {
+    return nameObj.name;
+  }
+
+  bool _shouldWrite(ExecutableElement element) {
+    return _configuration.withObjectMembers || !element.isObjectMember;
+  }
+
+  List<MapEntry<Name, T>> _sortedEntries<T>(
+    Iterable<MapEntry<Name, T>> entries,
+  ) {
+    return entries.sortedBy(
+      (e) => '${e.key.name} ${e.key.libraryUri}',
+    );
+  }
+
+  List<ExecutableElement> _withoutObject(List<ExecutableElement> elements) {
+    return elements.where(_shouldWrite).toList();
+  }
+
+  void _writeConflicts(List<Conflict> conflicts) {
+    if (conflicts.isEmpty) return;
+
+    _sink.writelnWithIndent('conflicts');
+    _sink.withIndent(() {
+      for (final conflict in conflicts) {
+        switch (conflict) {
+          case CandidatesConflict _:
+            _elementPrinter.writeElementList(
+              'CandidatesConflict',
+              conflict.candidates,
+            );
+          case NotUniqueExtensionMemberConflict _:
+            _elementPrinter.writeElementList(
+              'NotUniqueExtensionMemberConflict',
+              conflict.candidates,
+            );
+          default:
+            fail('Not implemented: ${conflict.runtimeType}');
+        }
+      }
+    });
+  }
+
+  void _writeListOfMaps(
+    String name,
+    List<Map<Name, ExecutableElement>> listOfMaps,
+  ) {
+    if (listOfMaps.isEmpty) return;
+
+    _sink.writelnWithIndent(name);
+    _sink.withIndent(() {
+      listOfMaps.forEachIndexed((index, map) {
+        _writeNameToMap('$index', map);
+      });
+    });
+  }
+
+  void _writeNameToListMap(
+    String name,
+    Map<Name, List<ExecutableElement>> map,
+  ) {
+    final isEmpty = map.values.expand((elements) => elements).where((element) {
+      if (_configuration.withObjectMembers) return true;
+      return !element.isObjectMember;
+    }).isEmpty;
+    if (isEmpty) return;
+
+    _sink.writelnWithIndent(name);
+    _sink.withIndent(() {
+      for (final entry in _sortedEntries(map.entries)) {
+        final name = _nameObjStr(entry.key);
+        final elements = _withoutObject(entry.value);
+        _elementPrinter.writeElementList(name, elements);
+      }
+    });
+  }
+
+  void _writeNameToMap(String name, Map<Name, ExecutableElement> map) {
+    final isEmpty = map.values.none(_shouldWrite);
+    if (isEmpty) return;
+
+    _sink.writelnWithIndent(name);
+    _sink.withIndent(() {
+      for (final entry in _sortedEntries(map.entries)) {
+        final name = _nameObjStr(entry.key);
+        final element = entry.value;
+        if (_shouldWrite(element)) {
+          _elementPrinter.writeNamedElement(name, element);
+        }
+      }
+    });
+  }
+}
+
+extension on LibraryElementImpl {
+  ExtensionTypeElementImpl extensionType(String name) {
+    return topLevelElements
+        .whereType<ExtensionTypeElementImpl>()
+        .singleWhere((e) => e.name == name);
+  }
+}
diff --git a/pkg/analyzer/test/src/summary/elements_test.dart b/pkg/analyzer/test/src/summary/elements_test.dart
index 6d5a699..eb228c6 100644
--- a/pkg/analyzer/test/src/summary/elements_test.dart
+++ b/pkg/analyzer/test/src/summary/elements_test.dart
@@ -46508,6 +46508,8 @@
     extensionTypes
       A @21
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @27
             type: int
@@ -46537,6 +46539,8 @@
         codeOffset: 0
         codeLength: 33
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @27
             codeOffset: 23
@@ -46574,6 +46578,8 @@
         codeOffset: 0
         codeLength: 27
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             codeOffset: 17
@@ -46609,6 +46615,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46641,6 +46649,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46673,6 +46683,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46705,6 +46717,8 @@
     extensionTypes
       A @32
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @43
             metadata
@@ -46742,6 +46756,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46802,6 +46818,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: num
@@ -46844,6 +46862,29 @@
 ''');
   }
 
+  test_interfaces_implicitObjectQuestion() async {
+    var library = await buildLibrary(r'''
+extension type X(int? it) {}
+''');
+
+    configuration.withConstructors = false;
+    checkElementText(library, r'''
+library
+  definingUnit
+    extensionTypes
+      X @15
+        representation: self::@extensionType::X::@field::it
+        interfaces
+          Object?
+        fields
+          final it @22
+            type: int?
+        accessors
+          synthetic get it @-1
+            returnType: int?
+''');
+  }
+
   test_interfaces_void() async {
     var library = await buildLibrary(r'''
 typedef A = void;
@@ -46898,6 +46939,8 @@
               staticType: null
             element: package:test/a.dart::@getter::foo
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @43
             type: int
@@ -46927,6 +46970,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46956,6 +47001,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -46989,6 +47036,8 @@
         codeOffset: 0
         codeLength: 21
         representation: self::@extensionType::A::@field::<empty>
+        interfaces
+          Object?
         fields
           final <empty> @17
             codeOffset: 17
@@ -47024,6 +47073,8 @@
     extensionTypes
       A @15
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @21
             type: int
@@ -47055,6 +47106,8 @@
             bound: num
           covariant U @32
         representation: self::@extensionType::A::@field::it
+        interfaces
+          Object
         fields
           final it @45
             type: Map<T, U>