Resynthesize type references.

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 393 matching lines @@
           break;
         case UnlinkedConstOperation.makeUntypedMap:
           _pushMap(null);
           break;
         case UnlinkedConstOperation.makeTypedMap:
           TypeName keyType = _newTypeName();
           TypeName valueType = _newTypeName();
           _pushMap(AstFactory.typeArgumentList(<TypeName>[keyType, valueType]));
           break;
         case UnlinkedConstOperation.pushReference:
+          EntityRef ref = uc.references[refPtr++];
+          _ReferenceInfo info = resynthesizer.referenceInfos[ref.reference];
+          if (info.type != null) {
+            Identifier node = _buildTypeIdentifierAst(info.type);
+            _push(node);
+          } else {
+            throw new StateError(
+                'Unsupported reference ${info.element?.runtimeType}');
+          }
+          break;
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
     }
     return stack.single;
   }
 
   TypeName _buildTypeAst(DartType type) {
     if (type is DynamicTypeImpl) {
       TypeName node = AstFactory.typeName4('dynamic');
       node.type = type;
       (node.name as SimpleIdentifier).staticElement = type.element;
       return node;
     } else if (type is InterfaceType) {
       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');
   }
 
+  Identifier _buildTypeIdentifierAst(DartType type) {
+    String name = type.name;
+    SimpleIdentifier node = AstFactory.identifier3(name);
+    node.staticElement = type.element;
+    return node;
+  }
+
   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 813 matching lines @@
       } else {
         return summaryResynthesizer.typeProvider.dynamicType;
       }
     }
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
               currentTypeParameters.length - type.paramReference]
           .type;
     } else {
-      DartType getTypeParameter(int i) {
+      DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i]);
         } else {
           return summaryResynthesizer.typeProvider.dynamicType;
         }
       }
       _ReferenceInfo referenceInfo = referenceInfos[type.reference];
       return referenceInfo.buildType(
-          getTypeParameter, type.implicitFunctionTypeIndices);
+          getTypeArgument, type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     try {
       currentTypeParameters =
@@ skipping 291 matching lines @@
   DartType type;
 
   /**
    * The number of type parameters accepted by the entity referred to by this
    * reference, or zero if it doesn't accept any type parameters.
    */
   final int numTypeParameters;
 
   /**
    * Create a new [_ReferenceInfo] object referring to an element called [name]
-   * via the element handle [elementHandle], and having [numTypeParameters]
-   * type parameters.
+   * via the element handle [element], and having [numTypeParameters] type
+   * parameters.
    *
    * For the special types `dynamic` and `void`, [specialType] should point to
    * the type itself.  Otherwise, pass `null` and the type will be computed
    * when appropriate.
    */
   _ReferenceInfo(
       this.name, this.element, DartType specialType, this.numTypeParameters) {
     if (specialType != null) {
       type = specialType;
-    } else if (numTypeParameters == 0) {
-      // We can precompute the type because it doesn't depend on type
-      // parameters.
+    } else {
       type = _buildType(null, null);
     }
   }
 
   /**
    * Build a [DartType] corresponding to the result of applying some type
    * arguments to the entity referred to by this [_ReferenceInfo].  The type
    * arguments are retrieved by calling [getTypeArgument].
    *
    * If [implicitFunctionTypeIndices] is not empty, a [DartType] should be
@@ skipping 13 matching lines @@
     if (result == null) {
       // TODO(paulberry): figure out how to handle this case (which should
       // only occur in the event of erroneous code).
       throw new UnimplementedError();
     }
     return result;
   }
 
   /**
    * If this reference refers to a type, build a [DartType] which instantiates
-   * it with type arguments returned by [getTypeArgument].  Otherwise return
-   * `null`.
+   * it with type arguments returned by [getTypeArgument] or with all `dynamic`
+   * type arguments if [getTypeArgument] is `null`.  Otherwise return `null`.
    *
    * If [implicitFunctionTypeIndices] is not null, a [DartType] should be
    * created which refers to a function type implicitly defined by one of the
    * element's parameters.  [implicitFunctionTypeIndices] is interpreted as in
    * [EntityRef.implicitFunctionTypeIndices].
    */
   DartType _buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     List<DartType> typeArguments = const <DartType>[];
     if (numTypeParameters != 0) {
       typeArguments = <DartType>[];
       for (int i = 0; i < numTypeParameters; i++) {
-        typeArguments.add(getTypeArgument(i));
+        DartType typeArgument = getTypeArgument != null

[Paul Berry, 2016/02/01 16:11:40]

Nit: Rather than make this change (which will burden all calls to _buildType),
how about just changing line 1623 from:

    type = _buildType(null, null);

to:

    type = _buildType((_) => DynamicTypeImpl.instance, null);

[scheglov, 2016/02/01 17:22:25]

Done.

+            ? getTypeArgument(i)
+            : DynamicTypeImpl.instance;
+        typeArguments.add(typeArgument);
       }
     }
     ElementHandle element = this.element; // To allow type promotion
     if (element is ClassElementHandle) {
       return new InterfaceTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments);
     } else if (element is FunctionTypeAliasElementHandle) {
       return new FunctionTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments, typeArguments.isNotEmpty);
     } else if (element is FunctionTypedElement &&
         implicitFunctionTypeIndices != null) {
       FunctionTypedElementComputer computer = () {
         FunctionTypedElement element = this.element;
         for (int index in implicitFunctionTypeIndices) {
           element = element.parameters[index].type.element;
         }
         return 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;
     }
   }
 }