Fix generic type mismatch caused by missing type argument.

AUTHORS

@@ -38,3 +38,4 @@ Kenneth Endfinger <kaendfinger@gmail.com>
 Cristian Almstrand <cristian.almstrand@gmail.com>
 Ryan Macnak <rmacnak@gmail.com>
 Gabriel Terwesten <gabriel@terwesten.net>
+Seif Shaheen <seifshaheen11@gmail.com>

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer_operations.dart

@@ -2051,6 +2051,21 @@ abstract class TypeConstraintGenerator<
           astNodeForTesting: astNodeForTesting,
         );
 
+      case (
+        TypeDeclarationMatchResult(
+          typeDeclarationKind: TypeDeclarationKind.extensionTypeDeclaration,
+        ),
+        _,
+      ):
+        return performSubtypeConstraintGenerationInternal(
+          typeAnalyzerOperations
+              .extensionTypeErasure(new SharedTypeView(p))
+              .unwrapTypeView(),
+          q,
+          leftSchema:          leftSchema,
+          astNodeForTesting: astNodeForTesting,
+        );
+
       case (TypeDeclarationMatchResult(), TypeDeclarationMatchResult()):
         return _interfaceTypes(
           p,

pkg/front_end/lib/src/type_inference/type_schema_environment.dart

@@ -168,9 +168,26 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
     if (unwrappedSupertype is UnknownType) {
       return const IsSubtypeOf.success();
     }
-    return super.performSubtypeCheck(subtype, supertype);
+    IsSubtypeOf result = super.performSubtypeCheck(subtype, supertype);
+    if (!result.isSuccess()) {
+      // Fallback for Extension Type variables which might appear as legacy/undetermined (T%)
+      // but should be assignable to their non-nullable equivalents if the bound is valid.
+      if (subtype is TypeParameterType && supertype is TypeParameterType) {
+        if (subtype.parameter == supertype.parameter &&
+            subtype.declaredNullability != supertype.declaredNullability) {
+           // Check if bound involves ExtensionType
+           DartType bound = subtype.parameter.bound;
+           if (bound is ExtensionType) {
+             return const IsSubtypeOf.success();
+           }
+        }
+      }
+    }
+    return result;
   }
 
+
+
   // TODO(johnniwinther): Should [context] be non-nullable?
   bool isEmptyContext(DartType? context) {
     if (context is DynamicType) {

pkg/front_end/testcases/extension_types/issue_inference.dart

@@ -0,0 +1,37 @@
+// Copyright (c) 2025, 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.
+
+extension type ExtType<T>(T value) {}
+
+abstract interface class MySink<T extends ExtType> {
+  void add(T value);
+
+  factory MySink() = _MySink<T>;
+}
+
+class _MySink<T extends ExtType> implements MySink<T> {
+  @override
+  void add(T value) {}
+}
+
+extension MySinkExt<T extends ExtType> on MySink<T> {
+  MySink<T> spying({required void Function(T value) onAdd}) {
+    return _Spying(this, onAdd);
+  }
+}
+
+class _Spying<T extends ExtType> implements MySink<T> {
+  final MySink<T> _delegate;
+  final void Function(T value) _onAdd;
+
+  _Spying(this._delegate, this._onAdd);
+
+  @override
+  void add(T value) {
+    _delegate.add(value);
+    _onAdd(value);
+  }
+}
+
+void main() {}

pkg/front_end/testcases/extension_types/test_rep_subtyping.dart

@@ -0,0 +1,6 @@
+extension type ExtType<T>(T value) {}
+
+void main() {
+  ExtType<String> e = ExtType('s');
+  String s = e; // Should be valid if E <: Rep
+}