refactor: dead code cleanup: generated partial hooks

[damyanpetev]

Removes the generated partial void extensibility hooks from src/components/Blazor/. They were a code-generation affordance: a seam for hand-written partials to intercept generated code. Now that the source is hand-maintained, the seam has no reason to exist — a hook with no implementation is unreachable code, and a hook with one is an indirection that reads better inlined at the call point.

After this series there are zero partial void members in src/. One commit per family so each can be reviewed on its own. Continues #316 (OnCreated* constructor hooks).

Commit	Family	Declarations	Call sites	Implementations	Lines
1	SerializeCoreIgb<X>	141	141	0	-696
2	OnEventUpdating<Prop>	16	16	0	-64
3	On<Prop>Changing	538	46	1 (inlined)	-666
4	FindByName<X>	141	141	5 (inlined)	-2686
5	OnHandling<Event>	121	121	2 (renamed)	-569
6	OnIgbTab*, GetSerializableTabsCollection	3	3	1 (inlined)	-12

Commits 1–6 total 149 files, +137 / -4830.

---

Commit 1 — SerializeCoreIgb<X>

Every generated type that overrides SerializeCore declared a hook and called it as the first statement after base.SerializeCore(ser):

partial void SerializeCoreIgbAccordion(RendererSerializer ser);

internal override void SerializeCore(RendererSerializer ser)
{
    base.SerializeCore(ser);

    SerializeCoreIgbAccordion(ser);

    if (IsPropDirty("SingleExpand"))
    { ser.AddBooleanProp("singleExpand", this._singleExpand); }
    ...
}

141 declarations, 141 call sites, 0 implementations repo-wide, including tests/ and stories/. Unlike a bare declaration, which the compiler erases for free, each of these also occupied a line inside the per-render property snapshot path.

Change	Count
partial void SerializeCoreIgb<X>(RendererSerializer ser); declarations removed	141
SerializeCoreIgb<X>(ser); call sites removed	141
SerializeCore overrides in classes with no declared serializable properties left with nothing to do, removed entirely	22

Commit 2 — OnEventUpdating<Prop>

The inbound half of two-way binding. When the client raises the change event for a bound property, the generated handler converts the payload, called this hook to let a partial adjust the value in flight, then wrote it back and invoked <Prop>Changed:

newValueSelected = (bool)(args.Detail);
;
OnEventUpdatingSelected(this._selected, ref newValueSelected);
if (UseDirectRender)
{
    this.Selected = newValueSelected;
}

Also removed: the 16 stray empty statements (; alone on a line)

---

Commit 3 — On<Prop>Changing

The generator declared one of these next to every property backing field, and the setter called it so a partial could rewrite the incoming value before the property stored it:

private IgbChatOptions? _options;

partial void OnOptionsChanging(ref IgbChatOptions? newValue);

[Parameter]
public IgbChatOptions? Options
{
    get { return this._options; }
    set
    {
        OnOptionsChanging(ref value);
        MarkPropDirty("Options");
        ...
    }
}

Change	Count
partial void On<Prop>Changing(ref T newValue); declarations removed	538
of which had no call site whatsoever	492
On<Prop>Changing(ref value); call sites removed	45
implementations folded into the setter	1

The one implementation

IgbChat.OnOptionsChanging lived in src/componentsBase/WebInputs/Chat.cs and normalized the incoming options object. Moved into the Options setter it was called from, which is now self-explanatory:

set
{
    // Never store a null options object, and input attachments are not supported yet.
    value ??= new IgbChatOptions();
    value.DisableInputAttachments = true;
    MarkPropDirty("Options");
    ...
}

---

Commit 4 — FindByName<X>

Name-based ref resolution: the client sends {"refType": "name", "id": "…"} and FindByName maps it back to the .NET instance. Every generated type declared a hook and an override that tried base, then the hook, then gave up:

partial void FindByNameAvatar(string name, ref object item);
public override object FindByName(string name)
{
    var baseResult = base.FindByName(name);
    if (baseResult != null) { return baseResult; }

    object item = null;
    FindByNameAvatar(name, ref item);
    if (item != null) { return item; }

    return null;
}

With the hook unimplemented that whole override reduces to return base.FindByName(name), so 135 of the 141 were forwarding-only and are removed entirely.

The 5 implementations (Accordion, Dropdown, Select, TileManager, Tree) were five byte-identical copies of the same ContentItems scan sitting in componentsBase/WebInputs. Each is now inlined into its own override, and the ref-parameter dance becomes a direct return:

foreach (var item in ContentItems)
{
    if (item.Name == name || item.ContainerId == name)
    {
        return item;
    }
}

IgbTabs is the sixth case — it keeps its override for the ActualTabsCollection lookup, minus the hook.

---

Commit 5 — OnHandling<Event>

Every event setter wrapped the hook in an onArgs lambda handed to SetHandler:

this.SetHandler<IgbExpansionPanelComponentEventArgs>(this.Name, "Opening", value, (args) =>
{
    OnHandlingOpening(args);

});

104 of the 121 lambdas contained nothing but the dead call. onArgs is an optional parameter that SetHandler null-checks before invoking (BaseRendererControl.cs:2952), so the argument is dropped outright rather than left as an empty lambda — one less closure allocated per wired event:

this.SetHandler<IgbExpansionPanelComponentEventArgs>(this.Name, "Opening", value);

The other 15 lambdas carry two-way binding write-back and keep their bodies, minus the hook call.

The 2 implementations become ordinary private methods named for what they do, called from the same point:

Was	Now
IgbTabs.OnHandlingChange	SyncSelectedTab
IgbInputBase.OnHandlingInputOcurred	RaiseValueChanging

Both stay in componentsBase/WebInputs beside the EnsureXHandled helpers they belong with. Only the hook indirection is gone — the call site now names a real method instead of dispatching to a partial that may or may not exist.

---

Commit 6 — the last three

• IgbTab.OnIgbTabInitializing / OnIgbTabDisposing — declared and called in OnInitializedAsync and Dispose, never implemented.

• IgbTabs.GetSerializableTabsCollection — declared and implemented in the same generated file, so the partial bought nothing. Its body assigned ActualTabsCollection unconditionally, which made the caller's read of _tabsCollection dead code:

  // was
  { var coll = this._tabsCollection; GetSerializableTabsCollection(ref coll); ser.AddCollectionProp("tabsCollection", coll); }
  // now
  { ser.AddCollectionProp("tabsCollection", ActualTabsCollection); }

---

Found while sweeping, not fixed here

IgbTab.Dispose() adds the tab to its parent collection instead of removing it (src/components/Blazor/Tab.cs:59):

public void Dispose()
{
    if (TabsParent != null)
    {
        var sv = (IgbTabs)TabsParent;
        sv.ContentTabsCollection.Add(this);   // Add, in Dispose
    }
}

OnInitializedAsync immediately above it does the identical Add. Compare IgbExpansionPanel.Dispose() in src/componentsBase/WebInputs/Accordion.cs, which calls ContentItems.Remove(this). This looks like a copy-paste fault in the generator template — a disposed tab is re-added to ContentTabsCollection, so the collection accumulates dead entries across re-renders. Left alone deliberately: it is a behaviour change that wants its own test and its own commit, not a line smuggled into a dead-code sweep.
Edit: #319

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.