Fix for searching constructor references.

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
 
+import 'package:analyzer/src/generated/utilities_general.dart';
+
 import 'ast.dart';
 import 'constant.dart' show EvaluationResultImpl;
 import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'resolver.dart';
 import 'scanner.dart' show Keyword;
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_dart.dart';
-import 'package:analyzer/src/generated/utilities_general.dart';
 
 
 /**
  * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
@@ skipping 1634 matching lines @@
   bool get isDefaultConstructor;
 
   /**
    * Return `true` if this constructor represents a factory constructor.
    *
    * @return `true` if this constructor represents a factory constructor
    */
   bool get isFactory;
 
   /**
+   * Return the offset of the character immediately following the last character
+   * of this constructor's name, or `null` if not named.
+   */
+  int get nameEnd;
+
+  /**
    * Return the resolved [ConstructorDeclaration] node that declares this
    * [ConstructorElement] .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [ConstructorDeclaration], not `null`.
    */
   @override
   ConstructorDeclaration get node;
 
   /**
+   * Return the offset of the `.` before this constructor name, or `null` if
+   * not named.
+   */
+  int get periodOffset;
+
+  /**
    * Return the constructor to which this constructor is redirecting, or `null` if this
    * constructor does not redirect to another constructor or if the library containing this
    * constructor has not yet been resolved.
    *
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
 }
 
 /**
@@ skipping 13 matching lines @@
    */
   ConstructorElement redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant instance creation
    * expressions).
    */
   List<ConstructorInitializer> constantInitializers;
 
   /**
+   * The offset of the `.` before this constructor name or `null` if not named.
+   */
+  int periodOffset;
+
+  /**
+   * Return the offset of the character immediately following the last character
+   * of this constructor's name, or `null` if not named.
+   */
+  int nameEnd;
+
+  /**
    * Initialize a newly created constructor element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ConstructorElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   /**
    * Initialize a newly created constructor element to have the given name.
@@ skipping 110 matching lines @@
   @override
   bool get isConst => baseElement.isConst;
 
   @override
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
   @override
   bool get isFactory => baseElement.isFactory;
 
   @override
+  int get nameEnd => baseElement.nameEnd;
+
+  @override
   ConstructorDeclaration get node => baseElement.node;
 
   @override
+  int get periodOffset => baseElement.periodOffset;
+
+  @override
   ConstructorElement get redirectedConstructor =>
       from(baseElement.redirectedConstructor, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   @override
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
@@ skipping 2931 matching lines @@
       }
       name = buffer.toString();
     }
     return name;
   }
 
   @override
   int get hashCode => internalHashCode(<DartType>[]);
 
   @override
-  int internalHashCode(List<DartType> visitedTypes) {
-    if (element == null) {
-      return 0;
-    } else if (visitedTypes.contains(this)) {
-      return 3;
-    }
-    visitedTypes.add(this);
-    // Reference the arrays of parameters
-    List<DartType> normalParameterTypes = this.normalParameterTypes;
-    List<DartType> optionalParameterTypes = this.optionalParameterTypes;
-    Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
-    // Generate the hashCode
-    int code = (returnType as TypeImpl).internalHashCode(visitedTypes);
-    for (int i = 0; i < normalParameterTypes.length; i++) {
-      code = (code << 1) +
-          (normalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
-    }
-    for (int i = 0; i < optionalParameterTypes.length; i++) {
-      code = (code << 1) +
-          (optionalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
-    }
-    for (DartType type in namedParameterTypes) {
-      code = (code << 1) + (type as TypeImpl).internalHashCode(visitedTypes);
-    }
-    return code;
-  }
-
-  @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes =
         new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     for (ParameterElement parameter in parameters) {
@@ skipping 203 matching lines @@
         (returnType as TypeImpl).internalEquals(
             otherType.returnType,
             visitedElementPairs);
     // Remove the pair from our visited pairs list
     visitedElementPairs.remove(elementPair);
     // Return the result
     return result;
   }
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) {
+    if (element == null) {
+      return 0;
+    } else if (visitedTypes.contains(this)) {
+      return 3;
+    }
+    visitedTypes.add(this);
+    // Reference the arrays of parameters
+    List<DartType> normalParameterTypes = this.normalParameterTypes;
+    List<DartType> optionalParameterTypes = this.optionalParameterTypes;
+    Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
+    // Generate the hashCode
+    int code = (returnType as TypeImpl).internalHashCode(visitedTypes);
+    for (int i = 0; i < normalParameterTypes.length; i++) {
+      code = (code << 1) +
+          (normalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
+    }
+    for (int i = 0; i < optionalParameterTypes.length; i++) {
+      code = (code << 1) +
+          (optionalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
+    }
+    for (DartType type in namedParameterTypes) {
+      code = (code << 1) + (type as TypeImpl).internalHashCode(visitedTypes);
+    }
+    return code;
+  }
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) ||
         type.isDynamic ||
         type.isDartCoreFunction ||
         type.isObject) {
       return true;
@@ skipping 1199 matching lines @@
   @override
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
 
   @override
-  int internalHashCode(List<DartType> visitedTypes) => hashCode;
-
-  @override
   List<InterfaceType> get interfaces {
     ClassElement classElement = element;
     List<InterfaceType> interfaces = classElement.interfaces;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<DartType> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return interfaces;
     }
     int count = interfaces.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
@@ skipping 165 matching lines @@
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return (element == otherType.element) &&
         TypeImpl.equalArrays(
             typeArguments,
             otherType.typeArguments,
             visitedElementPairs);
   }
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic
     // is not an instance of InterfaceType.
     //
     if (type.isDynamic) {
       return true;
     } else if (type is UnionType) {
@@ skipping 4136 matching lines @@
     return buffer.toString();
   }
 
   @override
   Set<DartType> get elements => _types;
 
   @override
   int get hashCode => _types.hashCode;
 
   @override
-  int internalHashCode(List<DartType> visitedTypes) => hashCode;
-
-  @override
   bool operator ==(Object other) {
     if (other == null || other is! UnionType) {
       return false;
     } else if (identical(this, other)) {
       return true;
     } else {
       return javaSetEquals(_types, (other as UnionType).elements);
     }
   }
 
@@ skipping 10 matching lines @@
       prefix = ",";
     }
     buffer.write("}");
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       this == object;
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // What version of subtyping do we want? See discussion below in
     // [internalIsSubtypeOf].
     if (AnalysisEngine.instance.strictUnionTypes) {
       // The less unsound version: all.
       for (DartType t in _types) {
         if (!(t as TypeImpl).internalIsMoreSpecificThan(
             type,
             withDynamic,
@@ skipping 458 matching lines @@
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
   @override
   int get hashCode => 2;
 
   @override
-  int internalHashCode(List<DartType> visitedTypes) => hashCode;
-
-  @override
   bool get isVoid => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) =>
       isSubtypeOf(type);
 
   @override
   bool internalIsSubtypeOf(DartType type,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(
           this,
           visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes,
       List<DartType> parameterTypes) =>
       this;
 }