Resynthesize top-level and class static property access 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 395 matching lines @@
           _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);
+          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);

[Paul Berry, 2016/02/01 19:27:16]

I bet this case (info.element == null but info.type != null) is only necessary
to handle `dynamic`.  Consider changing populateReferenceInfos() so that it just
populates the element appropriately in the case of `dynamic`, and then I think
we could just drop this case entirely.

Or if you'd rather let me experiment with that in a follow CL, let me know and
I'll take care of it.

[scheglov, 2016/02/01 19:42:18]

I will try to simplify this in the next CL.

             _push(node);
           } else {
-            throw new StateError(
-                'Unsupported reference ${info.element?.runtimeType}');
+            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);
       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 1005 matching lines @@
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = summaryResynthesizer.typeProvider.undefinedType;
       } else if (name == 'dynamic') {
         type = summaryResynthesizer.typeProvider.dynamicType;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
       } 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();
-          locationComponents.add(name);
+          locationComponents.add(identifier);
         } else {
+          String identifier = _getElementIdentifier(name, linkedReference.kind);
           locationComponents = getReferencedLocationComponents(
-              linkedReference.dependency, linkedReference.unit, name);
+              linkedReference.dependency, linkedReference.unit, identifier);
         }
         ElementLocation location =
             new ElementLocationImpl.con3(locationComponents);
         switch (linkedReference.kind) {
           case ReferenceKind.classOrEnum:
             element = new ClassElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
             break;
+          case ReferenceKind.topLevelPropertyAccessor:
+            element = new PropertyAccessorElementHandle(
+                summaryResynthesizer, location);
+            break;
           case ReferenceKind.propertyAccessor:
             assert(location.components.length == 4);
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.method:
             assert(location.components.length == 4);
             element = new MethodElementHandle(summaryResynthesizer, location);
             break;
           default:
@@ skipping 55 matching lines @@
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
     referenceInfos = null;
   }
+
+  /**
+   * If the given [kind] is a top-level or class member property accessor, and
+   * the given [name] does not end with `=`, i.e. does not denote a setter,
+   * return the getter identifier by appending `?`.
+   */
+  static String _getElementIdentifier(String name, ReferenceKind kind) {
+    if (kind == ReferenceKind.topLevelPropertyAccessor ||
+        kind == ReferenceKind.propertyAccessor) {
+      if (!name.endsWith('=')) {
+        return name + '?';
+      }
+    }
+    return name;
+  }
 }
 
 /**
  * Data structure used during resynthesis to record all the information that is
- * known about how to reserialize a single entry in [LinkedUnit.references]
+ * known about how to resynthesize a single entry in [LinkedUnit.references]
  * (and its associated entry in [UnlinkedUnit.references], if it exists).
  */
 class _ReferenceInfo {
   /**
    * The name of the entity referred to by this reference.
    */
   final String name;
 
   /**
    * The element referred to by this reference, or `null` if there is no
@@ skipping 95 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;
     }
   }
 }