Use null-aware operators to clean up the 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 72 matching lines @@
 
   /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
   BestPracticesVerifier(
       this._errorReporter, TypeProvider typeProvider, this._currentLibrary,
       {TypeSystem typeSystem})
       : _futureNullType = typeProvider.futureNullType,
-        _typeSystem = (typeSystem != null) ? typeSystem : new TypeSystemImpl();
+        _typeSystem = typeSystem ?? new TypeSystemImpl();
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _checkForUnnecessaryCast(node);
@@ skipping 100 matching lines @@
   @override
   Object visitIfStatement(IfStatement node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     _checkForDeprecatedMemberUse(node.uriElement, node);
     ImportElement importElement = node.element;
-    if (importElement != null) {
-      if (importElement.isDeferred) {
-        _checkForLoadLibraryFunction(node, importElement);
-      }
+    if (importElement != null && importElement.isDeferred) {
+      _checkForLoadLibraryFunction(node, importElement);
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitIndexExpression(node);
   }
 
@@ skipping 117 matching lines @@
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
       }
       return true;
     }
     Element rhsElement = rhsType.element;
-    LibraryElement libraryElement =
-        rhsElement != null ? rhsElement.library : null;
+    LibraryElement libraryElement = rhsElement?.library;
     if (libraryElement != null && libraryElement.isDartCore) {
       // if x is Object or null is Null
       if (rhsType.isObject ||
           (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
         if (node.notOperator == null) {
           // the is case
           _errorReporter.reportErrorForNode(
               HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
         } else {
           // the is not case
@@ skipping 47 matching lines @@
       if (!_typeSystem.isAssignableTo(actualStaticType, expectedStaticType)) {
         // A warning was created in the ErrorVerifier, return false, don't
         // create a hint when a warning has already been created.
         return false;
       }
     }
     //
     // Hint case: test propagated type information
     //
     // Compute the best types to use.
-    DartType expectedBestType = expectedPropagatedType != null
-        ? expectedPropagatedType
-        : expectedStaticType;
-    DartType actualBestType =
-        actualPropagatedType != null ? actualPropagatedType : actualStaticType;
+    DartType expectedBestType = expectedPropagatedType ?? expectedStaticType;
+    DartType actualBestType = actualPropagatedType ?? actualStaticType;
     if (actualBestType != null && expectedBestType != null) {
       if (!_typeSystem.isAssignableTo(actualBestType, expectedBestType)) {
         _errorReporter.reportTypeErrorForNode(
             hintCode, expression, [actualBestType, expectedBestType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableForArgument.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an hint code is generated on the passed node
    * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
-    DartType staticParameterType =
-        staticParameterElement == null ? null : staticParameterElement.type;
+    DartType staticParameterType = staticParameterElement?.type;
     ParameterElement propagatedParameterElement =
         argument.propagatedParameterElement;
-    DartType propagatedParameterType = propagatedParameterElement == null
-        ? null
-        : propagatedParameterElement.type;
+    DartType propagatedParameterType = propagatedParameterElement?.type;
     return _checkForArgumentTypeNotAssignableWithExpectedTypes(
         argument,
         staticParameterType,
         propagatedParameterType,
         HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
@@ skipping 355 matching lines @@
       _checkForPossibleNullConditionInSimpleExpression(condition);
     }
   }
 
   /**
    * Produce a hint if any of the parts of the given binary [condition] could
    * have a value of `null`.
    */
   void _checkForPossibleNullConditionInBinaryExpression(
       BinaryExpression condition) {
-    Token operator = condition.operator;
-    if (operator != null &&
-        (operator.type == TokenType.AMPERSAND_AMPERSAND ||
-            operator.type == TokenType.BAR_BAR)) {
+    TokenType type = condition.operator?.type;
+    if (type == TokenType.AMPERSAND_AMPERSAND || type == TokenType.BAR_BAR) {
       _checkForPossibleNullCondition(condition.leftOperand);
       _checkForPossibleNullCondition(condition.rightOperand);
     }
   }
 
   /**
    * Produce a hint if the operand of the given prefix [condition] could
    * have a value of `null`.
    */
   void _checkForPossibleNullConditionInPrefixExpression(
       PrefixExpression condition) {
     if (condition.operator?.type == TokenType.BANG) {
       _checkForPossibleNullCondition(condition.operand);
     }
   }
 
   /**
    * Produce a hint if the given [condition] could have a value of `null`.
    */
   void _checkForPossibleNullConditionInSimpleExpression(Expression condition) {
     if (condition is MethodInvocation) {
-      Token operator = condition.operator;
-      if (operator != null && operator.type == TokenType.QUESTION_PERIOD) {
+      if (condition.operator?.type == TokenType.QUESTION_PERIOD) {
         _errorReporter.reportErrorForNode(
             HintCode.NULL_AWARE_IN_CONDITION, condition);
       }
     } else if (condition is PropertyAccess) {
-      Token operator = condition.operator;
-      if (operator != null && operator.type == TokenType.QUESTION_PERIOD) {
+      if (condition.operator?.type == TokenType.QUESTION_PERIOD) {
         _errorReporter.reportErrorForNode(
             HintCode.NULL_AWARE_IN_CONDITION, condition);
       }
     }
   }
 
   /**
    * Check for the passed as expression for the [HintCode.UNNECESSARY_CAST] hint code.
    *
    * @param node the as expression to check
@@ skipping 859 matching lines @@
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.IS_DOUBLE],
    * [HintCode.IS_INT],
    * [HintCode.IS_NOT_DOUBLE], and
    * [HintCode.IS_NOT_INT].
    */
   bool _checkForIsDoubleHints(IsExpression node) {
     TypeName typeName = node.type;
     DartType type = typeName.type;
-    if (type != null && type.element != null) {
-      Element element = type.element;
+    Element element = type?.element;
+    if (element != null) {
       String typeNameStr = element.name;
       LibraryElement libraryElement = element.library;
       //      if (typeNameStr.equals(INT_TYPE_NAME) && libraryElement != null
       //          && libraryElement.isDartCore()) {
       //        if (node.getNotOperator() == null) {
       //          errorReporter.reportError(HintCode.IS_INT, node);
       //        } else {
       //          errorReporter.reportError(HintCode.IS_NOT_INT, node);
       //        }
       //        return true;
@@ skipping 27 matching lines @@
    *  The type system for this visitor
    */
   final TypeSystem _typeSystem;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
   DeadCodeVerifier(this._errorReporter, {TypeSystem typeSystem})
-      : this._typeSystem =
-            (typeSystem != null) ? typeSystem : new TypeSystemImpl();
+      : this._typeSystem = typeSystem ?? new TypeSystemImpl();
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     Token operator = node.operator;
     bool isAmpAmp = operator.type == TokenType.AMPERSAND_AMPERSAND;
     bool isBarBar = operator.type == TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
-          if (lhsResult.value.toBoolValue() == true && isBarBar) {
+          bool value = lhsResult.value.toBoolValue();
+          if (value == true && isBarBar) {
             // report error on else block: true || !e!
             _errorReporter.reportErrorForNode(
                 HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             lhsCondition?.accept(this);
             return null;
-          } else if (lhsResult.value.toBoolValue() == false && isAmpAmp) {
+          } else if (value == false && isAmpAmp) {
             // report error on if block: false && !e!
             _errorReporter.reportErrorForNode(
                 HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             lhsCondition?.accept(this);
             return null;
           }
         }
       }
       // How do we want to handle the RHS? It isn't dead code, but "pointless"
@@ skipping 134 matching lines @@
     node.body?.accept(this);
     node.finallyBlock?.accept(this);
     NodeList<CatchClause> catchClauses = node.catchClauses;
     int numOfCatchClauses = catchClauses.length;
     List<DartType> visitedTypes = new List<DartType>();
     for (int i = 0; i < numOfCatchClauses; i++) {
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         // on-catch clause found, verify that the exception type is not a
         // subtype of a previous on-catch exception type
-        TypeName typeName = catchClause.exceptionType;
-        if (typeName != null && typeName.type != null) {
-          DartType currentType = typeName.type;
+        DartType currentType = catchClause.exceptionType?.type;
+        if (currentType != null) {
           if (currentType.isObject) {
             // Found catch clause clause that has Object as an exception type,
             // this is equivalent to having a catch clause that doesn't have an
             // exception type, visit the block, but generate an error on any
             // following catch clauses (and don't visit them).
             catchClause?.accept(this);
             if (i + 1 != numOfCatchClauses) {
               // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
@@ skipping 1794 matching lines @@
         }
         // For switch members with no statements, don't visit the children,
         // otherwise, return false if no return is found in the children
         // statements.
         if (!switchMember.statements.isEmpty && !switchMember.accept(this)) {
           return false;
         }
       }
       // All of the members exit, determine whether there are possible cases
       // that are not caught by the members.
-      DartType type = node.expression == null ? null : node.expression.bestType;
+      DartType type = node.expression?.bestType;
       if (type is InterfaceType) {
         ClassElement element = type.element;
         if (element != null && element.isEnum) {
           // If some of the enum values are not covered, then a warning will
           // have already been generated, so there's no point in generating a
           // hint.
           return true;
         }
       }
       return hasDefault;
@@ skipping 708 matching lines @@
       if (importsLibrary.length == 1) {
         ImportDirective usedImportDirective = importsLibrary[0];
         _unusedImports.remove(usedImportDirective);
         _removeFromUnusedShownNamesMap(element, usedImportDirective);
         continue;
       }
       // Otherwise, find import directives using namespaces.
       String name = element.displayName;
       for (ImportDirective importDirective in importsLibrary) {
         Namespace namespace = _computeNamespace(importDirective);
-        if (namespace != null && namespace.get(name) != null) {
+        if (namespace?.get(name) != null) {
           _unusedImports.remove(importDirective);
           _removeFromUnusedShownNamesMap(element, importDirective);
         }
       }
     }
   }
 
   /**
    * Recursively add any exported library elements into the [libraryMap].
    */
@@ skipping 1253 matching lines @@
     }
     return null;
   }
 
   /**
    * A client is about to resolve a member in the given class declaration.
    */
   void prepareToResolveMembersInClass(ClassDeclaration node) {
     _enclosingClassDeclaration = node;
     enclosingClass = node.element;
-    typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
+    typeAnalyzer.thisType = enclosingClass?.type;
   }
 
   /**
    * If the given [type] is valid, strongly more specific than the
    * existing static type of the given [expression], record it as a propagated
    * type of the given [expression]. Otherwise, reset it to `null`.
    *
    * If [hasOldPropagatedType] is `true` then the existing propagated type
    * should also is checked.
    */
@@ skipping 232 matching lines @@
   Object visitCascadeExpression(CascadeExpression node) {
     InferenceContext.setTypeFromNode(node.target, node);
     return super.visitCascadeExpression(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     //
     // Resolve the metadata in the library scope.
     //
-    if (node.metadata != null) {
-      node.metadata.accept(this);
-    }
+    node.metadata?.accept(this);
     _enclosingClassDeclaration = node;
     //
     // Continue the class resolution.
     //
     ClassElement outerType = enclosingClass;
     try {
       enclosingClass = node.element;
-      typeAnalyzer.thisType =
-          enclosingClass == null ? null : enclosingClass.type;
+      typeAnalyzer.thisType = enclosingClass?.type;
       super.visitClassDeclaration(node);
       node.accept(elementResolver);
       node.accept(typeAnalyzer);
     } finally {
-      typeAnalyzer.thisType = outerType == null ? null : outerType.type;
+      typeAnalyzer.thisType = outerType?.type;
       enclosingClass = outerType;
       _enclosingClassDeclaration = null;
     }
     return null;
   }
 
   /**
    * Implementation of this method should be synchronized with
    * [visitClassDeclaration].
    */
   visitClassDeclarationIncrementally(ClassDeclaration node) {
     //
     // Resolve the metadata in the library scope.
     //
-    if (node.metadata != null) {
-      node.metadata.accept(this);
-    }
+    node.metadata?.accept(this);
     _enclosingClassDeclaration = node;
     //
     // Continue the class resolution.
     //
     enclosingClass = node.element;
-    typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
+    typeAnalyzer.thisType = enclosingClass?.type;
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
   }
 
   @override
   Object visitComment(Comment node) {
     AstNode parent = node.parent;
     if (parent is FunctionDeclaration ||
         parent is FunctionTypeAlias ||
         parent is ConstructorDeclaration ||
@@ skipping 197 matching lines @@
     if (node.metadata != null) {
       node.metadata.accept(this);
       ElementResolver.resolveMetadata(node);
     }
     //
     // Continue the enum resolution.
     //
     ClassElement outerType = enclosingClass;
     try {
       enclosingClass = node.element;
-      typeAnalyzer.thisType =
-          enclosingClass == null ? null : enclosingClass.type;
+      typeAnalyzer.thisType = enclosingClass?.type;
       super.visitEnumDeclaration(node);
       node.accept(elementResolver);
       node.accept(typeAnalyzer);
     } finally {
-      typeAnalyzer.thisType = outerType == null ? null : outerType.type;
+      typeAnalyzer.thisType = outerType?.type;
       enclosingClass = outerType;
       _enclosingClassDeclaration = null;
     }
     return null;
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (resolveOnlyCommentInFunctionBody) {
       return null;
@@ skipping 792 matching lines @@
       return;
     }
     FunctionExpression closure = mayBeClosure as FunctionExpression;
     // prepare expected closure type
     if (mayByFunctionType is! FunctionType) {
       return;
     }
     FunctionType expectedClosureType = mayByFunctionType as FunctionType;
     // If the expectedClosureType is not more specific than the static type,
     // return.
-    DartType staticClosureType =
-        closure.element != null ? closure.element.type : null;
+    DartType staticClosureType = closure.element?.type;
     if (staticClosureType != null &&
         !expectedClosureType.isMoreSpecificThan(staticClosureType)) {
       return;
     }
     // set propagated type for the closure
     closure.propagatedType = expectedClosureType;
     // set inferred types for parameters
     NodeList<FormalParameter> parameters = closure.parameters.parameters;
     List<ParameterElement> expectedParameters = expectedClosureType.parameters;
     for (int i = 0;
@@ skipping 1255 matching lines @@
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
       //
       // Check to see whether the type name is either 'dynamic' or 'void',
       // neither of which are in the name scope and hence will not be found by
       // normal means.
       //
       if (typeName.name == dynamicType.name) {
         _setElement(typeName, dynamicType.element);
-        if (argumentList != null) {
-          // TODO(brianwilkerson) Report this error
+//        if (argumentList != null) {
+//          // TODO(brianwilkerson) Report this error
 //          reporter.reportError(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, node, dynamicType.getName(), 0, argumentList.getArguments().size());
-        }
+//        }
         typeName.staticType = dynamicType;
         node.type = dynamicType;
         return;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         // There is no element for 'void'.
-        if (argumentList != null) {
-          // TODO(brianwilkerson) Report this error
+//        if (argumentList != null) {
+//          // TODO(brianwilkerson) Report this error
 //          reporter.reportError(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, node, voidType.getName(), 0, argumentList.getArguments().size());
-        }
+//        }
         typeName.staticType = voidType;
         node.type = voidType;
         return;
       }
       //
       // If not, the look to see whether we might have created the wrong AST
       // structure for a constructor name. If so, fix the AST structure and then
       // proceed.
       //
       AstNode parent = node.parent;
@@ skipping 129 matching lines @@
     DartType type = null;
     if (element is ClassElement) {
       _setElement(typeName, element);
       type = element.type;
     } else if (element is FunctionTypeAliasElement) {
       _setElement(typeName, element);
       type = element.type;
     } else if (element is TypeParameterElement) {
       _setElement(typeName, element);
       type = element.type;
-      if (argumentList != null) {
-        // Type parameters cannot have type arguments.
-        // TODO(brianwilkerson) Report this error.
-        //      resolver.reportError(ResolverErrorCode.?, keyType);
-      }
+//      if (argumentList != null) {
+//        // Type parameters cannot have type arguments.
+//        // TODO(brianwilkerson) Report this error.
+//        //      resolver.reportError(ResolverErrorCode.?, keyType);
+//      }
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = element.conflictingElements;
       type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isTypeNameInCatchClause(node)) {
@@ skipping 347 matching lines @@
 
   /**
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
   DartType getBestType(VariableElement element) {
     DartType bestType = getType(element);
-    return bestType == null ? element.type : bestType;
+    return bestType ?? element.type;
   }
 
   /**
    * Return the overridden type of the given element, or `null` if the type of the element has
    * not been overridden.
    *
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
@@ skipping 107 matching lines @@
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
     Element nonAccessor =
         element is PropertyAccessorElement ? element.variable : element;
     DartType type = _overridenTypes[nonAccessor];
     if (_overridenTypes.containsKey(nonAccessor)) {
       return type;
     }
-    if (type != null) {
-      return type;
-    } else if (_outerScope != null) {
-      return _outerScope.getType(nonAccessor);
-    }
-    return null;
+    return type ?? _outerScope?.getType(element);
   }
 
   /**
    * Clears the overridden type of the given [element].
    */
   void resetType(VariableElement element) {
     _overridenTypes[element] = null;
   }
 
   /**
@@ skipping 33 matching lines @@
    * Exit the current promotion scope.
    */
   void exitScope() {
     if (currentScope == null) {
       throw new IllegalStateException("No scope to exit");
     }
     currentScope = currentScope._outerScope;
   }
 
   /**
-   * Returns static type of the given variable - declared or promoted.
-   *
-   * @return the static type of the given variable - declared or promoted
+   * Return the static type of the given [variable] - declared or promoted.
    */
-  DartType getStaticType(VariableElement variable) {
-    DartType staticType = getType(variable);
-    if (staticType == null) {
-      staticType = variable.type;
-    }
-    return staticType;
-  }
+  DartType getStaticType(VariableElement variable) =>
+      getType(variable) ?? variable.type;
 
   /**
-   * Return the promoted type of the given element, or `null` if the type of the element has
-   * not been promoted.
-   *
-   * @param element the element whose type might have been promoted
-   * @return the promoted type of the given element
+   * Return the promoted type of the given [element], or `null` if the type of
+   * the element has not been promoted.
    */
-  DartType getType(Element element) {
-    if (currentScope == null) {
-      return null;
-    }
-    return currentScope.getType(element);
-  }
+  DartType getType(Element element) => currentScope?.getType(element);
 
   /**
    * Set the promoted type of the given element to the given type.
    *
    * @param element the element whose type might have been promoted
    * @param type the promoted type of the given element
    */
   void setType(Element element, DartType type) {
     if (currentScope == null) {
       throw new IllegalStateException("Cannot promote without a scope");
@@ skipping 1593 matching lines @@
 
   TypeSystem _typeSystem;
 
   _ConstantVerifier_validateInitializerExpression(
       TypeProvider typeProvider,
       ErrorReporter errorReporter,
       this.verifier,
       this.parameterElements,
       DeclaredVariables declaredVariables,
       {TypeSystem typeSystem})
-      : _typeSystem = (typeSystem != null) ? typeSystem : new TypeSystemImpl(),
+      : _typeSystem = typeSystem ?? new TypeSystemImpl(),
         super(
             new ConstantEvaluationEngine(typeProvider, declaredVariables,
                 typeSystem: typeSystem),
             errorReporter);
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
@@ skipping 83 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }