Use null-aware operators to clean up the code

pkg/analyzer/lib/src/dart/constant/evaluation.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.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 67 matching lines @@
 
   /**
    * Initialize a newly created [ConstantEvaluationEngine].  The [typeProvider]
    * is used to access known types.  [_declaredVariables] is the set of
    * variables declared on the command line using '-D'.  The [validator], if
    * given, is used to verify correct dependency analysis when running unit
    * tests.
    */
   ConstantEvaluationEngine(this.typeProvider, this._declaredVariables,
       {ConstantEvaluationValidator validator, TypeSystem typeSystem})
-      : validator = validator != null
-            ? validator
-            : new ConstantEvaluationValidator_ForProduction(),
-        typeSystem = typeSystem != null ? typeSystem : new TypeSystemImpl();
+      : validator =
+            validator ?? new ConstantEvaluationValidator_ForProduction(),
+        typeSystem = typeSystem ?? new TypeSystemImpl();
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct. The
    * [arguments] are the AST nodes of the arguments. The [argumentValues] are
    * the values of the unnamed arguments. The [namedArgumentValues] are the
    * values of the named arguments. The [expectedDefaultValueType] is the
    * allowed type of the "defaultValue" parameter (if present). Note:
    * "defaultValue" is always allowed to be null. Return `true` if the arguments
    * are correct, `false` if there is an error.
    */
@@ skipping 1367 matching lines @@
     return new DartObjectImpl(
         _typeProvider.symbolType, new SymbolState(buffer.toString()));
   }
 
   /**
    * Create an error associated with the given [node]. The error will have the
    * given error [code].
    */
   void _error(AstNode node, ErrorCode code) {
     _errorReporter.reportErrorForNode(
-        code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code, node);
+        code ?? CompileTimeErrorCode.INVALID_CONSTANT, node);
   }
 
   /**
    * Return the constant value of the static constant represented by the given
    * [element]. The [node] is the node to be used if an error needs to be
    * reported.
    */
   DartObjectImpl _getConstantValue(AstNode node, Element element) {
     Element variableElement =
         element is PropertyAccessorElement ? element.variable : element;
@@ skipping 432 matching lines @@
    */
   EvaluationResult(this.value, this._errors);
 
   /**
    * Return a list containing the errors that should be reported for the
    * expression(s) that were evaluated. If there are no such errors, the list
    * will be empty. The list can be empty even if the expression is not a valid
    * compile time constant if the errors would have been reported by other parts
    * of the analysis engine.
    */
-  List<AnalysisError> get errors =>
-      _errors == null ? AnalysisError.NO_ERRORS : _errors;
+  List<AnalysisError> get errors => _errors ?? AnalysisError.NO_ERRORS;
 
   /**
    * Return `true` if the expression is a compile-time constant expression that
    * would not throw an exception when evaluated.
    */
   bool get isValid => _errors == null;
 
   /**
    * Return an evaluation result representing the result of evaluating an
    * expression that is not a compile-time constant because of the given
@@ skipping 22 matching lines @@
    */
   List<AnalysisError> _errors;
 
   /**
    * The value of the expression, or `null` if the value couldn't be computed
    * due to errors.
    */
   final DartObjectImpl value;
 
   EvaluationResultImpl(this.value, [List<AnalysisError> errors]) {
-    this._errors = errors == null ? <AnalysisError>[] : errors;
+    this._errors = errors ?? <AnalysisError>[];
   }
 
   List<AnalysisError> get errors => _errors;
 
   bool equalValues(TypeProvider typeProvider, EvaluationResultImpl result) {
     if (this.value != null) {
       if (result.value == null) {
         return false;
       }
       return value == result.value;
     } else {
       return false;
     }
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }