Support for nullable reference types

Author: Nikolay Pianikov

src/Pure.DI.Core/Core/ApiInvocationProcessor.cs

@@ -433,7 +433,7 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                         var tagArguments = invocation.ArgumentList.Arguments.SkipWhile((arg, i) => arg.NameColon?.Name.Identifier.Text != "tags" && i < 2);
                         var tags = BuildTags(semanticModel, tagArguments);
                         VisitBind(metadataVisitor, semanticModel, invocation, tags, genericName);
-                        var rootBindSymbol = semantic.GetTypeSymbol<INamedTypeSymbol>(semanticModel, rootBindType);
+                        var rootBindSymbol = GetTypeSymbol(semanticModel, rootBindType);
                         VisitRoot(invocation, tags.FirstOrDefault(), metadataVisitor, semanticModel, invocation, invocationComments, rootBindSymbol);
                         break;
 
@@ -616,7 +616,7 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                                 nameof(Strings.Error_InvalidRootType));
                         }
 
-                        var rootSymbol = semantic.GetTypeSymbol<ITypeSymbol>(semanticModel, rootTypeSyntax);
+                        var rootSymbol = GetTypeSymbol(semanticModel, rootTypeSyntax);
                         VisitRoot(invocation, metadataVisitor, semanticModel, invocation, invocationComments, rootSymbol);
                         break;
 
