Use null-aware operators to clean up the code

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 630 matching lines @@
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     bool wasInAsync = _inAsync;
     bool wasInGenerator = _inGenerator;
     try {
       _inAsync = node.isAsynchronous;
       _inGenerator = node.isGenerator;
-      FunctionType functionType =
-          _enclosingFunction == null ? null : _enclosingFunction.type;
+      FunctionType functionType = _enclosingFunction?.type;
       DartType expectedReturnType = functionType == null
           ? DynamicTypeImpl.instance
           : functionType.returnType;
       ExecutableElement function = _enclosingFunction;
       bool isSetterWithImplicitReturn = function.hasImplicitReturnType &&
           function is PropertyAccessorElement &&
           function.isSetter;
       if (!isSetterWithImplicitReturn) {
         _checkForReturnOfInvalidType(node.expression, expectedReturnType);
       }
@@ skipping 1126 matching lines @@
     }
     ExecutableElement executableElement = method.element;
     if (executableElement == null) {
       return;
     }
     SimpleIdentifier methodName = method.name;
     if (methodName.isSynthetic) {
       return;
     }
     FormalParameterList formalParameterList = method.parameters;
-    NodeList<FormalParameter> parameterList =
-        formalParameterList != null ? formalParameterList.parameters : null;
+    NodeList<FormalParameter> parameterList = formalParameterList?.parameters;
     List<AstNode> parameters =
         parameterList != null ? new List.from(parameterList) : null;
     _checkForAllInvalidOverrideErrorCodesForExecutable(executableElement,
         executableElement.parameters, parameters, methodName);
   }
 
   /**
    * Verify that all classes of the given [withClause] are valid.
    *
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR],
@@ skipping 102 matching lines @@
    * don't have `return;` if the enclosing method has a return type.
    *
    * Check that the return type matches the type of the declared return type in
    * the enclosing method or function.
    *
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR],
    * [StaticWarningCode.RETURN_WITHOUT_VALUE], and
    * [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
   void _checkForAllReturnStatementErrorCodes(ReturnStatement statement) {
-    FunctionType functionType =
-        _enclosingFunction == null ? null : _enclosingFunction.type;
+    FunctionType functionType = _enclosingFunction?.type;
     DartType expectedReturnType = functionType == null
         ? DynamicTypeImpl.instance
         : functionType.returnType;
     Expression returnExpression = statement.expression;
     // RETURN_IN_GENERATIVE_CONSTRUCTOR
     bool isGenerativeConstructor(ExecutableElement element) =>
         element is ConstructorElement && !element.isFactory;
     if (isGenerativeConstructor(_enclosingFunction)) {
       if (returnExpression == null) {
         return;
@@ skipping 96 matching lines @@
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument].
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   void _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
-    DartType staticParameterType =
-        staticParameterElement == null ? null : staticParameterElement.type;
+    DartType staticParameterType = staticParameterElement?.type;
     _checkForArgumentTypeNotAssignableWithExpectedTypes(argument,
         staticParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * Verify that the given [expression] can be assigned to its corresponding
    * parameters. The [expectedStaticType] is the expected static type.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignableWithExpectedTypes].
@@ skipping 1643 matching lines @@
     if (node.identifier == null && node.loopVariable == null) {
       return;
     }
 
     DartType iterableType = getStaticType(node.iterable);
     if (iterableType.isDynamic) {
       return;
     }
 
     // The type of the loop variable.
-    SimpleIdentifier variable = node.identifier != null
-        ? node.identifier
-        : node.loopVariable.identifier;
+    SimpleIdentifier variable = node.identifier ?? node.loopVariable.identifier;
     DartType variableType = getStaticType(variable);
 
     DartType loopType = node.awaitKeyword != null
         ? _typeProvider.streamType
         : _typeProvider.iterableType;
 
     // Use an explicit string instead of [loopType] to remove the "<E>".
     String loopTypeName = node.awaitKeyword != null ? "Stream" : "Iterable";
 
     // The object being iterated has to implement Iterable<T> for some T that
@@ skipping 66 matching lines @@
    *
    * See [StaticTypeWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC].
    */
   bool _checkForInstanceMethodNameCollidesWithSuperclassStatic(
       ExecutableElement executableElement, SimpleIdentifier errorNameTarget) {
     String executableElementName = executableElement.name;
     if (executableElement is! PropertyAccessorElement &&
         !executableElement.isOperator) {
       HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
       InterfaceType superclassType = _enclosingClass.supertype;
-      ClassElement superclassElement =
-          superclassType == null ? null : superclassType.element;
+      ClassElement superclassElement = superclassType?.element;
       bool executableElementPrivate =
           Identifier.isPrivateName(executableElementName);
       while (superclassElement != null &&
           !visitedClasses.contains(superclassElement)) {
         visitedClasses.add(superclassElement);
         LibraryElement superclassLibrary = superclassElement.library;
         // Check fields.
         FieldElement fieldElt =
             superclassElement.getField(executableElementName);
         if (fieldElt != null) {
@@ skipping 31 matching lines @@
                     .INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
                 errorNameTarget,
                 [
                   executableElementName,
                   methodElement.enclosingElement.displayName
                 ]);
             return true;
           }
         }
         superclassType = superclassElement.supertype;
-        superclassElement =
-            superclassType == null ? null : superclassType.element;
+        superclassElement = superclassType?.element;
       }
     }
     return false;
   }
 
   /**
    * Verify that an 'int' can be assigned to the parameter corresponding to the
    * given [argument]. This is used for prefix and postfix expressions where
    * the argument value is implicit.
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   void _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
-    DartType staticParameterType =
-        staticParameterElement == null ? null : staticParameterElement.type;
+    DartType staticParameterType = staticParameterElement?.type;
     _checkForArgumentTypeNotAssignable(argument, staticParameterType, _intType,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * Verify that the given [annotation] isn't defined in a deferred library.
    *
    * See [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
    */
   void _checkForInvalidAnnotationFromDeferredLibrary(Annotation annotation) {
@@ skipping 2365 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }