Fix B-grade outliers: rename CollectionTypes, move dest/is from Makers, move patterns from TupleCompilation

- Rename CollectionTypes → TypedTreeCollections
- Move destInt32/destThrow/isThrow/isIDelegateEventType/destIDelegateEventType Makers→ExprTransforms
- Move (|Int32Expr|_|)/(|IntegralRange|_|) TupleCompilation→ConstantEvaluation

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: T-Gro

src/Compiler/TypedTree/TypedTreeOps.ExprConstruction.fs

@@ -518,7 +518,7 @@ module internal ExprConstruction =
     let (|InnerExprPat|) expr = stripExpr expr
 
 [<AutoOpen>]
-module internal CollectionTypes =
+module internal TypedTreeCollections =
 
     //--------------------------------------------------------------------------
     // Maps tracking extra information for values

src/Compiler/TypedTree/TypedTreeOps.ExprConstruction.fsi

@@ -335,7 +335,7 @@ module internal ExprConstruction =
     val (|InnerExprPat|): Expr -> Expr
 
 [<AutoOpen>]
-module internal CollectionTypes =
+module internal TypedTreeCollections =
 
     /// Mutable data structure mapping Val's to T based on stamp keys
     [<Sealed; NoEquality; NoComparison>]

src/Compiler/TypedTree/TypedTreeOps.ExprOps.fs

@@ -800,24 +800,6 @@ module internal Makers =
         else
             error (InternalError($"Unrecognized numeric type '{ty}'.", m))
 
-    let destInt32 =
-        function
-        | Expr.Const(Const.Int32 n, _, _) -> Some n
-        | _ -> None
-
-    let isIDelegateEventType g ty =
-        match tryTcrefOfAppTy g ty with
-        | ValueSome tcref -> tyconRefEq g g.fslib_IDelegateEvent_tcr tcref
-        | _ -> false
-
-    let destIDelegateEventType g ty =
-        if isIDelegateEventType g ty then
-            match argsOfAppTy g ty with
-            | [ ty1 ] -> ty1
-            | _ -> failwith "destIDelegateEventType: internal error"
-        else
-            failwith "destIDelegateEventType: not an IDelegateEvent type"
-
     let mkRefCellContentsRef (g: TcGlobals) =
         mkRecdFieldRef g.refcell_tcr_canon "contents"
 
@@ -1628,13 +1610,6 @@ module internal Makers =
     let mkThrow m ty e =
         mkAsmExpr ([ I_throw ], [], [ e ], [ ty ], m)
 
-    let destThrow =
-        function
-        | Expr.Op(TOp.ILAsm([ I_throw ], [ ty2 ]), [], [ e ], m) -> Some(m, ty2, e)
-        | _ -> None
-
-    let isThrow x = Option.isSome (destThrow x)
-
     // reraise - parsed as library call - internally represented as op form.
     let mkReraiseLibCall (g: TcGlobals) ty m =
         let ve, vt = typedExprForIntrinsic g m g.reraise_info
@@ -2284,6 +2259,31 @@ module internal ExprTransforms =
         tmp.SetDeclaringEntity parent
         tmp.SetIsMemberOrModuleBinding()
 
+    let destInt32 =
+        function
+        | Expr.Const(Const.Int32 n, _, _) -> Some n
+        | _ -> None
+
+    let destThrow =
+        function
+        | Expr.Op(TOp.ILAsm([ I_throw ], [ ty2 ]), [], [ e ], m) -> Some(m, ty2, e)
+        | _ -> None
+
+    let isThrow x = Option.isSome (destThrow x)
+
+    let isIDelegateEventType g ty =
+        match tryTcrefOfAppTy g ty with
+        | ValueSome tcref -> tyconRefEq g g.fslib_IDelegateEvent_tcr tcref
+        | _ -> false
+
+    let destIDelegateEventType g ty =
+        if isIDelegateEventType g ty then
+            match argsOfAppTy g ty with
+            | [ ty1 ] -> ty1
+            | _ -> failwith "destIDelegateEventType: internal error"
+        else
+            failwith "destIDelegateEventType: not an IDelegateEvent type"
+
     /// For match with only one non-failing target T0, the other targets, T1... failing (say, raise exception).
     ///   tree, T0(v0, .., vN) => rhs ; T1() => fail ; ...
     /// Convert it to bind T0's variables, then continue with T0's rhs:

src/Compiler/TypedTree/TypedTreeOps.ExprOps.fsi

@@ -150,8 +150,6 @@ module internal Makers =
     /// Makes an expression holding a constant 1 value of the given numeric type.
     val mkTypedOne: g: TcGlobals -> m: range -> ty: TType -> Expr
 
-    val destInt32: Expr -> int32 option
-
     val mkRefCellContentsRef: TcGlobals -> RecdFieldRef
 
     val mkSequential: range -> Expr -> Expr -> Expr
@@ -464,18 +462,10 @@ module internal Makers =
 
     val mkThrow: range -> TType -> Expr -> Expr
 
-    val destThrow: Expr -> (range * TType * Expr) option
-
-    val isThrow: Expr -> bool
-
     val mkReraiseLibCall: TcGlobals -> TType -> range -> Expr
 
     val mkReraise: range -> TType -> Expr
 
-    val isIDelegateEventType: TcGlobals -> TType -> bool
-
-    val destIDelegateEventType: TcGlobals -> TType -> TType
-
     /// Add a label to use as the target for a goto
     val mkLabelled: range -> ILCodeLabel -> Expr -> Expr
 
@@ -569,3 +559,13 @@ module internal ExprTransforms =
     /// Mutate a value to indicate it should be considered a local rather than a module-bound definition
     // REVIEW: this mutation should not be needed
     val ClearValReprInfo: Val -> Val
+
+    val destInt32: Expr -> int32 option
+
+    val destThrow: Expr -> (range * TType * Expr) option
+
+    val isThrow: Expr -> bool
+
+    val isIDelegateEventType: TcGlobals -> TType -> bool
+
+    val destIDelegateEventType: TcGlobals -> TType -> TType

src/Compiler/TypedTree/TypedTreeOps.Transforms.fs

@@ -1190,13 +1190,6 @@ module internal TupleCompilation =
         else
             mkAsmExpr ([ mkNormalCall (mkILMethodSpecForTupleItem g ty n) ], [], [ expr ], [ retTy ], m)
 
-    /// Match an Int32 constant expression
-    [<return: Struct>]
-    let (|Int32Expr|_|) expr =
-        match expr with
-        | Expr.Const(Const.Int32 n, _, _) -> ValueSome n
-        | _ -> ValueNone
-
     /// Match a try-finally expression
     [<return: Struct>]
     let (|TryFinally|_|) expr =
@@ -1231,7 +1224,9 @@ module internal TupleCompilation =
             ValueSome(startExpr, 1, finishExpr)
 
         // detect (RangeInt32 startExpr N finishExpr), the inlined/compiled form of 'n .. m' and 'n .. N .. m'
-        | Expr.App(Expr.Val(vf, _, _), _, [], [ startExpr; Int32Expr n; finishExpr ], _) when valRefEq g vf g.range_int32_op_vref ->
+        | Expr.App(Expr.Val(vf, _, _), _, [], [ startExpr; Expr.Const(Const.Int32 n, _, _); finishExpr ], _) when
+            valRefEq g vf g.range_int32_op_vref
+            ->
             ValueSome(startExpr, n, finishExpr)
 
         | _ -> ValueNone
@@ -1402,10 +1397,7 @@ module internal TupleCompilation =
             | Const.SByte v -> Const.SByte(abs v)
             | _ -> c
 
-    /// start..finish
-    /// start..step..finish
-    [<return: Struct>]
-    let (|IntegralRange|_|) g expr =
+    let tryMatchIntegralRange g expr =
         match expr with
         | ValApp g g.range_int32_op_vref ([], [ start; step; finish ], _) -> ValueSome(g.int32_ty, (start, step, finish))
         | ValApp g g.range_int64_op_vref ([], [ start; step; finish ], _) -> ValueSome(g.int64_ty, (start, step, finish))
@@ -2164,16 +2156,19 @@ module internal TupleCompilation =
 
             mkFastForLoop g (spFor, spIn, mWholeExpr, elemVar, startExpr, (step = 1), finishExpr, bodyExpr)
 
-        | OptimizeAllForExpressions,
-          CompiledForEachExpr g (_enumTy, rangeExpr & IntegralRange g (rangeTy, (start, step, finish)), elemVar, bodyExpr, ranges) when
-            g.langVersion.SupportsFeature LanguageFeature.LowerIntegralRangesToFastLoops
-            ->
-            let mBody, _spFor, _spIn, mFor, mIn, spInWhile, _mWhole = ranges
-
-            mkOptimizedRangeLoop g (mBody, mFor, mIn, spInWhile) (rangeTy, rangeExpr) (start, step, finish) (fun _count mkLoop ->
-                mkLoop (fun _idxVar loopVar -> mkInvisibleLet elemVar.Range elemVar loopVar bodyExpr))
-
         | OptimizeAllForExpressions, CompiledForEachExpr g (enumerableTy, enumerableExpr, elemVar, bodyExpr, ranges) ->
+            match
+                (if g.langVersion.SupportsFeature LanguageFeature.LowerIntegralRangesToFastLoops then
+                     tryMatchIntegralRange g enumerableExpr
+                 else
+                     ValueNone)
+            with
+            | ValueSome(rangeTy, (start, step, finish)) ->
+                let mBody, _spFor, _spIn, mFor, mIn, spInWhile, _mWhole = ranges
+
+                mkOptimizedRangeLoop g (mBody, mFor, mIn, spInWhile) (rangeTy, enumerableExpr) (start, step, finish) (fun _count mkLoop ->
+                    mkLoop (fun _idxVar loopVar -> mkInvisibleLet elemVar.Range elemVar loopVar bodyExpr))
+            | ValueNone ->
 
             let mBody, spFor, spIn, mFor, mIn, spInWhile, mWholeExpr = ranges
 
@@ -2725,6 +2720,18 @@ module internal ConstantEvaluation =
             Expr.Op(TOp.Array, [ elemTy ], args, m)
         | _ -> EvalAttribArgExpr SuppressLanguageFeatureCheck.No g x
 
+    /// Match an Int32 constant expression
+    [<return: Struct>]
+    let (|Int32Expr|_|) expr =
+        match expr with
+        | Expr.Const(Const.Int32 n, _, _) -> ValueSome n
+        | _ -> ValueNone
+
+    /// start..finish
+    /// start..step..finish
+    [<return: Struct>]
+    let (|IntegralRange|_|) g expr = tryMatchIntegralRange g expr
+
 [<AutoOpen>]
 module internal ResumableCodePatterns =
 

src/Compiler/TypedTree/TypedTreeOps.Transforms.fsi

@@ -191,19 +191,6 @@ module internal TupleCompilation =
     /// Make a TAST expression representing getting an item from a tuple
     val mkGetTupleItemN: TcGlobals -> range -> int -> ILType -> bool -> Expr -> TType -> Expr
 
-    [<return: Struct>]
-    val (|Int32Expr|_|): Expr -> int32 voption
-
-    /// Matches if the given expression is an application
-    /// of the range or range-step operator on an integral type
-    /// and returns the type, start, step, and finish if so.
-    ///
-    /// start..finish
-    ///
-    /// start..step..finish
-    [<return: Struct>]
-    val (|IntegralRange|_|): g: TcGlobals -> expr: Expr -> (TType * (Expr * Expr * Expr)) voption
-
     [<RequireQualifiedAccess>]
     module IntegralConst =
         /// Constant 0.
@@ -275,6 +262,19 @@ module internal ConstantEvaluation =
 
     val EvaledAttribExprEquality: TcGlobals -> Expr -> Expr -> bool
 
+    [<return: Struct>]
+    val (|Int32Expr|_|): Expr -> int32 voption
+
+    /// Matches if the given expression is an application
+    /// of the range or range-step operator on an integral type
+    /// and returns the type, start, step, and finish if so.
+    ///
+    /// start..finish
+    ///
+    /// start..step..finish
+    [<return: Struct>]
+    val (|IntegralRange|_|): g: TcGlobals -> expr: Expr -> (TType * (Expr * Expr * Expr)) voption
+
 [<AutoOpen>]
 module internal ResumableCodePatterns =