[Slai.life (huong8373tt-beep)]

Summary

• Flatten nested named string unions when generating C# enums.
• Preserve standard terminal members such as Succeeded, Failed, and Cancelled when an extensible provisioning-state union includes ResourceProvisioningState.
• Keep recursive union references safe and preserve existing support for open string, null, unnamed literals, and inline literal unions.
• Add a regression test and a Chronus change description.

Fixes #12367

Validation

• pnpm --filter @typespec/http-server-csharp build
• pnpm --filter @typespec/http-server-csharp test -- --run src/components/enums/enums.test.tsx
  • 21 test files passed
  • 236 tests passed
• pnpm exec prettier --check packages/http-server-csharp/src/components/enums/enums.tsx packages/http-server-csharp/src/components/enums/enums.test.tsx
• pnpm --filter @typespec/http-server-csharp lint
• git diff --check

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[azure-pipelines]

Azure Pipelines:
Successfully started running 1 pipeline(s).
1 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[Copilot]

🟡 Changes recommended

Nested-union flattening introduces conflicting enum members, invalid variant references that prevent compilation, and lost nullability for nullable wrappers.

3 open issues

• Resolve duplicate enum member names and conflicting defaults · New
• Handle nested non-literal union variants in type resolution · New
• Preserve nullability for flattened enum references · New

What changed in this PR

This PR addresses #12367 by flattening nested string unions in the C# HTTP server emitter, allowing provisioning-state enums to include standard terminal states alongside user-defined states.

Changes:

• Recursively collect nested string-literal members with cycle detection.
• Add a regression test for nested provisioning-state members.
• Add a Chronus fix entry for @typespec/http-server-csharp.

File	Description
packages/​http-server-csharp/​src/​components/​enums/​enums.tsx	Shares recursive member collection between enum detection and generation.
packages/​http-server-csharp/​src/​components/​enums/​enums.test.tsx	Checks that nested terminal states are included.
.chronus/​changes/​fix-http-server-csharp-nested-provisioning-state-2026-10-31.md	Documents the nested-union enum fix.

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

Addressed the three review findings in commit 5b0ea2720.

• Reject conflicting flattened enum member names/values instead of generating ambiguous C# members.
• Keep named nested union variants on the existing type-resolution path, so references such as Outer.Group remain valid.
• Preserve nullable wrappers around named nested unions rather than treating them as non-nullable enum references.

Added regression coverage for all three cases. Validation:

• @typespec/http-server-csharp Vitest suite: 241 passed
• Oxlint: 0 warnings / 0 errors
• Prettier check: passed
• git diff --check: passed

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🟡 Changes recommended

Union handling can reference enums that are never emitted, discard permitted nullability, and reject previously supported anonymous literal unions.

2 open issues

• Avoid nullable references to uncollected synthetic enums · New
• Preserve anonymous literal unions in named variants · New

1 previously missed issue

In code that hasn't changed since last review

Preserve nullability in anonymous nested unions

packages/​http-server-csharp/​src/​components/​enums/​enums.tsx:187

For union Maybe { "ready" | null }, this allows the anonymous nested union's null to be discarded and makes isUnionEnum(Maybe) true. type-expression/type-expression.tsx:207–208 then renders a non-nullable Maybe, so a required property cannot represent an allowed null value; keep nested nullable unions on the existing fallback path or propagate their nullability into type resolution.

3 resolved since last review

• Preserve nullability for flattened enum references
• Handle nested non-literal union variants in type resolution
• Resolve duplicate enum member names and conflicting defaults

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

Addressed the follow-up review findings in the current working tree:

• preserve anonymous inline literal unions in named variants;
• keep named nested-union variants on their existing type-resolution path;
• flatten direct nullable wrappers into an emitted enum while preserving ? in the generated C# type expression;
• retain conflict detection for duplicate member names/values.

Validation completed locally:

• http-server-csharp Vitest suite: 21 files, 243 tests passed;
• TypeScript tsc --noEmit: passed;
• Oxlint on changed files: 0 warnings / 0 errors;
• Prettier check: passed;
• git diff --check: passed.

I will push this as the next commit after the final diff check.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Slai.life (huong8373tt-beep)]

Pushed aa77e0f7d with the completed follow-up fixes and regression coverage.

The PR now preserves direct-null union semantics by emitting the flattened enum and rendering it as nullable (?), while retaining named nested-union fallback behavior and anonymous inline-literal flattening. The local verification in the previous comment completed successfully before push.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🟡 Changes recommended

Critical union-enum issues drop allowed nullability, emit invalid Status?? types, and allow generated C# name collisions that produce incorrect default initializers.

1 open issue

• Prevent duplicate nullable suffixes for optional enum values · New

2 previously missed issues

In code that hasn't changed since last review

Preserve nullability for anonymous union enums

packages/​http-server-csharp/​src/​components/​enums/​enums.tsx:183

The union.name exception accepts nullable anonymous unions, so union Status { "ready" | null } now qualifies as an enum even though isNullableUnionEnum only checks direct variants; TypeExpression consequently emits non-nullable Status, losing the allowed null (type-expression.tsx:208–209). Reject nested open/null variants for anonymous unions too, or propagate their nullability before accepting them.

Detect enum member collisions after C# name normalization

packages/​http-server-csharp/​src/​components/​enums/​enums.tsx:226

