Support returning Future<ExtensionType>

lib/src/builder.dart

@@ -1866,7 +1866,7 @@ class _MockClassInfo {
           _dummyFakedValue(dartType, invocation),
         ExtensionTypeElement2(:final typeErasure)
             when !typeErasure.containsPrivateName =>
-          _dummyValue(typeErasure, invocation),
+          _dummyValue(typeErasure, invocation).asA(_typeReference(dartType)),
         ExtensionTypeElement2() => _dummyValueFallbackToRuntime(
             dartType,
             invocation,

test/builder/auto_mocks_test.dart

@@ -4180,14 +4180,26 @@ void main() {
 
     test('are supported as return types', () async {
       await expectSingleNonNullableOutput(
-        dedent('''
+          dedent('''
         extension type E(int v) {}
         class Foo {
           E get v;
         }
         '''),
-        decodedMatches(allOf(contains('E get v'), contains('returnValue: 0'))),
-      );
+          decodedMatches(allOf(
+              contains('E get v'), contains('returnValue: (0 as _i2.E)'))));
+    });
+
+    test('are supported as Future return types', () async {
+      await expectSingleNonNullableOutput(
+          dedent('''
+        extension type E(int v) {}
+        class Foo {
+          Future<E> get v;
+        }
+        '''),
+          decodedMatches(allOf(contains('_i3.Future<_i2.E> get v'),
+              contains('returnValue: _i3.Future<_i2.E>.value((0 as _i2.E))'))));
     });
   });
   group('build_extensions support', () {

test/end2end/foo.dart

@@ -74,4 +74,7 @@ class UsesExtTypes {
   Ext extTypeReturn(int _) => Ext(42);
   bool privateExtTypeArg(ExtOfPrivate _) => true;
   ExtOfPrivate privateExtTypeReturn(int _) => ExtOfPrivate(private);
+  Future<Ext> futureExtTypeReturn(int _) => Future.value(Ext(43));
+  Future<ExtOfPrivate> futureExtOfPrivateTypeReturn(int _) =>
+      Future.value(ExtOfPrivate(private));
 }

test/end2end/generated_mocks_test.dart

@@ -365,6 +365,15 @@ void main() {
         expect(usesExtTypes.extTypeReturn(2), equals(Ext(42)));
         expect(usesExtTypes.extTypeReturn(42), equals(Ext(0)));
       });
+
+      test('a method using extension type as a return type can be stubbed',
+          () async {
+        when(usesExtTypes.futureExtTypeReturn(2))
+            .thenAnswer((_) => Future.value(Ext(42)));
+        expect(await usesExtTypes.futureExtTypeReturn(2), equals(Ext(42)));
+        expect(await usesExtTypes.futureExtTypeReturn(42), equals(Ext(0)));
+        expect(await usesExtTypes.futureExtTypeReturn(42), equals(0));
+      });
     });
   });