Use property accessor elements for type inference rather than top level variable elements.

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

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 710 matching lines @@
               new PropertyAccessorElementForLink_Executable(
                   this, null, unlinkedExecutable, syntheticVariable);
           _accessors.add(accessor);
           if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter) {
             syntheticVariable._getter = accessor;
           } else {
             syntheticVariable._setter = accessor;
           }
         }
       }
-      // TODO(paulberry): also add synthetic accessors.
+      for (TopLevelVariableElementForLink variable in topLevelVariables) {
+        _accessors.add(variable.getter);
+        if (!variable.isConst && !variable.isFinal) {
+          _accessors.add(variable.setter);
+        }
+      }
     }
     return _accessors;
   }
 
   @override
   LibraryElementForLink get enclosingElement;
 
   @override
   List<ClassElementForLink_Enum> get enums {
     if (_enums == null) {
@@ skipping 78 matching lines @@
   ReferenceableElementForLink getContainedName(name) {
     if (_containedNames == null) {
       _containedNames = <String, ReferenceableElementForLink>{};
       // TODO(paulberry): what's the correct way to handle name conflicts?
       for (ClassElementForLink_Class type in types) {
         _containedNames[type.name] = type;
       }
       for (ClassElementForLink_Enum enm in enums) {
         _containedNames[enm.name] = enm;
       }
-      for (TopLevelVariableElementForLink variable in topLevelVariables) {
-        _containedNames[variable.name] = variable;
-      }
       for (TopLevelFunctionElementForLink function in functions) {
         _containedNames[function.name] = function;
       }
       for (PropertyAccessorElementForLink accessor in accessors) {
-        // TODO(paulberry): consider handling synthetic accessors and getting
-        // rid of the loop above for topLevelVariables.
-        if (!accessor.isSynthetic) {
-          _containedNames[accessor.name] = accessor;
-        }
+        _containedNames[accessor.name] = accessor;
       }
       // TODO(paulberry): fill in other top level entities (typedefs
       // and executables).
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Compute the type referred to by the given linked type [slot] (interpreted
@@ skipping 1605 matching lines @@
 }
 
 /**
  * Specialization of [FieldElementForLink] for class fields.
  */
 class FieldElementForLink_ClassField extends VariableElementForLink
     implements FieldElementForLink {
   @override
   final ClassElementForLink_Class enclosingElement;
 
-  PropertyAccessorElementForLink_Variable _getter;
-  PropertyAccessorElementForLink_Variable _setter;
-
   /**
    * If this is an instance field, the type that was computed by
    * [InstanceMemberInferrer] (if any).  Otherwise `null`.
    */
   DartType _inferredInstanceType;
 
   FieldElementForLink_ClassField(ClassElementForLink_Class enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : enclosingElement = enclosingElement,
         super(unlinkedVariable, enclosingElement.enclosingElement);
 
   @override
-  PropertyAccessorElementForLink_Variable get getter =>
-      _getter ??= new PropertyAccessorElementForLink_Variable(this, false);
-
-  @override
   bool get isStatic => unlinkedVariable.isStatic;
 
   @override
-  PropertyAccessorElementForLink_Variable get setter {
-    if (!isConst && !isFinal) {
-      return _setter ??=
-          new PropertyAccessorElementForLink_Variable(this, true);
-    } else {
-      return null;
-    }
-  }
-
-  @override
   void set type(DartType inferredType) {
     assert(!isStatic);
     assert(_inferredInstanceType == null);
     _inferredInstanceType = inferredType;
   }
 
   @override
   TypeParameterizedElementForLink get _typeParameterContext => enclosingElement;
 
   /**
@@ skipping 1330 matching lines @@
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class TopLevelVariableElementForLink extends VariableElementForLink
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElementForLink enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
+  CompilationUnitElementForLink get enclosingElement => compilationUnit;
+
+  @override
   bool get isStatic => true;
 
   @override
   LibraryElementForLink get library => compilationUnit.library;
 
   @override
   TypeParameterizedElementForLink get _typeParameterContext => null;
 
   /**
    * Store the results of type inference for this variable in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
-      TypeInferenceNode typeInferenceNode = this.asTypeInferenceNode;
+      TypeInferenceNode typeInferenceNode = this._typeInferenceNode;
       if (typeInferenceNode != null) {
         compilationUnit._storeLinkedType(
             unlinkedVariable.inferredTypeSlot, inferredType, null);
       }
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for performing type inferrence
@@ skipping 95 matching lines @@
   }
 
   void evaluate(bool inCycle) {
     if (inCycle) {
       variableElement._inferredType = DynamicTypeImpl.instance;
     } else {
       variableElement._inferredType =
           new ExprTypeComputer(variableElement).compute();
     }
   }
+
+  @override
+  String toString() => 'TypeInferenceNode($variableElement)';
 }
 
 /**
  * Element representing a type parameter resynthesized from a summary during
  * linking.
  */
 class TypeParameterElementForLink implements TypeParameterElementImpl {
   /**
    * The unlinked representation of the type parameter in the summary.
    */
@@ skipping 289 matching lines @@
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) => this;
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
-class VariableElementForLink
-    implements
-        VariableElementImpl,
-        PropertyInducingElement,
-        ReferenceableElementForLink {
+abstract class VariableElementForLink
+    implements VariableElementImpl, PropertyInducingElement {
   /**
    * The unlinked representation of the variable in the summary.
    */
   final UnlinkedVariable unlinkedVariable;
 
   /**
    * If this variable is declared `const` and the enclosing library is
    * part of the build unit being linked, the variable's node in the
    * constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstNode _constNode;
 
   /**
    * If this variable has an initializer and an implicit type, and the enclosing
    * library is part of the build unit being linked, the variable's node in the
    * type inference dependency graph.  Otherwise `null`.
    */
   TypeInferenceNode _typeInferenceNode;
 
   FunctionElementForLink_Initializer _initializer;
   DartType _inferredType;
   DartType _declaredType;
+  PropertyAccessorElementForLink_Variable _getter;
+  PropertyAccessorElementForLink_Variable _setter;
 
   /**
    * The compilation unit in which this variable appears.
    */
   final CompilationUnitElementForLink compilationUnit;
 
   VariableElementForLink(this.unlinkedVariable, this.compilationUnit) {
     if (compilationUnit.isInBuildUnit && unlinkedVariable.constExpr != null) {
       _constNode = new ConstVariableNode(this);
       if (unlinkedVariable.type == null) {
         _typeInferenceNode = new TypeInferenceNode(this);
       }
     }
   }
 
-  @override
-  ConstructorElementForLink get asConstructor => null;
-
-  @override
-  ConstVariableNode get asConstVariable => _constNode;
-
-  @override
-  DartType get asStaticType => type;
-
-  @override
-  TypeInferenceNode get asTypeInferenceNode => _typeInferenceNode;
-
   /**
    * If the variable has an explicitly declared return type, return it.
    * Otherwise return `null`.
    */
   DartType get declaredType {
     if (unlinkedVariable.type == null) {
       return null;
     } else {
       return _declaredType ??= compilationUnit._resolveTypeRef(
           unlinkedVariable.type, _typeParameterContext);
     }
   }
 
   @override
+  PropertyAccessorElementForLink_Variable get getter =>
+      _getter ??= new PropertyAccessorElementForLink_Variable(this, false);
+
+  @override
   bool get hasImplicitType => unlinkedVariable.type == null;
 
   /**
    * Return the inferred type of the variable element.  Should only be called if
    * no type was explicitly declared.
    */
   DartType get inferredType {
     // We should only try to infer a type when none is explicitly declared.
     assert(unlinkedVariable.type == null);
     if (_inferredType == null) {
@@ skipping 41 matching lines @@
   @override
   String get name => unlinkedVariable.name;
 
   @override
   DartType get propagatedType {
     // TODO(paulberry): implement propagated types in the linker.
     return DynamicTypeImpl.instance;
   }
 
   @override
+  PropertyAccessorElementForLink_Variable get setter {
+    if (!isConst && !isFinal) {
+      return _setter ??=
+          new PropertyAccessorElementForLink_Variable(this, true);
+    } else {
+      return null;
+    }
+  }
+
+  @override
   DartType get type => declaredType ?? inferredType;
 
   @override
   void set type(DartType newType) {
     // TODO(paulberry): store inferred type.
   }
 
   /**
    * The context in which type parameters should be interpreted, or `null` if
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
-  DartType buildType(DartType getTypeArgument(int i),
-          List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeImpl.instance;
-
-  ReferenceableElementForLink getContainedName(String name) {
-    return new NonstaticMemberElementForLink(library, this, name);
-  }
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+  String toString() => '$enclosingElement.$name';
 }