New analyzer snapshot.

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';
@@ skipping 2700 matching lines @@
   /**
    * Return the element that either physically or logically encloses this element. This will be
    * `null` if this element is a library because libraries are the top-level elements in the
    * model.
    *
    * @return the element that encloses this element
    */
   Element get enclosingElement;
 
   /**
+   * Return a display name for the given element that includes the path to the compilation unit in
+   * which the type is defined.
+   *
+   * @param type the type for which an extended display name is to be returned
+   * @return a display name that can help distinguish between two types with the same name
+   */
+  String get extendedDisplayName;
+
+  /**
    * Return the kind of element that this is.
    *
    * @return the kind of this element
    */
   ElementKind get kind;
 
   /**
    * Return the library that contains this element. This will be the element itself if it is a
    * library element. This will be `null` if this element is an HTML file because HTML files
    * are not contained in libraries.
@@ skipping 357 matching lines @@
     return _enclosingElement.context;
   }
 
   @override
   String get displayName => _name;
 
   @override
   Element get enclosingElement => _enclosingElement;
 
   @override
+  String get extendedDisplayName {
+    String displayName = this.displayName;
+    Source source = this.source;
+    if (source != null) {
+      return "${displayName} (${source.fullName})";
+    }
+    return displayName;
+  }
+
+  @override
   LibraryElement get library => getAncestor((element) => element is LibraryElement);
 
   @override
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
   @override
   String get name => _name;
 
   @override
   AstNode get node => getNodeMatching((node) => node is AstNode);
@@ skipping 1331 matching lines @@
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The interface `FunctionElement` defines the behavior of elements representing a function.
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
+   * The name of the method that can be implemented by a class to allow its instances to be invoked
+   * as if they were a function.
+   */
+  static final String CALL_METHOD_NAME = "call";
+
+  /**
+   * The name of the method that will be invoked if an attempt is made to invoke an undefined method
+   * on an object.
+   */
+  static final String NO_SUCH_METHOD_METHOD_NAME = "noSuchMethod";
+
+  /**
    * The name of the synthetic function defined for libraries that are deferred.
    */
   static final String LOAD_LIBRARY_NAME = "loadLibrary";
 
   /**
    * Return the resolved [FunctionDeclaration] node that declares this [FunctionElement]
    * .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
@@ skipping 560 matching lines @@
   @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) {
       if (parameter.parameterKind == ParameterKind.NAMED) {
-        namedParameterTypes[parameter.name] = parameter.type.substitute2(typeArguments, typeParameters);
+        DartType type = parameter.type;
+        if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
+          type = type.substitute2(typeArguments, typeParameters);
+        }
+        namedParameterTypes[parameter.name] = type;
       }
     }
     return namedParameterTypes;
   }
 
   @override
   List<DartType> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.REQUIRED) {
-        types.add(parameter.type.substitute2(typeArguments, typeParameters));
+        DartType type = parameter.type;
+        if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
+          type = type.substitute2(typeArguments, typeParameters);
+        }
+        types.add(type);
       }
     }
     return new List.from(types);
   }
 
   @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.POSITIONAL) {
-        types.add(parameter.type.substitute2(typeArguments, typeParameters));
+        DartType type = parameter.type;
+        if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
+          type = type.substitute2(typeArguments, typeParameters);
+        }
+        types.add(type);
       }
     }
     return new List.from(types);
   }
 
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     // no parameters, quick return
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     // create specialized parameters
     List<ParameterElement> specializedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
     }
     return specializedParameters;
   }
 
   @override
   DartType get returnType {
     DartType baseReturnType = this.baseReturnType;
     if (baseReturnType == null) {
       // TODO(brianwilkerson) This is a patch. The return type should never be null and we need to
       // understand why it is and fix it.
       return DynamicTypeImpl.instance;
     }
+    // If there are no arguments to substitute, or if the arguments size doesn't match the parameter
+    // size, return the base return type.
+    if (typeArguments.length == 0 || typeArguments.length != typeParameters.length) {
+      return baseReturnType;
+    }
     return baseReturnType.substitute2(typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
 
   @override
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return element.typeParameters;
     }
     ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
@@ skipping 1519 matching lines @@
   @override
   PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember.from((element as ClassElementImpl).getSetter(setterName), this);
 
   @override
   InterfaceType get superclass {
     ClassElement classElement = element;
     InterfaceType supertype = classElement.supertype;
     if (supertype == null) {
       return null;
     }
-    return supertype.substitute2(typeArguments, classElement.type.typeArguments);
+    List<DartType> typeParameters = classElement.type.typeArguments;
+    if (typeArguments.length == 0 || typeArguments.length != typeParameters.length) {
+      return supertype;
+    }
+    return supertype.substitute2(typeArguments, typeParameters);
   }
 
   @override
   List<TypeParameterElement> get typeParameters => element.typeParameters;
 
   @override
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
@@ skipping 1265 matching lines @@
    */
   Element get baseElement => _baseElement;
 
   @override
   AnalysisContext get context => _baseElement.context;
 
   @override
   String get displayName => _baseElement.displayName;
 
   @override
+  String get extendedDisplayName => _baseElement.extendedDisplayName;
+
+  @override
   ElementKind get kind => _baseElement.kind;
 
   @override
   LibraryElement get library => _baseElement.library;
 
   @override
   ElementLocation get location => _baseElement.location;
 
   @override
   List<ElementAnnotation> get metadata => _baseElement.metadata;
@@ skipping 500 matching lines @@
   @override
   Element getAncestor(Predicate<Element> predicate) => null;
 
   @override
   String get displayName => _name;
 
   @override
   Element get enclosingElement => null;
 
   @override
+  String get extendedDisplayName => displayName;
+
+  @override
   ElementKind get kind => ElementKind.ERROR;
 
   @override
   LibraryElement get library => null;
 
   @override
   ElementLocation get location => null;
 
   @override
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
@@ skipping 1948 matching lines @@
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty array of type parameter types.
    */
   static List<TypeParameterType> EMPTY_ARRAY = new List<TypeParameterType>(0);
 
   /**
+   * The name of the type Type from dart.core.
+   */
+  static String _TYPE_CLASS_NAME = "Type";
+
+  /**
    * Return an array containing the type parameter types defined by the given array of type
    * parameter elements.
    *
    * @param typeParameters the type parameter elements defining the type parameter types to be
    *          returned
    * @return the type parameter types defined by the type parameter elements
    */
   static List<TypeParameterType> getTypes(List<TypeParameterElement> typeParameters) {
     int count = typeParameters.length;
     if (count == 0) {
@@ skipping 58 matching lines @@
     if (s.isDynamic) {
       return true;
     }
     return _isMoreSpecificThan(s, new Set<DartType>(), withDynamic, visitedTypePairs);
   }
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => isMoreSpecificThan2(type, true, new Set<TypeImpl_TypePair>());
 
   bool _isMoreSpecificThan(DartType s, Set<DartType> visitedTypes, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+    //
+    // If s is of type Type from dart.core, return true
+    //
+    Element sElement = s.element;
+    LibraryElement sLibrary = sElement != null ? sElement.library : null;
+    if (sLibrary != null && sLibrary.isDartCore && s.name == _TYPE_CLASS_NAME) {
+      return true;
+    }
+    //
     // T is a type parameter and S is the upper bound of T.
     //
     DartType bound = element.bound;
     if (s == bound) {
       return true;
     }
+    //
     // T is a type parameter and S is Object.
     //
     if (s.isObject) {
       return true;
     }
     // We need upper bound to continue.
     if (bound == null) {
       return false;
     }
     //
@@ skipping 353 matching lines @@
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf(type);
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
 }