Resynthesize generic class instance creations.

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';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 419 matching lines @@
       List<TypeName> argumentNodes =
           type.typeArguments.map(_buildTypeAst).toList();
       TypeName node = AstFactory.typeName4(type.name, argumentNodes);
       node.type = type;
       (node.name as SimpleIdentifier).staticElement = type.element;
       return node;
     }
     throw new StateError('Unsupported type $type');
   }
 
+  /**
+   * Return the [ConstructorElement] for the given [ref] and its linked [info].
+   * Both cases when [info] is a [ClassElement] and [ConstructorElement] are
+   * supported.  [ref] is used to get the type arguments and the name of the
+   * constructor.
+   */
+  _DeferredConstructorElement _createConstructorElement(
+      EntityRef ref, _ReferenceInfo info) {
+    bool isClass = info.element is ClassElement;
+    _ReferenceInfo classInfo = isClass ? info : info.enclosing;
+    List<DartType> typeArguments =
+        ref.typeArguments.map(resynthesizer.buildType).toList();
+    InterfaceType classType =
+        classInfo.buildType((i) => typeArguments[i], const <int>[]);
+    String name = isClass ? '' : info.name;
+    return new _DeferredConstructorElement(classType, name);
+  }
+
   InterpolationElement _newInterpolationElement(Expression expr) {
     if (expr is SimpleStringLiteral) {
       return new InterpolationString(expr.literal, expr.value);
     } else {
       return new InterpolationExpression(
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION),
           expr,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
     }
   }
@@ skipping 17 matching lines @@
   void _pushBinary(TokenType operator) {
     Expression right = _pop();
     Expression left = _pop();
     _push(AstFactory.binaryExpression(left, operator, right));
   }
 
   void _pushInstanceCreation() {
     EntityRef ref = uc.references[refPtr++];
     _ReferenceInfo info = resynthesizer.referenceInfos[ref.reference];
     // prepare ClassElement / ConstructorElement
-    String className;
-    ClassElement classElement;
     String constructorName;
-    ConstructorElement constructorElement;
+    _DeferredConstructorElement constructorElement;
     if (info.element is ConstructorElement) {
       constructorName = info.name;
-      constructorElement = info.element;
-      className = info.enclosing.name;
-      classElement = info.enclosing.element as ClassElement;
+      constructorElement = _createConstructorElement(ref, info);

[Paul Berry, 2016/02/02 22:01:16]

Nit: since the logic is the same for both constructor elements and class
elements, this line and line 515 can be lifted out of the conditional and merged
with line 509.

[scheglov, 2016/02/02 22:28:04]

Ah, yes.
This code used to be much more complex and different.
But now it is the same.
Thanks!

     } else if (info.element is ClassElement) {
-      className = info.name;
-      classElement = info.element;
       constructorName = null;
-      constructorElement = new ConstructorElementHandle(
-          resynthesizer.summaryResynthesizer,
-          new ElementLocationImpl.con3(
-              classElement.location.components.toList()..add('')));
+      constructorElement = _createConstructorElement(ref, info);
     } else {
       throw new StateError('Unsupported element for invokeConstructor '
           '${info.element?.runtimeType}');
     }
     // 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
-    SimpleIdentifier typeNameNode = AstFactory.identifier3(className);
-    typeNameNode.staticElement = classElement;
-    TypeName typeNode = AstFactory.typeName3(typeNameNode);
+    TypeName typeNode = _buildTypeAst(constructorElement.definingType);
     // create ConstructorName
     ConstructorName constructorNode;
     if (constructorName != null) {
-      constructorNode = AstFactory.constructorName(typeNode, info.name);
+      constructorNode = AstFactory.constructorName(typeNode, constructorName);
       constructorNode.name.staticElement = constructorElement;
     } else {
       constructorNode = AstFactory.constructorName(typeNode, null);
     }
     constructorNode.staticElement = constructorElement;
     // create InstanceCreationExpression
     InstanceCreationExpression instanceCreation = AstFactory
         .instanceCreationExpression(Keyword.CONST, constructorNode, arguments);
     instanceCreation.staticElement = constructorElement;
     _push(instanceCreation);
@@ skipping 27 matching lines @@
   List<Expression> _removeTopItems(int count) {
     int start = stack.length - count;
     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
+ * without creating the actual element.
+ */
+class _DeferredConstructorElement extends ConstructorElementHandle {
+  final InterfaceType definingType;
+  final String name;
+
+  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);
+  }
+
+  _DeferredConstructorElement._(
+      this.definingType, this.name, ElementLocation location)
+      : super(null, location);
+
+  @override
+  Element get actualElement {
+    ConstructorElement element = enclosingElement.getNamedConstructor(name);
+    return new ConstructorMember(element, definingType);
+  }
+
+  @override
+  String get displayName => name;
+
+  @override
+  ClassElement get enclosingElement {
+    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.
    */
   final SummaryResynthesizer summaryResynthesizer;
 
   /**
@@ skipping 930 matching lines @@
       int containingReference;
       if (i < numUnlinkedReferences) {
         name = unlinkedUnit.references[i].name;
         containingReference = unlinkedUnit.references[i].prefixReference;
       } else {
         name = linkedUnit.references[i].name;
         containingReference = linkedUnit.references[i].containingReference;
       }
       Element element;
       DartType type;
+      int numTypeParameters = linkedReference.numTypeParameters;
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = summaryResynthesizer.typeProvider.undefinedType;
         element = type.element;
       } else if (name == 'dynamic') {
         type = summaryResynthesizer.typeProvider.dynamicType;
         element = type.element;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
         element = type.element;
       } else {
@@ skipping 21 matching lines @@
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.topLevelPropertyAccessor:
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.constructor:
             assert(location.components.length == 4);
             element =
                 new ConstructorElementHandle(summaryResynthesizer, location);
+            numTypeParameters = enclosingInfo.numTypeParameters;
             break;
           case ReferenceKind.propertyAccessor:
             assert(location.components.length == 4);
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.method:
             assert(location.components.length == 4);
             element = new MethodElementHandle(summaryResynthesizer, location);
             break;
           default:
             // This is an element that doesn't (yet) need to be referred to
             // directly, so don't bother populating an element for it.
             // TODO(paulberry): add support for more kinds, as needed.
             break;
         }
       }
-      referenceInfos[i] = new _ReferenceInfo(enclosingInfo, name, element, type,
-          linkedReference.numTypeParameters);
+      referenceInfos[i] = new _ReferenceInfo(
+          enclosingInfo, name, element, type, numTypeParameters);
     }
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
@@ skipping 179 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;
     }
   }
 }