Use standard TypeImpl classes during linking.

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 42 matching lines @@
  *
  * - As much as possible, bookkeeping data is pointed to directly by
  *   the element objects, rather than being stored in maps.
  *
  * - Where possible, we favor method dispatch instead of "is" and "as"
  *   checks.  E.g. see [ReferenceableElementForLink.asConstructor].
  */
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/prelink.dart';
 
 /**
  * Link together the build unit consisting of [libraryUris], using
  * [getDependency] to fetch the [LinkedLibrary] objects from other
  * build units, and [getUnit] to fetch the [UnlinkedUnit] objects from
  * both this build unit and other build units.
@@ skipping 122 matching lines @@
    */
   final UnlinkedClass _unlinkedClass;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
   List<FieldElementForLink_ClassField> _fields;
-  InterfaceTypeForLink _supertype;
-  InterfaceTypeForLink _type;
-  List<TypeParameterTypeForLink> _typeParameterTypes;
+  InterfaceType _supertype;
+  InterfaceType _type;
+  List<TypeParameterType> _typeParameterTypes;
 
   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
+  String get displayName => _unlinkedClass.name;
+
+  @override
   List<FieldElementForLink_ClassField> get fields {
     if (_fields == null) {
       _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
         _fields.add(new FieldElementForLink_ClassField(this, field));
       }
     }
     return _fields;
   }
 
   @override
   bool get isObject => _unlinkedClass.hasNoSupertype;
 
   @override
   String get name => _unlinkedClass.name;
 
   @override
