Create the function to check the 'this' arg in extension methods; Add the new test case

Author: evgTSV

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -67,6 +67,7 @@ let inline noTailCall ceenv = { ceenv with tailCall = false }
 
 let inline TryFindIntrinsicOrExtensionMethInfo collectionSettings (cenv: cenv) (env: TcEnv) m ad nm ty =
     AllMethInfosOfTypeInScope collectionSettings cenv.infoReader env.NameEnv (Some nm) ad IgnoreOverrides m ty
+    |> List.filter (IsExtensionMethCompatibleWithTy cenv.g cenv.amap m ty)
 
 /// Ignores an attribute
 let inline IgnoreAttribute _ = None
@@ -998,18 +999,7 @@ let inline addVarsToVarSpace (varSpace: LazyWithContext<Val list * TcEnv, range>
     )
 
 let tryFindBuilderMethod (ceenv: ComputationExpressionContext<_>) (m: range) (methodName: string) =
-    let g = ceenv.cenv.g
-    let amap = ceenv.cenv.amap
     TryFindIntrinsicOrExtensionMethInfo ResultCollectionSettings.AtMostOneResult ceenv.cenv ceenv.env m ceenv.ad methodName ceenv.builderTy
-    |> List.filter (fun minfo ->
-            match minfo.GetObjArgTypes(amap, m, []) with
-            | thisTy :: _ ->
-                let ty1 = thisTy |> stripTyEqns g 
-                let ty2 = ceenv.builderTy |> stripTyEqns g
-
-                TypeRelations.TypeFeasiblySubsumesType 0 g amap m ty1 TypeRelations.CanCoerce ty2
-            | _ ->
-                false)
 
 let hasBuilderMethod ceenv m methodName =
     tryFindBuilderMethod ceenv m methodName |> isNil |> not

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -3121,6 +3121,7 @@ let BuildPossiblyConditionalMethodCall (cenv: cenv) env isMutable m isProp minfo
 
 let TryFindIntrinsicOrExtensionMethInfo collectionSettings (cenv: cenv) (env: TcEnv) m ad nm ty =
     AllMethInfosOfTypeInScope collectionSettings cenv.infoReader env.NameEnv (Some nm) ad IgnoreOverrides m ty
+    |> List.filter (IsExtensionMethCompatibleWithTy cenv.g cenv.amap m ty)
 
 let TryFindFSharpSignatureInstanceGetterProperty (cenv: cenv) (env: TcEnv) m nm ty (sigTys: TType list) =
     let g = cenv.g

src/Compiler/Checking/NameResolution.fs

@@ -762,6 +762,26 @@ let AllMethInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad fi
     else
         intrinsic @ ExtensionMethInfosOfTypeInScope collectionSettings infoReader nenv ad optFilter LookupIsInstance.Ambivalent m ty
 
+let IsExtensionMethCompatibleWithTy g amap m (ty: TType) (minfo: MethInfo) =
+    not minfo.IsExtensionMember ||
+    match minfo.GetObjArgTypes(amap, m, []) with
+    | thisTy :: _ ->
+        let ty1 = thisTy |> stripTyEqns g
+        let ty2 = ty |> stripTyEqns g
+
+        match ty1, ty2 with
+        | TType_var (tp1, _), _ ->
+            tp1.Constraints |> List.exists (function
+                | TyparConstraint.CoercesTo(targetCTy, _) ->
+                    let cTy = targetCTy |> stripTyEqns g
+                    TypeRelations.TypeFeasiblySubsumesType 0 g amap m cTy TypeRelations.CanCoerce ty2
+                | _ -> false)
+        | _, TType_var _ -> true
+        | _ ->
+            TypeRelations.TypeFeasiblySubsumesType 0 g amap m ty1 TypeRelations.CanCoerce ty2
+    | _ -> 
+        true
+
 //-------------------------------------------------------------------------
 // Helpers to do with building environments
 //-------------------------------------------------------------------------

src/Compiler/Checking/NameResolution.fsi

@@ -689,6 +689,15 @@ val internal AllMethInfosOfTypeInScope:
     ty: TType ->
         MethInfo list
 
+/// Check whether the 'this' argument of an extension method is compatible with the target type
+val internal IsExtensionMethCompatibleWithTy:
+    g: TcGlobals ->
+    amap: ImportMap ->
+    m: range ->
+    ty: TType ->
+    minfo: MethInfo ->
+        bool
+
 /// Used to report an error condition where name resolution failed due to an indeterminate type
 exception internal IndeterminateType of range
 

tests/FSharp.Compiler.ComponentTests/Conformance/Expressions/ComputationExpressions/CEExtensionMethodCapture.fs

@@ -53,7 +53,7 @@ let ``CE doesn't capture an extension method with generic type``() =
                 AsyncSeq(x)
 
         [<Extension>]
-        type PrivateExtensions =
+        type PublicExtensions =
             [<Extension>]
             static member inline Run(this: #FooClass) =
                 this
@@ -100,4 +100,37 @@ let ``CE captures a public extension method and procudes an error due to invalid
     """
     |> asExe
     |> compile
-    |> shouldFail
+    |> shouldFail
+
+// Deliberately trigger an error to ensure that a method is captured
+[<Fact>]
+let ``CE captures a public extension method with valid generic constrainted type and procudes an error due to invalid args``() =
+    FSharp """
+        open System.Runtime.CompilerServices
+
+        type AsyncSeq<'T>(i: 'T) = 
+            class
+            let l = [i]
+            member this.Data = l
+            end
+
+        type AsyncSeqBuilder() =
+            member _.Yield(x: 'T) : AsyncSeq<'T> =
+                AsyncSeq(x)
+
+        [<Extension>]
+        type PublicExtensions =
+            [<Extension>]
+            static member inline Run(this: #AsyncSeqBuilder, invalidArg: string) =
+                this
+
+        let asyncSeq = AsyncSeqBuilder()
+
+        let xs : AsyncSeq<int> =
+            asyncSeq {
+                yield 1
+            }
+    """
+    |> asExe
+    |> compile
+    |> shouldFail