Fix summarization of generic redirecting constructors (again).

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 512 matching lines @@
       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(constructorElement._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 33 matching lines @@
     int end = stack.length;
     List<Expression> items = stack.getRange(start, end).toList();
     stack.removeRange(start, end);
     return items;
   }
 }
 
 /**
  * The constructor element that has been resynthesized from a summary.  The
  * actual element won't be constructed until it is requested.  But properties
- * [definingType], [displayName], [enclosingElement] and [name] can be used
+ * [_definingType], [displayName], [enclosingElement] and [name] can be used

[scheglov, 2016/02/10 20:37:53]

Maybe we should exclude "_definingType" from the list.
It has never actually overridden any property of the superclass.

[Paul Berry, 2016/02/10 20:54:36]

Done.

  * without creating the actual element.
  */
 class _DeferredConstructorElement extends ConstructorElementHandle {
-  final InterfaceType definingType;
+  /**
+   * The type defining this constructor element.  If [_isMember] is `false`,
+   * 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);
+    return new _DeferredConstructorElement._(
+        definingType, name, location, true);
   }
 
   _DeferredConstructorElement._(
-      this.definingType, this.name, ElementLocation location)
+      this._definingType, this.name, ElementLocation location, this._isMember)
       : super(null, location);
 
   @override
   Element get actualElement {
     ConstructorElement element = enclosingElement.getNamedConstructor(name);
-    return new ConstructorMember(element, definingType);
+    if (_isMember && _definingType.typeArguments.isNotEmpty) {
+      return new ConstructorMember(element, _definingType);
+    } else {
+      return element;
+    }
   }
 
   @override
-  AnalysisContext get context => definingType.element.context;
+  AnalysisContext get context => _definingType.element.context;
 
   @override
   String get displayName => name;
 
   @override
   ClassElement get enclosingElement {
-    return definingType.element;
+    return _definingType.element;
   }
 }
 
 /**
  * An instance of [_LibraryResynthesizer] is responsible for resynthesizing the
  * elements in a single library from that library's summary.
  */
 class _LibraryResynthesizer {
   /**
    * The [SummaryResynthesizer] which is being used to obtain summaries.
@@ skipping 296 matching lines @@
             redirectedConstructor.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));
+                new ElementLocationImpl.con3(locationComponents),
+                false);
       }
     }
     holder.addConstructor(currentConstructor);
     currentConstructor = null;
   }
 
   /**
    * Build the documentation for the given [element].  Does nothing if
    * [serializedDocumentationComment] is `null`.
    */
@@ skipping 1091 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;
     }
   }
 }