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 4649 matching lines @@
    * declaration are replaced with the actual type arguments from the defining type, create a field
    * member representing the given field. Return the member that was created, or the base field if
    * no member was created.
    *
    * @param baseField the base field for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the field element that will return the correctly substituted types
    */
   static FieldElement from(FieldElement baseField, InterfaceType definingType) {
-    if (baseField == null || definingType.typeArguments.length == 0) {
-      return baseField;
-    }
-    DartType baseType = baseField.type;
-    if (baseType == null) {
-      return baseField;
-    }
-    List<DartType> argumentTypes = definingType.typeArguments;
-    List<DartType> parameterTypes = definingType.element.type.typeArguments;
-    DartType substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
+    if (!_isChangedByTypeSubstitution(baseField, definingType)) {
       return baseField;
     }
     // TODO(brianwilkerson) Consider caching the substituted type in the instance. It would use more
     // memory but speed up some operations. We need to see how often the type is being re-computed.
     return new FieldMember(baseField, definingType);
   }
 
   /**
+   * Determine whether the given field's type is changed when type parameters from the defining
+   * type's declaration are replaced with the actual type arguments from the defining type.
+   *
+   * @param baseField the base field
+   * @param definingType the type defining the parameters and arguments to be used in the
+   *          substitution
+   * @return true if the type is changed by type substitution.
+   */
+  static bool _isChangedByTypeSubstitution(FieldElement baseField, InterfaceType definingType) {
+    List<DartType> argumentTypes = definingType.typeArguments;
+    if (baseField != null && argumentTypes.length != 0) {
+      DartType baseType = baseField.type;
+      List<DartType> parameterTypes = definingType.element.type.typeArguments;
+      if (baseType != null) {
+        DartType substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
+        if (baseType != substitutedType) {
+          return true;
+        }
+      }
+      // If the field has a propagated type, then we need to check whether the propagated type
+      // needs substitution.
+      DartType basePropagatedType = baseField.propagatedType;
+      if (basePropagatedType != null) {
+        DartType substitutedPropagatedType = basePropagatedType.substitute2(argumentTypes, parameterTypes);
+        if (basePropagatedType != substitutedPropagatedType) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
    * Initialize a newly created element to represent a field of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   FieldMember(FieldElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
   @override
   FieldElement get baseElement => super.baseElement as FieldElement;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
   PropertyAccessorElement get getter => PropertyAccessorMember.from(baseElement.getter, definingType);
 
   @override
   DartType get propagatedType => substituteFor(baseElement.propagatedType);
 
   @override
   PropertyAccessorElement get setter => PropertyAccessorMember.from(baseElement.setter, definingType);
 
   @override
   bool get isStatic => baseElement.isStatic;
 
   @override
+  String toString() {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append(type);
+    builder.append(" ");
+    builder.append(displayName);
+    return builder.toString();
+  }
+
+  @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.
@@ skipping 2678 matching lines @@
       }
     }
     return false;
   }
 }
 
 /**
  * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
-  final String tagName;
+  String _tagName;
 
-  final String attributeName;
+  String _attributeName;
 
-  IsTagHasAttributeSelectorElementImpl(this.tagName, this.attributeName) : super(null, -1);
+  IsTagHasAttributeSelectorElementImpl(String tagName, String attributeName) : super("${tagName}[${attributeName}]", -1) {
+    this._tagName = tagName;
+    this._attributeName = attributeName;
+  }
 
   @override
-  bool apply(XmlTagNode node) => node.tag == tagName && node.getAttribute(attributeName) != null;
+  bool apply(XmlTagNode node) => node.tag == _tagName && node.getAttribute(_attributeName) != null;
+
+  String get attributeName => _attributeName;
+
+  String get tagName => _tagName;
 }
 
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
  */
 abstract class LabelElement implements Element {
   /**
    * Return the executable element in which this label is defined.
    *
@@ skipping 2459 matching lines @@
    * type's declaration are replaced with the actual type arguments from the defining type, create a
    * property accessor member representing the given property accessor. Return the member that was
    * created, or the base accessor if no member was created.
    *
    * @param baseAccessor the base property accessor for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the property accessor element that will return the correctly substituted types
    */
   static PropertyAccessorElement from(PropertyAccessorElement baseAccessor, InterfaceType definingType) {
-    if (baseAccessor == null || definingType.typeArguments.length == 0) {
-      return baseAccessor;
-    }
-    FunctionType baseType = baseAccessor.type;
-    List<DartType> argumentTypes = definingType.typeArguments;
-    List<DartType> parameterTypes = definingType.element.type.typeArguments;
-    FunctionType substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
+    if (!_isChangedByTypeSubstitution(baseAccessor, definingType)) {
       return baseAccessor;
     }
     // TODO(brianwilkerson) Consider caching the substituted type in the instance. It would use more
     // memory but speed up some operations. We need to see how often the type is being re-computed.
     return new PropertyAccessorMember(baseAccessor, definingType);
   }
 
   /**
+   * Determine whether the given property accessor's type is changed when type parameters from the
+   * defining type's declaration are replaced with the actual type arguments from the defining type.
+   *
+   * @param baseAccessor the base property accessor
+   * @param definingType the type defining the parameters and arguments to be used in the
+   *          substitution
+   * @return true if the type is changed by type substitution.
+   */
+  static bool _isChangedByTypeSubstitution(PropertyAccessorElement baseAccessor, InterfaceType definingType) {
+    List<DartType> argumentTypes = definingType.typeArguments;
+    if (baseAccessor != null && argumentTypes.length != 0) {
+      FunctionType baseType = baseAccessor.type;
+      List<DartType> parameterTypes = definingType.element.type.typeArguments;
+      FunctionType substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
+      if (baseType != substitutedType) {
+        return true;
+      }
+      // If this property accessor is based on a field, that field might have a propagated type.
+      // In which case we need to check whether the propagated type of the field needs substitution.
+      PropertyInducingElement field = baseAccessor.variable;
+      if (!field.isSynthetic) {
+        DartType baseFieldType = field.propagatedType;
+        if (baseFieldType != null) {
+          DartType substitutedFieldType = baseFieldType.substitute2(argumentTypes, parameterTypes);
+          if (baseFieldType != substitutedFieldType) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
    * Initialize a newly created element to represent a property accessor of the given parameterized
    * type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
@@ skipping 1390 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);
 }