Add more features to the summary linker.

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 105 matching lines @@
  * [UnlinkedUnit] objects.
  */
 typedef UnlinkedUnit GetUnitCallback(String absoluteUri);
 
 /**
  * Element representing a class or enum resynthesized from a summary
  * during linking.
  */
 abstract class ClassElementForLink
     implements ClassElement, ReferenceableElementForLink {
+  Map<String, ReferenceableElementForLink> _containedNames;
+
   @override
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
+  @override
+  ConstVariableNode get asConstVariable {
+    // TODO(paulberry): implement.
+    throw new UnimplementedError();
+  }
+
+  @override
+  List<ConstructorElementForLink> get constructors;
+
+  @override
+  List<FieldElementForLink> get fields;
+
   /**
    * Indicates whether this is the core class `Object`.
    */
   bool get isObject;
 
   @override
   String get name;
 
   @override
   ConstructorElementForLink get unnamedConstructor;
 
+  @override
+  ReferenceableElementForLink getContainedName(name) {
+    if (_containedNames == null) {
+      _containedNames = <String, ReferenceableElementForLink>{};
+      // TODO(paulberry): what's the correct way to handle name conflicts?
+      for (ConstructorElementForLink constructor in constructors) {
+        _containedNames[constructor.name] = constructor;
+      }
+      for (FieldElementForLink field in fields) {
+        // TODO(paulberry): do we need to handle nonstatic fields for
+        // consistent behavior with erroneous code?
+        if (field.isStatic) {
+          _containedNames[field.name] = field;
+        }
+      }
+      // TODO(paulberry): add methods.
+    }
+    return _containedNames.putIfAbsent(
+        name, () => UndefinedElementForLink.instance);
+  }
+
   /**
    * Perform type inference and cycle detection on this class and
    * store the resulting information in the enclosing elements.
    */
   void link(LinkedUnitBuilder linkedUnit);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a class resynthesized from a summary during
  * linking.
  */
 class ClassElementForLink_Class extends ClassElementForLink {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
-  List<FieldElementForLink> _fields;
+  List<FieldElementForLink_ClassField> _fields;
   InterfaceTypeForLink _supertype;
   InterfaceTypeForLink _type;
 
   ClassElementForLink_Class(this.enclosingElement, this._unlinkedClass);
 
   @override
   List<ConstructorElementForLink> get constructors {
     if (_constructors == null) {
       _constructors = <ConstructorElementForLink>[];
       for (UnlinkedExecutable unlinkedExecutable
           in _unlinkedClass.executables) {
         if (unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
           _constructors
               .add(new ConstructorElementForLink(this, unlinkedExecutable));
         }
       }
     }
     return _constructors;
   }
 
   @override
-  List<FieldElementForLink> get fields {
+  List<FieldElementForLink_ClassField> get fields {
     if (_fields == null) {
-      _fields = <FieldElementForLink>[];
+      _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
-        _fields.add(new FieldElementForLink(this, field));
+        _fields.add(new FieldElementForLink_ClassField(this, field));
       }
     }
     return _fields;
   }
 
   @override
   bool get isObject => _unlinkedClass.hasNoSupertype;
 
   @override
   String get name => _unlinkedClass.name;
@@ skipping 19 matching lines @@
       }
       _unnamedConstructorComputed = true;
     }
     return _unnamedConstructor;
   }
 
   @override
   DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
       List<int> implicitFunctionTypeIndices) {
     if (_unlinkedClass.typeParameters.length != 0) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
+      return new InterfaceTypeForLink(this);
     } else {
       return _type ??= new InterfaceTypeForLink(this);
     }
   }
 
   @override
