Split TypedTreeOps.fs (12,569 lines) into 7 focused files

[T-Gro]

Motivation

TypedTreeOps.fs was the 3rd largest file in the compiler at 12,569 lines. Unlike the top 2 (CheckExpressions.fs, IlxGen.fs) which are dominated by monolithic mutual-recursion chains, TypedTreeOps had 23 small independent function groups and ~9,700 standalone functions — making it the best candidate for splitting.

Being a single flat module, it became a natural "catch-all" destination for any utility that touched the typed tree. Over time this led to arbitrary function placement — container type helpers next to XML doc encoding, free variable accumulators next to attribute classification, expression builders next to measure algebra. The lack of internal structure made it hard to discover what is available, understand boundaries, or know where new code should go.

This PR splits it into 7 files organized by compilation phase, with 32 [<AutoOpen>] modules organized by semantic purpose. All 69 files that open FSharp.Compiler.TypedTreeOps require zero changes — the [<AutoOpen>] attribute preserves full API compatibility.

Structure

📁 src/Compiler/TypedTree/
│
├── TypedTreeOps.Remap.fs                    (1,695 lines)
│   Foundation: type-level substitution, construction, equivalence
│   ├── TypeRemapping         — Type parameter substitution (remap*, inst*, copy*)
│   ├── MeasureOps            — Measure unit algebra and normalization
│   ├── TypeBuilders          — Type constructors (mkFunTy, mkByrefTy, mkArrayTy…)
│   ├── TypeAbbreviations     — Type abbreviation reduction and application
│   ├── TypeDecomposition     — Type stripping, destruction, predicates (strip*, dest*, is*, try*)
│   └── TypeEquivalence       — Type equivalence and comparison (*AEquiv*)
│
├── TypedTreeOps.ExprConstruction.fs         (1,563 lines)
│   Expression building, type testing, container type helpers
│   ├── ExprConstruction      — Expression node builders (mkLambda, mkLet, mkBind, mkWhile…)
│   ├── TypedTreeCollections  — Stamp-based collection types (ValHash, ValMultiMap, TyconRefMultiMap)
│   ├── TypeTesters           — Type predicates and metadata (is*Ty, actual*, metadata queries)
│   └── CommonContainers     — Built-in container helpers (Option, RefCell, Nullable, Choice, List…)
│
├── TypedTreeOps.FreeVars.fs                 (1,552 lines)
│   Free variable analysis and display/pretty-printing
│   ├── FreeTypeVars          — Free type variable accumulation (acc*, free*, Collect*, empty*/union*)
│   ├── MemberRepresentation  — Member type shape queries (Get*MemberType*, Partition*, ArgInfos*)
│   ├── PrettyTypes           — Type prettification for diagnostics (Prettify*, fullDisplayText*)
│   └── SimplifyTypes         — Type constraint simplification and hierarchy
│
├── TypedTreeOps.Attributes.fs               (2,547 lines)
│   IL/F# attribute infrastructure and debug printing
│   ├── ILExtensions          — IL attribute decoding and well-known attribute matching
│   ├── AttributeHelpers      — F# attribute classification, entity/val flags, compilation mapping
│   ├── ByrefAndSpanHelpers   — Byref-like and Span type helpers (depend on attribute infra)
│   └── DebugPrint            — Debug layout functions for typed tree nodes (*L, show*)
│
├── TypedTreeOps.Remapping.fs                (2,929 lines)
│   Signature operations and expression-level remapping
│   ├── SignatureOps          — Signature remapping, hiding, module wrapping (Compute*, IsHidden*)
│   ├── ExprFreeVars          — Expression-level free variable analysis (acc*, free*)
│   ├── ExprRemapping         — Expression remapping, copying, instantiation (remap*, copy*, inst*)
│   └── ExprAnalysis          — Expression shape queries, mutability, witness types, mkApps
│
├── TypedTreeOps.ExprOps.fs                  (2,362 lines)
│   Expression operations: address-of, folding, intrinsic makers
│   ├── AddressOps            — Address-of operations and mutability analysis
│   ├── ExprFolding           — Generic expression tree folding (FoldExpr, FoldImplFile)
│   ├── Makers                — Intrinsic expression constructors (179 mk* for calls, boxing, seq…)
│   └── ExprTransforms        — Expression transformations (Adjust*, Make*BetaReduce, eta-expand)
│
└── TypedTreeOps.Transforms.fs               (3,018 lines)
    Late-stage transforms: encoding, nullness, rewriting, lowering patterns
    ├── XmlDocSignatures      — XML documentation signature encoding
    ├── NullnessAnalysis      — Null semantics classification (TypeNull*, nullnessOfTy)
    ├── TypeTestsAndPatterns  — Type test helpers and comparison/equality patterns
    ├── Rewriting             — Generic expression tree rewriting (RewriteExpr, RewriteImplFile)
    ├── TupleCompilation      — Tuple compilation and optimized range loops
    ├── ConstantEvaluation    — Compile-time constant evaluation and IL field init
    ├── ResumableCodePatterns — Active patterns for resumable code lowering
    └── SeqExprPatterns       — Active patterns for seq expression lowering

Key design decisions

• [<AutoOpen>] on every module — zero caller changes needed. The 69 files that open FSharp.Compiler.TypedTreeOps continue to work unchanged.
• Compilation order respected — F# requires earlier files to be independent of later ones. The 7-file order follows the dependency graph: types → expressions → free vars → attributes → remapping → operations → transforms.

[github-actions]

⚠️ Release notes required, but author opted out

Warning

Author opted out of release notes, check is disabled for this pull request.
cc @dotnet/fsharp-team-msft