-  InterfaceTypeForLink get supertype {
+  InterfaceType get supertype {
     if (isObject) {
       return null;
     }
     return _supertype ??= _computeSupertype();
   }
 
   /**
-   * Get a list of [TypeParameterTypeForLink] objects corresponding to the
+   * Get a list of [TypeParameterType] objects corresponding to the
    * class's type parameters.
    */
-  List<TypeParameterTypeForLink> get typeParameterTypes {
+  List<TypeParameterType> get typeParameterTypes {
     if (_typeParameterTypes == null) {
       _typeParameterTypes = _unlinkedClass.typeParameters
-          .map((UnlinkedTypeParam _) => new TypeParameterTypeForLink())
+          .map((UnlinkedTypeParam p) =>
+              new TypeParameterTypeImpl(new TypeParameterElementForLink(p)))
           .toList();
     }
     return _typeParameterTypes;
   }
 
   @override
   ConstructorElementForLink get unnamedConstructor {
     if (!_unnamedConstructorComputed) {
       for (ConstructorElementForLink constructor in constructors) {
         if (constructor.name.isEmpty) {
           _unnamedConstructor = constructor;
           break;
         }
       }
       _unnamedConstructorComputed = true;
     }
     return _unnamedConstructor;
   }
 
   @override
-  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
-      List<int> implicitFunctionTypeIndices) {
-    if (_unlinkedClass.typeParameters.length != 0) {
-      return new InterfaceTypeForLink(this);
+  DartType buildType(
+      DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
+    int numTypeParameters = _unlinkedClass.typeParameters.length;
+    if (numTypeParameters != 0) {
+      return new InterfaceTypeImpl(this);
     } else {
-      return _type ??= new InterfaceTypeForLink(this);
+      List<DartType> typeArguments = new List<DartType>(numTypeParameters);
+      for (int i = 0; i < numTypeParameters; i++) {
+        typeArguments[i] = getTypeArgument(i);
+      }
+      return _type ??= new InterfaceTypeImpl.elementWithNameAndArgs(

[scheglov, 2016/03/30 19:54:15]

Maybe we should use explicit if != null to avoid creating type arguments every
time.

[Paul Berry, 2016/03/30 19:59:53]

Whoops, you're right.  Thanks for catching this.

Done.

+          this, name, typeArguments);
     }
   }
 
   @override
-  TypeParameterTypeForLink getTypeParameterType(int index) {
-    List<TypeParameterTypeForLink> types = typeParameterTypes;
+  TypeParameterType getTypeParameterType(int index) {
+    List<TypeParameterType> types = typeParameterTypes;
     return types[types.length - index];
   }
 
   @override
   void link(LinkedUnitBuilder linkedUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
       constructorElement.link(linkedUnit);
     }
   }
 
-  InterfaceTypeForLink _computeSupertype() {
+  InterfaceType _computeSupertype() {
     if (_unlinkedClass.supertype != null) {
-      DartTypeForLink supertype =
+      DartType supertype =
           enclosingElement._resolveTypeRef(_unlinkedClass.supertype, this);
-      if (supertype is InterfaceTypeForLink) {
+      if (supertype is InterfaceType) {
         return supertype;
       }
       // In the event that the supertype isn't an interface type (which may
       // happen in the event of erroneous code) just fall through and pretend
       // the supertype is `Object`.
     }
     return enclosingElement.enclosingElement._linker.objectType;
   }
 }
 
 /**
  * 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;
+  InterfaceType _type;
   List<FieldElementForLink_EnumField> _fields;
 
   ClassElementForLink_Enum(this._unlinkedEnum);
 
   @override
   List<ConstructorElementForLink> get constructors => const [];
 
   @override
+  String get displayName => _unlinkedEnum.name;
+
+  @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),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      _type ??= new InterfaceTypeForLink(this);
+      _type ??= new InterfaceTypeImpl(this);
 
   @override
   void link(LinkedUnitBuilder linkedUnit) {}
 }
 
 /**
  * Element representing a compilation unit resynthesized from a
  * summary during linking.
  */
 abstract class CompilationUnitElementForLink implements CompilationUnitElement {
@@ skipping 123 matching lines @@
     return _references[index];
   }
 
   /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
-  DartTypeForLink _resolveTypeRef(
+  DartType _resolveTypeRef(
       EntityRef type, TypeParameterContext typeParameterContext,
       {bool defaultVoid: false}) {
     if (type == null) {
       if (defaultVoid) {
-        return VoidTypeForLink.instance;
+        return VoidTypeImpl.instance;
       } else {
-        return DynamicTypeForLink.instance;
+        return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } else {
-      DartTypeForLink getTypeArgument(int i) {
+      DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return _resolveTypeRef(type.typeArguments[i], typeParameterContext);
         } else {
-          return DynamicTypeForLink.instance;
+          return DynamicTypeImpl.instance;
         }
       }
       ReferenceableElementForLink element = _resolveRef(type.reference);
       return element.buildType(
           getTypeArgument, type.implicitFunctionTypeIndices);
     }
   }
 }
 
 /**
@@ skipping 316 matching lines @@
       _parameters = <ParameterElementForLink>[];
       for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
         _parameters.add(new ParameterElementForLink(
             unlinkedParam, enclosingElement.enclosingElement));
       }
     }
     return _parameters;
   }
 
   @override
-  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeForLink.instance;
+      DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) =>
       UndefinedElementForLink.instance;
 
   /**
    * Perform const cycle detection on this constructor.
    */
   void link(LinkedUnitBuilder linkedUnit) {
     if (_constNode != null && !isCycleFree) {
@@ skipping 23 matching lines @@
     List<ConstNode> dependencies = <ConstNode>[];
     collectDependencies(
         dependencies,
         variableElement.unlinkedVariable.constExpr,
         variableElement.compilationUnit);
     return dependencies;
   }
 }
 
 /**
- * Representation of a type resynthesized from a summary during linking.
- */
-class DartTypeForLink implements DartType {
-  const DartTypeForLink();
-
-  @override
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
-/**
  * An instance of [DependencyWalker] contains the core algorithms for
  * walking a dependency graph and evaluating nodes in a safe order.
  */
 abstract class DependencyWalker<NodeType extends Node<NodeType>> {
   /**
    * Called by [walk] to evaluate a single non-cyclical node, after
    * all that node's dependencies have been evaluated.
    */
   void evaluate(NodeType v);
 
@@ skipping 106 matching lines @@
         }
       }
     }
 
     // Kick off the algorithm starting with the starting point.
     strongConnect(startingPoint);
   }
 }
 
 /**
- * Representation of the dynamic type during linking.
- */
-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.
  */
 abstract class FieldElementForLink
     implements FieldElement, ReferenceableElementForLink {}
 
 /**
  * Specialization of [FieldElementForLink] for class fields.
  */
 class FieldElementForLink_ClassField extends VariableElementForLink
@@ skipping 35 matching lines @@
   }
 
   @override
   bool get isStatic => true;
 
   @override
   String get name =>
       unlinkedEnumValue == null ? 'values' : unlinkedEnumValue.name;
 
   @override