-  ReferenceableElementForLink getContainedName(name) {
-    // TODO(paulberry): implement.
-    throw new UnimplementedError();
-  }
-
-  @override
   void link(LinkedUnitBuilder linkedUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
       constructorElement.link(linkedUnit);
     }
   }
 }
 
 /**
  * Element representing an enum resynthesized from a summary during
  * linking.
  */
 class ClassElementForLink_Enum extends ClassElementForLink {
   /**
    * The unlinked representation of the enum in the summary.
    */
   final UnlinkedEnum _unlinkedEnum;
 
+  InterfaceTypeForLink _type;
+  List<FieldElementForLink_EnumField> _fields;
+
   ClassElementForLink_Enum(this._unlinkedEnum);
 
   @override
+  List<ConstructorElementForLink> get constructors => const [];
+
+  @override
+  List<FieldElementForLink_EnumField> get fields {
+    if (_fields == null) {
+      _fields = <FieldElementForLink_EnumField>[];
+      _fields.add(new FieldElementForLink_EnumField(null));
+      for (UnlinkedEnumValue value in _unlinkedEnum.values) {
+        _fields.add(new FieldElementForLink_EnumField(value));
+      }
+    }
+    return _fields;
+  }
+
+  @override
   bool get isObject => false;
 
   @override
   String get name => _unlinkedEnum.name;
 
   @override
   ConstructorElementForLink get unnamedConstructor => null;
 
   @override
   DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
-      List<int> implicitFunctionTypeIndices) {
-    // TODO(paulberry): implement.
-    throw new UnimplementedError();
-  }
-
-  @override
-  ReferenceableElementForLink getContainedName(name) {
-    // TODO(paulberry): implement.
-    throw new UnimplementedError();
-  }
+          List<int> implicitFunctionTypeIndices) =>
+      _type ??= new InterfaceTypeForLink(this);
 
   @override
   void link(LinkedUnitBuilder linkedUnit) {}
 }
 
 /**
  * Element representing a compilation unit resynthesized from a
  * summary during linking.
  */
 abstract class CompilationUnitElementForLink implements CompilationUnitElement {
   /**
    * The unlinked representation of the compilation unit in the
    * summary.
    */
   final UnlinkedUnit _unlinkedUnit;
 
   /**
    * For each entry in [UnlinkedUnit.references], the element referred
    * to by the reference, or `null` if it hasn't been located yet.
    */
   final List<ReferenceableElementForLink> _references;
 
   List<ClassElementForLink> _types;
   Map<String, ReferenceableElementForLink> _containedNames;
+  List<TopLevelVariableElementForLink> _topLevelVariables;
 
   @override
   final LibraryElementForLink enclosingElement;
 
   CompilationUnitElementForLink(
       this.enclosingElement, UnlinkedUnit unlinkedUnit)
       : _references = new List<ReferenceableElementForLink>(
             unlinkedUnit.references.length),
         _unlinkedUnit = unlinkedUnit;
 
   @override
   bool get isInBuildUnit;
 
   @override
+  List<TopLevelVariableElementForLink> get topLevelVariables {
+    if (_topLevelVariables == null) {
+      _topLevelVariables = <TopLevelVariableElementForLink>[];
+      for (UnlinkedVariable unlinkedVariable in _unlinkedUnit.variables) {
+        _topLevelVariables
+            .add(new TopLevelVariableElementForLink(this, unlinkedVariable));
+      }
+    }
+    return _topLevelVariables;
+  }
+
+  @override
   List<ClassElementForLink> get types {
     if (_types == null) {
       _types = <ClassElementForLink>[];
       for (UnlinkedClass unlinkedClass in _unlinkedUnit.classes) {
         _types.add(new ClassElementForLink_Class(this, unlinkedClass));
       }
       for (UnlinkedEnum unlinkedEnum in _unlinkedUnit.enums) {
         _types.add(new ClassElementForLink_Enum(unlinkedEnum));
       }
     }
     return _types;
   }
 
   /**
    * The linked representation of the compilation unit in the summary.
    */
   LinkedUnit get _linkedUnit;
 
   /**
    * Search the unit for a top level element with the given [name].
    * If no name is found, return the singleton instance of
    * [UndefinedElementForLink].
    */
   ReferenceableElementForLink getContainedName(name) {
     if (_containedNames == null) {
       _containedNames = <String, ReferenceableElementForLink>{};
+      // TODO(paulberry): what's the correct way to handle name conflicts?
       for (ClassElementForLink type in types) {
-        // TODO(paulberry): what's the correct way to handle name conflicts?
         _containedNames[type.name] = type;
       }
-      // TODO(paulberry): fill in other top level entities.
+      for (TopLevelVariableElementForLink variable in topLevelVariables) {
+        _containedNames[variable.name] = variable;
+      }
+      // TODO(paulberry): fill in other top level entities (typedefs
+      // and executables).
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
    * Return the element referred to by the given [index] in
@@ skipping 172 matching lines @@
         if (superClass != null && !superClass.isObject) {
           ConstructorElementForLink unnamedConstructor =
               superClass.unnamedConstructor;
           safeAddDependency(unnamedConstructor?._constNode);
         }
       }
       for (FieldElementForLink field in enclosingClass.fields) {
         // Note: non-static const isn't allowed but we handle it anyway so
         // that we won't be confused by incorrect code.
         if ((field.isFinal || field.isConst) && !field.isStatic) {
-          safeAddDependency(field._constNode);
+          safeAddDependency(field.asConstVariable);
         }
       }
       for (ParameterElementForLink parameterElement
           in constructorElement.parameters) {
         safeAddDependency(parameterElement._constNode);
       }
     }
     return dependencies;
   }
 
