Adjust extension method checking to work with generic types with no constrains. Add test. Minor refactoring.

Author: evgTSV

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -67,7 +67,6 @@ 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

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -3121,7 +3121,6 @@ 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

@@ -746,23 +746,18 @@ let ExtensionMethInfosOfTypeInScope (collectionSettings: ResultCollectionSetting
                 | _ -> [])
         extMemsDangling @ extMemsFromHierarchy
     |> List.filter (fun minfo ->
-        let isAccesible = AccessibilityLogic.IsMethInfoAccessible amap m ad minfo
+        let isAccesible = IsMethInfoAccessible amap m ad minfo
 
         isAccesible &&
         match isInstanceFilter with
         | LookupIsInstance.Ambivalent -> true
         | LookupIsInstance.Yes -> minfo.IsInstance
         | LookupIsInstance.No -> not minfo.IsInstance)
 
-/// Get all the available methods of a type (both intrinsic and extension)
-let AllMethInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad findFlag m ty =
-    let intrinsic = IntrinsicMethInfosOfType infoReader optFilter ad AllowMultiIntfInstantiations.Yes findFlag m ty
-    if collectionSettings = ResultCollectionSettings.AtMostOneResult && not (isNil intrinsic) then 
-        intrinsic
-    else
-        intrinsic @ ExtensionMethInfosOfTypeInScope collectionSettings infoReader nenv ad optFilter LookupIsInstance.Ambivalent m ty
+let IsExtensionMethCompatibleWithTy (infoReader: InfoReader) m (ty: TType) (minfo: MethInfo) =
+    let g = infoReader.g
+    let amap = infoReader.amap
 
-let IsExtensionMethCompatibleWithTy g amap m (ty: TType) (minfo: MethInfo) =
     not minfo.IsExtensionMember ||
     match minfo.GetObjArgTypes(amap, m, []) with
     | thisTy :: _ ->
@@ -771,17 +766,31 @@ let IsExtensionMethCompatibleWithTy g amap m (ty: TType) (minfo: MethInfo) =
 
         match ty1, ty2 with
         | TType_var (tp1, _), _ ->
-            tp1.Constraints |> List.exists (function
-                | TyparConstraint.CoercesTo(targetCTy, _) ->
+            let coercesToConstraints =
+                tp1.Constraints |> List.choose (function
+                    | TyparConstraint.CoercesTo(targetCTy, _) -> Some targetCTy
+                    | _ -> None)
+            match coercesToConstraints with
+            | [] -> true  // No CoercesTo constraint means it could match anything
+            | constraints ->
+                constraints |> List.exists (fun targetCTy ->
                     let cTy = targetCTy |> stripTyEqns g
-                    TypeRelations.TypeFeasiblySubsumesType 0 g amap m cTy TypeRelations.CanCoerce ty2
-                | _ -> false)
+                    TypeRelations.TypeFeasiblySubsumesType 0 g amap m cTy TypeRelations.CanCoerce ty2)
         | _, TType_var _ -> true
         | _ ->
             TypeRelations.TypeFeasiblySubsumesType 0 g amap m ty1 TypeRelations.CanCoerce ty2
     | _ -> 
         true
 
+/// Get all the available methods of a type (both intrinsic and extension)
+let AllMethInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad findFlag m ty =
+    let intrinsic = IntrinsicMethInfosOfType infoReader optFilter ad AllowMultiIntfInstantiations.Yes findFlag m ty
+    if collectionSettings = ResultCollectionSettings.AtMostOneResult && not (isNil intrinsic) then 
+        intrinsic
+    else
+        intrinsic @ ExtensionMethInfosOfTypeInScope collectionSettings infoReader nenv ad optFilter LookupIsInstance.Ambivalent m ty
+        |> List.filter (IsExtensionMethCompatibleWithTy infoReader m ty)
+
 //-------------------------------------------------------------------------
 // Helpers to do with building environments
 //-------------------------------------------------------------------------

src/Compiler/Checking/NameResolution.fsi

@@ -691,8 +691,7 @@ val internal AllMethInfosOfTypeInScope:
 
 /// Check whether the 'this' argument of an extension method is compatible with the target type
 val internal IsExtensionMethCompatibleWithTy:
-    g: TcGlobals ->
-    amap: ImportMap ->
+    infoReader: InfoReader ->
     m: range ->
     ty: TType ->
     minfo: MethInfo ->

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

@@ -134,3 +134,36 @@ let ``CE captures a public extension method with valid generic constrainted type
     |> asExe
     |> compile
     |> shouldFail
+
+// Deliberately trigger an error to ensure that a method is captured
+[<Fact>]
+let ``CE captures a public extension method with generic 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 Run(this: 'T, invalidArg: string) =
+                this
+
+        let asyncSeq = AsyncSeqBuilder()
+
+        let xs : AsyncSeq<int> =
+            asyncSeq {
+                yield 1
+            }
+    """
+    |> asExe
+    |> compile
+    |> shouldFail