Ensure that element handles never refer to Member objects.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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.
 
 library summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 495 matching lines @@
     // prepare ConstructorElement
     String constructorName;
     if (info.element is ConstructorElement) {
       constructorName = info.name;
     } else if (info.element is ClassElement) {
       constructorName = null;
     } else {
       throw new StateError('Unsupported element for invokeConstructor '
           '${info.element?.runtimeType}');
     }
-    _DeferredConstructorElement constructorElement =
-        resynthesizer._createConstructorElement(info, ref.typeArguments);
+    InterfaceType definingType =
+        resynthesizer._createConstructorDefiningType(info, ref.typeArguments);
+    ConstructorElement constructorElement = resynthesizer
+        ._createConstructorElement(definingType, info, ref.typeArguments);
     // prepare arguments
     List<Expression> arguments;
     {
       int numNamedArgs = uc.ints[intPtr++];
       int numPositionalArgs = uc.ints[intPtr++];
       int numArgs = numNamedArgs + numPositionalArgs;
       arguments = _removeTopItems(numArgs);
       // add names to the named arguments
       for (int i = 0; i < numNamedArgs; i++) {
         String name = uc.strings[stringPtr++];
         int index = numPositionalArgs + i;
         arguments[index] = AstFactory.namedExpression2(name, arguments[index]);
       }
     }
     // create TypeName
-    TypeName typeNode = _buildTypeAst(constructorElement._definingType);
+    TypeName typeNode = _buildTypeAst(definingType);
     // create ConstructorName
     ConstructorName constructorNode;
     if (constructorName != null) {
       constructorNode = AstFactory.constructorName(typeNode, constructorName);
       constructorNode.name.staticElement = constructorElement;
     } else {
       constructorNode = AstFactory.constructorName(typeNode, null);
     }
     constructorNode.staticElement = constructorElement;
     // create InstanceCreationExpression
@@ skipping 49 matching lines @@
    * then the type parameters of [_definingType] are not guaranteed to be
    * valid.
    */
   final InterfaceType _definingType;
 
   /**
    * The constructor name.
    */
   final String name;
 
-  /**
-   * Indicates whether the deferred element is a [ConstructorMember] or simply
-   * a [ConstructorElement].
-   */
-  final bool _isMember;
-
   factory _DeferredConstructorElement(InterfaceType definingType, String name) {
     List<String> components = definingType.element.location.components.toList();
     components.add(name);
     ElementLocationImpl location = new ElementLocationImpl.con3(components);
-    return new _DeferredConstructorElement._(
-        definingType, name, location, true);
+    return new _DeferredConstructorElement._(definingType, name, location);
   }
 
   _DeferredConstructorElement._(
-      this._definingType, this.name, ElementLocation location, this._isMember)
+      this._definingType, this.name, ElementLocation location)
       : super(null, location);
 
   @override
-  Element get actualElement {
-    ConstructorElement element = enclosingElement.getNamedConstructor(name);
-    if (_isMember && _definingType.typeArguments.isNotEmpty) {
-      return new ConstructorMember(element, _definingType);
-    } else {
-      return element;
-    }
-  }
+  Element get actualElement => enclosingElement.getNamedConstructor(name);
 
   @override
   AnalysisContext get context => _definingType.element.context;
 
   @override
   String get displayName => name;
 
   @override
   ClassElement get enclosingElement {
     return _definingType.element;
@@ skipping 294 matching lines @@
     currentConstructor.factory = serializedExecutable.isFactory;
     currentConstructor.const2 = serializedExecutable.isConst;
     currentConstructor.constantInitializers = serializedExecutable
         .constantInitializers
         .map(buildConstantInitializer)
         .toList();
     if (serializedExecutable.isRedirectedConstructor) {
       if (serializedExecutable.isFactory) {
         EntityRef redirectedConstructor =
             serializedExecutable.redirectedConstructor;
+        _ReferenceInfo info = referenceInfos[redirectedConstructor.reference];
+        List<EntityRef> typeArguments = redirectedConstructor.typeArguments;
         currentConstructor.redirectedConstructor = _createConstructorElement(
-            referenceInfos[redirectedConstructor.reference],
-            redirectedConstructor.typeArguments);
+            _createConstructorDefiningType(info, typeArguments),
+            info,
+            typeArguments);
       } else {
         List<String> locationComponents =
             currentCompilationUnit.location.components.toList();
         locationComponents.add(classType.name);
         locationComponents.add(serializedExecutable.redirectedConstructorName);
         currentConstructor.redirectedConstructor =
             new _DeferredConstructorElement._(
                 classType,
                 serializedExecutable.redirectedConstructorName,
-                new ElementLocationImpl.con3(locationComponents),
-                false);
+                new ElementLocationImpl.con3(locationComponents));
       }
     }
     holder.addConstructor(currentConstructor);
     currentConstructor = null;
   }
 
   /**
    * Build the documentation for the given [element].  Does nothing if
    * [serializedDocumentationComment] is `null`.
    */
