Serialize and resynthesize unresolved constant 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/ast/token.dart';
@@ skipping 505 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 ConstructorElement
+    TypeName typeNode;
     String constructorName;
-    if (info.element is ConstructorElement) {
-      constructorName = info.name;
-    } else if (info.element is ClassElement) {
-      constructorName = null;
+    ConstructorElement constructorElement;
+    if (info.element != null) {
+      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}');
+      }
+      InterfaceType definingType =
+          resynthesizer._createConstructorDefiningType(info, ref.typeArguments);
+      constructorElement =
+          resynthesizer._createConstructorElement(definingType, info);
+      typeNode = _buildTypeAst(definingType);
     } else {
-      throw new StateError('Unsupported element for invokeConstructor '
-          '${info.element?.runtimeType}');
+      if (info.enclosing != null) {
+        if (info.enclosing.enclosing != null) {
+          PrefixedIdentifier typeName = AstFactory.identifier5(
+              info.enclosing.enclosing.name, info.enclosing.name);
+          typeName.prefix.staticElement = info.enclosing.enclosing.element;
+          typeName.identifier.staticElement = info.enclosing.element;
+          typeName.identifier.staticType = info.enclosing.type;
+          typeNode = AstFactory.typeName3(typeName);
+          typeNode.type = info.enclosing.type;
+          constructorName = info.name;
+        } else if (info.enclosing.element != null) {
+          SimpleIdentifier typeName =
+              AstFactory.identifier3(info.enclosing.name);
+          typeName.staticElement = info.enclosing.element;
+          typeName.staticType = info.enclosing.type;
+          typeNode = AstFactory.typeName3(typeName);
+          typeNode.type = info.enclosing.type;
+          constructorName = info.name;
+        } else {
+          typeNode = AstFactory.typeName3(
+              AstFactory.identifier5(info.enclosing.name, info.name));
+          constructorName = null;
+        }
+      } else {
+        typeNode = AstFactory.typeName4(info.name);
+      }
     }
-    InterfaceType definingType =
-        resynthesizer._createConstructorDefiningType(info, ref.typeArguments);
-    ConstructorElement constructorElement =
-        resynthesizer._createConstructorElement(definingType, info);
     // 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(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 1253 matching lines @@
   /**
    * Populate [referenceInfos] with the correct information for the current
    * compilation unit.
    */
   void populateReferenceInfos() {
     int numLinkedReferences = linkedUnit.references.length;
     int numUnlinkedReferences = unlinkedUnit.references.length;
     referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
     for (int i = 0; i < numLinkedReferences; i++) {
       LinkedReference linkedReference = linkedUnit.references[i];
-      _ReferenceInfo enclosingInfo = null;
       String name;
       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;
       }
+      _ReferenceInfo enclosingInfo =
+          containingReference != 0 ? referenceInfos[containingReference] : null;
       Element element;
       DartType type;
       int numTypeParameters = linkedReference.numTypeParameters;
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = summaryResynthesizer.typeProvider.undefinedType;
         element = null;
       } else if (name == 'dynamic') {
         type = summaryResynthesizer.typeProvider.dynamicType;
         element = type.element;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
         element = type.element;
       } else {
         List<String> locationComponents;
-        if (containingReference != 0 &&
-            referenceInfos[containingReference].element is ClassElement) {
+        if (enclosingInfo != null && enclosingInfo.element is ClassElement) {
           String identifier = _getElementIdentifier(name, linkedReference.kind);
-          enclosingInfo = referenceInfos[containingReference];
           locationComponents =
               enclosingInfo.element.location.components.toList();
           locationComponents.add(identifier);
         } else {
           String identifier = _getElementIdentifier(name, linkedReference.kind);
           locationComponents = getReferencedLocationComponents(
               linkedReference.dependency, linkedReference.unit, identifier);
         }
         ElementLocation location =
             new ElementLocationImpl.con3(locationComponents);
@@ skipping 312 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;
     }
   }
 }