Initial support for nullable analysis for Unions #81721

AlekseyTs · 2025-12-16T19:43:40Z

No description provided.

AlekseyTs · 2025-12-17T16:04:00Z

@333fred, @RikkiGibson, @dotnet/roslyn-compiler Please review

AlekseyTs · 2025-12-17T20:26:11Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+
+            if (CheckDisallowedNullAssignment(operandType, parameterAnnotations, conversionOperand.Syntax))
+            {
+                LearnFromNonNullTest(conversionOperand, ref State);


;

I'll be adding a PROTOTYPE comment to cover this code path #Closed

333fred

Done review pass (commit 1)

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs

AlekseyTs · 2025-12-18T19:32:01Z

@dotnet/roslyn-compiler For a second review

AlekseyTs · 2025-12-19T16:32:38Z

@dotnet/roslyn-compiler For a second review

AlekseyTs · 2025-12-22T15:53:41Z

@dotnet/roslyn-compiler For a second review

CyrusNajmabadi · 2025-12-22T16:38:52Z

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

+                return property is
+                {
+                    IsStatic: false,
+                    DeclaredAccessibility: Accessibility.Public,


just checking, it's intentional that this is public, and not just accessible to the caller? #Resolved

Yes it is intentional. Definition of the interface from the spec:

public interface IUnion { // The value of the union or null object? Value { get; } }

BTW, this is not a new code, a member method got simply changed to a local function

Yes it is intentional. Definition of the interface from the spec:

Thanks :)

BTW, this is not a new code, a member method got simply changed to a local function

Understood. It was still something that i wanted to double check :)

CyrusNajmabadi · 2025-12-22T16:39:22Z

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

+                    DeclaredAccessibility: Accessibility.Public,
+                    IsAbstract: true,
+                    GetMethod: not null,
+                    SetMethod: null,


intentional that it definitely has no set method, not that it doesn't matter if it does/doesn't have it? #Resolved

intentional that it definitely has no set method, not that it doesn't matter if it does/doesn't have it?

Same response, intentional ,,,

Ok. This part was a bit odd to me though. it wasn't clear that a member that is a superset of what is needed is inadmissible. IMO, this would be worth bringing to an email/ldm for clarity. I'm totally fine if the resolution is "no, it can't have a setter". but i def want to know if that's the intent, vs "we don't care if it has a setter or not".

CyrusNajmabadi · 2025-12-22T16:41:11Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                        _variables[containingSlot].Symbol.GetTypeOrReturnType().Type is NamedTypeSymbol { IsUnionTypeNoUseSiteDiagnostics: true, UnionCaseTypes: not [] } unionType &&
+                        Binder.GetUnionTypeValuePropertyNoUseSiteDiagnostics(unionType) == (object)property:
+                    {
+                        // For union types where none of the case types are nullable, the default state for Value is "not null" rather than "maybe null".


is this only referring to 'nullable' for nullable-reference-types, or does this also encompass nullable value types? tahnks. #Resolved

is this only referring to 'nullable' for nullable-reference-types, or does this also encompass nullable value types?

This is referring to nullable in terms of nullable analysis, and covers both kinds of types. BTW, this quotes the feature spec.

CyrusNajmabadi · 2025-12-22T16:42:58Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                                    {
+                                        SetState(ref this.State, valueSlot, operandState);
+                                    }
+                                }


i'm curious if this code could be shared with the similar code on like 4276 #Resolved

i'm curious if this code could be shared with the similar code on lik

I will evaluate the possibility while working on the following changes

CyrusNajmabadi · 2025-12-22T16:43:37Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                            if (valueSlot > 0)
+                            {
+                                SetState(ref this.State, valueSlot, operandState);
+                            }


similar question here. there seems to be a common pattern of reading the operand state, making a new slot, and then storing state. #Resolved

similar question here.

The next change in the pipeline moves this code into VisitUnionConversion and it gets shared across the callers this way.

CyrusNajmabadi · 2025-12-22T16:44:13Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

                                    {
-                                        TrackNullableStateOfTupleConversion(conversionOpt, conversionOperand, conversion, targetType, operandType.Type, slot, valueSlot, assignmentKind, parameterOpt, reportWarnings: reportRemainingWarnings);
+                                        int slot = GetOrCreatePlaceholderSlot(conversionOpt);
+                                        if (slot > 0)


should this (and the valueslot check above) have assertions that these are greater than 0? or is tehre an expectation that you could get 0/negative? if so, perhaps comment that. #Resolved

should this ...

This is an existing code and I am not planning to add asserts or comments to it.

CyrusNajmabadi · 2025-12-22T16:44:54Z

Haven't looked at tests ye. want i want to better understnd this null walking code first.

AlekseyTs · 2026-01-06T17:38:52Z

@RikkiGibson, @dotnet/roslyn-compiler For a second review

CyrusNajmabadi · 2026-01-06T17:42:06Z

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

            var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
-            return HasTopLevelNullabilityImplicitConversion(source, destination) &&
-                ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo).Kind != ConversionKind.NoConversion;
+            Conversion conversion = ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo);