@@ skipping 48 matching lines @@
       List<ConstNode> dependencies,
       UnlinkedConst unlinkedConst,
       CompilationUnitElementForLink compilationUnit) {
     if (unlinkedConst == null) {
       return;
     }
     int refPtr = 0;
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushReference:
-          // TODO(paulberry): implement.
-          throw new UnimplementedError();
+          EntityRef ref = unlinkedConst.references[refPtr++];
+          ConstVariableNode variable =
+              compilationUnit._resolveRef(ref.reference).asConstVariable;
+          if (variable != null) {
+            dependencies.add(variable);
+          }
+          break;
         case UnlinkedConstOperation.makeTypedList:
           refPtr++;
           break;
         case UnlinkedConstOperation.makeTypedMap:
           refPtr += 2;
           break;
         case UnlinkedConstOperation.invokeConstructor:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstructorElementForLink element =
               compilationUnit._resolveRef(ref.reference).asConstructor;
@@ skipping 29 matching lines @@
         parameterElement._unlinkedParam.defaultValue,
         parameterElement.compilationUnit);
     return dependencies;
   }
 }
 
 /**
  * Element representing a constructor resynthesized from a summary
  * during linking.
  */
-class ConstructorElementForLink implements ConstructorElement {
+class ConstructorElementForLink
+    implements ConstructorElement, ReferenceableElementForLink {
   /**
    * The unlinked representation of the constructor in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   /**
    * If this is a `const` constructor and the enclosing library is
    * part of the build unit being linked, the constructor's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstConstructorNode _constNode;
 
   @override
   final ClassElementForLink_Class enclosingElement;
 
   List<ParameterElementForLink> _parameters;
 
   ConstructorElementForLink(this.enclosingElement, this._unlinkedExecutable) {
     if (enclosingElement.enclosingElement.isInBuildUnit &&
         _unlinkedExecutable.constCycleSlot != 0) {
       _constNode = new ConstConstructorNode(this);
     }
   }
 
   @override
+  ConstructorElementForLink get asConstructor => this;
+
+  @override
+  ConstVariableNode get asConstVariable => null;
+
+  @override
   bool get isCycleFree {
     if (!_constNode.isEvaluated) {
       new ConstDependencyWalker().walk(_constNode);
     }
     return _constNode.isCycleFree;
   }
 
   @override
   String get name => _unlinkedExecutable.name;
 
   @override
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
       _parameters = <ParameterElementForLink>[];
       for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
         _parameters.add(new ParameterElementForLink(
             unlinkedParam, enclosingElement.enclosingElement));
       }
     }
     return _parameters;
   }
 
+  @override
+  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+          List<int> implicitFunctionTypeIndices) =>
+      DynamicTypeForLink.instance;
+
+  @override
+  ReferenceableElementForLink getContainedName(name) =>
+      UndefinedElementForLink.instance;
+
   /**
    * Perform const cycle detection on this constructor.
    */
   void link(LinkedUnitBuilder linkedUnit) {
     if (_constNode != null && !isCycleFree) {
       linkedUnit.constCycles.add(_unlinkedExecutable.constCycleSlot);
     }
   }
 
   @override
@@ skipping 178 matching lines @@
 class DynamicTypeForLink extends DartTypeForLink {
   /**
    * Singleton instance of the dynamic type.
    */
   static const DynamicTypeForLink instance = const DynamicTypeForLink._();
 
   const DynamicTypeForLink._();
 }
 
 /**
- * Element representing a field resynthesized from a summary during linking.
+ * Element representing a field resynthesized from a summary during
+ * linking.
  */
-class FieldElementForLink extends VariableElementForLink
-    implements FieldElement {
-  /**
-   * The unlinked representation of the field in the summary.
-   */
+abstract class FieldElementForLink
+    implements FieldElement, ReferenceableElementForLink {}
+
+/**
+ * Specialization of [FieldElementForLink] for class fields.
+ */
+class FieldElementForLink_ClassField extends VariableElementForLink
+    implements FieldElementForLink {
+  @override
   final ClassElementForLink_Class enclosingElement;
 
-  FieldElementForLink(ClassElementForLink_Class enclosingElement,
+  FieldElementForLink_ClassField(ClassElementForLink_Class enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : enclosingElement = enclosingElement,
         super(unlinkedVariable, enclosingElement.enclosingElement);
 
   @override
-  bool get isConst => unlinkedVariable.isConst;
+  bool get isStatic => unlinkedVariable.isStatic;
+}
+
+/**
+ * Specialization of [FieldElementForLink] for enum fields.
+ */
+class FieldElementForLink_EnumField extends FieldElementForLink
+    implements FieldElement {
+  /**
+   * The unlinked representation of the field in the summary, or `null` if this
+   * is an enum's `values` field.
+   */
+  final UnlinkedEnumValue unlinkedEnumValue;
+
+  FieldElementForLink_EnumField(this.unlinkedEnumValue);
 
   @override
-  bool get isFinal => unlinkedVariable.isFinal;
+  ConstructorElementForLink get asConstructor => null;
 
   @override
-  bool get isStatic => unlinkedVariable.isStatic;
+  ConstVariableNode get asConstVariable {
+    // Even though enum fields are constants, there is no need to include them
+    // in the const dependency graph because they can't participate in a
+    // circularity.
+    return null;
+  }
+
+  @override
+  bool get isStatic => true;
+
+  @override
+  String get name =>
+      unlinkedEnumValue == null ? 'values' : unlinkedEnumValue.name;
+
+  @override
+  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+          List<int> implicitFunctionTypeIndices) =>
+      DynamicTypeForLink.instance;
+
+  @override
+  ReferenceableElementForLink getContainedName(name) =>
+      UndefinedElementForLink.instance;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Representation of an interface type during linking.
+ *
+ * TODO(paulberry): add the ability to represent type arguments.
  */
 class InterfaceTypeForLink extends DartTypeForLink implements InterfaceType {
   @override
   final ClassElementForLink element;
 
   InterfaceTypeForLink(this.element);
 }
 
 /**
  * Element representing a library resynthesied from a summary during
@@ skipping 207 matching lines @@
  */
 abstract class ReferenceableElementForLink {
   /**
    * If this element can be used in a constructor invocation context,
    * return the associated constructor (which may be `this` or some
    * other element).  Otherwise return `null`.
    */
   ConstructorElementForLink get asConstructor;
 
   /**
+   * If this element can be used in a getter context to refer to a
+   * constant variable, return the [ConstVariableNode] for the
+   * constant value.  Otherwise return `null`.
+   */
+  ConstVariableNode get asConstVariable;
+
+  /**
    * Return the type indicated by this element when it is used in a
    * type instantiation context.  If this element can't legally be
    * instantiated as a type, return the dynamic type.
    */
   DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
       List<int> implicitFunctionTypeIndices);
 
   /**
    * If this element contains other named elements, return the
    * contained element having the given [name].  If this element can't
    * contain other named elements, or it doesn't contain an element
    * with the given name, return the singleton of
    * [UndefinedElementForLink].
    */
   ReferenceableElementForLink getContainedName(name);
 }
 
 /**
+ * Element representing a top level variable resynthesized from a
+ * summary during linking.
+ */
+class TopLevelVariableElementForLink extends VariableElementForLink
+    implements TopLevelVariableElement {
+  TopLevelVariableElementForLink(CompilationUnitElement enclosingElement,
+      UnlinkedVariable unlinkedVariable)
+      : super(unlinkedVariable, enclosingElement);
+
+  @override
+  bool get isStatic => true;
+}
+
+/**
  * Singleton element used for unresolved references.
  */
 class UndefinedElementForLink implements ReferenceableElementForLink {
   static const UndefinedElementForLink instance =
       const UndefinedElementForLink._();
 
   const UndefinedElementForLink._();
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
+  ConstVariableNode get asConstVariable => null;
+
+  @override
   DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeForLink.instance;
 
   @override
   ReferenceableElementForLink getContainedName(name) => this;
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
-class VariableElementForLink {
+class VariableElementForLink
+    implements VariableElement, ReferenceableElementForLink {
   /**
    * 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;
 
   /**
    * 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);
     }
   }
+
+  @override
+  ConstructorElementForLink get asConstructor => null;
+
+  @override
+  ConstVariableNode get asConstVariable => _constNode;
+
+  @override
+  bool get isConst => unlinkedVariable.isConst;
+
+  @override
+  bool get isFinal => unlinkedVariable.isFinal;
+
+  @override
+  bool get isStatic;
+
+  @override
+  String get name => unlinkedVariable.name;
+
+  @override
+  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+          List<int> implicitFunctionTypeIndices) =>
+      DynamicTypeForLink.instance;
+
+  ReferenceableElementForLink getContainedName(name) {
+    // TODO(paulberry): implement.
+    // TODO(paulberry): make sure that circularities involving
+    // ".length" are handled correctly.
+    return UndefinedElementForLink.instance;
+  }
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Representation of the void type during linking.
  */
 class VoidTypeForLink extends DartTypeForLink {
   static const VoidTypeForLink instance = const VoidTypeForLink._();
   const VoidTypeForLink._();
 }
 
@@ skipping 77 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }