feat: support nullable types (#217)

* reproduce #215

* Update DiagnosticVerifier.cs

* use symbolInfo when typeInfo does not work

* build for debug too

* throw exception for DEBUG

Author: Meir017

.github/workflows/ci.yml

@@ -7,6 +7,20 @@ on:
     branches: 
     - main
 jobs:
+  build-debug:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup .NET 6
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 6.0.x
+      - run: dotnet test --configuration Debug --filter 'TestCategory=Completed' /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura
   build:
     strategy:
       matrix:

src/FluentAssertions.Analyzers.Tests/DiagnosticVerifier.cs

@@ -31,6 +31,7 @@ static DiagnosticVerifier()
             {
                 typeof(object), // System.Private.CoreLib
                 typeof(Console), // System
+                typeof(Uri), // System.Private.Uri
                 typeof(Enumerable), // System.Linq
                 typeof(CSharpCompilation), // Microsoft.CodeAnalysis.CSharp
                 typeof(Compilation), // Microsoft.CodeAnalysis

src/FluentAssertions.Analyzers.Tests/Tips/SanityTests.cs

@@ -354,5 +354,43 @@ public class TestType3
                 Locations = new[] { new DiagnosticResultLocation("Test0.cs", 12, 9) }
             });
         }
+        
+        [TestMethod]
+        [Implemented(Reason = "https://github.com/fluentassertions/fluentassertions.analyzers/issues/215")]
+        public void ShouldNotFailToAnalyze()
+        {
+            const string source = @"
+#nullable enable
+using Xunit;
+using FluentAssertions;
+using FluentAssertions.Extensions;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+public class TestClass
+{
+    public static void Main()
+    {
+        var otherComponent = new OtherComponent();
+        otherComponent.Name.Should().Be(""SomeOtherComponent"");
+        otherComponent.Version.Should().Be(""1.2.3"");
+        otherComponent.DownloadUrl.Should().Be(new Uri(""https://sampleurl.com""));
+        otherComponent.Hash.Should().Be(""SampleHash"");
     }
-}
+}
+
+public class OtherComponent
+{
+    public string? Name { get; set; }
+
+    public string? Version { get; set; }
+
+    public Uri? DownloadUrl { get; set; }
+
+    public string? Hash { get; set; }
+}";
+
+            DiagnosticVerifier.VerifyCSharpDiagnosticUsingAllAnalyzers(source);
+        }
+    }
+}

src/FluentAssertions.Analyzers/Utilities/FluentAssertionsAnalyzer.cs

@@ -47,24 +47,28 @@ private void AnalyzeExpressionStatementSyntax(SyntaxNodeAnalysisContext context)
         protected virtual bool ShouldAnalyzeVariableNamedType(INamedTypeSymbol type, SemanticModel semanticModel) => true;
         protected virtual bool ShouldAnalyzeVariableType(ITypeSymbol type, SemanticModel semanticModel) => true;
 
-        private bool ShouldAnalyzeVariableTypeCore(ITypeSymbol type, SemanticModel semanticModel)
+        private bool ShouldAnalyzeVariableTypeCore(IdentifierNameSyntax identifier, SemanticModel semanticModel)
         {
-            if (type is INamedTypeSymbol namedType)
+            ISymbol symbol = semanticModel.GetTypeInfo(identifier).Type ?? semanticModel.GetSymbolInfo(identifier).Symbol;  
+            if (symbol is INamedTypeSymbol namedType)
             {
                 return ShouldAnalyzeVariableNamedType(namedType, semanticModel);
             }
 
-            return ShouldAnalyzeVariableType(type, semanticModel);
+            if (symbol is ITypeSymbol typeSymbol)
+            {
+                return ShouldAnalyzeVariableType(typeSymbol, semanticModel);
+            }
+
+            return false;
         }
 
         protected virtual Diagnostic AnalyzeExpression(ExpressionSyntax expression, SemanticModel semanticModel)
         {
             var variableNameExtractor = new VariableNameExtractor(semanticModel);
             expression.Accept(variableNameExtractor);
 
-            if (variableNameExtractor.PropertiesAccessed
-                .ConvertAll(identifier => semanticModel.GetTypeInfo(identifier))
-                .TrueForAll(typeInfo => !ShouldAnalyzeVariableTypeCore(typeInfo.Type, semanticModel))) {
+            if (variableNameExtractor.PropertiesAccessed.TrueForAll(identifier => !ShouldAnalyzeVariableTypeCore(identifier, semanticModel))) {
                 return null;
             }
 
@@ -106,7 +110,12 @@ private Diagnostic AnalyzeExpressionSafely(ExpressionSyntax expression, Semantic
                     expressionString = expression.ToString();
                 } catch {}
                 Console.Error.WriteLine($"Failed to analyze expression in {GetType().FullName}. expression: {expressionString}\n{e}");
+
+                #if DEBUG
+                throw e;
+                #else
                 return null;
+                #endif
             }
         }
     }