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) {

[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();
 //          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;
+    // 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);
     } else {
       return new InterpolationExpression(
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION),
           expr,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
     }
   }
@@ skipping 1134 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) {
@@ skipping 66 matching lines @@
         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;
     }
   }
 }