@@ -1033,7 +1033,7 @@ private void VisitRoot(
         SemanticModel semanticModel,
         InvocationExpressionSyntax invocation,
         IReadOnlyCollection<string> invocationComments,
-        INamedTypeSymbol rootSymbol)
+        ITypeSymbol rootSymbol)
     {
         tag ??= new MdTag(0, null);
         var rootArgs = arguments.GetArgs(invocation.ArgumentList, "name", "kind");
@@ -1062,13 +1062,15 @@ private void VisitBind(
         GenericNameSyntax genericName)
     {
         var contractTypes = genericName.TypeArgumentList.Arguments;
+        // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
         foreach (var contractType in contractTypes)
         {
+            var contractTypeSymbol = GetTypeSymbol(semanticModel, contractType);
             metadataVisitor.VisitContract(
                 new MdContract(
                     semanticModel,
                     invocation,
-                    semantic.GetTypeSymbol<ITypeSymbol>(semanticModel, contractType),
+                    contractTypeSymbol,
                     ContractKind.Explicit,
                     tags));
         }
@@ -1388,7 +1390,7 @@ private MdResolver CreateResolver(
                 var resolverTag = new MdTag(0, tagValue);
                 if (args[1] is {} argSyntax2)
                 {
-                    var argType2 = GetDefaultType(semanticModel, invocation, 1) ?? GetArgSymbol(semanticModel, argSyntax2) ?? resultType;
+                    var argType2 = GetDefaultType(semanticModel, invocation, 0) ?? GetArgSymbol(semanticModel, argSyntax2) ?? resultType;
                     if (argType2 is null or IErrorTypeSymbol)
                     {
                         throw new CompileErrorException(
@@ -1461,14 +1463,27 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
         };
 
         ITypeSymbol? defaultType = null;
+        // ReSharper disable once InvertIf
         if (name is GenericNameSyntax genericName && genericName.TypeArgumentList.Arguments.Count > typeArgPosition)
         {
-            defaultType = semantic.GetTypeSymbol<ITypeSymbol>(semanticModel, genericName.TypeArgumentList.Arguments[typeArgPosition]);
+            var typeArgument = genericName.TypeArgumentList.Arguments[typeArgPosition];
+            defaultType = GetTypeSymbol(semanticModel, typeArgument);
         }
 
         return defaultType;
     }
 
+    private ITypeSymbol GetTypeSymbol(SemanticModel semanticModel, TypeSyntax typeSyntax)
+    {
+        var typeSymbol = semantic.GetTypeSymbol<ITypeSymbol>(semanticModel, typeSyntax);
+        if (typeSyntax is NullableTypeSyntax && typeSymbol.IsReferenceType)
+        {
+            typeSymbol = typeSymbol.WithNullableAnnotation(NullableAnnotation.Annotated);
+        }
+
+        return typeSymbol;
+    }
+
     private static bool HasContextTag(ExpressionSyntax? tag, ParameterSyntax contextParameter) =>
         tag is MemberAccessExpressionSyntax memberAccessExpression
         && memberAccessExpression.IsKind(SyntaxKind.SimpleMemberAccessExpression)

src/Pure.DI.Core/Core/BindingBuilder.cs

@@ -10,7 +10,8 @@ sealed class BindingBuilder(
     [Tag(SpecialBindingIdGenerator)] IIdGenerator specialBindingIdGenerator,
     IBaseSymbolsProvider baseSymbolsProvider,
     ILocationProvider locationProvider,
-    ILifetimeProvider lifetimeProvider)
+    ILifetimeProvider lifetimeProvider,
+    ITypeSymbolComparer typeSymbolComparer)
     : IBindingBuilder
 {
     private readonly List<MdContract> _contracts = [];
@@ -130,7 +131,7 @@ private IEnumerable<MdContract> CreateExplicitContractsFromImplementation(
         // Only search for base symbols if the implementation is a concrete class or struct
         if (implementationType is { SpecialType: Microsoft.CodeAnalysis.SpecialType.None, TypeKind: TypeKind.Class or TypeKind.Struct, IsAbstract: false })
         {
-            var specialTypes = setup.SpecialTypes.Select(i => i.Type).ToImmutableHashSet(SymbolEqualityComparer.Default);
+            var specialTypes = setup.SpecialTypes.Select(i => i.Type).ToImmutableHashSet(typeSymbolComparer.Runtime);
             baseSymbols = baseSymbolsProvider
                 .GetBaseSymbols(implementationType, (type, deepness) => deepness switch
                 {
@@ -141,7 +142,7 @@ private IEnumerable<MdContract> CreateExplicitContractsFromImplementation(
                 .Select(i => i.Type);
         }
 
-        var contracts = new HashSet<ITypeSymbol>(baseSymbols, SymbolEqualityComparer.Default) { implementationType };
+        var contracts = new HashSet<ITypeSymbol>(baseSymbols, typeSymbolComparer.Runtime) { implementationType };
         var tags = implementationContracts
             .SelectMany(i => i.Tags)
             .GroupBy(i => i.Value)
@@ -154,7 +155,7 @@ private IEnumerable<MdContract> CreateExplicitContractsFromImplementation(
         }
     }
 
-    private static bool IsSuitableForBinding(ImmutableHashSet<ISymbol?> specialTypes, ITypeSymbol type)
+    private static bool IsSuitableForBinding(ImmutableHashSet<ITypeSymbol> specialTypes, ITypeSymbol type)
     {
         // Checks if the type is an interface or an abstract class, which are typical candidates for DI contracts.
         var isAbstractOrInterface = type.TypeKind == TypeKind.Interface || type.IsAbstract;

src/Pure.DI.Core/Core/BindingsFactory.cs

@@ -4,7 +4,8 @@ class BindingsFactory(
     Func<IFastBuilder<RewriterContext<MdFactory>, MdFactory>> factoryRewriterFactory,
     ITypes types,
     IMarker marker,
-    ILifetimeProvider lifetimeProvider)
+    ILifetimeProvider lifetimeProvider,
+    IInjectionComparer injectionComparer)
     : IBindingsFactory
 {
     public MdBinding CreateGenericBinding(
@@ -160,9 +161,8 @@ public MdBinding CreateConstructBinding(
         object? explicitDefaultValue = null,
         object? state = null)
     {
-        elementType = elementType.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
         var dependencyContracts = new List<MdContract>();
-        var contracts = new HashSet<Injection>();
+        var contracts = new HashSet<Injection>(injectionComparer);
         var originalIds = new HashSet<int>();
         if (constructKind is MdConstructKind.Array or MdConstructKind.AsyncEnumerable or MdConstructKind.Enumerable or MdConstructKind.Span)
         {
@@ -260,4 +260,4 @@ private IEnumerable<MdContract> GetMatchedMdContracts(MdSetup setup, ITypeSymbol
 
         return new MdTag(0, injection.Tag);
     }
-}
+}

src/Pure.DI.Core/Core/Code/BuildTools.cs

@@ -13,7 +13,8 @@ sealed class BuildTools(
     IUniqueNameProvider uniqueNameProvider,
     ILocks locks,
     ISymbolNames symbolNames,
-    ICompilations compilations)
+    ICompilations compilations,
+    ITypeSymbolComparer typeSymbolComparer)
     : IBuildTools
 {
     public string NullCheck(Compilation compilation, string variableName)
@@ -47,10 +48,10 @@ public Lines OnCreated(CodeContext ctx, VarInjection varInjection)
             return new Lines();
         }
 
-        var baseTypes = new Lazy<ImmutableHashSet<ISymbol?>>(() =>
+        var baseTypes = new Lazy<ImmutableHashSet<ITypeSymbol>>(() =>
             baseSymbolsProvider.GetBaseSymbols(varInjection.Var.InstanceType, (_, _) => true)
                 .Select(i => i.Type)
-                .ToImmutableHashSet(SymbolEqualityComparer.Default));
+                .ToImmutableHashSet(typeSymbolComparer.Runtime));
 
         var accLines = ctx.Accumulators
             .Where(acc => acc.Lifetime == varInjection.Var.AbstractNode.Lifetime)
@@ -142,8 +143,7 @@ private string OnInjectedInternal(CodeContext ctx, VarInjection varInjection)
             }
         }
 
-        if (varInjection.Var.InstanceType.IsReferenceType
-            && varInjection.Var.InstanceType.NullableAnnotation == NullableAnnotation.Annotated
+        if (varInjection.Var.InstanceType is { IsReferenceType: true, NullableAnnotation: NullableAnnotation.Annotated }
             && varInjection.ContractType.NullableAnnotation != NullableAnnotation.Annotated)
         {
             variableCode = $"{variableCode}!";

src/Pure.DI.Core/Core/Code/ClassDiagramBuilder.cs

@@ -14,6 +14,7 @@ sealed class ClassDiagramBuilder(
     ITypes types,
     ILocationProvider locationProvider,
     IGlobalProperties globalProperties,
+    ITypeSymbolComparer typeSymbolComparer,
     CancellationToken cancellationToken)
     : IBuilder<CompositionCode, Lines>
 {
@@ -88,8 +89,8 @@ public Lines Build(CompositionCode composition)
                 lines.AppendLine($"{composition.Name.ClassName} --|> IAsyncDisposable");
             }
 
-            var typeSymbols = new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default);
-            foreach (var node in graph.Vertices.GroupBy(i => i.Type, SymbolEqualityComparer.Default).Select(i => i.First()).OrderBy(i => i.Binding.Id))
+            var typeSymbols = new HashSet<ITypeSymbol>(typeSymbolComparer.Dependency);
+            foreach (var node in graph.Vertices.GroupBy(i => i.Type, typeSymbolComparer.Dependency).Select(i => i.First()).OrderBy(i => i.Binding.Id))
             {
                 cancellationToken.ThrowIfCancellationRequested();
                 if (node.Root is not null)
@@ -326,14 +327,18 @@ private string FormatType(MdSetup setup, ISymbol? symbol, FormatOptions options)
 
         return symbol switch
         {
-            INamedTypeSymbol { IsGenericType: true } namedTypeSymbol => $"{namedTypeSymbol.Name}{options.StartGenericArgsSymbol}{string.Join(options.TypeArgsSeparator, namedTypeSymbol.TypeArguments.Select(FormatSymbolLocal))}{options.FinishGenericArgsSymbol}",
-            IArrayTypeSymbol array => $"Array{options.StartGenericArgsSymbol}{FormatType(setup, array.ElementType, options)}{options.FinishGenericArgsSymbol}",
+            INamedTypeSymbol { IsGenericType: true } namedTypeSymbol => $"{namedTypeSymbol.Name}{options.StartGenericArgsSymbol}{string.Join(options.TypeArgsSeparator, namedTypeSymbol.TypeArguments.Select(FormatSymbolLocal))}{options.FinishGenericArgsSymbol}{FormatNullableSuffix(namedTypeSymbol)}",
+            IArrayTypeSymbol array => $"Array{options.StartGenericArgsSymbol}{FormatType(setup, array.ElementType, options)}{options.FinishGenericArgsSymbol}{FormatNullableSuffix(array)}",
+            ITypeSymbol type => $"{type.Name}{FormatNullableSuffix(type)}",
             _ => symbol?.Name ?? "Unresolved"
         };
 
         string FormatSymbolLocal(ITypeSymbol i) => FormatSymbol(setup, i, options);
     }
 
+    private static string FormatNullableSuffix(ITypeSymbol type) =>
+        type is { IsReferenceType: true, NullableAnnotation: NullableAnnotation.Annotated } ? "?" : "";
+
     private string ResolveTypeName(MdSetup setup, ITypeSymbol typeSymbol)
     {
         var typeName = typeResolver.Resolve(setup, typeSymbol).Name;
@@ -474,4 +479,4 @@ public string ActualKind
             }
         }
     }
-}
+}

src/Pure.DI.Core/Core/Code/CompositionClassBuilder.cs

@@ -2,7 +2,6 @@
 
 namespace Pure.DI.Core.Code;
 
-using Microsoft.CodeAnalysis;
 using Parts;
 using static LinesExtensions;
 using static Tag;
@@ -21,10 +20,7 @@ public CompositionCode Build(CompositionCode composition)
     {
         var code = composition.Code;
         code.AppendComments("<auto-generated/>", $"by {information.Description}");
-        if (composition.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable)
-        {
-            code.AppendLine("#nullable enable annotations");
-        }
+        code.AppendLine("#nullable enable annotations");
 
         code.AppendLine("#pragma warning disable CS0162");
 

src/Pure.DI.Core/Core/Code/FactoryRewriter.cs

@@ -409,7 +409,7 @@ private static bool LambdaDeclaresParameter(LambdaExpressionSyntax lambda, strin
                         : SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression, SyntaxFactory.Token(SyntaxKind.FalseKeyword));
 
                 case nameof(IContext.RootType):
-                    return SyntaxFactory.ParseExpression($"typeof({typeResolver.Resolve(_ctx!.RootContext.Graph.Source, _ctx!.RootContext.Root.Injection.Type)})");
+                    return SyntaxFactory.ParseExpression($"typeof({typeResolver.ResolveRuntime(_ctx!.RootContext.Graph.Source, _ctx!.RootContext.Root.Injection.Type)})");
 
                 case nameof(IContext.RootName):
                     return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(_ctx!.RootContext.Root.DisplayName));
@@ -427,7 +427,7 @@ private IEnumerable<string> GetConsumers(MdSetup setup)
     {
         foreach (var parent in _ctx?.Parents.Reverse() ?? [])
         {
-            yield return $"typeof({typeResolver.Resolve(setup, parent.Var.InstanceType)})";
+            yield return $"typeof({typeResolver.ResolveRuntime(setup, parent.Var.InstanceType)})";
         }
 
         yield return $"typeof({_ctx!.RootContext.Graph.Source.Name.FullName})";

src/Pure.DI.Core/Core/Code/ITypeResolver.cs

@@ -3,4 +3,6 @@ namespace Pure.DI.Core.Code;
 interface ITypeResolver
 {
     TypeDescription Resolve(MdSetup setup, ITypeSymbol type);
-}
+
+    TypeDescription ResolveRuntime(MdSetup setup, ITypeSymbol type);
+}

src/Pure.DI.Core/Core/Code/ImplementationCodeBuilder.cs

@@ -176,7 +176,8 @@ private string CreateInstantiation(
             .ToList();
 
         var args = string.Join(", ", ctorArgs.Select(i => buildTools.OnInjected(ctx, i)));
-        code.Append(var.InstanceType.IsTupleType ? $"({args})" : $"new {typeResolver.Resolve(ctx.RootContext.Graph.Source, var.InstanceType)}({args})");
+        var instanceType = RemoveNullableAnnotation(var.InstanceType);
+        code.Append(var.InstanceType.IsTupleType ? $"({args})" : $"new {typeResolver.Resolve(ctx.RootContext.Graph.Source, instanceType)}({args})");
         if (required.Count > 0)
         {
             code.Append($" {LinesExtensions.BlockStart} ");
@@ -191,4 +192,12 @@ private string CreateInstantiation(
 
         return code.ToString();
     }
+
+    private static ITypeSymbol RemoveNullableAnnotation(ITypeSymbol type) =>
+        type switch
+        {
+            INamedTypeSymbol namedType => namedType.WithNullableAnnotation(NullableAnnotation.NotAnnotated),
+            IArrayTypeSymbol arrayType => arrayType.WithNullableAnnotation(NullableAnnotation.NotAnnotated),
+            _ => type.WithNullableAnnotation(NullableAnnotation.NotAnnotated)
+        };
 }

src/Pure.DI.Core/Core/Code/NodeTools.cs

@@ -7,7 +7,8 @@ namespace Pure.DI.Core.Code;
 
 sealed class NodeTools(
     ITypes types,
-    ICache<NodeTools.LazyKey, bool> isLazy) : INodeTools
+    ICache<NodeTools.LazyKey, bool> isLazy,
+    ITypeSymbolComparer typeSymbolComparer) : INodeTools
 {
     public bool IsLazy(DependencyNode node, DependencyGraph graph) =>
         isLazy.Get(new LazyKey(node, graph.Source.SemanticModel), key =>
@@ -41,12 +42,12 @@ private bool IsAsyncDisposable(Compilation compilation, ISymbol type) =>
     private static bool IsDelegate(DependencyNode node) =>
         node.Type.TypeKind == TypeKind.Delegate;
 
-    private static bool IsLazyFactory(DpFactory factory, SemanticModel semanticModel) =>
+    private bool IsLazyFactory(DpFactory factory, SemanticModel semanticModel) =>
         factory.Resolvers.All(i => IsLazy(factory, i.Source.Source, semanticModel))
         && factory.Initializers.All(i => IsLazy(factory, i.Source.Source, semanticModel))
         && factory.OverridesMap.Values.All(i => IsLazy(factory, i.Source.Source, semanticModel));
 
-    private static bool IsLazy(DpFactory factory, ExpressionSyntax source, SemanticModel semanticModel)
+    private bool IsLazy(DpFactory factory, ExpressionSyntax source, SemanticModel semanticModel)
     {
         if (semanticModel.SyntaxTree != factory.Source.Factory.SyntaxTree)
         {
@@ -75,7 +76,7 @@ private static bool IsLazy(DpFactory factory, ExpressionSyntax source, SemanticM
                 continue;
             }
 
-            return !SymbolEqualityComparer.Default.Equals(factoryType, invocationType);
+            return !typeSymbolComparer.RuntimeEquals(factoryType, invocationType);
         }
 
         return false;
@@ -99,4 +100,4 @@ public override int GetHashCode()
             }
         }
     }
-}
+}