make csla.analyzers nullable aware

Source/Csla.Analyzers/Csla.Analyzers/AsynchronousBusinessRuleInheritingFromBusinessRuleAnalyzer.cs

@@ -47,6 +47,11 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
       if (!methodNode.ContainsDiagnostics)
       {
         var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodNode);
+        if (methodSymbol is null)
+        {
+          return;
+        }
+
         var typeSymbol = methodSymbol.ContainingType;
 
         if(typeSymbol.IsBusinessRule() && methodSymbol.Name == "Execute" && methodSymbol.IsAsync)

Source/Csla.Analyzers/Csla.Analyzers/AsynchronousBusinessRuleInheritingFromBusinessRuleChangeToBusinessRuleAsyncCodeFix.cs

@@ -36,21 +36,31 @@ public sealed class AsynchronousBusinessRuleInheritingFromBusinessRuleChangeToBu
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
       var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
-
+      if (root is null)
+      {
+        return;
+      }
       context.CancellationToken.ThrowIfCancellationRequested();
 
       var diagnostic = context.Diagnostics.First();
       var methodNode = root.FindNode(diagnostic.Location.SourceSpan) as MethodDeclarationSyntax;
+      if (methodNode is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
       await AddCodeFixAsync(context, root, diagnostic, methodNode);
     }
 
-    private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode root,
-      Diagnostic diagnostic, MethodDeclarationSyntax methodNode)
+    private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode root, Diagnostic diagnostic, MethodDeclarationSyntax methodNode)
     {
       var model = await context.Document.GetSemanticModelAsync(context.CancellationToken);
       var methodSymbol = model.GetDeclaredSymbol(methodNode);
+      if (methodSymbol is null)
+      {
+        return;
+      }
       var typeSymbol = methodSymbol.ContainingType;
 
       var newRoot = root;
@@ -91,13 +101,17 @@ private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode roo
           AsynchronousBusinessRuleInheritingFromBusinessRuleChangeToBusinessRuleAsyncCodeFixConstants.UpdateToAsyncEquivalentsDescription), diagnostic);
     }
 
-    private static BaseListSyntax GetBaseTypes(TypeDeclarationSyntax typeNode)
+    private static BaseListSyntax? GetBaseTypes(TypeDeclarationSyntax typeNode)
     {
       var currentBaseList = typeNode.BaseList;
+      if (currentBaseList is null)
+      {
+        return null;
+      }
 
       var list = new SeparatedSyntaxList<BaseTypeSyntax>();
 
-      foreach (var baseTypeNode in typeNode.BaseList.DescendantNodes().OfType<SimpleBaseTypeSyntax>())
+      foreach (var baseTypeNode in typeNode.BaseList!.DescendantNodes().OfType<SimpleBaseTypeSyntax>())
       {
         var baseTypeNodeIdentifier = baseTypeNode.DescendantNodes().OfType<IdentifierNameSyntax>().Single();
 

Source/Csla.Analyzers/Csla.Analyzers/BusinessRuleDoesNotUseAddMethodsOnContextAnalyzer.cs

@@ -47,6 +47,10 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
       if (!methodNode.ContainsDiagnostics)
       {
         var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodNode);
+        if (methodSymbol is null)
+        {
+          return;
+        }
         var typeSymbol = methodSymbol.ContainingType;
 
         if (typeSymbol.IsBusinessRule() && 

Source/Csla.Analyzers/Csla.Analyzers/CheckConstructorsAnalyzer.cs

@@ -56,9 +56,9 @@ private static void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context)
       var classNode = (ClassDeclarationSyntax)context.Node;
       var classSymbol = context.SemanticModel.GetDeclaredSymbol(classNode);
 
-      if (classSymbol.IsStereotype() && !(classSymbol?.IsAbstract).Value)
+      if (classSymbol.IsStereotype() && !classSymbol.IsAbstract)
       {
-        foreach (var constructor in classSymbol?.Constructors)
+        foreach (var constructor in classSymbol.Constructors)
         {
           if (!constructor.IsStatic)
           {
@@ -86,7 +86,7 @@ private static void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context)
 
         if (!hasPublicNoArgumentConstructor)
         {
-          var properties = new Dictionary<string, string>
+          var properties = new Dictionary<string, string?>
           {
             [PublicNoArgumentConstructorIsMissingConstants.HasNonPublicNoArgumentConstructor] = hasNonPublicNoArgumentConstructor.ToString()
           }.ToImmutableDictionary();

Source/Csla.Analyzers/Csla.Analyzers/CheckConstructorsAnalyzerPublicConstructorCodeFix.cs

@@ -35,11 +35,18 @@ public sealed class CheckConstructorsAnalyzerPublicConstructorCodeFix
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
       var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
-
+      if (root is null)
+      {
+        return;
+      }
       context.CancellationToken.ThrowIfCancellationRequested();
 
       var diagnostic = context.Diagnostics.First();
       var classNode = root.FindNode(diagnostic.Location.SourceSpan) as ClassDeclarationSyntax;
+      if (classNode is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
 
@@ -51,14 +58,16 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         if (context.Document.SupportsSemanticModel)
         {
           var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
-          AddCodeFixWithUpdatingNonPublicConstructor(
-            context, root, diagnostic, classNode, model);
+          if (model is null)
+          {
+            return;
+          }
+          AddCodeFixWithUpdatingNonPublicConstructor(context, root, diagnostic, classNode, model);
         }
       }
       else
       {
-        AddCodeFixWithNewPublicConstructor(
-          context, root, diagnostic, classNode);
+        AddCodeFixWithNewPublicConstructor(context, root, diagnostic, classNode);
       }
     }
 

Source/Csla.Analyzers/Csla.Analyzers/Csla.Analyzers.csproj

@@ -9,12 +9,18 @@
     <BaseOutputPath>..\..\..\Bin</BaseOutputPath>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <IsRoslynComponent>true</IsRoslynComponent>
+    <Nullable>enable</Nullable>
+    <WarningsAsErrors>nullable</WarningsAsErrors>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.10.0" PrivateAssets="all" />
     <PackageReference Update="NETStandard.Library" PrivateAssets="all" />
+    <PackageReference Include="Polyfill" Version="7.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>

Source/Csla.Analyzers/Csla.Analyzers/DoesChildOperationHaveRunLocalAnalyzer.cs

@@ -42,6 +42,11 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
       var methodNode = (MethodDeclarationSyntax)context.Node;
 
       var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodNode);
+      if (methodSymbol is null)
+      {
+        return;
+      }
+
       var typeSymbol = methodSymbol.ContainingType;
 
       if (typeSymbol.IsStereotype() && methodSymbol.IsChildDataPortalOperation() &&

Source/Csla.Analyzers/Csla.Analyzers/DoesChildOperationHaveRunLocalRemoveAttributeCodeFix.cs

@@ -33,18 +33,25 @@ public sealed class DoesChildOperationHaveRunLocalRemoveAttributeCodeFix
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
       var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+      if (root is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
 
       var diagnostic = context.Diagnostics.First();
       var methodNode = root.FindNode(diagnostic.Location.SourceSpan) as MethodDeclarationSyntax;
+      if (methodNode is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
       await AddCodeFixAsync(context, root, diagnostic, methodNode);
     }
 
-    private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode root,
-      Diagnostic diagnostic, MethodDeclarationSyntax methodNode)
+    private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode root, Diagnostic diagnostic, MethodDeclarationSyntax methodNode)
     {
       var newRoot = root;
 
@@ -55,7 +62,16 @@ private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode roo
       {
         foreach (var attribute in methodSymbol.GetAttributes().Where(_ => _.AttributeClass.IsRunLocalAttribute()))
         {
+          if (attribute.ApplicationSyntaxReference is null)
+          {
+            continue;
+          }
+
           newRoot = newRoot.RemoveNode(await attribute.ApplicationSyntaxReference.GetSyntaxAsync(), SyntaxRemoveOptions.KeepNoTrivia);
+          if (newRoot is null)
+          {
+            return;
+          }
         }
       }
 
@@ -72,6 +88,10 @@ private static async Task AddCodeFixAsync(CodeFixContext context, SyntaxNode roo
       foreach(var attributeListToRemove in attributeListsToRemove)
       {
         newRoot = newRoot.RemoveNode(attributeListToRemove, SyntaxRemoveOptions.KeepEndOfLine);
+        if (newRoot is null)
+        {
+          return;
+        }
       }
 
       context.RegisterCodeFix(

Source/Csla.Analyzers/Csla.Analyzers/DoesOperationHaveAttributeAddAttributeCodeFix.cs

@@ -50,11 +50,19 @@ public sealed class DoesOperationHaveAttributeAddAttributeCodeFix
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
       var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+      if (root is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
 
       var diagnostic = context.Diagnostics.First();
       var methodNode = root.FindNode(diagnostic.Location.SourceSpan) as MethodDeclarationSyntax;
+      if (methodNode is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
 

Source/Csla.Analyzers/Csla.Analyzers/DoesOperationHaveAttributeAnalyzer.cs

@@ -42,6 +42,10 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
       var methodNode = (MethodDeclarationSyntax)context.Node;
 
       var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodNode);
+      if (methodSymbol is null)
+      {
+        return;
+      }
       var typeSymbol = methodSymbol.ContainingType;
 
       if (typeSymbol.IsStereotype())

Source/Csla.Analyzers/Csla.Analyzers/EvaluateManagedBackingFieldsAnalyzer.cs

@@ -58,10 +58,8 @@ private static void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
             {
               foreach (var classMember in classSymbol.GetMembers())
               {
-                if (classMember.Kind == SymbolKind.Property)
+                if (classMember.Kind == SymbolKind.Property && classMember is IPropertySymbol classProperty)
                 {
-                  var classProperty = classMember as IPropertySymbol;
-
                   if (!classProperty.IsIndexer)
                   {
                     if (DetermineIfPropertyUsesField(context, fieldSymbol, classProperty))
@@ -93,9 +91,7 @@ private static void CheckForDiagnostics(SyntaxNodeAnalysisContext context, Field
       }
     }
 
-    private static bool DetermineIfPropertyUsesField(SyntaxNodeAnalysisContext context, 
-      IFieldSymbol fieldSymbol, IPropertySymbol classProperty, 
-      Func<PropertyDeclarationSyntax, SyntaxNode> propertyBody)
+    private static bool DetermineIfPropertyUsesField(SyntaxNodeAnalysisContext context, IFieldSymbol fieldSymbol, IPropertySymbol classProperty, Func<PropertyDeclarationSyntax, SyntaxNode?> propertyBody)
     {
       var root = context.Node.SyntaxTree.GetRoot();
       var rootSpan = root.FullSpan;
@@ -117,23 +113,22 @@ private static bool DetermineIfPropertyUsesField(SyntaxNodeAnalysisContext conte
       return false;
     }
 
-    private static bool DetermineIfPropertyUsesField(SyntaxNodeAnalysisContext context,
-      IFieldSymbol fieldSymbol, IPropertySymbol classProperty)
+    private static bool DetermineIfPropertyUsesField(SyntaxNodeAnalysisContext context, IFieldSymbol fieldSymbol, IPropertySymbol classProperty)
     {
       if (classProperty.GetMethod != null)
       {
         return DetermineIfPropertyUsesField(
           context, fieldSymbol, classProperty,
           propertyNode => propertyNode.ExpressionBody as SyntaxNode ??
-            propertyNode.AccessorList.Accessors.Single(
+            propertyNode.AccessorList?.Accessors.Single(
               _ => _.IsKind(SyntaxKind.GetAccessorDeclaration)));
       }
 
       if (classProperty.SetMethod != null)
       {
         return DetermineIfPropertyUsesField(
           context, fieldSymbol, classProperty,
-          propertyNode => propertyNode.AccessorList.Accessors.Single(
+          propertyNode => propertyNode.AccessorList?.Accessors.Single(
             _ => _.IsKind(SyntaxKind.SetAccessorDeclaration)));
       }
 

Source/Csla.Analyzers/Csla.Analyzers/EvaluateManagedBackingFieldsCodeFix.cs

@@ -31,6 +31,10 @@ public sealed class EvaluateManagedBackingFieldsCodeFix
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
       var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+      if (root is null)
+      {
+        return;
+      }
 
       context.CancellationToken.ThrowIfCancellationRequested();
 

Source/Csla.Analyzers/Csla.Analyzers/EvaluateManagedBackingFieldsWalker.cs

@@ -8,7 +8,7 @@ namespace Csla.Analyzers
   internal sealed class EvaluateManagedBackingFieldsWalker
     : CSharpSyntaxWalker
   {
-    internal EvaluateManagedBackingFieldsWalker(SyntaxNode node, SemanticModel model, IFieldSymbol fieldSymbol)
+    internal EvaluateManagedBackingFieldsWalker(SyntaxNode? node, SemanticModel model, IFieldSymbol fieldSymbol)
     {
       (FieldSymbol, Model) = (fieldSymbol, model);
       Visit(node);
@@ -17,6 +17,10 @@ internal EvaluateManagedBackingFieldsWalker(SyntaxNode node, SemanticModel model
     public override void VisitInvocationExpression(InvocationExpressionSyntax node)
     {
       var invocationSymbol = Model.GetSymbolInfo(node).Symbol as IMethodSymbol;
+      if (invocationSymbol is null)
+      {
+        return;
+      }
 
       if (invocationSymbol.IsPropertyInfoManagementMethod())
       {

Source/Csla.Analyzers/Csla.Analyzers/EvaluateOperationAttributeUsageAnalyzer.cs

@@ -40,18 +40,25 @@ public override void Initialize(AnalysisContext context)
     private static void AnalyzerAttributeDeclaration(SyntaxNodeAnalysisContext context)
     {
       var attributeNode = (AttributeSyntax)context.Node;
-      var attributeSymbol = context.SemanticModel.GetSymbolInfo(attributeNode).Symbol.ContainingSymbol as ITypeSymbol;
+      var attributeSymbol = context.SemanticModel.GetSymbolInfo(attributeNode).Symbol?.ContainingSymbol as ITypeSymbol;
 
       if (attributeSymbol.IsDataPortalOperationAttribute())
       {
         var methodNode = attributeNode.FindParent<MethodDeclarationSyntax>();
+        if (methodNode is null)
+        {
+          return;
+        }
         var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodNode);
+        if (methodSymbol is null)
+        {
+          return;
+        }
         var typeSymbol = methodSymbol.ContainingType;
 
         if (!typeSymbol.IsStereotype() || methodSymbol.IsStatic)
         {
-          context.ReportDiagnostic(Diagnostic.Create(
-            operationUsageRule, attributeNode.GetLocation()));
+          context.ReportDiagnostic(Diagnostic.Create(operationUsageRule, attributeNode.GetLocation()));
         }
       }
     }