i know this didn't change. but so i understand better. what's the logic used to determine if the use site info can/should be discarded, vs having the caller of this pass in info to fill in that data? #Resolved

i know this didn't change. but so i understand better. what's the logic used to determine if the use site info can/should be discarded, vs having the caller of this pass in info to fill in that data?

I do not know if this answer is going to help much, but the decision is usually made based on the planned/expected usage pattern for the API and whether we will be interested in the info in the callers.

CyrusNajmabadi · 2026-01-06T17:43:28Z

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

-                ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo).Kind != ConversionKind.NoConversion;
+            Conversion conversion = ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo);
+            return conversion.Kind != ConversionKind.NoConversion &&
+                   (conversion.IsUnion || conversion.IsUserDefined || HasTopLevelNullabilityImplicitConversion(source, destination));


i guess i'm not understanding why having a conversion be a union or user-defined means that there are "any nullability implicit conversion". Does this fall out from something in the spec? something else? #Resolved

i guess i'm not understanding why having a conversion be a union or user-defined means that there are "any nullability implicit conversion". Does this fall out from something in the spec? something else?

The logic in HasTopLevelNullabilityImplicitConversion doesn't look appropriate for user-defined and union conversions because nullability doesn't transfer directly from source to result in these cases. The change was prompted by new tests that I added.

CyrusNajmabadi · 2026-01-06T17:44:32Z

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

-                    if (!conversions.HasTopLevelNullabilityImplicitConversion(s, d))
+                    Conversion conversion = conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u);
+
+                    if (!conversion.IsUserDefined && !conversion.IsUnion && !conversions.HasTopLevelNullabilityImplicitConversion(s, d))


this check seems to be the negation of the check done in HasAnyNullabilityImplicitConversion. Would it make sense to extract to some named helper that both could use that would then be clearer as to why it is the right check in both locations? #Resolved

this check seems to be the negation of the check done in HasAnyNullabilityImplicitConversion. Would it make sense to extract to some named helper that both could use that would then be clearer as to why it is the right check in both locations?

I do not think this is worthwhile and not planning doing that. There are other call sites for HasTopLevelNullabilityImplicitConversion

CyrusNajmabadi · 2026-01-06T17:44:58Z

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

-                    if (!conversions.HasTopLevelNullabilityImplicitConversion(s, d))
+                    Conversion conversion = conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast);
+
+                    if (!conversion.IsUserDefined && !conversion.IsUnion && !conversions.HasTopLevelNullabilityImplicitConversion(s, d))


same concern here. doing the same check in 3 places def makes it seem worthwhile to extract out. #Resolved

same concern here. doing the same check in 3 places def makes it seem worthwhile to extract out.

I have no plans doing that

CyrusNajmabadi · 2026-01-06T17:45:19Z

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs

-
-            return conversions.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(source, destination, ref useSiteInfo).Exists;
+            Conversion conversion = conversions.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(source, destination, ref useSiteInfo);
+            return conversion.Exists && (conversion.IsUnion || conversion.IsUserDefined || conversions.HasTopLevelNullabilityImplicitConversion(sourceWithAnnotations, destinationWithAnnotations));


here as well. #WontFix

having the same logic in 4 places def seems like something worth extracting. especially since, frm my readin ghere, if we updated one, we'd want to update all 4 of these.

CyrusNajmabadi · 2026-01-06T17:49:31Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                case PropertySymbol { Name: WellKnownMemberNames.ValuePropertyName } property when
+                        variable.ContainingSlot is > 0 and var containingSlot &&
+                        property.ContainingType.IsWellKnownTypeIUnion() &&
+                        _variables[containingSlot].Symbol.GetTypeOrReturnType().Type is NamedTypeSymbol { IsUnionTypeNoUseSiteDiagnostics: true, UnionCaseTypes: not [] } unionType &&


interesting to have the not [] check there. Does a union require at least one case-type? (this is not a comment about the code, just trying to wrap my head around how the language views things). #Resolved

just trying to wrap my head around how the language views things

There is nothing interesting we can possibly do for a union type without case types.

CyrusNajmabadi · 2026-01-06T17:51:36Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

                conversionsWithoutNullability.HasIdentityOrImplicitReferenceConversion(possibleDerived, possibleBase, ref discardedUseSiteInfo) ||
-                conversionsWithoutNullability.HasBoxingConversion(possibleDerived, possibleBase, ref discardedUseSiteInfo);
+                conversionsWithoutNullability.HasBoxingConversion(possibleDerived, possibleBase, ref discardedUseSiteInfo) ||
+                (possibleBase.IsInterfaceType() && conversionsWithoutNullability.HasImplicitConversionToOrImplementsVarianceCompatibleInterface(possibleDerived, (NamedTypeSymbol)possibleBase, ref discardedUseSiteInfo, needSupportForRefStructInterfaces: out _));


i'm not really understanding the purpose/impact of this code here. Would it be possible to break this up into individual checks, with an explanation of why this case is not a slot member? #Resolved

i'm not really understanding the purpose/impact of this code here. Would it be possible to break this up into individual checks, with an explanation of why this case is not a slot member?

This change isn't union specific. Ref structs implementing interfaces cannot be boxed. Therefore, the previous check for HasBoxingConversion fails for them even when a ref struct implements the interface. This change simply patches the condition to properly handle ref struct scenarios.

CyrusNajmabadi · 2026-01-06T17:55:04Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

                var resultState = NullableFlowState.NotNull;
                if (type is object &&
-                    (hasObjectInitializer || type.IsStructType()))
+                    (hasObjectInitializer || type.IsStructType() || isSuitableUnionConstruction(type, constructor, out _)))


rthis is a bit interesting. it seems like we'll almost always call into this a second time below. so maybe it would make sense to just life this out and always call it, always assigning to out PropertySymbol? valueProperty. Then, inside, you can just check if htat value is non-null to go into the innermost if-block. #Resolved

Then, inside, you can just check if htat value is non-null to go into the innermost if-block.

I am more comfortable with the current code flow for now.

