Don't use 'info.type', always set 'element'.

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 396 matching lines @@
           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.element != null) {
-            Identifier node = _buildElementAst(info.name, info.element);
-            _push(node);
-          } else if (info.type != null) {
-            Identifier node = _buildElementAst(info.name, info.type.element);
+            SimpleIdentifier node = AstFactory.identifier3(info.name);
+            node.staticElement = info.element;
             _push(node);
           } else {
             throw new StateError('Unsupported reference ${ref.toMap()}');
           }
           break;
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
     }
     return stack.single;
   }
 
-  Identifier _buildElementAst(String name, Element element) {
-    SimpleIdentifier node = AstFactory.identifier3(name);
-    node.staticElement = element;
-    return node;
-  }
-
   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);
@@ skipping 1010 matching lines @@
       LinkedReference linkedReference = linkedUnit.references[i];
       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;
       }
-      ElementHandle element;
+      Element element;
       DartType type;
       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 {
         List<String> locationComponents;
         if (containingReference != 0 &&
             referenceInfos[containingReference].element is ClassElement) {
           String identifier = _getElementIdentifier(name, linkedReference.kind);
           locationComponents = referenceInfos[containingReference]
               .element
               .location
               .components
               .toList();
@@ skipping 25 matching lines @@
           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;
         }
       }

[scheglov, 2016/02/01 20:19:25]

Or we could use code like this here:
element ??= type?.element;

[Paul Berry, 2016/02/01 20:33:29]

IMHO, it's a little easier to follow as is, since `element` is assigned exactly
once in each code path.  But it's your call.

       referenceInfos[i] = new _ReferenceInfo(
           name, element, type, linkedReference.numTypeParameters);
     }
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit(CompilationUnitElementImpl unit, int unitNum) {
@@ skipping 174 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;
     }
   }
 }