Prepare the base LoweringVisitor class for the upcoming refactoring by adding shared helper methods and consolidating duplicated visitor methods. This commit adds infrastructure without changing any observable behavior -- the subclass visitor methods still override the new base class methods via hiding.

**New helper methods in LoweringVisitor:**
- InferAttributeStructure: determines quote style from attribute syntax
- ComputeAttributeValueSourceSpan: computes source span of attribute values
- ExtractAttributeData: extracts attribute name/value pairs for tag helper binding (avoids re-scanning the syntax tree in the resolution phase)
- ComputeSourceSpanFromChildren: aggregates child source spans (replaces duplicated inline logic in CSharp expression visitors)

**Consolidated visitor methods moved to base class:**
- VisitMarkupDynamicAttributeValue, VisitMarkupLiteralAttributeValue, VisitCSharpTemplateBlock, VisitCSharpExpressionLiteral: were duplicated across LegacyFileKindVisitor and ComponentFileKindVisitor with minor differences. The new base versions are unified and include awareness of the _insideUnresolvedAttribute flag (used by later commits).
- VisitAttributeValue, Combine: shared attribute value merging logic

**Other changes:**
- Added class-level documentation explaining the phase's role
- Moved LooksLikeAComponentName to top-level class scope (needed by the resolution phase in a later commit)
- Added _insideUnresolvedAttribute field to base class (set by visitor changes in the next commit)

The subclass methods are marked with 'new' to make the intentional hiding explicit. They will be removed in the following commits when each visitor is refactored to use the base class implementations.

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

With the shared infrastructure in place, refactor all three visitor subclasses to produce unresolved IR nodes instead of resolved tag helper nodes.

**Core architectural change:**
Switch ExecuteCore to use the pre-tag-helper syntax tree. The lowering phase now runs before the tag helper rewrite phase, so elements that might be tag helpers appear as regular MarkupElementSyntax (not MarkupTagHelperElementSyntax). This means the VisitMarkupTagHelper* methods are no longer called and can be removed. Instead, ALL elements are lowered as unresolved ElementOrTagHelperIntermediateNode, with pre-computed data for the resolution phase.

**LegacyFileKindVisitor changes:**
- VisitMarkupElement now wraps all elements in ElementOrTagHelperIntermediateNode with pre-computed boundary indices (StartTagEndIndex, BodyEndIndex), extracted attribute data, and tag structure flags
- VisitMarkupAttributeBlock creates MarkupOrTagHelperAttributeIntermediateNode with two pre-computed fallback forms: AsTagHelperAttribute (merged attribute value via base VisitAttributeValue) and AsMarkupAttribute (full attribute as HTML via new LowerAttributeAsHtml)
- Removed 7 VisitMarkupTagHelper* overrides (dead code with pre-rewrite tree)
- Removed duplicate VisitAttributeValue/Combine (now inherited from base)
- VisitHtmlContent gains boundary awareness to prevent merging across regions

**ComponentFileKindVisitor changes:**
- Same unresolved pattern: VisitMarkupElement wraps in ElementOrTagHelperIntermediateNode with IsComponent=true
- Attributes get fallback forms like Legacy
- Removed 9 VisitMarkupTagHelper* overrides and duplicate methods
- Removed LooksLikeAComponentName (moved to top-level in prior commit)

**ComponentImportFileKindVisitor changes:**
- Removed dead DefaultVisit and VisitMarkupTagHelperElement overrides
- Uses ComputeSourceSpanFromChildren helper (added in prior commit)

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

Add BuildLegacyTagHelper and all its helper methods, completing the legacy (.cshtml) tag helper construction path. This handles how the resolution phase converts unresolved elements that match legacy tag helpers into TagHelperIntermediateNode IR.

The legacy construction algorithm processes each attribute on the element:
- Minimized bound attributes (e.g., <input disabled>) -> create property node with empty children
- Bound attributes with values -> create property node, then dispatch to shared value lowering pipeline (stubbed, implemented in following commit)
- Unbound attributes -> convert pre-parsed HTML values back to tag helper form via ConvertValueChildren/PopulateUnboundAttributeValue