@@ skipping 930 matching lines @@
   /**
    * Return the new handle of the `String.length` getter element.
    */
   PropertyAccessorElementHandle _buildStringLengthPropertyAccessorElement() =>
       new PropertyAccessorElementHandle(
           summaryResynthesizer,
           new ElementLocationImpl.con3(
               <String>['dart:core', 'dart:core', 'String', 'length?']));
 
   /**
+   * Return the defining type for a [ConstructorElement] by applying
+   * [typeArgumentRefs] to the given linked [info].
+   */
+  InterfaceType _createConstructorDefiningType(
+      _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {
+    bool isClass = info.element is ClassElement;
+    _ReferenceInfo classInfo = isClass ? info : info.enclosing;
+    List<DartType> typeArguments = typeArgumentRefs.map(buildType).toList();
+    return classInfo.buildType((i) {
+      if (i < typeArguments.length) {
+        return typeArguments[i];
+      } else {
+        return DynamicTypeImpl.instance;
+      }
+    }, const <int>[]);
+  }
+
+  /**
    * Return the [ConstructorElement] by applying [typeArgumentRefs] to the
    * given linked [info].  Both cases when [info] is a [ClassElement] and
    * [ConstructorElement] are supported.
    */
-  _DeferredConstructorElement _createConstructorElement(
+  ConstructorElement _createConstructorElement(InterfaceType classType,
       _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {

[scheglov, 2016/02/10 21:53:26]

Do we need "typeArgumentRefs" here now?
Shoudl we document 'classType'?

[Paul Berry, 2016/02/10 22:10:59]

You're right--we don't need it anymore.  I've removed it and updated the
documentation to refer to [classType] and [info].

     bool isClass = info.element is ClassElement;
-    _ReferenceInfo classInfo = isClass ? info : info.enclosing;
-    List<DartType> typeArguments = typeArgumentRefs.map(buildType).toList();
-    InterfaceType classType = classInfo.buildType((i) {
-      if (i < typeArguments.length) {
-        return typeArguments[i];
-      } else {
-        return DynamicTypeImpl.instance;
-      }
-    }, const <int>[]);
     String name = isClass ? '' : info.name;
-    return new _DeferredConstructorElement(classType, name);
+    _DeferredConstructorElement element =
+        new _DeferredConstructorElement(classType, name);
+    if (info.numTypeParameters != 0) {
+      return new ConstructorMember(element, classType);
+    } else {
+      return element;
+    }
   }
 
   /**
    * If the given [kind] is a top-level or class member property accessor, and
    * the given [name] does not end with `=`, i.e. does not denote a setter,
    * return the getter identifier by appending `?`.
    */
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
@@ skipping 123 matching lines @@
                 }
               : () => this.element;
       // TODO(paulberry): Is it a bug that we have to pass `false` for
       // isInstantiated?
       return new DeferredFunctionTypeImpl(computer, null, typeArguments, false);
     } else {
       return null;
     }
   }
 }