With union Inner { ready: "inner" } and union Outer { Ready: "outer", Inner }, the raw names pass this check but both normalize to Ready under the naming policy used at enums.tsx:124. getEnumDefaultInitializer (model-helpers.ts:111–112) then generates Outer.Ready for both string defaults, although they must serialize differently. Reject collisions using the generated C# identifiers, or disambiguate members and their initializer references, with a regression covering both defaults.

2 resolved since last review

• Avoid nullable references to uncollected synthetic enums
• Preserve anonymous literal unions in named variants

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

Addressed the latest review in dff404f3b.

• Enum-member conflict detection now uses the same C# name normalization used during emission, so ready and Ready cannot silently produce conflicting Ready members/defaults.
• Nullable union-enums now have a single suffix owner: callers that already render optional/nullable syntax request the non-suffixed enum type; direct type expressions retain ?. This covers models, error constructors, business interfaces, controllers, and mock implementations.
• The nullability check also follows anonymous inline union wrappers, so an inline ... | null member cannot be flattened while losing nullability.

Validation:

• @typespec/http-server-csharp Vitest suite: 21 files, 244 tests passed.
• Prettier: passed.
• Oxlint: 0 warnings / 0 errors.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🟡 Changes recommended

Nested unions and pass-through expressions can produce invalid C# types such as Status?? because nullability suppression is not consistently applied.

3 open issues

• Preserve nullable=false through union and property pass-throughs · New
• Avoid duplicate nullable suffix for nested nullable unions · New
• Prevent duplicate nullable suffixes for optional enum values

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

Addressed the latest review findings in commit 9cc18133f.

• Forward nullable through UnionVariant, ModelProperty, nullable-union unwrapping, and same-kind union pass-throughs so callers do not create duplicate nullable suffixes.
• Keep explicit null reachable through nested named unions when determining enum nullability.
• Added a regression covering nullable={false} through a nested nullable union.

Validation:

• Full @typespec/http-server-csharp Vitest suite: 21 files, 245 tests passed.
• Oxlint on changed files: 0 warnings / 0 errors.
• Prettier check: passed.
• git diff --check: passed.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🟡 Changes recommended

A critical issue remains: named inline union groups containing non-string-literal variants are accepted as enums, causing references such as Outer.Group to generate C# that does not compile.

2 open issues

• Exclude mixed inline groups from enum generation · New
• Prevent duplicate nullable suffixes for optional enum values

2 resolved since last review

• Avoid duplicate nullable suffix for nested nullable unions
• Preserve nullable=false through union and property pass-throughs

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

I’m checking the latest review feedback against the current commit before making any changes. I’ll update the PR only if the feedback identifies a reproducible issue.

[Slai.life (huong8373tt-beep)]

Addressed the latest Copilot review findings in commit ec7653ca0.

• Anonymous inline groups are flattened only when every member is a string literal; nullable/open/mixed groups remain on the normal union path so their semantics and references are preserved.
• Updated the nullable=false regression to cover a direct nullable union-enum without introducing an unresolved nested synthetic reference.

Validation:

• Full @typespec/http-server-csharp Vitest suite: 21 files, 246 tests passed.
• Oxlint on changed files: 0 warnings / 0 errors.
• Prettier check: passed.
• git diff --check: passed.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🔵 Needs a closer look

Human assessment is needed because nested-union handling can generate unresolved enum references, while nullable-signature coverage gaps and exponential traversal add further uncertainty.

1 open issue

• Prevent duplicate nullable suffixes for optional enum values

1 resolved since last review

• Exclude mixed inline groups from enum generation

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

Addressed the latest review findings in commit 181e33d1d.

• Named variants that contain anonymous string-literal unions continue to flatten, while named variants containing nullable or mixed inline unions remain on the existing non-enum path.
• Added an end-to-end nullable parameter regression covering nested nullable union enums through generated interfaces, mocks, and controllers.

Validation:

• Full @typespec/http-server-csharp Vitest suite: 21 files, 246 tests passed.
• Oxlint on changed files: 0 warnings / 0 errors.
• Prettier check: passed.
• git diff --check: passed.

Slai Agent Runtime performed the investigation, implementation, and test execution. The account owner authorized this contribution and is responsible for its content.

[Copilot]

🔵 Needs a closer look

Human assessment is needed because union-variant handling can produce unresolved enum references, while shared nested unions can trigger exponential traversal work.

1 open issue

• Prevent duplicate nullable suffixes for optional enum values

_{Review effort: Balanced}

[Slai.life (huong8373tt-beep)]

I reviewed the latest Copilot findings in review 5721614214 against the current head ec7653ca0. The mixed named inline-group case is now covered by the existing guard: named variants are flattened only when their anonymous union contains string literals exclusively; nullable/open/mixed groups stay on the normal union path. The nullable suffix handling is also covered by the nullable propagation and nested-nullable regression already in the current head. The focused verification passes: enums.test.tsx and nullable-parameters.test.ts — 19 tests passed; Prettier passed; git diff --check is clean. No additional code change is necessary for these findings.

[Slai.life (huong8373tt-beep)]

I reviewed the findings in reviews 5721614214 and 5721723594 against the current head 181e33d1d. No additional code change is needed: named variants containing anonymous literal-only unions remain flattenable, while named nullable/open/mixed groups stay on the normal union path; the nullable suffix is owned by the caller via nullable propagation, preventing ?? in optional parameters and nested nullable unions. The focused enum/type-expression and nullable-parameter regressions pass locally, and the full http-server-csharp suite passed (246 tests). I will leave the current implementation unchanged unless a maintainer identifies a reproducible failure.