New analyzer snapshot.

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';
 import 'java_core.dart';
 import 'java_engine.dart' show ObjectUtilities;
 import 'source.dart' show Source;
 import 'error.dart' show AnalysisError, ErrorCode, CompileTimeErrorCode;
 import 'scanner.dart' show Token, TokenType;
 import 'ast.dart';
 import 'element.dart';
 import 'resolver.dart' show TypeProvider;
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart' show ParameterKind;
@@ skipping 202 matching lines @@
 
 /**
  * Instances of the class `ConstantFinder` are used to traverse the AST structures of all of
  * the compilation units being resolved and build a table mapping constant variable elements to the
  * declarations of those variables.
  */
 class ConstantFinder extends RecursiveAstVisitor<Object> {
   /**
    * A table mapping constant variable elements to the declarations of those variables.
    */
-  final Map<VariableElement, VariableDeclaration> variableMap = new Map<VariableElement, VariableDeclaration>();
+  final HashMap<VariableElement, VariableDeclaration> variableMap = new HashMap<VariableElement, VariableDeclaration>();
 
   /**
    * A table mapping constant constructors to the declarations of those constructors.
    */
-  final Map<ConstructorElement, ConstructorDeclaration> constructorMap = new Map<ConstructorElement, ConstructorDeclaration>();
+  final HashMap<ConstructorElement, ConstructorDeclaration> constructorMap = new HashMap<ConstructorElement, ConstructorDeclaration>();
 
   /**
    * A collection of constant constructor invocations.
    */
   final List<InstanceCreationExpression> constructorInvocations = new List<InstanceCreationExpression>();
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     if (node.constKeyword != null) {
@@ skipping 50 matching lines @@
 
   /**
    * A graph in which the nodes are the constants, and the edges are from each constant to the other
    * constants that are referenced by it.
    */
   DirectedGraph<AstNode> referenceGraph = new DirectedGraph<AstNode>();
 
   /**
    * A table mapping constant variables to the declarations of those variables.
    */
-  Map<VariableElement, VariableDeclaration> _variableDeclarationMap;
+  HashMap<VariableElement, VariableDeclaration> _variableDeclarationMap;
 
   /**
    * A table mapping constant constructors to the declarations of those constructors.
    */
-  Map<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
+  HashMap<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
 
   /**
    * A collection of constant constructor invocations.
    */
   List<InstanceCreationExpression> _constructorInvocations;
 
   /**
    * Initialize a newly created constant value computer.
    *
    * @param typeProvider the type provider used to access known types
@@ skipping 160 matching lines @@
     } else {
       // Should not happen.
       AnalysisEngine.instance.logger.logError("Constant value computer trying to compute the value of a node which is not a VariableDeclaration, InstanceCreationExpression, FormalParameter, or ConstructorDeclaration");
       return;
     }
   }
 
   ValidResult _evaluateConstructorCall(NodeList<Expression> arguments, ConstructorElement constructor, ConstantVisitor constantVisitor) {
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues = new List<DartObjectImpl>(argumentCount);
-    Map<String, DartObjectImpl> namedArgumentValues = new Map<String, DartObjectImpl>();
+    HashMap<String, DartObjectImpl> namedArgumentValues = new HashMap<String, DartObjectImpl>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
         NamedExpression namedExpression = argument;
         String name = namedExpression.name.label.name;
         namedArgumentValues[name] = constantVisitor._valueOf(namedExpression.expression);
         argumentValues[i] = constantVisitor.null2;
       } else {
         argumentValues[i] = constantVisitor._valueOf(argument);
       }
@@ skipping 22 matching lines @@
     beforeGetConstantInitializers(constructor);
     ConstructorElementImpl constructorBase = _getConstructorBase(constructor) as ConstructorElementImpl;
     List<ConstructorInitializer> initializers = constructorBase.constantInitializers;
     if (initializers == null) {
       // This can happen in some cases where there are compile errors in the code being analyzed
       // (for example if the code is trying to create a const instance using a non-const
       // constructor, or the node we're visiting is involved in a cycle).  The error has already
       // been reported, so consider it an unknown value to suppress further errors.
       return constantVisitor._validWithUnknownValue(definingClass);
     }
-    Map<String, DartObjectImpl> fieldMap = new Map<String, DartObjectImpl>();
-    Map<String, DartObjectImpl> parameterMap = new Map<String, DartObjectImpl>();
+    HashMap<String, DartObjectImpl> fieldMap = new HashMap<String, DartObjectImpl>();
+    HashMap<String, DartObjectImpl> parameterMap = new HashMap<String, DartObjectImpl>();
     List<ParameterElement> parameters = constructorBase.parameters;
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       ParameterElement parameter = parameters[i];
       while (parameter is ParameterMember) {
         parameter = (parameter as ParameterMember).baseElement;
       }
       DartObjectImpl argumentValue = null;
       if (parameter.parameterKind == ParameterKind.NAMED) {
         argumentValue = namedArgumentValues[parameter.name];
@@ skipping 54 matching lines @@
       if (superConstructor != null) {
         if (superArguments == null) {
           superArguments = new NodeList<Expression>(null);
         }
         _evaluateSuperConstructorCall(fieldMap, superConstructor, superArguments, initializerVisitor);
       }
     }
     return constantVisitor._valid(definingClass, new GenericState(fieldMap));
   }
 
-  void _evaluateSuperConstructorCall(Map<String, DartObjectImpl> fieldMap, ConstructorElement superConstructor, NodeList<Expression> superArguments, ConstantVisitor initializerVisitor) {
+  void _evaluateSuperConstructorCall(HashMap<String, DartObjectImpl> fieldMap, ConstructorElement superConstructor, NodeList<Expression> superArguments, ConstantVisitor initializerVisitor) {
     if (superConstructor != null && superConstructor.isConst) {
       ValidResult evaluationResult = _evaluateConstructorCall(superArguments, superConstructor, initializerVisitor);
       fieldMap[GenericState.SUPERCLASS_FIELD] = evaluationResult.value;
     }
   }
 
   /**
    * Attempt to follow the chain of factory redirections until a constructor is reached which is not
    * a const factory constructor.
    *
@@ skipping 127 matching lines @@
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider _typeProvider;
 
   /**
    * An shared object representing the value 'null'.
    */
   DartObjectImpl _nullObject;
 
-  Map<String, DartObjectImpl> _lexicalEnvironment;
+  HashMap<String, DartObjectImpl> _lexicalEnvironment;
 
   /**
    * Initialize a newly created constant visitor.
    *
    * @param typeProvider the type provider used to access known types
    * @param lexicalEnvironment values which should override simpleIdentifiers, or null if no
    *          overriding is necessary.
    */
   ConstantVisitor.con1(this._typeProvider) {
     this._lexicalEnvironment = null;
   }
 
   /**
    * Initialize a newly created constant visitor.
    *
    * @param typeProvider the type provider used to access known types
    * @param lexicalEnvironment values which should override simpleIdentifiers, or null if no
    *          overriding is necessary.
    */
-  ConstantVisitor.con2(this._typeProvider, Map<String, DartObjectImpl> lexicalEnvironment) {
+  ConstantVisitor.con2(this._typeProvider, HashMap<String, DartObjectImpl> lexicalEnvironment) {
     this._lexicalEnvironment = lexicalEnvironment;
   }
 
   @override
   EvaluationResultImpl visitAdjacentStrings(AdjacentStrings node) {
     EvaluationResultImpl result = null;
     for (StringLiteral string in node.strings) {
       if (result == null) {
         result = string.accept(this);
       } else {
@@ skipping 147 matching lines @@
     }
     return _valid(_typeProvider.listType, new ListState(new List.from(elements)));
   }
 
   @override
   EvaluationResultImpl visitMapLiteral(MapLiteral node) {
     if (node.constKeyword == null) {
       return new ErrorResult.con1(node, CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL);
     }
     ErrorResult result = null;
-    Map<DartObjectImpl, DartObjectImpl> map = new Map<DartObjectImpl, DartObjectImpl>();
+    HashMap<DartObjectImpl, DartObjectImpl> map = new HashMap<DartObjectImpl, DartObjectImpl>();
     for (MapLiteralEntry entry in node.entries) {
       EvaluationResultImpl keyResult = entry.key.accept(this);
       EvaluationResultImpl valueResult = entry.value.accept(this);
       result = _union(result, keyResult);
       result = _union(result, valueResult);
       if (keyResult is ValidResult && valueResult is ValidResult) {
         map[keyResult.value] = valueResult.value;
       }
     }
     if (result != null) {
@@ skipping 472 matching lines @@
   }
 
   @override
   double get doubleValue {
     if (_state is DoubleState) {
       return (_state as DoubleState).value;
     }
     return null;
   }
 
-  Map<String, DartObjectImpl> get fields => _state.fields;
+  HashMap<String, DartObjectImpl> get fields => _state.fields;
 
   @override
   int get intValue {
     if (_state is IntState) {
       return (_state as IntState).value;
     }
     return null;
   }
 
   @override
@@ skipping 269 matching lines @@
 }
 
 /**
  * Instances of the class `DeclaredVariables` provide access to the values of variables that
  * have been defined on the command line using the `-D` option.
  */
 class DeclaredVariables {
   /**
    * A table mapping the names of declared variables to their values.
    */
-  Map<String, String> _declaredVariables = new Map<String, String>();
+  HashMap<String, String> _declaredVariables = new HashMap<String, String>();
 
   /**
    * Define a variable with the given name to have the given value.
    *
    * @param variableName the name of the variable being defined
    * @param value the value of the variable
    */
   void define(String variableName, String value) {
     _declaredVariables[variableName] = value;
   }
@@ skipping 1071 matching lines @@
 }
 
 /**
  * Instances of the class `GenericState` represent the state of an object representing a Dart
  * object for which there is no more specific state.
  */
 class GenericState extends InstanceState {
   /**
    * The values of the fields of this instance.
    */
-  final Map<String, DartObjectImpl> _fieldMap;
+  final HashMap<String, DartObjectImpl> _fieldMap;
 
   /**
    * Pseudo-field that we use to represent fields in the superclass.
    */
   static String SUPERCLASS_FIELD = "(super)";
 
   /**
    * A state that can be used to represent an object whose state is not known.
    */
-  static GenericState UNKNOWN_VALUE = new GenericState(new Map<String, DartObjectImpl>());
+  static GenericState UNKNOWN_VALUE = new GenericState(new HashMap<String, DartObjectImpl>());
 
   /**
    * Initialize a newly created state to represent a newly created object.
    *
    * @param fieldMap the values of the fields of this instance
    */
   GenericState(this._fieldMap);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
@@ skipping 22 matching lines @@
     }
     for (String fieldName in otherFields) {
       if (state._fieldMap[fieldName] != _fieldMap[fieldName]) {
         return false;
       }
     }
     return true;
   }
 
   @override
-  Map<String, DartObjectImpl> get fields => _fieldMap;
+  HashMap<String, DartObjectImpl> get fields => _fieldMap;
 
   @override
   String get typeName => "user defined type";
 
   @override
   int get hashCode {
     int hashCode = 0;
     for (DartObjectImpl value in _fieldMap.values) {
       hashCode += value.hashCode;
     }
@@ skipping 119 matching lines @@
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '==' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   BoolState equalEqual(InstanceState rightOperand);
 
   /**
    * If this represents a generic dart object, return a map from its fieldnames to their values.
    * Otherwise return null.
    */
-  Map<String, DartObjectImpl> get fields => null;
+  HashMap<String, DartObjectImpl> get fields => null;
 
   /**
    * Return the name of the type of this value.
    *
    * @return the name of the type of this value
    */
   String get typeName;
 
   /**
    * Return this object's value if it can be represented exactly, or `null` if either the
@@ skipping 807 matching lines @@
 }
 
 /**
  * The unique instance of the class `ListState` represents the state of an object representing
  * a map.
  */
 class MapState extends InstanceState {
   /**
    * The entries in the map.
    */
-  final Map<DartObjectImpl, DartObjectImpl> _entries;
+  final HashMap<DartObjectImpl, DartObjectImpl> _entries;
 
   /**
    * Initialize a newly created state to represent a map with the given entries.
    *
    * @param entries the entries in the map
    */
   MapState(this._entries);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.from(this == rightOperand);
   }
 
   @override
   bool operator ==(Object object) {
     if (object is! MapState) {
       return false;
     }
-    Map<DartObjectImpl, DartObjectImpl> otherElements = (object as MapState)._entries;
+    HashMap<DartObjectImpl, DartObjectImpl> otherElements = (object as MapState)._entries;
     int count = _entries.length;
     if (otherElements.length != count) {
       return false;
     } else if (count == 0) {
       return true;
     }
     for (MapEntry<DartObjectImpl, DartObjectImpl> entry in getMapEntrySet(_entries)) {
       DartObjectImpl key = entry.getKey();
       DartObjectImpl value = entry.getValue();
       DartObjectImpl otherValue = otherElements[key];
       if (value != otherValue) {
         return false;
       }
     }
     return true;
   }
 
   @override
   String get typeName => "Map";
 
   @override
   Map<Object, Object> get value {
-    Map<Object, Object> result = new Map<Object, Object>();
+    HashMap<Object, Object> result = new HashMap<Object, Object>();
     for (MapEntry<DartObjectImpl, DartObjectImpl> entry in getMapEntrySet(_entries)) {
       DartObjectImpl key = entry.getKey();
       DartObjectImpl value = entry.getValue();
       if (!key.hasExactValue || !value.hasExactValue) {
         return null;
       }
       result[key.value] = value.value;
     }
     return result;
   }
@@ skipping 191 matching lines @@
 
   /**
    * A graph in which the nodes are the constant variables and the edges are from each variable to
    * the other constant variables that are referenced in the head's initializer.
    */
   final DirectedGraph<AstNode> _referenceGraph;
 
   /**
    * A table mapping constant variables to the declarations of those variables.
    */
-  final Map<VariableElement, VariableDeclaration> _variableDeclarationMap;
+  final HashMap<VariableElement, VariableDeclaration> _variableDeclarationMap;
 
   /**
    * A table mapping constant constructors to the declarations of those constructors.
    */
-  final Map<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
+  final HashMap<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
 
   /**
    * Initialize a newly created reference finder to find references from the given variable to other
    * variables and to add those references to the given graph.
    *
    * @param source the element representing the variable whose initializer will be visited
    * @param referenceGraph a graph recording which variables (heads) reference which other variables
    *          (tails) in their initializers
    * @param variableDeclarationMap A table mapping constant variables to the declarations of those
    *          variables.
@@ skipping 683 matching lines @@
   ErrorResult _error(AstNode node, ErrorCode code) => new ErrorResult.con1(node, code);
 
   /**
    * Return a result object representing the given value.
    *
    * @param value the value to be represented as a result object
    * @return a result object representing the given value
    */
   ValidResult _valueOf(DartObjectImpl value) => new ValidResult(value);
 }