Create fewer unnecessary lists

pkg/analyzer/lib/src/generated/constant.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
@@ skipping 638 matching lines @@
         argumentNodes[i] = argument;
       }
     }
     constructor = _followConstantRedirectionChain(constructor);
     InterfaceType definingClass = constructor.returnType as InterfaceType;
     if (constructor.isFactory) {
       // We couldn't find a non-factory constructor.  See if it's because we reached an external
       // const factory constructor that we can emulate.
       if (constructor.name == "fromEnvironment") {
         if (!_checkFromEnvironmentArguments(arguments, argumentValues, namedArgumentValues, definingClass)) {
-          errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node, []);
+          errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           return null;
         }
         String variableName = argumentCount < 1 ? null : argumentValues[0].stringValue;
         if (identical(definingClass, typeProvider.boolType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment = _declaredVariables.getBool(typeProvider, variableName);
           return _computeValueFromEnvironment(valueFromEnvironment, new DartObjectImpl(typeProvider.boolType, BoolState.FALSE_STATE), namedArgumentValues);
         } else if (identical(definingClass, typeProvider.intType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment = _declaredVariables.getInt(typeProvider, variableName);
           return _computeValueFromEnvironment(valueFromEnvironment, new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE), namedArgumentValues);
         } else if (identical(definingClass, typeProvider.stringType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment = _declaredVariables.getString(typeProvider, variableName);
           return _computeValueFromEnvironment(valueFromEnvironment, new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE), namedArgumentValues);
         }
       } else if (constructor.name == "" && identical(definingClass, typeProvider.symbolType) && argumentCount == 1) {
         if (!_checkSymbolArguments(arguments, argumentValues, namedArgumentValues)) {
-          errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node, []);
+          errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           return null;
         }
         String argumentValue = argumentValues[0].stringValue;
         return new DartObjectImpl(definingClass, new SymbolState(argumentValue));
       }
       // Either it's an external const factory constructor that we can't emulate, or an error
       // occurred (a cycle, or a const constructor trying to delegate to a non-const constructor).
       // In the former case, the best we can do is consider it an unknown value.  In the latter
       // case, the error has already been reported, so considering it an unknown value will
       // suppress further errors.
@@ skipping 424 matching lines @@
 
   @override
   DartObjectImpl visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     DartObjectImpl conditionResult = condition.accept(this);
     DartObjectImpl thenResult = node.thenExpression.accept(this);
     DartObjectImpl elseResult = node.elseExpression.accept(this);
     if (conditionResult == null) {
       return conditionResult;
     } else if (!conditionResult.isBool) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, condition, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, condition);
       return null;
     } else if (thenResult == null) {
       return thenResult;
     } else if (elseResult == null) {
       return elseResult;
     }
     conditionResult = _dartObjectComputer.applyBooleanConversion(condition, conditionResult);
     if (conditionResult == null) {
       return conditionResult;
     }
