Tackle symbol comparison warnings

Author: GrahamTheCoder

CodeConverter/CSharp/CommonConversions.cs

@@ -75,7 +75,7 @@ public CommonConversions(Document document, SemanticModel semanticModel,
         foreach (var name in declarator.Names) {
 
             var declaredSymbol = SemanticModel.GetDeclaredSymbol(name);
-            if (symbolsToSkip?.Contains(declaredSymbol) == true) continue;
+            if (symbolsToSkip?.Contains(declaredSymbol, SymbolEqualityComparer.IncludeNullability) == true) continue;
             var declaredSymbolType = declaredSymbol.GetSymbolType();
             var equalsValueClauseSyntax = await ConvertEqualsValueClauseSyntaxAsync(declarator, name, vbInitValue, declaredSymbolType, declaredSymbol, initializerOrMethodDecl);
             var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
@@ -107,7 +107,7 @@ public bool ShouldPreferExplicitType(VBSyntax.ExpressionSyntax exp,
         exp = op.Syntax as VBSyntax.ExpressionSyntax;
         var vbInitConstantValue = SemanticModel.GetConstantValue(exp);
         isNothingLiteral = vbInitConstantValue.HasValue && vbInitConstantValue.Value == null || exp is VBSyntax.LiteralExpressionSyntax les && les.IsKind(SyntaxKind.NothingLiteralExpression);
-        bool shouldPreferExplicitType = expConvertedType != null && (expConvertedType.HasCsKeyword() || !expConvertedType.Equals(op.Type));
+        bool shouldPreferExplicitType = expConvertedType != null && (expConvertedType.HasCsKeyword() || !expConvertedType.Equals(op.Type, SymbolEqualityComparer.IncludeNullability));
         return shouldPreferExplicitType;
     }
 
@@ -172,7 +172,7 @@ private CSSyntax.VariableDeclarationSyntax CreateVariableDeclaration(VariableDec
         CSSyntax.EqualsValueClauseSyntax equalsValueClauseSyntax, IMethodSymbol initSymbol, CSSyntax.VariableDeclaratorSyntax v)
     {
         var requireExplicitType = requireExplicitTypeForAll ||
-                                  vbInitializerType != null && !Equals(declaredSymbolType, vbInitializerType);
+                                  vbInitializerType != null && !SymbolEqualityComparer.IncludeNullability.Equals(declaredSymbolType, vbInitializerType);
         bool useVar = equalsValueClauseSyntax != null && !preferExplicitType && !requireExplicitType;
         var typeSyntax = initSymbol == null || !initSymbol.IsAnonymousFunction()
             ? GetTypeSyntax(declaredSymbolType, useVar)
@@ -267,7 +267,7 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
                     text = idSymbol.ContainingType.Name;
                     if (normalizedText.EndsWith("Attribute", StringComparison.OrdinalIgnoreCase))
                         text = text.Remove(text.Length - "Attribute".Length);
-                } else if (idSymbol.IsKind(SymbolKind.Parameter) && idSymbol.ContainingSymbol.IsAccessorWithValueInCsharp() && ((idSymbol.IsImplicitlyDeclared && idSymbol.Name.WithHalfWidthLatinCharacters().Equals("value", StringComparison.OrdinalIgnoreCase)) || idSymbol.Equals(idSymbol.ContainingSymbol.GetParameters().FirstOrDefault(x => !x.IsImplicitlyDeclared)))) {
+                } else if (idSymbol.IsKind(SymbolKind.Parameter) && idSymbol.ContainingSymbol.IsAccessorWithValueInCsharp() && ((idSymbol.IsImplicitlyDeclared && idSymbol.Name.WithHalfWidthLatinCharacters().Equals("value", StringComparison.OrdinalIgnoreCase)) || idSymbol.Equals(idSymbol.ContainingSymbol.GetParameters().FirstOrDefault(x => !x.IsImplicitlyDeclared), SymbolEqualityComparer.IncludeNullability))) {
                     // The case above is basically that if the symbol is a parameter, and the corresponding definition is a property set definition
                     // AND the first explicitly declared parameter is this symbol, we need to replace it with value.
                     text = "value";

CodeConverter/CSharp/DefiniteAssignmentAnalyzer.cs

@@ -7,6 +7,6 @@ public static bool IsDefinitelyAssignedBeforeRead(ISymbol localSymbol, DataFlowA
     {
         if (!methodFlow.ReadInside.Contains(localSymbol)) return true;
         var unassignedVariables = methodFlow.GetVbUnassignedVariables();
-        return unassignedVariables != null && !unassignedVariables.Contains(localSymbol);
+        return unassignedVariables != null && !unassignedVariables.Contains(localSymbol, SymbolEqualityComparer.IncludeNullability);
     }
 }

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -66,9 +66,11 @@ private static Dictionary<ITypeSymbol, string> CreateConvertMethodsLookupByRetur
 
         var convertMethods = convertType.GetMembers().Where(m =>
             m.Name.StartsWith("To", StringComparison.Ordinal) && m.GetParameters().Length == 1);
+
         var methodsByType = convertMethods
             .GroupBy(m => new { ReturnType = m.GetReturnType(), Name = $"{ConvertType.FullName}.{m.Name}" })
-            .ToDictionary(m => m.Key.ReturnType, m => m.Key.Name);
+            .ToDictionary(m => m.Key.ReturnType, m => m.Key.Name, SymbolEqualityComparer.IncludeNullability);
+
         return methodsByType;
     }
 

CodeConverter/Common/SymbolRenamer.cs

@@ -80,6 +80,7 @@ private static (ISymbol Original, string NewName)[] GetMethodSymbolsWithNewNames
         bool specialSymbolUsingName, bool caseSensitive)
     {
         var stringComparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
+#pragma warning disable RS1024 // Compare symbols correctly - analzyer bug, I'm intentionally using my own comparer, not the default ambiguous one
         var methodsBySignature = methodSymbols
             .ToLookup(m => m.GetUnqualifiedMethodSignature(caseSensitive))
             .Where(g => g.Count() > 1)
@@ -91,6 +92,7 @@ private static (ISymbol Original, string NewName)[] GetMethodSymbolsWithNewNames
                     !specialSymbolUsingName).ToArray();
                 return symbolsWithNewNames;
             }).ToArray();
+#pragma warning restore RS1024 // Compare symbols correctly
 
         foreach (var newMethodNames in methodsBySignature.Select(m => m.NewName))
         {