Resynthesize type references.

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

Index: pkg/analyzer/lib/src/summary/resynthesize.dart
diff --git a/pkg/analyzer/lib/src/summary/resynthesize.dart b/pkg/analyzer/lib/src/summary/resynthesize.dart
index 6e9e8b58de96b75255654888ef5fa1fcc8b14ddc..7ce0954d021b50f6c102f895998cdbf421c5af14 100644
--- a/pkg/analyzer/lib/src/summary/resynthesize.dart
+++ b/pkg/analyzer/lib/src/summary/resynthesize.dart
@@ -411,6 +411,16 @@ class _ConstExprBuilder {
           _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) {

[Paul Berry, 2016/01/31 13:41:02]

This won't work properly if the class in question takes generic parameters (see
the comment on _ReferenceInfo.type, which says "If this reference refers to a
non-generic type, the type it refers to.  Otherwise `null`."

To fix it, we could either (a) change the code here call `info.buildType` and
pass the appropriate number of instances of `dynamic` to populate the type
parameters, or (b) change the behavior of the _ReferenceInfo constructor so that
it always populates _ReferenceInfo.type.

I think I would prefer (b).  If you'd prefer to leave this as a failing test
case and let me fix it, let me know.

[scheglov, 2016/01/31 18:55:29]

Done.

+            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();
@@ -437,6 +447,15 @@ class _ConstExprBuilder {
     throw new StateError('Unsupported type $type');
   }
 
+  Identifier _buildTypeIdentifierAst(DartType type) {
+    String name = type.name;
+    SimpleIdentifier node = AstFactory.identifier3(name);
+    node.staticElement = type.element;
+    // TODO(scheglov) it seems that resolver does not do this
+//    node.staticType = resynthesizer.summaryResynthesizer.typeProvider.typeType;

[Paul Berry, 2016/01/31 13:41:02]

I'm confused about this commented out code and the comment above it.  If the
resolver does not do this, how are the tests passing?

[scheglov, 2016/01/31 18:55:29]

1. We should do this.
2. Resolver does not do this.
3. So, this code is commented out for now in constants AST resynthesizer.
4. If we uncomment the code, tests will start *failing*.

[scheglov, 2016/01/31 20:24:01]

Actually, I'm wrong.
Resolver does set the type correctly.
But ConstantAstCloner does not copy it.
I guess we don't use types during computing constant values.
So, I'm removing this commented line and the static type check in tests.

+    return node;
+  }
+
   InterpolationElement _newInterpolationElement(Expression expr) {
     if (expr is SimpleStringLiteral) {
       return new InterpolationString(expr.literal, expr.value);
@@ -1591,8 +1610,8 @@ class _ReferenceInfo {
 
   /**
    * 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