Use the new precedence service.

src/EditorFeatures/CSharp/Wrapping/BinaryExpression/CSharpBinaryExpressionWrapper.cs

@@ -9,7 +9,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.Wrapping.BinaryExpression
     internal class CSharpBinaryExpressionWrapper : AbstractBinaryExpressionWrapper<BinaryExpressionSyntax>
     {
         public CSharpBinaryExpressionWrapper()
-            : base(CSharpSyntaxFactsService.Instance)
+            : base(CSharpSyntaxFactsService.Instance, CSharpPrecedenceService.Instance)
         {
         }
 

src/EditorFeatures/Core/Wrapping/BinaryExpression/AbstractBinaryExpressionWrapper.cs

@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.Editor.Wrapping.BinaryExpression
 {
@@ -13,10 +14,14 @@ internal abstract partial class AbstractBinaryExpressionWrapper<TBinaryExpressio
         where TBinaryExpressionSyntax : SyntaxNode
     {
         private readonly ISyntaxFactsService _syntaxFacts;
+        private readonly IPrecedenceService _precedenceService;
 
-        protected AbstractBinaryExpressionWrapper(ISyntaxFactsService syntaxFacts)
+        protected AbstractBinaryExpressionWrapper(
+            ISyntaxFactsService syntaxFacts,
+            IPrecedenceService precedenceService)
         {
             _syntaxFacts = syntaxFacts;
+            _precedenceService = precedenceService;
         }
 
         /// <summary>
@@ -34,15 +39,18 @@ protected AbstractBinaryExpressionWrapper(ISyntaxFactsService syntaxFacts)
                 return null;
             }
 
-            if (!IsLogicalExpression(binaryExpr))
+            var precedence = _precedenceService.GetPrecedenceKind(binaryExpr);
+            if (precedence == PrecedenceKind.Other)
             {
                 return null;
             }
 
-            // Don't process this binary expression if it's in a parent logical expr.  We'll just
-            // allow our caller to walk up to that and call back into us to handle.  This way, we're
-            // always starting at the topmost logical binary expr.
-            if (IsLogicalExpression(binaryExpr.Parent))
+            // Don't process this binary expression if it's in a parent binary expr of the same
+            // precedence.  We'll just allow our caller to walk up to that and call back into us 
+            // to handle.  This way, we're always starting at the topmost binary expr of this
+            // precedence.
+            if (binaryExpr.Parent is TBinaryExpressionSyntax parentBinary &&
+                precedence == _precedenceService.GetPrecedenceKind(parentBinary))
             {
                 return null;
             }
@@ -77,29 +85,27 @@ protected AbstractBinaryExpressionWrapper(ISyntaxFactsService syntaxFacts)
         private ImmutableArray<SyntaxNodeOrToken> GetExpressionsAndOperators(TBinaryExpressionSyntax binaryExpr)
         {
             var result = ArrayBuilder<SyntaxNodeOrToken>.GetInstance();
-            AddExpressionsAndOperators(binaryExpr, result);
+            AddExpressionsAndOperators(
+                _precedenceService.GetPrecedenceKind(binaryExpr), binaryExpr, result);
             return result.ToImmutableAndFree();
         }
 
         private void AddExpressionsAndOperators(
-            SyntaxNode expr, ArrayBuilder<SyntaxNodeOrToken> result)
+            PrecedenceKind precedence, SyntaxNode expr, ArrayBuilder<SyntaxNodeOrToken> result)
         {
-            if (IsLogicalExpression(expr))
+            if (expr is TBinaryExpressionSyntax &&
+                precedence == _precedenceService.GetPrecedenceKind(expr))
             {
                 _syntaxFacts.GetPartsOfBinaryExpression(
                     expr, out var left, out var opToken, out var right);
-                AddExpressionsAndOperators(left, result);
+                AddExpressionsAndOperators(precedence, left, result);
                 result.Add(opToken);
-                AddExpressionsAndOperators(right, result);
+                AddExpressionsAndOperators(precedence, right, result);
             }
             else
             {
                 result.Add(expr);
             }
         }
-
-        private bool IsLogicalExpression(SyntaxNode node)
-            => _syntaxFacts.IsLogicalAndExpression(node) ||
-               _syntaxFacts.IsLogicalOrExpression(node);
     }
 }

src/EditorFeatures/VisualBasic/Wrapping/BinaryExpression/VisualBasicBinaryExpressionWrapper.vb

@@ -8,7 +8,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Wrapping.BinaryExpression
         Inherits AbstractBinaryExpressionWrapper(Of BinaryExpressionSyntax)
 
         Public Sub New()
-            MyBase.New(VisualBasicSyntaxFactsService.Instance)
+            MyBase.New(VisualBasicSyntaxFactsService.Instance, VisualBasicPrecedenceService.Instance)
         End Sub
 
         Protected Overrides Function GetNewLineBeforeOperatorTrivia(newLine As SyntaxTriviaList) As SyntaxTriviaList