Import: share a referenced project's CCU instead of pickling it

[auduchinok]

A project reference pickles its signature once and every consumer unpickles its own copy: five projects
referencing one hub hold five copies of its signature TAST. The pickled tree is already in the shape
consumers need, so offer it directly through IImportedProjectCcu, and pickle only when something asks.
Depends on the shared imported assemblies change (#20296), whose keys let a consumer establish it will hold
the same ccus.

Four things make it usable:

• Remapped against a ccu made for this view, not the project's live one, which a consumer would else hold
  whole.
• PruneExportedSignatureInPlace brings it to the shape unpickling produces: no value definitions, no
  display-only data, no compiled-representation cache. Rescoping happens in the same traversal that builds
  the tree - ILScopeRef.Local is what internal is rooted at, so a consumer would otherwise read the
  reference's internals as its own.
• Every non-local reference is re-pointed at the reading project's ccu of the same name, as u_ccuref does
  for a consumer reading the bytes; a name the reader lacks keeps ours. This is what lets a consumer on
  another framework take the contents.
• What each name bound to is recorded, and a second consumer takes that copy only where it resolves all of
  them alike. Consumers that disagree get a copy each, capped at eight.

Binding runs once the batch is registered and before anything relinks: an assembly unpickled beside it
resolves the names it mentions against what is registered, and a delayed CCU is an error there rather than
a wait.

Solution	Projects	main	This	Retained
ReSharper.FSharp	10	385.94 MB	304.64 MB	-81.30 MB (-21.1%)
Fantomas	8	350.42 MB	275.79 MB	-74.63 MB (-21.3%)
FSharp.Compiler.Service	14	879.43 MB	818.39 MB	-61.04 MB (-6.9%)
FsToolkit.ErrorHandling	8	87.77 MB	69.36 MB	-18.42 MB (-21.0%)
Oxpecker	16	131.67 MB	114.24 MB	-17.43 MB (-13.2%)
Prime	5	112.22 MB	97.93 MB	-14.29 MB (-12.7%)
IcedTasks	7	96.97 MB	92.37 MB	-4.61 MB (-4.8%)
consoleapp	1	29.38 MB	29.37 MB	0.00 MB

The numbers are smaller due to other FSharpChecker creation flags.

consoleapp has no project references. Not all of this is the handover: switching the handover alone off and
on inside one build moves the compiler's own solution by 2 MB rather than 61, the rest coming from dropping
the language version out of the import reuse key, which lets projects that differ only in it share one
imported graph.

Also fixes a check-then-act race in BackgroundCompiler that predates this: builders were cached without a
second look under the gate, so callers arriving together each built the project, and a project built twice
is two of everything it imports. Nothing here survives that.

[github-actions]

❗ Release notes required

You can open this PR in browser to add release notes: open in github.dev

---

✅ Found changes and release notes in following paths:

Change path	Release notes path	Description
`src/Compiler`	docs/release-notes/.FSharp.Compiler.Service/11.0.100.md

[auduchinok]

This is ready.

[T-Gro]

🤖 🕵️ AI review — verify independently.

[T-Gro]

🤖 🕵️ FS3261 despite --checknulls- after another project warms the same checker: this copy keeps the cached project's checkNullness (both compiler modes).

// First project: --langversion:8.0 --checknulls+
module Warm
let x = 1

// Then, same FSharpChecker:
// --langversion:9.0 --checknulls- --warnaserror+
module Target
let x: string = null
// Warm checker: FS3261. Fresh checker: no diagnostics.

[T-Gro]

🤖 🕵️ Second consumer gets FS0001 (Shared.Carried versus Shared.Carried): cached Middle.dll stays linked to the first consumer's bound copy. Sharing disabled: both pass.

// Dependency.fs: two distinct projects, both named Dependency
module Dependency
type Marker = Marker

// Shared.fs: one project referencing Dependency project 1
module Shared
type Carried = { Value: Dependency.Marker option }

// Middle.fs: compiled DLL referencing Shared.dll and Dependency.dll
module Middle
let carry (x: Shared.Carried) = x

// Check consumer 1, then consumer 2, using the same checker:
// 1 references Shared project + Dependency project 1 + Middle.dll
// 2 references SAME Shared project + Dependency project 2 + SAME Middle.dll
module Consumer
let x: Shared.Carried = Middle.carry { Value = None }

[T-Gro]

🤖 🕵️ FS0001 on a valid consumer extension with shared project references: the exported trait retains the producer's resolution context. Unpickling clears it, letting the consumer supply its own.

// Library.fs, --langversion:preview
module Library
let inline negate (x: ^T) =
    (^T : (static member Negate: ^T -> ^T) x)

// Consumer.fs, --langversion:preview; references Library project
module Consumer
type System.Int32 with
    static member Negate(x: int) = -x
let value = Library.negate 42
// Sharing on: FS0001, int lacks Negate. Off: no diagnostics.

[T-Gro]

🤖 🕵️ Missing-reference FS0074 disappears: the producer fallback lets the consumer use the public Leaf.Carried type without referencing Leaf. Sharing disabled: FS0074; enabled: no diagnostics.

// Leaf.fs
module Leaf
type Carried = { Value: int }

// Middle.fs, references Leaf project
module Middle
let make () : Leaf.Carried = { Value = 1 }

// Consumer.fs, references Middle project but NOT Leaf
module Consumer
let value = (Middle.make()).Value

[T-Gro]

🤖 🕵️ Imported anonymous-record assembly metadata becomes (None, ""): its owner still points to the compiling CCU rather than viewedCcu, for both struct and reference records.

// Library.fs
module Library
let record = {| Value = 1 |} // also: struct {| Value = 1 |}

// Consumer.fs, references Library project
module Consumer
let record = Library.record

// FCS client: apply to Library.record from the referenced assembly
let metadata (value: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue) =
    let owner = value.FullType.AnonRecordTypeDetails.Assembly
    owner.FileName, owner.QualifiedName
// Sharing on: (None, ""). Off: output path and full assembly identity.

[T-Gro]

🤖 🕵️ MembersFunctionsAndValues returns the default C.M twice: the explicit implementation survives pruning and relinks to it. p_tcaug filters these entries before export.

// Library.fs
module Library
type IFoo =
    abstract M: unit -> int
type C() =
    abstract M: unit -> int
    default _.M() = 2
    interface IFoo with
        member _.M() = 1

// FCS client: apply to imported Library.C in a referencing project
let members (classType: FSharp.Compiler.Symbols.FSharpEntity) =
    classType.MembersFunctionsAndValues
    |> Seq.filter (fun m -> m.LogicalName = "M" && not m.IsDispatchSlot)
    |> Seq.map (fun m -> m.DisplayName, m.IsExplicitInterfaceImplementation)
    |> Seq.toArray
// Sharing on: [|("M", false); ("M", false)|]. Off: [|("M", false)|].

[github-actions]

🔍 Tooling Safety Check — Affects-Compiler-Output, Affects-Design-Time
Affects-Compiler-Output: Typed-tree remapping changes project-reference compilation inputs.
Affects-Design-Time: FCS background compilation now shares imported project signatures.

Generated by PR Tooling Safety Check · gpt56 707.4K · ◷