The key complexity is ConvertValueChildren, which must reverse the lowering phase's pre-parsed HTML structure. During lowering, attribute values were expanded into HtmlAttributeValue and CSharpExpressionAttributeValue nodes. The legacy construction path must convert these back into flat token sequences that TagHelperPropertyIntermediateNode expects.

Also adds ConvertUnresolvedValuesToBasicForm (shared between legacy and component paths) which converts unresolved attribute value IR nodes into standard HtmlContent/CSharpExpression shapes.

NOTE: LowerUnresolvedAttributeValues is stubbed -- the shared value lowering pipeline that handles string vs non-string attribute value conversion will be implemented in a following commit. BuildComponentTagHelper remains stubbed as well.

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

Add BuildComponentTagHelper and all its helper methods, completing the component (.razor) tag helper construction path. This handles how the resolution phase converts unresolved elements that match Blazor component tag helpers into TagHelperIntermediateNode IR.

The component construction algorithm processes each attribute:
- Directive attributes (@Bind, @OnClick, @ref) -> ConvertToUnresolvedDirectiveAttribute with parameter support (e.g., @Bind:after, @OnClick:preventDefault)
- Bound properties (Value, Class) -> ConvertToUnresolvedBoundProperty
- Unbound HTML attributes -> ConvertToUnresolvedUnboundAttribute

Key differences from legacy construction:
- Components support directive attributes with rich parameter binding
- Component attributes undergo NormalizeBoundPropertyChildren to merge adjacent CSharp tokens and match the expected IR structure
- Components use ConvertExpressionAttributeValuesToCSharpExpression to normalize expression attribute values into CSharpExpressionIntermediateNode

Also adds shared component post-processing helpers:
- ConvertComponentAttributeToTagHelper: handles special attribute types (HtmlAttribute, ComponentAttribute, SplatAttribute)
- CopyAsTagHelperAttributeValues: copies attribute values into expected tag helper property structure
- FlattenToDirectCSharpTokens/FlattenDirectiveChildrenToCSharpTokens: recursive token flattening for directive parameter matching

NOTE: LowerUnresolvedAttributeValues remains stubbed -- the shared value lowering pipeline will be implemented in the following commit.

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

Replace the LowerUnresolvedAttributeValues stub with the full shared value lowering pipeline. This is the final piece of the resolution phase -- it handles converting unresolved attribute value IR nodes into their final CSharp/HtmlContent form for both legacy and component tag helpers.

The value lowering pipeline dispatches based on two axes: (1) string vs non-string attribute type (determines output structure), and (2) legacy vs component context (determines lowering strategy).

**Non-string value lowering (produces CSharp tokens):**
- Legacy: ClassifyValueContent examines the attribute's children to detect the pattern -- implicit expression, explicit expression, code block, or mixed content. Each has specialized handling: implicit expressions extract content from source text, explicit @(expr) emits structured @, (, content, ) tokens, code blocks preserve CSharpCode nodes directly, and mixed content with @@ escapes emits CSharpExpression for escapes.
- Component: simpler -- flatten each child directly to CSharp tokens using FlattenToDirectCSharpTokens recursive helper.

**String value lowering (produces HtmlContent/CSharp nodes):**
- Legacy: groups adjacent literal tokens into 'pending parts' that are flushed as HtmlContent nodes, with CSharp expressions emitted inline. Adjacent literals are batched into single HtmlContent nodes.
- Component: processes each child individually, converting expression attribute values inline and merging adjacent HtmlContent nodes.

Also adds remaining utility methods: EmitExplicitExpressionTokens, EmitParenthesizedExpressionTokens, EmitEscapedAtCSharpExpression, CollectAllTokenContent, and CollectUnresolvedLiteralContent.

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

Insert DefaultTagHelperResolutionPhase into the compiler pipeline between lowering and the tag helper rewrite phase. The new phase order is: Discovery -> Lowering -> Resolution -> Rewrite -> ...

Lowering now runs first on the original syntax tree, and resolution handles tag helper binding on IR nodes.

Downstream fixes required by the new pipeline:
- SourceGeneratorProjectEngine: change split point and re-run from discovery+1 when tag helpers change (since lowering now produces unresolved nodes dependent on discovery results)
- ComponentLoweringPass: transfer diagnostics from TagHelperIntermediateNode to ComponentChildContentIntermediateNode during child content rewriting
- ComponentBindLoweringPass: guard against empty children in @Bind:event parameters (unresolved pipeline can produce zero-child parameter nodes)
- ComponentTypeArgumentIntermediateNode: handle HtmlContent form of type argument values produced by the unresolved pipeline

Note: existing tests are updated in the following commit.

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

Adapt tests to the new compiler pipeline where resolution runs after lowering as a separate phase.

Test logic changes:
- NodeWriter tests: update ExecutePhasesThrough to target DefaultTagHelperResolutionPhase instead of the lowering phase, and use FindDescendant<T>() for robust IR traversal
- DefaultRazorTagHelperBinderPhaseTest: refactor from syntax-tree-based to IR-based assertions, since the binder phase now feeds into lowering+resolution rather than rewriting the syntax tree directly
- RazorProjectEngineTest: update phase ordering assertion
- LoweringPhaseIntegrationTest: update phase endpoint

IR baseline updates (499 files) -- systematic differences from the new pipeline:
- Source span adjustments from different boundary computation
- LazyIntermediateToken -> IntermediateToken type changes
- HtmlContent span changes for whitespace between tag helper attributes

No codegen, mapping, or diagnostic baselines change -- only .ir.txt

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

Add end-to-end compilation tests exercising real-world Blazor component patterns through the source generator pipeline. These catch regressions that IR-level tests miss by verifying actual C# compilation succeeds:

- Router with CascadingAuthenticationState (default Blazor template pattern)
- @Bind with generic components
- RenderFragment<T> implicit context variables in nested wrappers
- AuthorizeView with nested ChildContent and RenderFragment
- Various component nesting depths

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

Add API helpers and reduce allocations per review suggestions:
- Add IntermediateNodeCollection.AddRange(PooledArrayBuilder) overload
  to replace foreach+Add loops when copying from pooled builders
- Add TagHelperMatchingConventions.HasAttributeMatches() for
  existence-only checks, avoiding PooledArrayBuilder allocation when
  the actual matches aren't needed
- Replace PooledArrayBuilder<string> + string.Concat(ToArray()) with
  pooled StringBuilder at all 4 content-collection sites, eliminating
  intermediate array allocations
- Update CollectAllTokenContent to take StringBuilder directly

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

Address review comments from davidwengier:
- Use 'or' pattern match for type checks in component attribute
  handling (ComponentTagHelperResolver)
- Use property pattern for HasMissingEndCloseAngle + EndTagSpan
  check (DefaultTagHelperResolutionPhase)
- Remove leftover comments from deleted VisitMarkupDynamicAttributeValue
  method that were incorrectly left above VisitCSharpExplicitExpression
  (DefaultRazorIntermediateNodeLoweringPhase)

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

- Replace HashSet<string> with PooledHashSet<string> for
  renderedBoundAttributeNames in both Component and Legacy resolvers,
  avoiding per-element HashSet allocation. Uses try/finally for
  disposal since PooledHashSet is a ref struct that cannot be passed
  by ref from a using declaration.
- Change Children.Count > 0 to > 1 for merged source span computation
  since a single child's source span is already set directly and
  doesn't need merging.

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

Refactor ConvertComponentAttributeToTagHelper to take HtmlAttributeIntermediateNode
directly instead of IntermediateNode with a type check. At the call site, split
the type check so HtmlAttributeIntermediateNode calls the method while other
already-resolved attribute types (ComponentAttribute, Splat, SetKey,
ReferenceCapture) are added directly to the tag helper node.

Suggested by ToddGrun.

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