AST-based type inference clean-up

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 112 matching lines @@
 
 /**
  * Create an [EntityRefBuilder] representing the given [type], in a form
  * suitable for inclusion in [LinkedUnit.types].  [compilationUnit] is the
  * compilation unit in which the type will be used.  If [slot] is provided, it
  * is stored in [EntityRefBuilder.slot].
  */
 EntityRefBuilder _createLinkedType(
     DartType type,
     CompilationUnitElementInBuildUnit compilationUnit,
-    TypeParameterContext typeParameterContext,
+    TypeParameterizedElementForLink typeParameterContext,
     {int slot}) {
   EntityRefBuilder result = new EntityRefBuilder(slot: slot);
   if (type is InterfaceType) {
     ClassElementForLink element = type.element;
     result.reference = compilationUnit.addReference(element);
     if (type.typeArguments.isNotEmpty) {
       result.typeArguments = type.typeArguments
           .map((DartType t) =>
               _createLinkedType(t, compilationUnit, typeParameterContext))
           .toList();
@@ skipping 195 matching lines @@
         }
       }
     }
     return _constructors;
   }
 
   @override
   String get displayName => _unlinkedClass.name;
 
   @override
-  TypeParameterContext get enclosingTypeParameterContext => null;
+  TypeParameterizedElementForLink get enclosingTypeParameterContext => null;
 
   @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;
@@ skipping 341 matching lines @@
   }
 
   /**
    * 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?
    */
   DartType _resolveTypeRef(
-      EntityRef type, TypeParameterContext typeParameterContext,
+      EntityRef type, TypeParameterizedElementForLink typeParameterContext,
       {bool defaultVoid: false}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
@@ skipping 147 matching lines @@
    */
   void _storeConstCycle(int slot) {
     _linkedUnit.constCycles.add(slot);
   }
 
   /**
    * Store the given [linkedType] in the given [slot] of the this compilation
    * unit's linked type list.
    */
   void _storeLinkedType(int slot, DartType linkedType,
-      TypeParameterContext typeParameterContext) {
+      TypeParameterizedElementForLink typeParameterContext) {
     if (slot != 0) {
       if (linkedType != null && !linkedType.isDynamic) {
         _linkedUnit.types.add(_createLinkedType(
             linkedType, this, typeParameterContext,
             slot: slot));
       }
     }
   }
 }
 
@@ skipping 443 matching lines @@
     strongConnect(startingPoint);
   }
 }
 
 /**
  * Base class for executable elements resynthesized from a summary during
  * linking.
  */
 abstract class ExecutableElementForLink extends Object
     with TypeParameterizedElementForLink
-    implements ExecutableElementImpl, TypeParameterContext {
+    implements ExecutableElementImpl {
   /**
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   List<TypeParameterElementForLink> _typeParameters;
   List<ParameterElementForLink> _parameters;
 
   /**
    * TODO(paulberry): this won't always be a class element.
    */
   @override
   final ClassElementForLink_Class enclosingElement;
 
   ExecutableElementForLink(this.enclosingElement, this._unlinkedExecutable);
 
   @override
-  TypeParameterContext get enclosingTypeParameterContext => enclosingElement;
+  TypeParameterizedElementForLink get enclosingTypeParameterContext =>
+      enclosingElement;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
@@ skipping 528 matching lines @@
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
    * The context in which type parameters should be interpreted.
    */
-  final TypeParameterContext _typeParameterContext;
+  final TypeParameterizedElementForLink _typeParameterContext;
 
   /**
    * If this parameter has a default value and the enclosing library
    * is part of the build unit being linked, the parameter's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstNode _constNode;
 
   /**
    * The compilation unit in which this parameter appears.
@@ skipping 181 matching lines @@
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElement enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
   bool get isStatic => true;
 }
 
 /**
- * Interface representing elements which can serve as the context within which
- * type parameter indices are interpreted.
- */
-abstract class TypeParameterContext {
-  /**
-   * Find out how many type parameters are in scope in this context.
-   */
-  int get typeParameterNestingLevel;
-
-  /**
-   * Convert the given [index] into a type parameter type.
-   */
-  TypeParameterType getTypeParameterType(int index);
-}
-
-/**
  * Element representing a type parameter resynthesized from a summary during
  * linking.
  */
 class TypeParameterElementForLink implements TypeParameterElement {
   /**
    * The unlinked representation of the type parameter in the summary.
    */
   final UnlinkedTypeParam _unlinkedTypeParam;
 
   /**
@@ skipping 13 matching lines @@
   TypeParameterTypeImpl get type => _type ??= new TypeParameterTypeImpl(this);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Mixin representing an element which can have type parameters.
  */
 abstract class TypeParameterizedElementForLink
-    implements TypeParameterizedElement, TypeParameterContext {
+    implements TypeParameterizedElement {
   List<TypeParameterType> _typeParameterTypes;
   List<TypeParameterElementForLink> _typeParameters;
   int _nestingLevel;
 
   /**
    * Get the type parameter context enclosing this one, if any.
    */
-  TypeParameterContext get enclosingTypeParameterContext;
+  TypeParameterizedElementForLink get enclosingTypeParameterContext;
 
-  @override
+  /**
+   * Find out how many type parameters are in scope in this context.
+   */
   int get typeParameterNestingLevel =>
       _nestingLevel ??= _unlinkedTypeParams.length +
           (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
 
   List<TypeParameterElementForLink> get typeParameters {
     if (_typeParameters == null) {
       int enclosingNestingLevel =
           enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
       int numTypeParameters = _unlinkedTypeParams.length;
       _typeParameters =
@@ skipping 18 matching lines @@
     }
     return _typeParameterTypes;
   }
 
   /**
    * Get the [UnlinkedTypeParam]s representing the type parameters declared by
    * this element.
    */
   List<UnlinkedTypeParam> get _unlinkedTypeParams;
 
-  @override
+  /**
+   * Convert the given [index] into a type parameter type.
+   */
   TypeParameterType getTypeParameterType(int index) {
     List<TypeParameterType> types = typeParameterTypes;
     if (index <= types.length) {
       return types[types.length - index];
     } else if (enclosingTypeParameterContext != null) {
       return enclosingTypeParameterContext
           .getTypeParameterType(index - types.length);
     } else {
       // If we get here, it means that a summary contained a type parameter index
       // that was out of range.
@@ skipping 339 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }