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

pkg/analyzer/lib/src/generated/resolver.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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 499 matching lines @@
     return problemReported;
   }
 
   /**
    * Produce a hint if the given [target] could have a value of `null`.
    */
   void _checkForCanBeNullAfterNullAware(Expression target, Token operator) {
     if (operator?.type == TokenType.QUESTION_PERIOD) {
       return;
     }
-    while (target is ParenthesizedExpression) {
-      target = (target as ParenthesizedExpression).expression;
-    }
+    target = target?.unParenthesized;
     if (target is MethodInvocation) {
       if (target.operator?.type == TokenType.QUESTION_PERIOD) {
         _errorReporter.reportErrorForNode(
             HintCode.CAN_BE_NULL_AFTER_NULL_AWARE, target);
       }
     } else if (target is PropertyAccess) {
       if (target.operator.type == TokenType.QUESTION_PERIOD) {
         _errorReporter.reportErrorForNode(
             HintCode.CAN_BE_NULL_AFTER_NULL_AWARE, target);
       }
@@ skipping 278 matching lines @@
         _errorReporter.reportErrorForNode(
             HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
       }
     }
   }
 
   /**
    * Produce a hint if the given [condition] could have a value of `null`.
    */
   void _checkForPossibleNullCondition(Expression condition) {
-    while (condition is ParenthesizedExpression) {
-      condition = (condition as ParenthesizedExpression).expression;
-    }
+    condition = condition?.unParenthesized;
     if (condition is BinaryExpression) {
       _checkForPossibleNullConditionInBinaryExpression(condition);
     } else if (condition is PrefixExpression) {
       _checkForPossibleNullConditionInPrefixExpression(condition);
     } else {
       _checkForPossibleNullConditionInSimpleExpression(condition);
     }
   }
 
   /**
@@ skipping 4789 matching lines @@
     } else if (expression is PropertyAccess) {
       element = expression.propertyName.staticElement;
     }
     if (element is VariableElement) {
       return element;
     }
     return null;
   }
 
   /**
-   * Return the static element associated with the given expression whose type can be promoted, or
-   * `null` if there is no element whose type can be promoted.
-   *
-   * @param expression the expression with which the element is associated
-   * @return the element associated with the given expression
+   * Return the static element associated with the given expression whose type
+   * can be promoted, or `null` if there is no element whose type can be
+   * promoted.
    */
   VariableElement getPromotionStaticElement(Expression expression) {
-    while (expression is ParenthesizedExpression) {
-      expression = (expression as ParenthesizedExpression).expression;
-    }
+    expression = expression?.unParenthesized;
     if (expression is SimpleIdentifier) {
       Element element = expression.staticElement;
       if (element is VariableElement) {
         ElementKind kind = element.kind;
         if (kind == ElementKind.LOCAL_VARIABLE ||
             kind == ElementKind.PARAMETER) {
           return element;
         }
       }
     }
@@ skipping 1517 matching lines @@
    * following the given expression will not be reached).
    *
    * @param expression the expression being tested
    * @return `true` if the given expression terminates abruptly
    */
   bool _isAbruptTerminationExpression(Expression expression) {
     // TODO(brianwilkerson) This needs to be significantly improved. Ideally we
     // would eventually turn this into a method on Expression that returns a
     // termination indication (normal, abrupt with no exception, abrupt with an
     // exception).
-    while (expression is ParenthesizedExpression) {
-      expression = (expression as ParenthesizedExpression).expression;
-    }
+    expression = expression?.unParenthesized;
     return expression is ThrowExpression || expression is RethrowExpression;
   }
 
   /**
    * Return `true` if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    *
    * @param statement the statement being tested
    * @return `true` if the given statement terminates abruptly
    */
@@ skipping 3702 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }