yield! 1..10

Author: edgarfgp

src/Compiler/Checking/Expressions/CheckArrayOrListComputedExpressions.fs

@@ -173,20 +173,22 @@ let TcArrayOrListComputedExpression (cenv: TcFileState) env (overallTy: OverallT
 
                 TcExprUndelayed cenv overallTy env tpenv replacementExpr
         | _ ->
-            let containsExplicitYields =
-                let rec hasYieldBang expr cont =
+            let containsRangeMixedWithYields =
+                let rec hasRangeAndYield expr hasRange hasYield cont =
                     match expr with
-                    | SynExpr.YieldOrReturnFrom _ -> cont true
+                    | SynExpr.IndexRange _ -> cont true hasYield
+                    | SynExpr.YieldOrReturnFrom _ -> cont hasRange true
                     | SynExpr.Sequential(_, _, e1, e2, _, _) ->
-                        hasYieldBang e1 (fun e1Has -> if e1Has then cont true else hasYieldBang e2 cont)
-                    | _ -> cont false
-
-                hasYieldBang comp id
-
+                        hasRangeAndYield e1 hasRange hasYield (fun r1 y1 ->
+                            hasRangeAndYield e2 r1 y1 cont)
+                    | _ -> cont hasRange hasYield
+                
+                hasRangeAndYield comp false false (fun r y -> r && y)
+            
             // Transform mixed expressions with explicit yields to ensure all elements are properly yielded
             let comp =
                 if
-                    containsExplicitYields
+                    containsRangeMixedWithYields
                     && g.langVersion.SupportsFeature LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions
                 then
                     match comp with
@@ -200,18 +202,8 @@ let TcArrayOrListComputedExpression (cenv: TcFileState) env (overallTy: OverallT
                         let elems = getElems comp []
                         transformMixedListWithExplicitYields elems m
                     | _ -> comp
-                else if containsExplicitYields then
-                    // Check if any element is a range expression (tail recursive)
-                    let rec hasRangeInMixedYield expr cont =
-                        match expr with
-                        | SynExpr.IndexRange _ -> cont true
-                        | SynExpr.Sequential(_, _, e1, e2, _, _) ->
-                            hasRangeInMixedYield e1 (fun e1Has -> if e1Has then cont true else hasRangeInMixedYield e2 cont)
-                        | _ -> cont false
-
-                    if hasRangeInMixedYield comp id then
-                        checkLanguageFeatureAndRecover g.langVersion LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions m
-
+                else if containsRangeMixedWithYields then
+                    checkLanguageFeatureAndRecover g.langVersion LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions m
                     comp
                 else
                     comp

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -2284,9 +2284,12 @@ let rec TryTranslateComputationExpression
 
             // Rewrite range expressions in yield! to their sequence form
             let synYieldExpr =
-                match RewriteRangeExpr synYieldExpr with
-                | Some rewrittenExpr -> rewrittenExpr
-                | None -> synYieldExpr
+                if isRangeExpr then
+                    match RewriteRangeExpr synYieldExpr with
+                    | Some rewrittenExpr -> rewrittenExpr
+                    | None -> synYieldExpr
+                else
+                    synYieldExpr
 
             let yieldFromExpr =
                 mkSourceExpr synYieldExpr ceenv.sourceMethInfo ceenv.builderValName

src/Compiler/Checking/Expressions/CheckExpressionsOps.fs

@@ -452,6 +452,23 @@ let transformMixedListWithExplicitYields elems m =
         | RangeExpr rangeExpr -> cont (``yield!`` rangeExpr expr)
         | SynExpr.YieldOrReturnFrom _ -> cont expr
         | SynExpr.YieldOrReturn _ -> cont expr
+        | SynExpr.IfThenElse(ifExpr, thenExpr, elseExprOpt, spIfToThen, isFromErrorRecovery, range, trivia) ->
+            transformExpr thenExpr (fun transformedThen ->
+                match elseExprOpt with
+                | Some elseExpr ->
+                    transformExpr elseExpr (fun transformedElse ->
+                        cont (
+                            SynExpr.IfThenElse(
+                                ifExpr,
+                                transformedThen,
+                                Some transformedElse,
+                                spIfToThen,
+                                isFromErrorRecovery,
+                                range,
+                                trivia
+                            )
+                        ))
+                | None -> cont (SynExpr.IfThenElse(ifExpr, transformedThen, None, spIfToThen, isFromErrorRecovery, range, trivia)))
         | _ -> cont (``yield`` expr)
 
     let rec loop elems cont =

src/Compiler/Checking/Expressions/CheckSequenceExpressions.fs

@@ -381,9 +381,12 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
 
             // Rewrite range expressions in yield! to their sequence form
             let synYieldExpr =
-                match RewriteRangeExpr synYieldExpr with
-                | Some rewrittenExpr -> rewrittenExpr
-                | None -> synYieldExpr
+                if isRangeExpr then
+                    match RewriteRangeExpr synYieldExpr with
+                    | Some rewrittenExpr -> rewrittenExpr
+                    | None -> synYieldExpr
+                else
+                    synYieldExpr
 
             let resultExpr, genExprTy, tpenv = TcExprOfUnknownType cenv env tpenv synYieldExpr
 

tests/FSharp.Compiler.ComponentTests/Language/SequenceExpressions/MixedSequenceExpressionTests.fs

@@ -361,6 +361,22 @@ let f = [|-3; 1..10; 19|]
     // SOURCE=SequenceExpressions13.fs 	# SequenceExpressions13.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SequenceExpressions13.fs"|])>]
     let ``Preview: SequenceExpressions13 fs`` compilation =
+        compilation
+        |> withLangVersionPreview
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
+    // SOURCE=SequenceExpressions14.fs 	# SequenceExpressions14.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SequenceExpressions14.fs"|])>]
+    let ``Version 9: SequenceExpressions14 fs`` compilation =
+        compilation
+        |> withLangVersion90
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
+    // SOURCE=SequenceExpressions13.fs 	# SequenceExpressions13.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SequenceExpressions14.fs"|])>]
+    let ``Preview: SequenceExpressions14 fs`` compilation =
         compilation
         |> withLangVersionPreview
         |> verifyCompileAndRun

tests/FSharp.Compiler.ComponentTests/Language/SequenceExpressions/SequenceExpressions14.fs

@@ -0,0 +1,16 @@
+module BackwardCompatTest
+        
+let makeCustomAttributes() =
+    [|
+        if true then
+            yield "attr1"
+            yield! ["attr2"; "attr3"]
+        yield! ["attr4"]
+    |]
+
+let attrs = makeCustomAttributes()
+let expected = [|"attr1"; "attr2"; "attr3"; "attr4"|]
+
+if attrs <> expected then failwithf $"attrs failed: got {attrs}"
+
+printfn "Backward compatibility test passed!"