-  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeForLink.instance;
+      DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String 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
  * linking.  The type parameter, [UnitElement], represents the type
  * that will be used for the compilation unit elements.
  */
 abstract class LibraryElementForLink<
         UnitElement extends CompilationUnitElementForLink>
     implements LibraryElement {
   /**
    * Pointer back to the linker.
    */
@@ skipping 185 matching lines @@
 
   NonstaticMemberElementForLink(this._constNode);
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => _constNode;
 
   @override
-  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeForLink.instance;
+      DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) => this;
 }
 
 /**
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
 class ParameterElementForLink implements ParameterElement {
@@ skipping 41 matching lines @@
    * 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);
+  DartType buildType(
+      DartType 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(String name);
 }
@@ skipping 13 matching lines @@
 }
 
 /**
  * Interface representing elements which can serve as the context within which
  * type parameter indices are interpreted.
  */
 abstract class TypeParameterContext {
   /**
    * Convert the given [index] into a type parameter type.
    */
-  TypeParameterTypeForLink getTypeParameterType(int index);
+  TypeParameterType getTypeParameterType(int index);
 }
 
 /**
- * Representation of a type based on a type parameter during linking.
- *
- * TODO(paulberry): add more functionality as needed.
+ * Element representing a type parameter resynthesized from a summary during
+ * linking.
  */
-class TypeParameterTypeForLink extends DartTypeForLink
-    implements TypeParameterType {}
+class TypeParameterElementForLink implements TypeParameterElement {
+  /**
+   * The unlinked representation of the type parameter in the summary.
+   */
+  final UnlinkedTypeParam _unlinkedTypeParam;
+
+  TypeParameterElementForLink(this._unlinkedTypeParam);
+
+  @override
+  String get name => _unlinkedTypeParam.name;
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
 
 /**
  * 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),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeForLink.instance;
+      DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) => this;
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class VariableElementForLink
@@ skipping 33 matching lines @@
   @override
   bool get isFinal => unlinkedVariable.isFinal;
 
   @override
   bool get isStatic;
 
   @override
   String get name => unlinkedVariable.name;
 
   @override
-  DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
+  DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
-      DynamicTypeForLink.instance;
+      DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_constNode);
   }
 
   @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._();
-}
-
-/**
  * Instances of [_Linker] contain the necessary information to link
  * together a single build unit.
  */
 class _Linker {
   /**
    * Callback to ask the client for a [LinkedLibrary] for a
    * dependency.
    */
   final GetDependencyCallback getDependency;
 
@@ skipping 10 matching lines @@
   final Map<Uri, LibraryElementForLink> _libraries =
       <Uri, LibraryElementForLink>{};
 
   /**
    * List of library elements for the libraries in the build unit
    * being linked.
    */
   final List<LibraryElementInBuildUnit> _librariesInBuildUnit =
       <LibraryElementInBuildUnit>[];
 
-  InterfaceTypeForLink _objectType;
+  InterfaceType _objectType;
   LibraryElementForLink _coreLibrary;
 
   _Linker(Map<String, LinkedLibraryBuilder> linkedLibraries, this.getDependency,
       this.getUnit) {
     // Create elements for the libraries to be linked.  The rest of
     // the element model will be created on demand.
     linkedLibraries
         .forEach((String absoluteUri, LinkedLibraryBuilder linkedLibrary) {
       Uri uri = Uri.parse(absoluteUri);
       _librariesInBuildUnit.add(_libraries[uri] =
           new LibraryElementInBuildUnit(this, uri, linkedLibrary));
     });
   }
 
   /**
    * Get the library element for `dart:core`.
    */
   LibraryElementForLink get coreLibrary =>
       _coreLibrary ??= getLibrary(Uri.parse('dart:core'));
 
   /**
    * Get the `InterfaceType` for the type `Object`.
    */
-  InterfaceTypeForLink get objectType => _objectType ??= coreLibrary
+  InterfaceType get objectType => _objectType ??= coreLibrary
       .getContainedName('Object')
-      .buildType((int i) => DynamicTypeForLink.instance, const []);
+      .buildType((int i) => DynamicTypeImpl.instance, const []);
 
   /**
    * Get the library element for the library having the given [uri].
    */
   LibraryElementForLink getLibrary(Uri uri) => _libraries.putIfAbsent(
       uri,
       () => new LibraryElementInDependency(
           this, uri, getDependency(uri.toString())));
 
   /**
    * Perform type inference and const cycle detection on all libraries
    * in the build unit being linked.
    */
   void link() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.link();
     }
     // TODO(paulberry): set dependencies.
   }
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }