Add a (public) utility method to clean-up code

pkg/analysis_server/lib/src/services/correction/util.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library services.src.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart'
     show SourceChange, SourceEdit;
@@ skipping 1266 matching lines @@
       }
     }
     return null;
   }
 
   /**
    * @return the [InvertedCondition] for the given logical expression.
    */
   _InvertedCondition _invertCondition0(Expression expression) {
     if (expression is BooleanLiteral) {
-      BooleanLiteral literal = expression;
-      if (literal.value) {
+      if (expression.value) {
         return _InvertedCondition._simple("false");
       } else {
         return _InvertedCondition._simple("true");
       }
-    }
-    if (expression is BinaryExpression) {
-      BinaryExpression binary = expression;
-      TokenType operator = binary.operator.type;
-      Expression le = binary.leftOperand;
-      Expression re = binary.rightOperand;
+    } else if (expression is BinaryExpression) {
+      TokenType operator = expression.operator.type;
+      Expression le = expression.leftOperand;
+      Expression re = expression.rightOperand;
       _InvertedCondition ls = _invertCondition0(le);
       _InvertedCondition rs = _invertCondition0(re);
       if (operator == TokenType.LT) {
         return _InvertedCondition._binary2(ls, " >= ", rs);
       }
       if (operator == TokenType.GT) {
         return _InvertedCondition._binary2(ls, " <= ", rs);
       }
       if (operator == TokenType.LT_EQ) {
         return _InvertedCondition._binary2(ls, " > ", rs);
       }
       if (operator == TokenType.GT_EQ) {
         return _InvertedCondition._binary2(ls, " < ", rs);
       }
       if (operator == TokenType.EQ_EQ) {
         return _InvertedCondition._binary2(ls, " != ", rs);
       }
       if (operator == TokenType.BANG_EQ) {
         return _InvertedCondition._binary2(ls, " == ", rs);
       }
       if (operator == TokenType.AMPERSAND_AMPERSAND) {
         return _InvertedCondition._binary(
             TokenType.BAR_BAR.precedence, ls, " || ", rs);
       }
       if (operator == TokenType.BAR_BAR) {
         return _InvertedCondition._binary(
             TokenType.AMPERSAND_AMPERSAND.precedence, ls, " && ", rs);
       }
-    }
-    if (expression is IsExpression) {
-      IsExpression isExpression = expression;
-      String expressionSource = getNodeText(isExpression.expression);
-      String typeSource = getNodeText(isExpression.type);
-      if (isExpression.notOperator == null) {
+    } else if (expression is IsExpression) {
+      String expressionSource = getNodeText(expression.expression);
+      String typeSource = getNodeText(expression.type);
+      if (expression.notOperator == null) {
         return _InvertedCondition._simple("$expressionSource is! $typeSource");
       } else {
         return _InvertedCondition._simple("$expressionSource is $typeSource");
       }
-    }
-    if (expression is PrefixExpression) {
-      PrefixExpression prefixExpression = expression;
-      TokenType operator = prefixExpression.operator.type;
+    } else if (expression is PrefixExpression) {
+      TokenType operator = expression.operator.type;
       if (operator == TokenType.BANG) {
-        Expression operand = prefixExpression.operand;
-        while (operand is ParenthesizedExpression) {
-          ParenthesizedExpression pe = operand as ParenthesizedExpression;
-          operand = pe.expression;
-        }
+        Expression operand = expression.operand.unParenthesized;
         return _InvertedCondition._simple(getNodeText(operand));
       }
-    }
-    if (expression is ParenthesizedExpression) {
-      ParenthesizedExpression pe = expression;
-      Expression innerExpression = pe.expression;
-      while (innerExpression is ParenthesizedExpression) {
-        innerExpression =
-            (innerExpression as ParenthesizedExpression).expression;
-      }
-      return _invertCondition0(innerExpression);
+    } else if (expression is ParenthesizedExpression) {
+      return _invertCondition0(expression.unParenthesized);
     }
     DartType type = expression.bestType;
     if (type.displayName == "bool") {
       return _InvertedCondition._simple("!${getNodeText(expression)}");
     }
     return _InvertedCondition._simple(getNodeText(expression));
   }
 
   /**
    * Checks if [type] is visible at [targetOffset].
@@ skipping 149 matching lines @@
       _InvertedCondition expr, int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }