From 4c715807425c122681bf3389a34a4700178e5a1c Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Wed, 19 Mar 2025 17:11:18 +0000 Subject: [PATCH 1/6] Use a more accurate range for ce Combine methods --- .../CheckComputationExpressions.fs | 8 + .../Language/ComputationExpressionTests.fs | 392 ++++++++++++++++++ 2 files changed, 400 insertions(+) diff --git a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs index 22b603d211a..0056db4891d 100644 --- a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs @@ -1624,6 +1624,14 @@ let rec TryTranslateComputationExpression ceenv.builderTy ) then + let m = + match innerComp2 with + | SynExpr.App(argExpr = e1; funcExpr = e2) -> unionRanges e1.Range e2.Range + | SynExpr.YieldOrReturn(trivia = synExprYieldOrReturnTrivia) -> synExprYieldOrReturnTrivia.YieldOrReturnKeyword + | SynExpr.YieldOrReturnFrom(trivia = synExprYieldOrReturnFromTrivia) -> + synExprYieldOrReturnFromTrivia.YieldOrReturnFromKeyword + | _ -> innerComp1.Range + error (Error(FSComp.SR.tcRequireBuilderMethod ("Combine"), m)) if diff --git a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs index 3555e97fd2d..c2e8f86fe3b 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs @@ -605,6 +605,398 @@ let run r2 r3 = (Error 708, Line 24, Col 19, Line 24, Col 26, "This control construct may only be used if the computation expression builder defines a 'ReturnFrom' method") ] + [] + let ``This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + +let result = ResultBuilder() + +let run r2 r3 = + result { + let! r2 = r2 + let! r3 = r3 + if r2 = Ok 1 then + do! r2 + return r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 27, Col 9, Line 27, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence2 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + for i in [ 1] do + do! r2 + return r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 32, Col 9, Line 32, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 5 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + for i in [ 1] do + do! r2 + return! r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 32, Col 9, Line 32, Col 16, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 7 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + match r2 with + | 0 -> do! r2 + | _ -> do! r2 + return! r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 33, Col 9, Line 33, Col 16, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 8 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + match! r2 with + | 0 -> do! r2 + | _ -> do! r2 + return! r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 33, Col 9, Line 33, Col 16, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 9 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + match! r2 with + | 0 -> do! r2 + | _ -> do! r2 + return r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 33, Col 9, Line 33, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence3 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.Yield(x: 'T) = Ok x + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + for i in [ 1] do + yield r2 + return r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 34, Col 9, Line 34, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 4 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.Yield(x: 'T) = Ok x + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + for i in [ 1] do + yield r2 + yield r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 34, Col 9, Line 34, Col 14, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + [] + let ``Sequence 6 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Result = + let zip x1 x2 = + match x1,x2 with + | Ok x1res, Ok x2res -> Ok (x1res, x2res) + | Error e, _ -> Error e + | _, Error e -> Error e + +type ResultBuilder() = + member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2 + member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x + member _.Bind(x: Result<'T,'U>, f) = + match x with + | Ok x -> f x + | Error e -> Error e + + member _.Zero() = Ok () + + member _.Yield(x: 'T) = Ok x + + member _.YieldFrom(x: Result<'T,'U>) = x + + member _.For(sequence: #seq<'T>, binder: 'T -> Result<_, _>) = + sequence + |> Seq.map binder + |> Seq.fold (fun acc x -> Result.bind (fun () -> x) acc) (Ok ()) + +let result = ResultBuilder() + +let run (r2: Result) (r3: Result) = + result { + let! r2 = r2 + let! r3 = r3 + for i in [ 1] do + yield! r2 + yield! r3 + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 36, Col 9, Line 36, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + [] let ``Type constraint mismatch when using return!`` () = Fsx """ From 9c55a8b3194332231e70df40b9d92969d8edca2f Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Thu, 20 Mar 2025 09:33:38 +0000 Subject: [PATCH 2/6] fix test --- .../DataExpressions/ComputationExpressions/E_MissingCombine.fs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/ComputationExpressions/E_MissingCombine.fs b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/ComputationExpressions/E_MissingCombine.fs index 5a8e82d4074..b06d74f93e9 100644 --- a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/ComputationExpressions/E_MissingCombine.fs +++ b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/ComputationExpressions/E_MissingCombine.fs @@ -1,6 +1,6 @@ // #Regression #Conformance #DataExpressions #ComputationExpressions // Regression test for FSHARP1.0:6149 -//This control construct may only be used if the computation expression builder defines a 'Combine' method$ +//This control construct may only be used if the computation expression builder defines a 'Combine' method$ type R = S of string From abdf473f0185d723cc76a97fcff7fd4094001a20 Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Fri, 21 Mar 2025 10:03:00 +0000 Subject: [PATCH 3/6] one more test --- .../CheckComputationExpressions.fs | 13 ++++----- .../Language/ComputationExpressionTests.fs | 28 +++++++++++++++++++ 2 files changed, 34 insertions(+), 7 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs index 0056db4891d..2aea0be57e0 100644 --- a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs @@ -1624,15 +1624,14 @@ let rec TryTranslateComputationExpression ceenv.builderTy ) then - let m = + let combineRange = match innerComp2 with - | SynExpr.App(argExpr = e1; funcExpr = e2) -> unionRanges e1.Range e2.Range - | SynExpr.YieldOrReturn(trivia = synExprYieldOrReturnTrivia) -> synExprYieldOrReturnTrivia.YieldOrReturnKeyword - | SynExpr.YieldOrReturnFrom(trivia = synExprYieldOrReturnFromTrivia) -> - synExprYieldOrReturnFromTrivia.YieldOrReturnFromKeyword - | _ -> innerComp1.Range + | SynExpr.YieldOrReturn(trivia = yieldOrReturn) -> yieldOrReturn.YieldOrReturnKeyword + | SynExpr.YieldOrReturnFrom(trivia = yieldOrReturnFrom) -> yieldOrReturnFrom.YieldOrReturnFromKeyword + | SynExpr.App(range = m) -> m + | _ -> m - error (Error(FSComp.SR.tcRequireBuilderMethod ("Combine"), m)) + error (Error(FSComp.SR.tcRequireBuilderMethod "Combine", combineRange)) if isNil ( diff --git a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs index c2e8f86fe3b..a76ff57e803 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs @@ -997,6 +997,34 @@ let run (r2: Result) (r3: Result) = (Error 708, Line 36, Col 9, Line 36, Col 15, "This control construct may only be used if the computation expression builder defines a 'Combine' method") ] + [] + let ``Sequence 10 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Test = + type R = S of string + + type T() = + member x.Bind(p: R, rest: (string -> R)) = + match p with + | S(s) -> rest s + member x.Zero() = S("l") + member x.For(s : seq, rest: (int -> unit)) = S("") + + let t = new T() + + let t' = t { + let a = 10 + for x in [1] do () + 0 |> ignore + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 17, Col 7, Line 17, Col 18, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + [] let ``Type constraint mismatch when using return!`` () = Fsx """ From 3a19b979abf2b57b6e78003e5bdf7ba109755de5 Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Tue, 25 Mar 2025 15:41:31 +0000 Subject: [PATCH 4/6] more tests --- .../CheckComputationExpressions.fs | 18 +++-- .../Language/ComputationExpressionTests.fs | 74 +++++++++++++++++++ 2 files changed, 84 insertions(+), 8 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs index 2aea0be57e0..230e8cb82e9 100644 --- a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs @@ -1612,6 +1612,14 @@ let rec TryTranslateComputationExpression // "cexpr; cexpr" is treated as builder.Combine(cexpr1, cexpr1) let m1 = rangeForCombine innerComp1 + let combineDelayRange = + match innerComp2 with + | SynExpr.YieldOrReturn(trivia = yieldOrReturn) -> yieldOrReturn.YieldOrReturnKeyword + | SynExpr.YieldOrReturnFrom(trivia = yieldOrReturnFrom) -> yieldOrReturnFrom.YieldOrReturnFromKeyword + | SynExpr.ForEach(range = m) -> m + | SynExpr.App(range = m) -> m + | _ -> m + if isNil ( TryFindIntrinsicOrExtensionMethInfo @@ -1624,14 +1632,8 @@ let rec TryTranslateComputationExpression ceenv.builderTy ) then - let combineRange = - match innerComp2 with - | SynExpr.YieldOrReturn(trivia = yieldOrReturn) -> yieldOrReturn.YieldOrReturnKeyword - | SynExpr.YieldOrReturnFrom(trivia = yieldOrReturnFrom) -> yieldOrReturnFrom.YieldOrReturnFromKeyword - | SynExpr.App(range = m) -> m - | _ -> m - error (Error(FSComp.SR.tcRequireBuilderMethod "Combine", combineRange)) + error (Error(FSComp.SR.tcRequireBuilderMethod "Combine", combineDelayRange)) if isNil ( @@ -1645,7 +1647,7 @@ let rec TryTranslateComputationExpression ceenv.builderTy ) then - error (Error(FSComp.SR.tcRequireBuilderMethod ("Delay"), m)) + error (Error(FSComp.SR.tcRequireBuilderMethod "Delay", combineDelayRange)) let combineCall = mkSynCall diff --git a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs index a76ff57e803..8ff94cf7ad8 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs @@ -1025,6 +1025,80 @@ module Test = (Error 708, Line 17, Col 7, Line 17, Col 18, "This control construct may only be used if the computation expression builder defines a 'Combine' method") ] + [] + let ``Sequence 11 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Test = + type R = S of string + + type T() = + member x.Bind(p: R, rest: string -> R) = + match p with + | S(s) -> rest s + member x.Zero() = S("l") + member x.For(s: seq, rest: (int -> R)) = + let folder state item = + match state with + | S(str) -> + match rest item with + | S(itemStr) -> S(str + itemStr) + Seq.fold folder (S("")) s + + let t = new T() + + let t' = t { + let a = 10 + for x in [1] do + () + for x in [1] do + () + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 24, Col 7, Line 25, Col 13, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + + [] + let ``Sequence 12 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Test = + type R = S of string + + type T() = + member x.Bind(p: R, rest: string -> R) = + match p with + | S(s) -> rest s + member x.Zero() = S("l") + member x.Yield(value: 'a) = S(string value) + member x.For(s: seq, rest: (int -> R)) = + let folder state item = + match state with + | S(str) -> + match rest item with + | S(itemStr) -> S(str + itemStr) + Seq.fold folder (S("")) s + + let t = new T() + + let t' = t { + let a = 10 + for x in [1] -> + () + for x in [1] -> + () + } + + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 25, Col 7, Line 26, Col 13, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + [] let ``Type constraint mismatch when using return!`` () = Fsx """ From 004b5b7d364c70f0d4ee66dafabc5579881162fd Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Tue, 25 Mar 2025 15:43:41 +0000 Subject: [PATCH 5/6] release notes --- docs/release-notes/.FSharp.Compiler.Service/9.0.300.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/release-notes/.FSharp.Compiler.Service/9.0.300.md b/docs/release-notes/.FSharp.Compiler.Service/9.0.300.md index 5f722b11a12..dfe68c9dc93 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/9.0.300.md +++ b/docs/release-notes/.FSharp.Compiler.Service/9.0.300.md @@ -27,6 +27,7 @@ * Symbols: Add FSharpAssembly.IsFSharp ([PR #18290](https://github.com/dotnet/fsharp/pull/18290)) * Type parameter constraint `null` in generic code will now automatically imply `not struct` ([Issue #18320](https://github.com/dotnet/fsharp/issues/18320), [PR #18323](https://github.com/dotnet/fsharp/pull/18323)) * Add a switch to determine whether to generate a default implementation body for overridden method when completing. [PR #18341](https://github.com/dotnet/fsharp/pull/18341) +* Use a more accurate range for CE Combine methods. [PR #18394](https://github.com/dotnet/fsharp/pull/18394) ### Changed From f91b0c6d292de98fc7538dd710d7f4b51c188b1f Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Tue, 25 Mar 2025 16:46:08 +0000 Subject: [PATCH 6/6] simplify check and add more tests --- .../CheckComputationExpressions.fs | 4 +- .../Language/ComputationExpressionTests.fs | 38 +++++++++++++++++++ 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs index 230e8cb82e9..3a19cab4587 100644 --- a/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckComputationExpressions.fs @@ -1616,9 +1616,7 @@ let rec TryTranslateComputationExpression match innerComp2 with | SynExpr.YieldOrReturn(trivia = yieldOrReturn) -> yieldOrReturn.YieldOrReturnKeyword | SynExpr.YieldOrReturnFrom(trivia = yieldOrReturnFrom) -> yieldOrReturnFrom.YieldOrReturnFromKeyword - | SynExpr.ForEach(range = m) -> m - | SynExpr.App(range = m) -> m - | _ -> m + | expr -> expr.Range if isNil ( diff --git a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs index 8ff94cf7ad8..55d49dbebc7 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs @@ -1098,6 +1098,44 @@ module Test = |> withDiagnostics [ (Error 708, Line 25, Col 7, Line 26, Col 13, "This control construct may only be used if the computation expression builder defines a 'Combine' method") ] + + [] + let ``Sequence 13 This control construct may only be used if the computation expression builder defines a 'Combine' method`` () = + Fsx """ +module Test = + type R = S of string + + type T() = + member x.Bind(p: R, rest: string -> R) = + match p with + | S(s) -> rest s + member x.Zero() = S("l") + member x.For(s: seq, rest: (int -> R)) = + let folder state item = + match state with + | S(str) -> + match rest item with + | S(itemStr) -> S(str + itemStr) + Seq.fold folder (S("")) s + + let t = new T() + + let t' = t { + let a = 10 + for x in [1] do () + if true then + () + else + () + } + """ + |> ignoreWarnings + |> typecheck + |> shouldFail + |> withDiagnostics [ + (Error 708, Line 23, Col 7, Line 26, Col 13, "This control construct may only be used if the computation expression builder defines a 'Combine' method") + ] + [] let ``Type constraint mismatch when using return!`` () =