@@ skipping 39 matching lines @@
     }
     return _dartObjectComputer.performToString(node, result);
   }
 
   @override
   DartObjectImpl visitInterpolationString(InterpolationString node) => new DartObjectImpl(_typeProvider.stringType, new StringState(node.value));
 
   @override
   DartObjectImpl visitListLiteral(ListLiteral node) {
     if (node.constKeyword == null) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL, node, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL, node);
       return null;
     }
     bool errorOccurred = false;
     List<DartObjectImpl> elements = new List<DartObjectImpl>();
     for (Expression element in node.elements) {
       DartObjectImpl elementResult = element.accept(this);
       if (elementResult == null) {
         errorOccurred = true;
       } else {
         elements.add(elementResult);
       }
     }
     if (errorOccurred) {
       return null;
     }
     DartType elementType = _typeProvider.dynamicType;
     if (node.typeArguments != null && node.typeArguments.arguments.length == 1) {
       DartType type = node.typeArguments.arguments[0].type;
       if (type != null) {
         elementType = type;
       }
     }
     InterfaceType listType = _typeProvider.listType.substitute4([elementType]);
     return new DartObjectImpl(listType, new ListState(elements));
   }
 
   @override
   DartObjectImpl visitMapLiteral(MapLiteral node) {
     if (node.constKeyword == null) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL, node, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL, node);
       return null;
     }
     bool errorOccurred = false;
     HashMap<DartObjectImpl, DartObjectImpl> map = new HashMap<DartObjectImpl, DartObjectImpl>();
     for (MapLiteralEntry entry in node.entries) {
       DartObjectImpl keyResult = entry.key.accept(this);
       DartObjectImpl valueResult = entry.value.accept(this);
       if (keyResult == null || valueResult == null) {
         errorOccurred = true;
       } else {
@@ skipping 206 matching lines @@
     return null2;
   }
 
   /**
    * Create an error associated with the given node.
    *
    * @param node the AST node associated with the error
    * @param code the error code indicating the nature of the error
    */
   void _error(AstNode node, ErrorCode code) {
-    _errorReporter.reportErrorForNode(code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code, node, []);
+    _errorReporter.reportErrorForNode(code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code, node);
   }
 
   /**
    * Return the constant value of the static constant represented by the given element.
    *
    * @param node the node to be used if an error needs to be reported
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   DartObjectImpl _getConstantValue(AstNode node, Element element) {
@@ skipping 141 matching lines @@
    */
   final TypeProvider _typeProvider;
 
   DartObjectComputer(this._errorReporter, this._typeProvider);
 
   DartObjectImpl add(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.add(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
         return null;
       }
     }
     return null;
   }
 
   /**
    * Return the result of applying boolean conversion to this result.
    *
    * @param node the node against which errors should be reported
    * @return the result of applying boolean conversion to the given value
    */
   DartObjectImpl applyBooleanConversion(AstNode node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.convertToBool(_typeProvider);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl bitAnd(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.bitAnd(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl bitNot(Expression node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.bitNot(_typeProvider);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl bitOr(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.bitOr(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl bitXor(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.bitXor(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl concatenate(Expression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.concatenate(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl divide(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.divide(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl equalEqual(Expression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.equalEqual(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl greaterThan(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.greaterThan(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl greaterThanOrEqual(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.greaterThanOrEqual(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl integerDivide(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.integerDivide(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl isIdentical(Expression node, DartObjectImpl leftOperand,
                              DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.isIdentical(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl lessThan(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.lessThan(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl lessThanOrEqual(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.lessThanOrEqual(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl logicalAnd(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.logicalAnd(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl logicalNot(Expression node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.logicalNot(_typeProvider);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl logicalOr(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.logicalOr(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl minus(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.minus(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl negated(Expression node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.negated(_typeProvider);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl notEqual(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.notEqual(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl performToString(AstNode node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.performToString(_typeProvider);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl remainder(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.remainder(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl shiftLeft(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.shiftLeft(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   DartObjectImpl shiftRight(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.shiftRight(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
   /**
    * Return the result of invoking the 'length' getter on this result.
    *
    * @param node the node against which errors should be reported
    * @return the result of invoking the 'length' getter on this result
    */
   EvaluationResultImpl stringLength(Expression node, EvaluationResultImpl evaluationResult) {
     if (evaluationResult.value != null) {
       try {
         return new EvaluationResultImpl.con1(evaluationResult.value.stringLength(_typeProvider));
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return new EvaluationResultImpl.con1(null);
   }
 
   DartObjectImpl times(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.times(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
-        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+        _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 }
 
 /**
  * Instances of the class `DartObjectImpl` represent an instance of a Dart class.
  */
 class DartObjectImpl implements DartObject {
   /**
    * The run-time type of this object.
    */
   final ParameterizedType type;
 
   /**
    * The state of the object.
    */
   final InstanceState _state;
 
   /**
+   * An empty list of objects.
+   */
+  static const List<DartObjectImpl> EMPTY_LIST = const <DartObjectImpl>[];
+
+  /**
    * Initialize a newly created object to have the given type and state.
    *
    * @param type the run-time type of this object
    * @param state the state of the object
    */
   DartObjectImpl(this.type, this._state);
 
   /**
    * Return the result of invoking the '+' operator on this object with the given argument.
    *
@@ skipping 2859 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }