Shrink the mixed range change and fix the range lowering it exposed

Review asked for a smaller diff without code comments. The intent now sits in
names (BareRangeExpr, RangeAsSingleValue, mkRangeSplice, rewriteYieldFromRange,
rejectRangeOperand, SimpleSemicolonSequenceWithRanges); one rejectRangeOperand
replaces the recovery arms for yield and return of a range; the tests are four
compilations instead of a fixture per scenario.

Fixes found on the way:
- a unativeint range with a single element was treated as empty (EmptyRange),
  which also dropped the element of [ 2un..2un ] and skipped for _ in 2un..2un on main
- convertSimpleReturnToExpr declines BindReturn for a returned range and stays
  free of diagnostics, so FS3925 is reported once by the return arm
- the counted loop reads a mutable range operand before the later operands run
  and no longer counts extra elements for a nativeint range with the smallest step
- a then sequence is not split into the elements of a flat literal
- query { return 1..3 } reports FS3144 only

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: xperiandri

docs/release-notes/.FSharp.Compiler.Service/11.0.200.md

@@ -12,6 +12,7 @@
 * Fix `NativePtr.stackalloc` used inside the `with` handler, filter or `finally` block of a `try` expression producing an assembly that throws `InvalidProgramException` at method load. Direct or mandatory-inline allocations are now reported at compile time as error FS3924; calls to non-inline allocation helpers, including handler-local helpers, remain legal and retain their method boundary during inlining and let-binding elimination. ([Issue #20295](https://github.com/dotnet/fsharp/issues/20295), [PR #20491](https://github.com/dotnet/fsharp/pull/20491))
 * Preserve SRTP code generation when extension constraint solutions are disabled. ([PR #20773](https://github.com/dotnet/fsharp/pull/20773))
 * `FsiEvaluationSession.EvalInteraction` and `EvalInteractionNonThrowing` evaluate every `;;`-separated interaction in the text they are given, as their documentation has always said, instead of silently discarding everything after the first. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))
+* Fix the counted-loop lowering of integral ranges: a range with a single `unativeint` element is no longer treated as empty, a mutable range bound is read before the later bounds are evaluated, and a `nativeint` range with the smallest step no longer yields extra elements. ([PR #20759](https://github.com/dotnet/fsharp/pull/20759))
 * Prevent `InvalidProgramException` when runtime async awaits a `Task<T>` upcast to `Task`, including through `ConfigureAwait`. ([Issue #20686](https://github.com/dotnet/fsharp/issues/20686), [PR #20726](https://github.com/dotnet/fsharp/pull/20726))
 * Struct/reference anonymous-record mismatches now name anonymous records rather than tuples. ([Issue #6110](https://github.com/dotnet/fsharp/issues/6110), [PR #20681](https://github.com/dotnet/fsharp/pull/20681))
 * Preserve constraint inference order when explicit generic arguments share a caller type parameter, avoiding spurious FS0001 errors with multiply implemented generic interfaces. ([PR #20491](https://github.com/dotnet/fsharp/pull/20491))

src/Compiler/Checking/Expressions/CheckArrayOrListComputedExpressions.fs

@@ -16,7 +16,6 @@ let TcArrayOrListComputedExpression (cenv: TcFileState) env (overallTy: OverallT
     let g = cenv.g
 
     // The syntax '[ n .. m ]' and '[ n .. step .. m ]' is not really part of array or list syntax.
-    // It could be in the future, e.g. '[ 1; 2..30; 400 ]'
     //
     // The elaborated form of '[ n .. m ]' is 'List.ofSeq (seq (op_Range n m))' and this shouldn't change
     match RewriteRangeExpr comp with
@@ -99,12 +98,8 @@ let TcArrayOrListComputedExpression (cenv: TcFileState) env (overallTy: OverallT
                 | _ -> SynExpr.ArrayOrList(isArray, elems, m)
 
             TcExprUndelayed cenv overallTy env tpenv replacementExpr
-        | _ ->
-
-            let comp =
-                match comp with
-                | SimpleSemicolonSequenceWithRanges cenv valuesAndRanges -> valuesAndRanges
-                | _ -> comp
+        | SimpleSemicolonSequenceWithRanges cenv comp
+        | comp ->
 
             let genCollElemTy = NewInferenceType g
 

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -2447,27 +2447,13 @@ let rec TryTranslateComputationExpression
 
             Some(translatedCtxt returnFromCall)
 
-        // A range is not yielded or returned as one value (FS-1031). Recover 'yield e1..e2' as 'yield! e1..e2' when the
-        // builder can splice; otherwise 'Yield' or 'Return' takes an argument of any type, so no type error follows.
-        | SynExpr.YieldOrReturn(((isYield, _) as flags), (BareRangeExpr _ as synRange), mFull, ({ YieldOrReturnKeyword = m } as trivia)) when
-            cenv.g.langVersion.SupportsFeature LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions
-            ->
-            errorR (Error(FSComp.SR.tcRangeIsNotASingleValue (), synRange.Range))
-
-            let recovery =
-                if isYield && hasBuilderMethod ceenv m "YieldFrom" then
-                    mkRangeSplice synRange
-                else
-                    SynExpr.YieldOrReturn(flags, arbExpr ("rangeAsSingleValue", synRange.Range), mFull, trivia)
-
-            TryTranslateComputationExpression ceenv firstTry q varSpace recovery translatedCtxt
-
         | SynExpr.YieldOrReturn((isYield, _), synYieldOrReturnExpr, mFull, { YieldOrReturnKeyword = m }) ->
             let methName = (if isYield then "Yield" else "Return")
 
             if ceenv.isQuery && not isYield then
                 error (Error(FSComp.SR.tcReturnMayNotBeUsedInQueries (), m))
 
+            let synYieldOrReturnExpr = rejectRangeOperand cenv synYieldOrReturnExpr
             requireBuilderMethod methName ceenv m m
 
             let yieldOrReturnCall =
@@ -2765,6 +2751,8 @@ and TranslateComputationExpressionBind
 /// The inner option indicates if a custom operation is involved inside
 and convertSimpleReturnToExpr (ceenv: ComputationExpressionContext<'a>) comp varSpace innerComp =
     match innerComp with
+    | SynExpr.YieldOrReturn((false, _), RangeAsSingleValue ceenv.cenv, _, _) -> None
+
     | SynExpr.YieldOrReturn((false, _), returnExpr, m, _) ->
         let returnExpr =
             SynExpr.DebugPoint(DebugPointAtLeafExpr.Yes(false, m), false, returnExpr)

src/Compiler/Checking/Expressions/CheckExpressionsOps.fs

@@ -182,30 +182,33 @@ let RewriteRangeExpr synExpr =
         Some otherExpr
     | _ -> None
 
-/// A closed range 'e1..e2' or 'e1..e2..e3' that is not parenthesized, as a call to '(..)' or '(.. ..)'.
 [<return: Struct>]
 let (|BareRangeExpr|_|) synExpr =
+    RewriteRangeExpr synExpr |> ValueOption.ofOption
+
+let (|RangeAsSingleValue|_|) (cenv: TcFileState) synExpr =
     match synExpr with
-    | SynExpr.IndexRange _ ->
-        match RewriteRangeExpr synExpr with
-        | Some rangeExpr -> ValueSome rangeExpr
-        | None -> ValueNone
-    | _ -> ValueNone
+    | BareRangeExpr _ -> cenv.g.langVersion.SupportsFeature LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions
+    | _ -> false
 
-/// A range in element position of a list, array, sequence or computation expression
-/// splices its elements, as 'yield! e1..e2' does (FS-1031).
 let mkRangeSplice (synRange: SynExpr) =
     let m = synRange.Range
     SynExpr.YieldOrReturnFrom((true, false), synRange, m, { YieldOrReturnFromKeyword = m })
 
-/// The source of 'yield! e1..e2' is '(..) e1 e2' (FS-1031).
 let rewriteYieldFromRange (cenv: TcFileState) synExpr =
     match synExpr with
-    | BareRangeExpr rangeExpr ->
+    | BareRangeExpr rangeCall ->
         checkLanguageFeatureAndRecover cenv.g.langVersion LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions synExpr.Range
-        rangeExpr
+        rangeCall
     | _ -> synExpr
 
+let rejectRangeOperand (cenv: TcFileState) operand =
+    match operand with
+    | RangeAsSingleValue cenv ->
+        errorR (Error(FSComp.SR.tcRangeIsNotASingleValue (), operand.Range))
+        arbExpr ("rangeAsSingleValue", operand.Range)
+    | _ -> operand
+
 /// Check if a computation or sequence expression is syntactically free of 'yield' (though not yield!)
 let YieldFree (_cenv: TcFileState) expr =
     let rec YieldFree expr =
@@ -273,35 +276,37 @@ let rec TryGetSimpleSemicolonSequenceOfComprehension expr acc cenv acceptDepreca
 let (|SimpleSemicolonSequence|_|) cenv acceptDeprecated cexpr =
     TryGetSimpleSemicolonSequenceOfComprehension cexpr [] cenv acceptDeprecated
 
-/// A flat list or array of values with at least one range, such as '[ 0; 1..3; 10 ]' (FS-1031),
-/// as '[ yield 0; 1..3; yield 10 ]': every value stays an element, as in a list literal.
 [<return: Struct>]
 let (|SimpleSemicolonSequenceWithRanges|_|) cenv cexpr =
-    let yieldElement (e: SynExpr) =
-        SynExpr.YieldOrReturn((true, false), e, e.Range, { YieldOrReturnKeyword = e.Range })
-
-    let rec collectReversed expr acc hasRange =
+    let isRange = RewriteRangeExpr >> Option.isSome
+
+    let yieldValue expr =
+        SynExpr.YieldOrReturn((true, false), expr, expr.Range, SynExprYieldOrReturnTrivia.Zero)
+
+    let sequential head tail =
+        SynExpr.Sequential(
+            DebugPointAtSequential.SuppressNeither,
+            true,
+            head,
+            tail,
+            unionRanges head.Range tail.Range,
+            SynExprSequentialTrivia.Zero
+        )
+
+    let rec elements acc expr =
         match expr with
-        | SynExpr.Sequential(isTrueSeq = true; expr1 = BareRangeExpr _ as e1; expr2 = e2) -> collectReversed e2 (e1 :: acc) true
-        | SynExpr.Sequential(isTrueSeq = true; expr1 = e1; expr2 = e2) when IsSimpleSemicolonSequenceElement e1 cenv false ->
-            collectReversed e2 (yieldElement e1 :: acc) hasRange
-        | BareRangeExpr _ -> ValueSome(expr :: acc)
-        | _ when hasRange && IsSimpleSemicolonSequenceElement expr cenv false -> ValueSome(yieldElement expr :: acc)
-        | _ -> ValueNone
-
-    match collectReversed cexpr [] false with
-    | ValueSome(last :: before) ->
-        let mkSequential (tail: SynExpr) (e: SynExpr) =
-            SynExpr.Sequential(
-                DebugPointAtSequential.SuppressNeither,
-                true,
-                e,
-                tail,
-                unionRanges e.Range tail.Range,
-                SynExprSequentialTrivia.Zero
-            )
-
-        ValueSome(List.fold mkSequential last before)
+        | SynExpr.Sequential(isTrueSeq = true; expr1 = head; expr2 = tail) -> elements (head :: acc) tail
+        | _ -> List.rev (expr :: acc)
+
+    match elements [] cexpr with
+    | elems when
+        List.exists isRange elems
+        && List.forall (fun e -> isRange e || IsSimpleSemicolonSequenceElement e cenv false) elems
+        ->
+        elems
+        |> List.map (fun e -> if isRange e then e else yieldValue e)
+        |> List.reduceBack sequential
+        |> ValueSome
     | _ -> ValueNone
 
 let elimFastIntegerForLoop (spFor, spTo, id, start: SynExpr, dir, finish: SynExpr, innerExpr, m: range) =

src/Compiler/Checking/Expressions/CheckSequenceExpressions.fs

@@ -7,7 +7,6 @@ open FSharp.Compiler.CheckBasics
 open FSharp.Compiler.CheckExpressions
 open FSharp.Compiler.CheckExpressionsOps
 open FSharp.Compiler.ConstraintSolver
-open FSharp.Compiler.Features
 open FSharp.Compiler.NameResolution
 open FSharp.Compiler.PatternMatchCompilation
 open FSharp.Compiler.Syntax
@@ -405,12 +404,9 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
 
             Some(resultExpr, tpenv)
 
-        // A range is not yielded or returned as one value (FS-1031); recover as 'yield! e1..e2'.
-        | SynExpr.YieldOrReturn(flags = (isYield, _); expr = BareRangeExpr _ as synRange; range = m) when
-            g.langVersion.SupportsFeature LanguageFeature.AllowMixedRangesAndValuesInSeqExpressions
-            ->
+        | SynExpr.YieldOrReturn(flags = (isYield, _); expr = RangeAsSingleValue cenv as synRange; range = m) ->
             if isYield then
-                errorR (Error(FSComp.SR.tcRangeIsNotASingleValue (), synRange.Range))
+                rejectRangeOperand cenv synRange |> ignore
             else
                 errorR (Error(FSComp.SR.tcSeqResultsUseYield (), m))
 

src/Compiler/Optimize/LowerComputedCollections.fs

@@ -199,8 +199,6 @@ let LowerComputedListOrArraySeqExpr tcVal g amap m collectorTy overallSeqExpr =
                 Result.Ok (flag, exprR)
             | Result.Error msg -> Result.Error msg
 
-        // yield! start..step..finish over an integral type: a counted loop adding each element,
-        // instead of AddMany over the range's enumerator.
         | IntegralRange g (rangeTy, (start, step, finish)) when
             not isUninteresting
             && g.langVersion.SupportsFeature LanguageFeature.LowerIntegralRangesToFastLoops

src/Compiler/TypedTree/TypedTreeOps.Transforms.fs

@@ -1468,7 +1468,7 @@ module internal TupleCompilation =
             start <= 0xffffffffUL
             && step <= 0xffffffffUL
             && finish <= 0xffffffffUL
-            && finish <= start
+            && finish < start
             ->
             ValueSome EmptyRange
 
@@ -1520,12 +1520,6 @@ module internal TupleCompilation =
             ValueSome(Const.UInt64((uint64 finish - uint64 start) / (uint64 Int64.MaxValue + 1UL) + 1UL))
         | Expr.Const(value = Const.Int64 start), Expr.Const(value = Const.Int64 Int64.MinValue), Expr.Const(value = Const.Int64 finish) ->
             ValueSome(Const.UInt64((uint64 start - uint64 finish) / (uint64 Int64.MaxValue + 1UL) + 1UL))
-        | Expr.Const(value = Const.IntPtr start), Expr.Const(value = Const.IntPtr Int64.MinValue), Expr.Const(value = Const.IntPtr finish) when
-            start <= finish
-            ->
-            ValueSome(Const.UIntPtr((uint64 start - uint64 finish) / (uint64 Int64.MaxValue + 1UL) + 1UL))
-        | Expr.Const(value = Const.IntPtr start), Expr.Const(value = Const.IntPtr Int64.MinValue), Expr.Const(value = Const.IntPtr finish) ->
-            ValueSome(Const.UIntPtr((uint64 start - uint64 finish) / (uint64 Int64.MaxValue + 1UL) + 1UL))
 
         | Expr.Const(value = Const.Int64 start), Expr.Const(value = Const.Int64 step), Expr.Const(value = Const.Int64 finish) when
             start <= finish
@@ -1998,34 +1992,14 @@ module internal TupleCompilation =
         (buildLoop: Count -> ((Idx -> Elem -> Body) -> Loop) -> Expr)
         =
         let inline mkLetBindingsIfNeeded f =
-            match start, step, finish with
-            | (Expr.Const _ | Expr.Val _), (Expr.Const _ | Expr.Val _), (Expr.Const _ | Expr.Val _) -> f start step finish
-
-            | (Expr.Const _ | Expr.Val _), (Expr.Const _ | Expr.Val _), _ ->
-                mkCompGenLetIn finish.Range (nameof finish) rangeTy finish (fun (_, finish) -> f start step finish)
-
-            | _, (Expr.Const _ | Expr.Val _), (Expr.Const _ | Expr.Val _) ->
-                mkCompGenLetIn start.Range (nameof start) rangeTy start (fun (_, start) -> f start step finish)
-
-            | (Expr.Const _ | Expr.Val _), _, (Expr.Const _ | Expr.Val _) ->
-                mkCompGenLetIn step.Range (nameof step) rangeTy step (fun (_, step) -> f start step finish)
-
-            | _, (Expr.Const _ | Expr.Val _), _ ->
-                mkCompGenLetIn start.Range (nameof start) rangeTy start (fun (_, start) ->
-                    mkCompGenLetIn finish.Range (nameof finish) rangeTy finish (fun (_, finish) -> f start step finish))
-
-            | (Expr.Const _ | Expr.Val _), _, _ ->
-                mkCompGenLetIn step.Range (nameof step) rangeTy step (fun (_, step) ->
-                    mkCompGenLetIn finish.Range (nameof finish) rangeTy finish (fun (_, finish) -> f start step finish))
-
-            | _, _, (Expr.Const _ | Expr.Val _) ->
-                mkCompGenLetIn start.Range (nameof start) rangeTy start (fun (_, start) ->
-                    mkCompGenLetIn step.Range (nameof step) rangeTy step (fun (_, step) -> f start step finish))
-
-            | _, _, _ ->
-                mkCompGenLetIn start.Range (nameof start) rangeTy start (fun (_, start) ->
-                    mkCompGenLetIn step.Range (nameof step) rangeTy step (fun (_, step) ->
-                        mkCompGenLetIn finish.Range (nameof finish) rangeTy finish (fun (_, finish) -> f start step finish)))
+            let bindIfNeeded name operand k =
+                match operand with
+                | Expr.Const _ -> k operand
+                | Expr.Val(valRef, _, _) when not valRef.IsMutable -> k operand
+                | _ -> mkCompGenLetIn operand.Range name rangeTy operand (fun (_, bound) -> k bound)
+
+            bindIfNeeded (nameof start) start (fun start ->
+                bindIfNeeded (nameof step) step (fun step -> bindIfNeeded (nameof finish) finish (fun finish -> f start step finish)))
 
         mkLetBindingsIfNeeded (fun start step finish ->
             /// Start at 0 and count up through count - 1.