Csla.Generator.AutoSerialization.* nullable aware

#1233

Author: StefanOssendorf

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.Attributes.CSharp/Csla.Generator.AutoSerialization.Attributes.CSharp.csproj

@@ -14,6 +14,8 @@
     <IsPackable>false</IsPackable>
     <BaseOutputPath>..\..\..\..\..\Bin</BaseOutputPath>
     <OutputPath>..\..\..\..\..\bin\packages\</OutputPath>
+    <Nullable>enable</Nullable>
+    <WarningsAsErrors>nullable</WarningsAsErrors>
   </PropertyGroup>
 
   <ItemGroup>

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/ContainerDefinitionsExtractor.cs

@@ -22,19 +22,17 @@ internal static class ContainerDefinitionsExtractor
     /// <returns>The definitions of all of the containers of the type for which generation is being performed</returns>
     public static IReadOnlyList<ExtractedContainerDefinition> GetContainerDefinitions(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
     {
-      NamespaceDeclarationSyntax namespaceDeclaration;
-      TypeDeclarationSyntax containingTypeDeclaration;
-      List<ExtractedContainerDefinition> containers = new List<ExtractedContainerDefinition>();
+      List<ExtractedContainerDefinition> containers = [];
 
       // Iterate through the containing types should the target type be nested inside other types
-      containingTypeDeclaration = targetTypeDeclaration;
+      var containingTypeDeclaration = targetTypeDeclaration;
       while (containingTypeDeclaration.Parent is TypeDeclarationSyntax syntax)
       {
         containingTypeDeclaration = syntax;
         containers.Add(GetContainerDefinition(containingTypeDeclaration));
       }
 
-      namespaceDeclaration = containingTypeDeclaration.Parent as NamespaceDeclarationSyntax;
+      var namespaceDeclaration = containingTypeDeclaration.Parent as NamespaceDeclarationSyntax;
       if (namespaceDeclaration is not null)
       {
         containers.Add(GetContainerDefinition(namespaceDeclaration));

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/DefinitionExtractionContext.cs

@@ -39,11 +39,8 @@ public DefinitionExtractionContext(SemanticModel semanticModel)
     /// <returns>The namespace in which the type is declared, or an empty string if it is global</returns>
     public string GetTypeNamespace(TypeDeclarationSyntax typeDeclarationSyntax)
     {
-      INamedTypeSymbol typeSymbol;
-
-      typeSymbol = _semanticModel.GetDeclaredSymbol(typeDeclarationSyntax) as INamedTypeSymbol;
-      if (typeSymbol is null || typeSymbol.ContainingNamespace is null) return string.Empty;
-      return typeSymbol.ContainingNamespace.ToString();
+      var typeSymbol = _semanticModel.GetDeclaredSymbol(typeDeclarationSyntax) as INamedTypeSymbol;
+      return typeSymbol?.ContainingNamespace?.ToString() ?? string.Empty;
     }
 
     /// <summary>
@@ -53,16 +50,12 @@ public string GetTypeNamespace(TypeDeclarationSyntax typeDeclarationSyntax)
     /// <returns>The namespace in which the type is declared, or an empty string if it is global</returns>
     public string GetTypeNamespace(TypeSyntax typeSyntax)
     {
-      INamedTypeSymbol typeSymbol;
-      
       if (typeSyntax is NullableTypeSyntax nullableTypeSyntax)
       {
         typeSyntax = nullableTypeSyntax.ElementType;
       }
-
-      typeSymbol = _semanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
-      if (typeSymbol is null || typeSymbol.ContainingNamespace is null) return string.Empty;
-      return typeSymbol.ContainingNamespace.ToString();
+      var typeSymbol = _semanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
+      return typeSymbol?.ContainingNamespace?.ToString() ?? string.Empty;
     }
 
     /// <summary>
@@ -72,9 +65,11 @@ public string GetTypeNamespace(TypeSyntax typeSyntax)
     /// <returns>Boolean true if the type is decorated with the AutoSerializable attribute, otherwise false</returns>
     public bool IsTypeAutoSerializable(TypeDeclarationSyntax typeDeclarationSyntax)
     {
-      INamedTypeSymbol typeSymbol;
-
-      typeSymbol = _semanticModel.GetDeclaredSymbol(typeDeclarationSyntax) as INamedTypeSymbol;
+      if (_semanticModel.GetDeclaredSymbol(typeDeclarationSyntax) is not INamedTypeSymbol typeSymbol)
+      {
+        return false;
+      }
+      
       return IsTypeDecoratedBy(typeSymbol, _autoSerializableAttributeName, _serializationNamespace);
     }
 
@@ -85,10 +80,11 @@ public bool IsTypeAutoSerializable(TypeDeclarationSyntax typeDeclarationSyntax)
     /// <returns>Boolean true if the type is decorated with the AutoSerializable attribute, otherwise false</returns>
     public bool IsTypeAutoSerializable(TypeSyntax typeSyntax)
     {
-      INamedTypeSymbol typeSymbol;
-
-      typeSymbol = _semanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
-      if (typeSymbol is null) return false;
+      if(_semanticModel.GetSymbolInfo(typeSyntax).Symbol is not INamedTypeSymbol typeSymbol)
+      {
+        return false;
+      }
+      
       return IsTypeDecoratedBy(typeSymbol, _autoSerializableAttributeName, _serializationNamespace);
     }
 
@@ -100,10 +96,10 @@ public bool IsTypeAutoSerializable(TypeSyntax typeSyntax)
     /// <returns>Boolean true if the type implements the IMobileObject interface, otherwise false</returns>
     public bool DoesTypeImplementIMobileObject(TypeSyntax typeSyntax)
     {
-      INamedTypeSymbol typeSymbol;
-
-      typeSymbol = _semanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
-      if (typeSymbol is null) return false;
+      if (_semanticModel.GetSymbolInfo(typeSyntax).Symbol is not INamedTypeSymbol typeSymbol)
+      {
+        return false;
+      }
 
       foreach (ITypeSymbol interfaceSymbol in typeSymbol.AllInterfaces)
       {
@@ -180,11 +176,9 @@ private bool IsTypeDecoratedBy(INamedTypeSymbol typeSymbol, string desiredAttrib
     /// <returns>Boolean true if the type is decorated with the attribute, otherwise false</returns>
     private bool IsPropertyDecoratedWith(PropertyDeclarationSyntax propertyDeclaration, string desiredAttributeTypeName, string desiredAttributeTypeNamespace)
     {
-      INamedTypeSymbol appliedAttributeSymbol;
-
       foreach (AttributeSyntax attributeSyntax in propertyDeclaration.AttributeLists.SelectMany(al => al.Attributes))
       {
-        appliedAttributeSymbol = _semanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
+        var appliedAttributeSymbol = _semanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
         if (IsMatchingTypeSymbol(appliedAttributeSymbol, desiredAttributeTypeName, desiredAttributeTypeNamespace))
         {
           return true;
@@ -202,11 +196,9 @@ private bool IsPropertyDecoratedWith(PropertyDeclarationSyntax propertyDeclarati
     /// <returns>Boolean true if the type is decorated with the attribute, otherwise false</returns>
     private bool IsFieldDecoratedWith(FieldDeclarationSyntax fieldDeclaration, string desiredAttributeTypeName, string desiredAttributeTypeNamespace)
     {
-      INamedTypeSymbol appliedAttributeSymbol;
-
       foreach (AttributeSyntax attributeSyntax in fieldDeclaration.AttributeLists.SelectMany(al => al.Attributes))
       {
-        appliedAttributeSymbol = _semanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
+        var appliedAttributeSymbol = _semanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
         if (IsMatchingTypeSymbol(appliedAttributeSymbol, desiredAttributeTypeName, desiredAttributeTypeNamespace))
         {
           return true;
@@ -222,15 +214,18 @@ private bool IsFieldDecoratedWith(FieldDeclarationSyntax fieldDeclaration, strin
     /// <param name="desiredTypeName">The name of the attribute whose presence we are testing for</param>
     /// <param name="desiredTypeNamespace">The namespace of the attribute whose presence we are testing for</param>
     /// <returns>Boolean true if the symbol seems to represent the desired type by name and namespace</returns>
-    private bool IsMatchingTypeSymbol(INamedTypeSymbol appliedAttributeSymbol, string desiredTypeName, string desiredTypeNamespace)
+    private bool IsMatchingTypeSymbol(INamedTypeSymbol? appliedAttributeSymbol, string desiredTypeName, string desiredTypeNamespace)
     {
-      INamespaceSymbol namespaceSymbol;
+      if (appliedAttributeSymbol is null)
+      {
+        return false;
+      }
 
       // Match on the type name
       if (!appliedAttributeSymbol.Name.Equals(desiredTypeName, StringComparison.InvariantCultureIgnoreCase)) return false;
-
+      
       // Match on the namespace of the type
-      namespaceSymbol = appliedAttributeSymbol.ContainingNamespace;
+      INamespaceSymbol namespaceSymbol = appliedAttributeSymbol.ContainingNamespace;
       if (namespaceSymbol is null) return false;
       return IsMatchingNamespaceSymbol(namespaceSymbol, desiredTypeNamespace);
     }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/FieldDefinitionExtractor.cs

@@ -26,14 +26,18 @@ internal static class FieldDefinitionExtractor
     /// <returns>A readonly list of ExtractedFieldDefinition containing the data extracted from the syntax tree</returns>
     public static ExtractedFieldDefinition ExtractFieldDefinition(DefinitionExtractionContext extractionContext, FieldDeclarationSyntax fieldDeclaration)
     {
-      ExtractedFieldDefinition fieldDefinition = new ExtractedFieldDefinition();
-
-      fieldDefinition.FieldName = GetFieldName(fieldDeclaration);
-      fieldDefinition.TypeDefinition.TypeName = GetFieldTypeName(fieldDeclaration);
-      fieldDefinition.TypeDefinition.TypeNamespace = extractionContext.GetTypeNamespace(fieldDeclaration.Declaration.Type);
-      fieldDefinition.TypeDefinition.IsAutoSerializable = extractionContext.IsTypeAutoSerializable(fieldDeclaration.Declaration.Type);
-      fieldDefinition.TypeDefinition.ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(fieldDeclaration.Declaration.Type);
-      fieldDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(fieldDeclaration);
+      var fieldDefinition = new ExtractedFieldDefinition
+      {
+        FieldName = GetFieldName(fieldDeclaration),
+        TypeDefinition = new ExtractedMemberTypeDefinition
+        {
+          TypeName = GetFieldTypeName(fieldDeclaration),
+          TypeNamespace = extractionContext.GetTypeNamespace(fieldDeclaration.Declaration.Type),
+          IsAutoSerializable = extractionContext.IsTypeAutoSerializable(fieldDeclaration.Declaration.Type),
+          ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(fieldDeclaration.Declaration.Type),
+          Nullable = GetFieldTypeNullable(fieldDeclaration)
+        }
+      };
       return fieldDefinition;
     }
 

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/PropertyDefinitionExtractor.cs

@@ -26,14 +26,18 @@ internal static class PropertyDefinitionExtractor
     /// <returns>A readonly list of ExtractedPropertyDefinition containing the data extracted from the syntax tree</returns>
     public static ExtractedPropertyDefinition ExtractPropertyDefinition(DefinitionExtractionContext extractionContext, PropertyDeclarationSyntax propertyDeclaration)
     {
-      ExtractedPropertyDefinition propertyDefinition = new ExtractedPropertyDefinition();
-
-      propertyDefinition.PropertyName = GetPropertyName(propertyDeclaration);
-      propertyDefinition.TypeDefinition.TypeName = GetPropertyTypeName(propertyDeclaration);
-      propertyDefinition.TypeDefinition.TypeNamespace = extractionContext.GetTypeNamespace(propertyDeclaration.Type);
-      propertyDefinition.TypeDefinition.IsAutoSerializable = extractionContext.IsTypeAutoSerializable(propertyDeclaration.Type);
-      propertyDefinition.TypeDefinition.ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(propertyDeclaration.Type);
-      propertyDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(propertyDeclaration);
+      ExtractedPropertyDefinition propertyDefinition = new ExtractedPropertyDefinition
+      {
+        PropertyName = GetPropertyName(propertyDeclaration),
+        TypeDefinition = new ExtractedMemberTypeDefinition
+        {
+          TypeName = GetPropertyTypeName(propertyDeclaration),
+          TypeNamespace = extractionContext.GetTypeNamespace(propertyDeclaration.Type),
+          IsAutoSerializable = extractionContext.IsTypeAutoSerializable(propertyDeclaration.Type),
+          ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(propertyDeclaration.Type),
+          Nullable = GetFieldTypeNullable(propertyDeclaration)
+        }
+      };
 
       return propertyDefinition;
     }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/TypeDefinitionExtractor.cs

@@ -27,19 +27,20 @@ internal static class TypeDefinitionExtractor
     /// <returns>ExtractedTypeDefinition containing the data extracted from the syntax tree</returns>
     public static ExtractedTypeDefinition ExtractTypeDefinition(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
     {
-      ExtractedTypeDefinition definition = new ExtractedTypeDefinition();
       StringBuilder fullyQualifiedNameBuilder = new StringBuilder();
 
-      definition.TypeName = GetTypeName(targetTypeDeclaration);
-      definition.TypeKind = GetTypeKind(targetTypeDeclaration);
-      definition.Namespace = GetNamespace(targetTypeDeclaration);
-      definition.Scope = GetScopeDefinition(targetTypeDeclaration);
+      var definition = new ExtractedTypeDefinition
+      {
+        TypeName = GetTypeName(targetTypeDeclaration),
+        TypeKind = GetTypeKind(targetTypeDeclaration),
+        Namespace = GetNamespace(targetTypeDeclaration),
+        Scope = GetScopeDefinition(targetTypeDeclaration),
+      };
 
       foreach (ExtractedContainerDefinition containerDefinition in ContainerDefinitionsExtractor.GetContainerDefinitions(extractionContext, targetTypeDeclaration))
       {
         definition.ContainerDefinitions.Add(containerDefinition);
-        fullyQualifiedNameBuilder.Append(containerDefinition.Name);
-        fullyQualifiedNameBuilder.Append('.');
+        fullyQualifiedNameBuilder.Append(containerDefinition.Name).Append('.');
       }
 
       foreach (ExtractedPropertyDefinition propertyDefinition in PropertyDefinitionsExtractor.ExtractPropertyDefinitions(extractionContext, targetTypeDeclaration))
@@ -73,13 +74,11 @@ private static string GetNamespace(TypeDeclarationSyntax targetTypeDeclaration)
 
       // Get the containing syntax node for the type declaration
       // (could be a nested type, for example)
-      SyntaxNode potentialNamespaceParent = targetTypeDeclaration.Parent;
+      SyntaxNode? potentialNamespaceParent = targetTypeDeclaration.Parent;
 
       // Keep moving "out" of nested classes etc until we get to a namespace
       // or until we run out of parents
-      while (potentialNamespaceParent != null &&
-             potentialNamespaceParent is not NamespaceDeclarationSyntax
-             && potentialNamespaceParent is not FileScopedNamespaceDeclarationSyntax)
+      while (potentialNamespaceParent != null && potentialNamespaceParent is not NamespaceDeclarationSyntax && potentialNamespaceParent is not FileScopedNamespaceDeclarationSyntax)
       {
         potentialNamespaceParent = potentialNamespaceParent.Parent;
       }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/ExtractedContainerDefinition.cs

@@ -18,12 +18,12 @@ public class ExtractedContainerDefinition
     /// <summary>
     /// The name of the container, such as the class name or namespace name
     /// </summary>
-    public string Name { get; set; }
+    public required string Name { get; init; }
 
     /// <summary>
     /// The full definition of the container for use in source generation
     /// </summary>
-    public string FullDefinition { get; set; }
+    public required string FullDefinition { get; init; }
 
   }
 }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/ExtractedFieldDefinition.cs

@@ -18,12 +18,12 @@ public class ExtractedFieldDefinition : IMemberDefinition
     /// <summary>
     /// The name of the field
     /// </summary>
-    public string FieldName { get; set; }
+    public required string FieldName { get; init; }
 
     /// <summary>
     /// The definition of the type of this field
     /// </summary>
-    public ExtractedMemberTypeDefinition TypeDefinition { get; } = new();
+    public required ExtractedMemberTypeDefinition TypeDefinition { get; init; }
 
     /// <summary>
     /// The member name for the field

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/ExtractedMemberTypeDefinition.cs

@@ -18,12 +18,12 @@ public class ExtractedMemberTypeDefinition
     /// <summary>
     /// The name of the type
     /// </summary>
-    public string TypeName { get; set; }
+    public required string TypeName { get; init; }
 
     /// <summary>
     /// The namespace in which the type is defined
     /// </summary>
-    public string TypeNamespace { get; set; }
+    public required string TypeNamespace { get; init; }
 
     /// <summary>
     /// Whether the type is marked as AutoSerializable

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/ExtractedPropertyDefinition.cs

@@ -18,12 +18,12 @@ public class ExtractedPropertyDefinition : IMemberDefinition
     /// <summary>
     /// The name of the property
     /// </summary>
-    public string PropertyName { get; set; }
+    public required string PropertyName { get; init; }
 
     /// <summary>
     /// The definition of the type of this property
     /// </summary>
-    public ExtractedMemberTypeDefinition TypeDefinition { get; } = new();
+    public required ExtractedMemberTypeDefinition TypeDefinition { get; init; }
 
     /// <summary>
     /// The member name for the field

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/ExtractedTypeDefinition.cs

@@ -18,7 +18,7 @@ public class ExtractedTypeDefinition
     /// <summary>
     /// The namespace in which the type resides
     /// </summary>
-    public string Namespace { get; set; }
+    public required string Namespace { get; init; }
 
     /// <summary>
     /// The scope of the class
@@ -28,32 +28,32 @@ public class ExtractedTypeDefinition
     /// <summary>
     /// The name of the type, excluding any namespace
     /// </summary>
-    public string TypeName { get; set; }
+    public required string TypeName { get; init; }
 
     /// <summary>
     /// The name of the kind of type being represented
     /// </summary>
-    public string TypeKind { get; set; }
+    public required string TypeKind { get; init; }
 
     /// <summary>
     /// The fully qualified name of the type, including namespace
     /// </summary>
-    public string FullyQualifiedName { get; set; }
+    public string FullyQualifiedName { get; set; } = string.Empty;
 
     /// <summary>
     /// The container definitions for this type
     /// </summary>
-    public IList<ExtractedContainerDefinition> ContainerDefinitions { get; private set; } = new List<ExtractedContainerDefinition>();
+    public IList<ExtractedContainerDefinition> ContainerDefinitions { get; private set; } = [];
 
     /// <summary>
     /// The properties to be included in serialization
     /// </summary>
-    public IList<ExtractedPropertyDefinition> Properties { get; private set; } = new List<ExtractedPropertyDefinition>();
+    public IList<ExtractedPropertyDefinition> Properties { get; private set; } = [];
 
     /// <summary>
     /// The fields to be included in serialization
     /// </summary>
-    public IList<ExtractedFieldDefinition> Fields { get; private set; } = new List<ExtractedFieldDefinition>();
+    public IList<ExtractedFieldDefinition> Fields { get; private set; } = [];
 
   }
 

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/GenerationResults.cs

@@ -18,12 +18,12 @@ public class GenerationResults
     /// <summary>
     /// The fully qualified name of the generated type
     /// </summary>
-    public string FullyQualifiedName { get; set; }
+    public required string FullyQualifiedName { get; init; }
 
     /// <summary>
     /// The source code that has been generated by the builder
     /// </summary>
-    public string GeneratedSource { get; set; }
+    public required string GeneratedSource { get; init; }
 
   }
 

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/IncrementalSerializationPartialsGenerator.cs

@@ -30,7 +30,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 {
                   return TypeDefinitionExtractor.ExtractTypeDefinition(new DefinitionExtractionContext(ctx.SemanticModel), typeDeclarationSyntax);
                 }
-                return null;
+                return default!;
               })
           .Where(static m => m is not null);