CyrusNajmabadi · 2026-01-06T17:56:33Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                            }
+                            else
+                            {
+                                operandState = argumentResults[0].RValueType.State;


i'm curious why this is the right operand state if the operand slot was <= 0. #Resolved

i'm curious why this is the right operand state if the operand slot was <= 0.

If we don't have a slot for the argument, this is the only information we have for its state.

CyrusNajmabadi · 2026-01-06T17:57:44Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                           constructor.ContainingType.Equals(type, TypeCompareKind.AllIgnoreOptions) &&
+                           type is NamedTypeSymbol { IsUnionTypeNoUseSiteDiagnostics: true } unionType &&
+                           NamedTypeSymbol.IsSuitableUnionConstructor(constructor) &&
+                           (valueProperty = Binder.GetUnionTypeValuePropertyNoUseSiteDiagnostics(unionType)) is { };


fwiw, doing the assignment/check to the out param within this complex epression was difficult to discover/understand. I think breaking into a simple assignment and null check would be clearer and more idiomatic. #Resolved

CyrusNajmabadi · 2026-01-06T18:02:14Z

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs

+
+    static void Test5(bool? x)
+    {
+#line 500


the use of #line is helpful. thanks. #Resolved

CyrusNajmabadi · 2026-01-06T18:02:50Z

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs

+        [CombinatorialData]
+        public void NullableAnalysis_05_State_From_Constructor([CombinatorialValues("class", "struct")] string typeKind)
+        {
+            var src = @"


curious why concat instead of string (or raw string) interpolation. Parsing this out def took more mental effort for me :) #Resolved

curious why concat instead of string (or raw string) interpolation.

Personal preference

CyrusNajmabadi · 2026-01-06T18:03:13Z

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs

+    static void Test2()
+    {
+#line 200
+        var s = new S1("""");


raw strings would make internal string literals easier to reason about when reviewing. tnx. #WontFix

CyrusNajmabadi · 2026-01-06T18:06:04Z

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs

+        }
+
+        [Fact]
+        public void NullableAnalysis_19_State_From_Null_Test()


reached this test. pausing.

Misclick, not finished yet, sorry.

RikkiGibson

LGTM, comment is not blocking.

RikkiGibson · 2026-01-07T02:22:25Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                                Debug.Assert(conversionOperandSlot > 0);
+                            }
+
+                            if (conversionOperandSlot > 0 && valueFieldSlot > 0)


I didn't follow why we only want to perform the below SetState call when valueFieldSlot > 0. I don't think there is any test in UnionsTests which fails when the condition is removed.

I didn't follow why we only want to perform the below SetState call when valueFieldSlot > 0.

Probably the thinking was that setting the state is not really useful otherwise. Only when valueFieldSlot > 0 the valueFieldType.State is actually coming from this.State. I am changing this code significantly in the next PR and this logic is changing as well.

Initial support for nullable analysis for Unions

8766804

AlekseyTs requested review from 333fred and RikkiGibson December 16, 2025 19:43

AlekseyTs requested a review from a team as a code owner December 16, 2025 19:43

AlekseyTs added Area-Compilers Feature - Unions labels Dec 16, 2025

AlekseyTs commented Dec 17, 2025

View reviewed changes

333fred reviewed Dec 18, 2025

View reviewed changes

PR feedback

462727f

AlekseyTs requested a review from 333fred December 18, 2025 16:19

333fred reviewed Dec 18, 2025

View reviewed changes

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs Show resolved Hide resolved

src/Compilers/CSharp/Test/CSharp15/UnionsTests.cs Show resolved Hide resolved

AlekseyTs requested a review from 333fred December 18, 2025 17:18

333fred approved these changes Dec 18, 2025

View reviewed changes

Add tests

904354d

AlekseyTs requested a review from a team December 18, 2025 19:31

CyrusNajmabadi reviewed Dec 22, 2025

View reviewed changes

AlekseyTs requested a review from CyrusNajmabadi December 22, 2025 17:11

CyrusNajmabadi reviewed Jan 6, 2026

View reviewed changes

RikkiGibson previously approved these changes Jan 6, 2026

View reviewed changes

Refactor inline assignment

ce06fd9

RikkiGibson approved these changes Jan 7, 2026

View reviewed changes

AlekseyTs merged commit 2e48d2f into dotnet:features/Unions Jan 7, 2026
25 checks passed

Initial support for nullable analysis for Unions #81721

Initial support for nullable analysis for Unions #81721

Conversation

AlekseyTs commented Dec 16, 2025

Uh oh!

AlekseyTs commented Dec 17, 2025

Uh oh!

AlekseyTs Dec 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

333fred left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

AlekseyTs commented Dec 18, 2025

Uh oh!

AlekseyTs commented Dec 19, 2025

Uh oh!

AlekseyTs commented Dec 22, 2025

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Dec 22, 2025 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 22, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi commented Dec 22, 2025

Uh oh!

AlekseyTs commented Jan 6, 2026

Uh oh!

CyrusNajmabadi Jan 6, 2026 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Jan 6, 2026 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

AlekseyTs Dec 17, 2025 •

edited

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

CyrusNajmabadi Dec 22, 2025 •

edited by AlekseyTs

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

AlekseyTs Jan 6, 2026 •

edited

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading

CyrusNajmabadi Jan 6, 2026 •

edited by AlekseyTs

Loading