Refactor so that GetSymbolInfo can be called last

src/Features/CSharp/Portable/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs

@@ -38,10 +38,11 @@ protected override bool IsEquals(BinaryExpressionSyntax condition)
         protected override bool IsNotEquals(BinaryExpressionSyntax condition)
             => condition.Kind() == SyntaxKind.NotEqualsExpression;
 
-        protected override bool TryAnalyzePatternCondition(SyntaxNode conditionNode, out SyntaxNode conditionLeft, out SyntaxNode conditionRight, out bool isEquals)
+        protected override bool TryAnalyzePatternCondition(
+            ISyntaxFactsService syntaxFacts, SyntaxNode conditionNode, 
+            out SyntaxNode conditionPartToCheck, out bool isEquals)
         {
-            conditionLeft = null;
-            conditionRight = null;
+            conditionPartToCheck = null;
             isEquals = true;
 
             var patternExpression = conditionNode as IsPatternExpressionSyntax;
@@ -56,8 +57,12 @@ protected override bool TryAnalyzePatternCondition(SyntaxNode conditionNode, out
                 return false;
             }
 
-            conditionLeft = patternExpression.Expression;
-            conditionRight = constantPattern.Expression;
+            if (!syntaxFacts.IsNullLiteralExpression(constantPattern.Expression))
+            {
+                return false;
+            }
+
+            conditionPartToCheck = patternExpression.Expression;
             return true;
         }
     }

src/Features/Core/Portable/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs

@@ -50,7 +50,9 @@ protected AbstractUseNullPropagationDiagnosticAnalyzer()
         protected abstract ISyntaxFactsService GetSyntaxFactsService();
         protected abstract ISemanticFactsService GetSemanticFactsService();
 
-        protected abstract bool TryAnalyzePatternCondition(SyntaxNode conditionNode, out SyntaxNode conditionLeft, out SyntaxNode conditionRight, out bool isEquals);
+        protected abstract bool TryAnalyzePatternCondition(
+            ISyntaxFactsService syntaxFacts, SyntaxNode conditionNode, 
+            out SyntaxNode conditionPartToCheck, out bool isEquals);
 
         protected override void InitializeWorker(AnalysisContext context)
         {
@@ -100,26 +102,12 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol e
 
             var isEqualityLikeCondition = TryAnalyzeCondition(
                 context, syntaxFacts, referenceEqualsMethodOpt, conditionNode,
-                out var conditionLeft, out var conditionRight, out var isEquals);
+                out var conditionPartToCheck, out var isEquals);
             if (!isEqualityLikeCondition)
             {
                 return;
             }
 
-            var conditionLeftIsNull = syntaxFacts.IsNullLiteralExpression(conditionLeft);
-            var conditionRightIsNull = syntaxFacts.IsNullLiteralExpression(conditionRight);
-
-            if (conditionRightIsNull && conditionLeftIsNull)
-            {
-                // null == null    nothing to do here.
-                return;
-            }
-
-            if (!conditionRightIsNull && !conditionLeftIsNull)
-            {
-                return;
-            }
-
             // Needs to be of the form:
             //      x == null ? null : ...    or
             //      x != null ? ...  : null;
@@ -133,7 +121,6 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol e
                 return;
             }
 
-            var conditionPartToCheck = conditionRightIsNull ? conditionLeft : conditionRight;
             var whenPartToCheck = isEquals ? whenFalseNode : whenTrueNode;
 
             var semanticFacts = GetSemanticFactsService();
@@ -186,49 +173,48 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol e
 
         private bool TryAnalyzeCondition(
             SyntaxNodeAnalysisContext context, ISyntaxFactsService syntaxFacts, IMethodSymbol referenceEqualsMethodOpt, SyntaxNode conditionNode,
-            out SyntaxNode conditionLeft, out SyntaxNode conditionRight, out bool isEquals)
+            out SyntaxNode conditionPartToCheck, out bool isEquals)
         {
             switch (conditionNode)
             {
                 case TBinaryExpressionSyntax binaryExpression:
                     return TryAnalyzeBinaryExpressionCondition(
-                        syntaxFacts, binaryExpression, out conditionLeft, out conditionRight, out isEquals);
+                        syntaxFacts, binaryExpression, out conditionPartToCheck, out isEquals);
 
                 case TInvocationExpression invocation:
                     return TryAnalyzeInvocationCondition(
                         context, syntaxFacts, referenceEqualsMethodOpt, invocation,
-                        out conditionLeft, out conditionRight, out isEquals);
+                        out conditionPartToCheck, out isEquals);
 
                 default:
                     return TryAnalyzePatternCondition(
-                        conditionNode, out conditionLeft, out conditionRight, out isEquals);
+                        syntaxFacts, conditionNode, out conditionPartToCheck, out isEquals);
             }
         }
 
         private bool TryAnalyzeBinaryExpressionCondition(
             ISyntaxFactsService syntaxFacts, TBinaryExpressionSyntax condition,
-            out SyntaxNode conditionLeft, out SyntaxNode conditionRight, out bool isEquals)
+            out SyntaxNode conditionPartToCheck, out bool isEquals)
         {
             isEquals = IsEquals(condition);
             if (!isEquals && !IsNotEquals(condition))
             {
-                conditionLeft = null;
-                conditionRight = null;
+                conditionPartToCheck = null;
                 return false;
             }
             else
             {
-                syntaxFacts.GetPartsOfBinaryExpression(condition, out conditionLeft, out conditionRight);
-                return true;
+                syntaxFacts.GetPartsOfBinaryExpression(condition, out var conditionLeft, out var conditionRight);
+                conditionPartToCheck = GetConditionPartToCheck(syntaxFacts, conditionLeft, conditionRight);
+                return conditionPartToCheck != null;
             }
         }
 
         private static bool TryAnalyzeInvocationCondition(
             SyntaxNodeAnalysisContext context, ISyntaxFactsService syntaxFacts, IMethodSymbol referenceEqualsMethodOpt, TInvocationExpression invocation,
-            out SyntaxNode conditionLeft, out SyntaxNode conditionRight, out bool isEquals)
+            out SyntaxNode conditionPartToCheck, out bool isEquals)
         {
-            conditionLeft = null;
-            conditionRight = null;
+            conditionPartToCheck = null;
             isEquals = true;
 
             var expression = syntaxFacts.GetExpressionOfInvocationExpression(invocation);
@@ -255,17 +241,42 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol e
                 return false;
             }
 
+            var conditionLeft = syntaxFacts.GetExpressionOfArgument(arguments[0]);
+            var conditionRight = syntaxFacts.GetExpressionOfArgument(arguments[1]);
+            if (conditionLeft == null || conditionRight == null)
+            {
+                return false;
+            }
+
+            conditionPartToCheck = GetConditionPartToCheck(syntaxFacts, conditionLeft, conditionRight);
+            if (conditionPartToCheck == null)
+            {
+                return false;
+            }
+
             var semanticModel = context.SemanticModel;
             var cancellationToken = context.CancellationToken;
             var symbol = semanticModel.GetSymbolInfo(invocation, cancellationToken).Symbol;
-            if (!referenceEqualsMethodOpt.Equals(symbol))
+            return referenceEqualsMethodOpt.Equals(symbol);
+        }
+
+        private static SyntaxNode GetConditionPartToCheck(ISyntaxFactsService syntaxFacts, SyntaxNode conditionLeft, SyntaxNode conditionRight)
         {
-                return false;
+            var conditionLeftIsNull = syntaxFacts.IsNullLiteralExpression(conditionLeft);
+            var conditionRightIsNull = syntaxFacts.IsNullLiteralExpression(conditionRight);
+
+            if (conditionRightIsNull && conditionLeftIsNull)
+            {
+                // null == null    nothing to do here.
+                return null;
+            }
+
+            if (!conditionRightIsNull && !conditionLeftIsNull)
+            {
+                return null;
             }
 
-            conditionLeft = syntaxFacts.GetExpressionOfArgument(arguments[0]);
-            conditionRight = syntaxFacts.GetExpressionOfArgument(arguments[1]);
-            return conditionLeft != null && conditionRight != null;
+            return conditionRightIsNull ? conditionLeft : conditionRight;
         }
 
         internal static SyntaxNode GetWhenPartMatch(

src/Features/VisualBasic/Portable/UseNullPropagation/VisualBasicUseNullPropagationDiagnosticAnalyzer.vb

@@ -42,9 +42,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseNullPropagation
             Return condition.Kind() = SyntaxKind.IsNotExpression
         End Function
 
-        Protected Overrides Function TryAnalyzePatternCondition(conditionNode As SyntaxNode, ByRef conditionLeft As SyntaxNode, ByRef conditionRight As SyntaxNode, ByRef isEquals As Boolean) As Boolean
-            conditionLeft = Nothing
-            conditionRight = Nothing
+        Protected Overrides Function TryAnalyzePatternCondition(syntaxFacts As ISyntaxFactsService, conditionNode As SyntaxNode, ByRef conditionPartToCheck As SyntaxNode, ByRef isEquals As Boolean) As Boolean
+            conditionPartToCheck = Nothing
             isEquals = False
             Return False
         End Function