Fixed nullability issues

src/EntityFrameworkCore.Projectables.Generator/EntityFrameworkCore.Projectables.Generator.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <NoWarn>$(NoWarn);nullable;NU5128</NoWarn>
+    <NoWarn>$(NoWarn);NU5128</NoWarn>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
@@ -15,4 +15,8 @@
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisVersion)" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Internal\" />
+  </ItemGroup>
 </Project>

src/EntityFrameworkCore.Projectables.Generator/ExpressionSyntaxRewriter.cs

@@ -135,7 +135,7 @@ namespace EntityFrameworkCore.Projectables.Generator
                         node
                     );
                 }
-                else if (symbolInfo.Symbol.Kind is SymbolKind.NamedType && node.Parent.Kind() is not SyntaxKind.QualifiedName)
+                else if (symbolInfo.Symbol.Kind is SymbolKind.NamedType && node.Parent?.Kind() is not SyntaxKind.QualifiedName)
                 {
                     var typeInfo = _semanticModel.GetTypeInfo(node);
 

src/EntityFrameworkCore.Projectables.Generator/ProjectableDescriptor.cs

@@ -11,28 +11,28 @@ namespace EntityFrameworkCore.Projectables.Generator
 {
     public class ProjectableDescriptor
     {
-        public IEnumerable<string> UsingDirectives { get; set; }
+        public IEnumerable<string>? UsingDirectives { get; set; }
 
-        public string ClassNamespace { get; set; }
+        public string? ClassNamespace { get; set; }
 
-        public IEnumerable<string> NestedInClassNames { get; set; }
+        public IEnumerable<string>? NestedInClassNames { get; set; }
 
-        public string TargetClassNamespace { get; set; }
+        public string? TargetClassNamespace { get; set; }
 
-        public IEnumerable<string> TargetNestedInClassNames { get; set; }
+        public IEnumerable<string>? TargetNestedInClassNames { get; set; }
 
-        public string ClassName { get; set; }
+        public string? ClassName { get; set; }
 
-        public string MemberName { get; set; }
+        public string? MemberName { get; set; }
 
-        public string ReturnTypeName { get; set; }
+        public string? ReturnTypeName { get; set; }
 
-        public ParameterListSyntax ParametersList { get; set; }
+        public ParameterListSyntax? ParametersList { get; set; }
 
-        public TypeParameterListSyntax TypeParameterList { get; set; }
+        public TypeParameterListSyntax? TypeParameterList { get; set; }
         
-        public IEnumerable<TypeParameterConstraintClauseSyntax> ConstraintClauses { get; set; }
+        public IEnumerable<TypeParameterConstraintClauseSyntax>? ConstraintClauses { get; set; }
 
-        public SyntaxNode Body { get; set; }
+        public SyntaxNode? Body { get; set; }
     }
 }

src/EntityFrameworkCore.Projectables.Generator/ProjectableInterpreter.cs

@@ -35,7 +35,7 @@ namespace EntityFrameworkCore.Projectables.Generator
             var projectableAttributeTypeSymbol = context.Compilation.GetTypeByMetadataName("EntityFrameworkCore.Projectables.ProjectableAttribute");
 
             var projectableAttributeClass = memberSymbol.GetAttributes()
-                .Where(x => x.AttributeClass.Name == "ProjectableAttribute")
+                .Where(x => x.AttributeClass?.Name == "ProjectableAttribute")
                 .FirstOrDefault();
 
             if (projectableAttributeClass is null || !SymbolEqualityComparer.Default.Equals(projectableAttributeClass.AttributeClass, projectableAttributeTypeSymbol))

src/EntityFrameworkCore.Projectables.Generator/ProjectionExpressionGenerator.cs

@@ -26,17 +26,26 @@ namespace EntityFrameworkCore.Projectables.Generator
             {
                 var projectables = receiver.Candidates
                     .Select(x => ProjectableInterpreter.GetDescriptor(x, context))
-                    .Where(x => x is not null);
+                    .Where(x => x is not null)
+                    .Select(x => x!);
 
                 var resultBuilder = new StringBuilder();
 
                 foreach (var projectable in projectables)
                 {
+                    if (projectable.MemberName is null)
+                    {
+                        throw new InvalidOperationException("Expected a memberName here");
+                    }
+
                     resultBuilder.Clear();
 
-                    foreach (var usingDirective in projectable.UsingDirectives.Distinct())
+                    if (projectable.UsingDirectives is not null)
                     {
-                        resultBuilder.AppendLine(usingDirective);
+                        foreach (var usingDirective in projectable.UsingDirectives.Distinct())
+                        {
+                            resultBuilder.AppendLine(usingDirective);
+                        }
                     }
 
                     if (projectable.TargetClassNamespace is not null)
@@ -60,9 +69,10 @@ namespace EntityFrameworkCore.Projectables.Generator
                     }
 
                     var generatedClassName = ProjectionExpressionClassNameGenerator.GenerateName(projectable.ClassNamespace, projectable.NestedInClassNames, projectable.MemberName);
+
                     var lambdaTypeArguments = SyntaxFactory.TypeArgumentList(
                         SyntaxFactory.SeparatedList(
-                            projectable.ParametersList.Parameters.Select(p => p.Type)
+                            projectable.ParametersList?.Parameters.Where(p => p.Type is not null).Select(p => p.Type!)
                         )
                     );
 
@@ -72,7 +82,7 @@ namespace EntityFrameworkCore.Projectables.Generated
 {{
     public static class {generatedClassName}
     {{
-        public static System.Linq.Expressions.Expression<System.Func<{lambdaTypeArguments.Arguments}, {projectable.ReturnTypeName}>> Expression{(projectable.TypeParameterList.Parameters.Any() ? projectable.TypeParameterList.ToString() : string.Empty)}()");
+        public static System.Linq.Expressions.Expression<System.Func<{lambdaTypeArguments.Arguments}, {projectable.ReturnTypeName}>> Expression{(projectable.TypeParameterList?.Parameters.Any() == true ? projectable.TypeParameterList.ToString() : string.Empty)}()");
 
                     if (projectable.ConstraintClauses is not null)
                     {

src/EntityFrameworkCore.Projectables/Services/ProjectionExpressionClassNameGenerator.cs

@@ -10,14 +10,14 @@ namespace EntityFrameworkCore.Projectables.Services
     {
         public const string Namespace = "EntityFrameworkCore.Projectables.Generated";
 
-        public static string GenerateName(string? namespaceName, IEnumerable<string> nestedInClassNames, string memberName)
+        public static string GenerateName(string? namespaceName, IEnumerable<string>? nestedInClassNames, string memberName)
         {
             var stringBuilder = new StringBuilder();
 
             return GenerateNameImpl(stringBuilder, namespaceName, nestedInClassNames, memberName);
         }
 
-        public static string GenerateFullName(string? namespaceName, IEnumerable<string> nestedInClassNames, string memberName)
+        public static string GenerateFullName(string? namespaceName, IEnumerable<string>? nestedInClassNames, string memberName)
         {
             var stringBuilder = new StringBuilder(Namespace);
             stringBuilder.Append('.');
@@ -25,14 +25,17 @@ namespace EntityFrameworkCore.Projectables.Services
             return GenerateNameImpl(stringBuilder, namespaceName, nestedInClassNames, memberName);
         }
 
-        static string GenerateNameImpl(StringBuilder stringBuilder, string? namespaceName, IEnumerable<string> nestedInClassNames, string memberName)
+        static string GenerateNameImpl(StringBuilder stringBuilder, string? namespaceName, IEnumerable<string>? nestedInClassNames, string memberName)
         {
             stringBuilder.Append(namespaceName?.Replace('.', '_'));
             stringBuilder.Append('_');
-            foreach (var className in nestedInClassNames)
+            if (nestedInClassNames is not null)
             {
-                stringBuilder.Append(className);
-                stringBuilder.Append('_');
+                foreach (var className in nestedInClassNames)
+                {
+                    stringBuilder.Append(className);
+                    stringBuilder.Append('_');
+                }
             }
             stringBuilder.Append(memberName);