Catalog / Generators / convert-to-nullable-aware

Convert to Nullable-Aware

Enables nullable reference types in one file and adds the ? annotations its code shows it needs, so the file compiles without new warnings. Files are converted one at a time, so a project can move to nullable gradually.

This is a generator: the annotations are the ones this file's flow requires, chosen by following the compiler's warnings, not the only possible set; a person might instead initialise a field or add a null check. The after/ fixtures pin that choice. Run-time behaviour does not change; the annotations only inform the compiler.

The target is the file: "target": { "file": "Directory.cs" }.

Precondition

The file has no #nullable directive and its project does not already enable nullable reference types.
Every nullable warning that enabling produces can be answered by annotating a declaration in the file (see below).

Transformation

#nullable enable becomes the first line, followed by a blank line and the file as it was, including any leading comment.
The file is compiled and each new warning is answered by annotating one declaration with ?, repeating until no warning remains:

| Warning | Annotated | |---|---| | CS8600, CS8601, CS8625: a possibly null value assigned or initialised | the local, field, property or parameter it is stored in | | CS8604, CS8625: a possibly null argument | the parameter it is passed to | | CS8603: a possibly null return | the method's, property's or local function's return type | | CS8618: a member left unset by the constructor | the field, property or event | | CS8765, CS8767: a parameter less nullable than the member it overrides or implements | the parameter |

So a null followed through a return, a local and an argument annotates each declaration in turn.

Only reference types and unconstrained type parameters (T?) are annotated, and only when written explicitly: var locals are already inferred nullable.

Preserved

Behaviour, and every other file: callers in files that are still nullable-oblivious see no warnings and are not changed.

Limitations

Annotations are only added, never removed, and !, null checks and [NotNull]-style attributes are never introduced.
A field declaration naming several variables is annotated as a whole.
Warnings about generic type arguments (List<string> holding null), delegates, or members declared in other files are not answered, so the conversion is refused.

Error codes

Code	Meaning
`already-nullable-aware`	the file has a `#nullable` directive or its project enables nullable
`unresolved-warning`	a warning remains that no annotation fixes, such as CS8602, a dereference of a possibly null value

Cases

Diffs show each file from before to after. /*[*/ … /*]*/ marks a selection and /*^*/ a caret; the runner removes them before the refactoring runs.

#already-nullable-aware

Refuses a file that already sets its nullable context

refusal

TargetGreeter.cs

Refusesalready-nullable-aware; every file is left unchanged

Greeter.csinput

View fixture on GitHub

#constructor-and-event

Annotates a field and an event the constructor leaves unset, and leaves the fields it sets

success

TargetBasket.cs

Basket.csmodified

View fixture on GitHub

#generic

Annotates an unconstrained type parameter that may hold its default value

success

TargetCache.cs

Cache.csmodified

View fixture on GitHub

#null-flows

Enables nullable in the file and annotates the field, return and parameter that hold null; a file calling it that is not converted is left alone

success

TargetDirectory.cs

Directory.csmodified

Report.csunchanged

View fixture on GitHub

#overrides-and-comments

Matches the nullability of an overridden parameter, and puts the directive above a leading comment

success

TargetMoney.cs

Money.csmodified

View fixture on GitHub

#possible-null-dereference

Refuses when a value that may be null is dereferenced, which no annotation can fix

refusal

TargetDirectory.cs

Refusesunresolved-warning mentioning “CS8602”; every file is left unchanged

Directory.csinput

View fixture on GitHub

#project-nullable

Refuses a file in a project that already enables nullable

refusal

TargetGreeter.cs

Projectnullable enable

Refusesalready-nullable-aware; every file is left unchanged

Greeter.csinput

View fixture on GitHub

#propagation

Follows a null through a return, an explicitly typed local and an argument, annotating each declaration in turn

success

TargetLabels.cs

Labels.csmodified

View fixture on GitHub

1		#nullable enable
2
3		namespace Shop
4		{
5		public class Greeter
6		{
7		public string Greet(string name) => "Hello " + name;
8		}
9		}

	1	+	#nullable enable
	2	+
1	3		using System;
2	4		using System.Collections.Generic;
3	5
4	6		namespace Shop
5	7		{
6	8		public class Basket
7	9		{
8	10		private readonly List<string> _items;
9		−	private string _coupon;
	11	+	private string? _coupon;
10	12
11	13		public Basket(IEnumerable<string> items)
12	14		{
13	15		_items = new List<string>(items);
14	16		}
15	17
16		−	public event Action Changed;
	18	+	public event Action? Changed;
17	19
18	20		public void Apply(string coupon)
19	21		{
20	22		_coupon = coupon;
21	23		Changed?.Invoke();
22	24		}
23	25
24	26		public int CouponLength => _coupon?.Length ?? 0;
25	27
26	28		public int Count => _items.Count;
27	29		}
28	30		}

	1	+	#nullable enable
	2	+
1	3		using System.Collections.Generic;
2	4
3	5		namespace Shop
4	6		{
5	7		public class Cache<T>
6	8		{
7	9		private readonly Dictionary<string, T> _items = new Dictionary<string, T>();
8	10
9		−	public T Get(string key)
	11	+	public T? Get(string key)
10	12		{
11	13		return _items.TryGetValue(key, out var value) ? value : default;
12	14		}
13	15		}
14	16		}

	1	+	#nullable enable
	2	+
1	3		using System.Collections.Generic;
2	4
3	5		namespace Shop
4	6		{
5	7		public class Directory
6	8		{
7	9		private readonly Dictionary<string, string> _emails = new Dictionary<string, string>();
8		−	private string _lastLookup;
	10	+	private string? _lastLookup;
9	11
10		−	public string LastLookup => _lastLookup;
	12	+	public string? LastLookup => _lastLookup;
11	13
12		−	public string Find(string name)
	14	+	public string? Find(string name)
13	15		{
14	16		_lastLookup = name;
15	17		if (_emails.TryGetValue(name, out var email))
16	18		return email;
17	19
18	20		return null;
19	21		}
20	22
21		−	public string Describe(string name, string fallback = null)
	23	+	public string Describe(string name, string? fallback = null)
22	24		{
23	25		var email = Find(name);
24	26		return email ?? fallback ?? "unknown";
25	27		}
26	28		}
27	29		}

	1	+	#nullable enable
	2	+
1	3		// Money values used across the shop.
2	4		namespace Shop
3	5		{
4	6		public class Money
5	7		{
6	8		public Money(decimal amount)
7	9		{
8	10		Amount = amount;
9	11		}
10	12
11	13		public decimal Amount { get; }
12	14
13		−	public override bool Equals(object obj) => obj is Money other && other.Amount == Amount;
	15	+	public override bool Equals(object? obj) => obj is Money other && other.Amount == Amount;
14	16
15	17		public override int GetHashCode() => Amount.GetHashCode();
16	18		}
17	19		}

1	1	namespace Shop
2	2	{
3	3	public class Report
4	4	{
5	5	public int Length(Directory directory) => directory.Find("ann").Length;
6	6	}
7	7	}

1		namespace Shop
2		{
3		public class Directory
4		{
5		private string _owner;
6
7		public void Claim(string owner)
8		{
9		_owner = owner;
10		}
11
12		public int OwnerLength() => _owner.Length;
13		}
14		}