Move TypeParameterizedElementForLink and TypeParameterElementForLink to impl.

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/ast/token.dart';
@@ skipping 530 matching lines @@
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
     }
   }
 
   /**
    * Convert the next reference to the [DartType] and return the AST
    * corresponding to this type.
    */
   TypeName _newTypeName() {
     EntityRef typeRef = uc.references[refPtr++];
-    DartType type = resynthesizer.buildType(typeRef);
+    DartType type = resynthesizer.buildType(
+        typeRef, resynthesizer._currentTypeParameterizedElement);
     return _buildTypeAst(type);
   }
 
   Expression _pop() => stack.removeLast();
 
   void _push(Expression expr) {
     stack.add(expr);
   }
 
   void _pushBinary(TokenType operator) {
@@ skipping 132 matching lines @@
   List<Expression> _removeTopItems(int count) {
     int start = stack.length - count;
     int end = stack.length;
     List<Expression> items = stack.getRange(start, end).toList();
     stack.removeRange(start, end);
     return items;
   }
 }
 
 /**
+ * Temporary [TypeParameterizedElementMixin] implementation.
+ *
+ * TODO(scheglov) remove after moving resynthesize logic to Impl.
+ */
+class _CurrentTypeParameterizedElement
+    implements TypeParameterizedElementMixin {
+  final _UnitResynthesizer unitResynthesizer;
+
+  _CurrentTypeParameterizedElement(this.unitResynthesizer);
+
+  @override
+  TypeParameterType getTypeParameterType(int index) {
+    return unitResynthesizer.getTypeParameterFromScope(index);
+  }
+
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * A class element that has been resynthesized from a summary.  The actual
  * element won't be constructed until it is requested.  But properties
  * [context],  [displayName], [enclosingElement] and [name] can be used without
  * creating the actual element.  This allows to put these elements into
  * namespaces without creating actual elements until they are really needed.
  */
 class _DeferredClassElement extends ClassElementHandle {
   final _UnitResynthesizer unitResynthesizer;
   final CompilationUnitElement unitElement;
   final UnlinkedClass serializedClass;
@@ skipping 810 matching lines @@
     if (numTypeArguments != 0) {
       typeArguments = <DartType>[];
       for (int i = 0; i < numTypeArguments; i++) {
         typeArguments.add(getTypeArgument(i));
       }
     }
     return typeArguments;
   }
 }
 
+class _ResynthesizerContext implements ResynthesizerContext {
+  final _UnitResynthesizer _unitResynthesizer;
+
+  _ResynthesizerContext(this._unitResynthesizer);
+
+  @override
+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
+      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
+    return _unitResynthesizer.buildType(type, typeParameterContext,
+        defaultVoid: defaultVoid,
+        instantiateToBoundsAllowed: instantiateToBoundsAllowed);
+  }
+}
+
 /**
  * An instance of [_UnitResynthesizer] is responsible for resynthesizing the
  * elements in a single unit from that unit's summary.
  */
 class _UnitResynthesizer {
   /**
    * The [_LibraryResynthesizer] which is being used to obtain summaries.
    */
   final _LibraryResynthesizer libraryResynthesizer;
 
@@ skipping 74 matching lines @@
   int numLinkedReferences;
   int numUnlinkedReferences;
 
   /**
    * List of [_ReferenceInfo] objects describing the references in the current
    * compilation unit.  This list is works as a lazily filled cache, use
    * [getReferenceInfo] to get the [_ReferenceInfo] for an index.
    */
   List<_ReferenceInfo> referenceInfos;
 
+  /**
+   * The [ResynthesizerContext] for this resynthesize session.
+   */
+  ResynthesizerContext _resynthesizerContext;
+
+  /**
+   * TODO(scheglov) clean up after moving resynthesize logic to Impl.
+   */
+  TypeParameterizedElementMixin _currentTypeParameterizedElement;
+
   _UnitResynthesizer(this.libraryResynthesizer, this.unlinkedUnit,
       this.linkedUnit, this.unit) {
     for (EntityRef t in linkedUnit.types) {
       linkedTypeMap[t.slot] = t;
     }
     constCycles = linkedUnit.constCycles.toSet();
     numLinkedReferences = linkedUnit.references.length;
     numUnlinkedReferences = unlinkedUnit.references.length;
     referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
+    _resynthesizerContext = new _ResynthesizerContext(this);
+    _currentTypeParameterizedElement =
+        new _CurrentTypeParameterizedElement(this);
   }
 
   SummaryResynthesizer get summaryResynthesizer =>
       libraryResynthesizer.summaryResynthesizer;
 
   TypeProvider get typeProvider => summaryResynthesizer.typeProvider;
 
   /**
    * Build the annotations for the given [element].
    */
@@ skipping 99 matching lines @@
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Resynthesize a [ClassElementImpl].  If [handle] is not `null`, then
    * executables are not resynthesized, and [InterfaceTypeImpl] is created
    * around the [handle], so that executables are resynthesized lazily.
    */
   ClassElementImpl buildClassImpl(
       UnlinkedClass serializedClass, ClassElementHandle handle) {
-    ClassElementImpl classElement =
-        new ClassElementImpl.forSerialized(serializedClass);
+    ClassElementImpl classElement = new ClassElementImpl.forSerialized(
+        _resynthesizerContext, serializedClass);
     classElement.hasBeenInferred = summaryResynthesizer.strongMode;
-    classElement.typeParameters =
-        buildTypeParameters(serializedClass.typeParameters);
     classElement.mixinApplication = serializedClass.isMixinApplication;
     InterfaceTypeImpl correspondingType =
         new InterfaceTypeImpl(handle ?? classElement);
     if (serializedClass.supertype != null) {
-      classElement.supertype = buildType(serializedClass.supertype);
+      classElement.supertype =
+          buildType(serializedClass.supertype, classElement);
     } else if (!libraryResynthesizer.isCoreLibrary) {
       classElement.supertype = typeProvider.objectType;
     }
-    classElement.interfaces =
-        serializedClass.interfaces.map(buildType).toList();
-    classElement.mixins = serializedClass.mixins.map(buildType).toList();
-    correspondingType.typeArguments = getCurrentTypeArguments();
+    classElement.interfaces = serializedClass.interfaces
+        .map((EntityRef t) => buildType(t, classElement))
+        .toList();
+    classElement.mixins = serializedClass.mixins
+        .map((EntityRef t) => buildType(t, classElement))
+        .toList();
+    // TODO(scheglov) move to ClassElementImpl
+    correspondingType.typeArguments = classElement.typeParameterTypes;
     classElement.type = correspondingType;
     buildAnnotations(classElement, serializedClass.annotations);
-    currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
     // TODO(scheglov) Somehow Observatory shows too much time spent here
     // during DDC run on the large codebase. I would expect only Object here.
     if (handle == null) {
       buildClassExecutables(classElement, serializedClass);
     }
     fields = null;
     constructors = null;
     return classElement;
   }
@@ skipping 26 matching lines @@
   }
 
   /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
    * [classType] is the type of the class for which this element is a
    * constructor.
    */
   void buildConstructor(UnlinkedExecutable serializedExecutable,
       ElementHolder holder, InterfaceType classType) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
-    currentConstructor =
-        new ConstructorElementImpl.forSerialized(serializedExecutable);
+    currentConstructor = new ConstructorElementImpl.forSerialized(
+        _resynthesizerContext, serializedExecutable);
     currentConstructor.isCycleFree = serializedExecutable.isConst &&
         !constCycles.contains(serializedExecutable.constCycleSlot);
     if (serializedExecutable.name.isEmpty) {
       currentConstructor.nameEnd =
           serializedExecutable.nameOffset + classType.name.length;
     } else {
       currentConstructor.nameEnd = serializedExecutable.nameEnd;
       currentConstructor.periodOffset = serializedExecutable.periodOffset;
     }
     constructors[serializedExecutable.name] = currentConstructor;
@@ skipping 150 matching lines @@
     UnlinkedExecutableKind kind = serializedExecutable.kind;
     String name = serializedExecutable.name;
     if (kind == UnlinkedExecutableKind.setter) {
       assert(name.endsWith('='));
       name = name.substring(0, name.length - 1);
     }
     switch (kind) {
       case UnlinkedExecutableKind.functionOrMethod:
         if (isTopLevel) {
           FunctionElementImpl executableElement =
-              new FunctionElementImpl.forSerialized(serializedExecutable);
+              new FunctionElementImpl.forSerialized(
+                  _resynthesizerContext, serializedExecutable);
           buildExecutableCommonParts(executableElement, serializedExecutable);
           holder.addFunction(executableElement);
         } else {
           MethodElementImpl executableElement =
-              new MethodElementImpl.forSerialized(serializedExecutable);
+              new MethodElementImpl.forSerialized(
+                  _resynthesizerContext, serializedExecutable);
           buildExecutableCommonParts(executableElement, serializedExecutable);
           holder.addMethod(executableElement);
         }
         break;
       case UnlinkedExecutableKind.getter:
       case UnlinkedExecutableKind.setter:
         PropertyAccessorElementImpl executableElement =
-            new PropertyAccessorElementImpl.forSerialized(serializedExecutable);
+            new PropertyAccessorElementImpl.forSerialized(
+                _resynthesizerContext, serializedExecutable);
         buildExecutableCommonParts(executableElement, serializedExecutable);
         DartType type;
         if (kind == UnlinkedExecutableKind.getter) {
           type = executableElement.returnType;
         } else {
           type = executableElement.parameters[0].type;
         }
         holder.addAccessor(executableElement);
         PropertyInducingElementImpl implicitVariable;
         if (isTopLevel) {
@@ skipping 27 matching lines @@
     executableElement.typeParameters =
         buildTypeParameters(serializedExecutable.typeParameters);
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.kind == UnlinkedExecutableKind.constructor) {
       // Caller handles setting the return type.
       assert(serializedExecutable.returnType == null);
     } else {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
-      executableElement.returnType =
-          buildLinkedType(serializedExecutable.inferredReturnTypeSlot) ??
-              buildType(serializedExecutable.returnType,
-                  defaultVoid: isSetter && summaryResynthesizer.strongMode);
+      executableElement.returnType = buildLinkedType(
+              serializedExecutable.inferredReturnTypeSlot,
+              _currentTypeParameterizedElement) ??
+          buildType(
+              serializedExecutable.returnType, _currentTypeParameterizedElement,
+              defaultVoid: isSetter && summaryResynthesizer.strongMode);
       executableElement.hasImplicitReturnType =
           serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, getCurrentTypeArguments(skipLevels: 1), false);
     buildAnnotations(executableElement, serializedExecutable.annotations);
     executableElement.functions =
         serializedExecutable.localFunctions.map(buildLocalFunction).toList();
     executableElement.labels =
         serializedExecutable.localLabels.map(buildLocalLabel).toList();
@@ skipping 79 matching lines @@
       // TODO(paulberry): what if the getter and setter have a type mismatch?
       variable.final2 = false;
       return variable;
     }
   }
 
   /**
    * Build the appropriate [DartType] object corresponding to a slot id in the
    * [LinkedUnit.types] table.
    */
-  DartType buildLinkedType(int slot) {
+  DartType buildLinkedType(
+      int slot, TypeParameterizedElementMixin typeParameterContext) {
     if (slot == 0) {
       // A slot id of 0 means there is no [DartType] object to build.
       return null;
     }
     EntityRef type = linkedTypeMap[slot];
     if (type == null) {
       // A missing entry in [LinkedUnit.types] means there is no [DartType]
       // stored in this slot.
       return null;
     }
-    return buildType(type);
+    return buildType(type, typeParameterContext);
   }
 
   /**
    * Resynthesize a local [FunctionElement].
    */
   FunctionElementImpl buildLocalFunction(
       UnlinkedExecutable serializedExecutable) {
-    FunctionElementImpl element =
-        new FunctionElementImpl.forSerialized(serializedExecutable);
+    FunctionElementImpl element = new FunctionElementImpl.forSerialized(
+        _resynthesizerContext, serializedExecutable);
     if (serializedExecutable.visibleOffset != 0) {
       element.setVisibleRange(serializedExecutable.visibleOffset,
           serializedExecutable.visibleLength);
     }
     buildExecutableCommonParts(element, serializedExecutable);
     return element;
   }
 
   /**
    * Resynthesize a [LabelElement].
@@ skipping 83 matching lines @@
       List<ParameterElement> subParameters = serializedParameter.parameters
           .map((UnlinkedParam p) => buildParameter(p, synthetic: synthetic))
           .toList();
       if (synthetic) {
         parameterTypeElement.parameters = subParameters;
       } else {
         parameterElement.parameters = subParameters;
         parameterTypeElement.shareParameters(subParameters);
         parameterTypeElement.enclosingElement = parameterElement;
       }
-      parameterTypeElement.returnType = buildType(serializedParameter.type);
+      parameterTypeElement.returnType =
+          buildType(serializedParameter.type, _currentTypeParameterizedElement);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, getCurrentTypeArguments(), false);
       parameterTypeElement.type = parameterElement.type;
     } else {
       if (serializedParameter.isInitializingFormal &&
           serializedParameter.type == null) {
         // The type is inherited from the matching field.
         parameterElement.type =
             fields[serializedParameter.name]?.type ?? DynamicTypeImpl.instance;
       } else {
-        parameterElement.type =
-            buildLinkedType(serializedParameter.inferredTypeSlot) ??
-                buildType(serializedParameter.type);
+        parameterElement.type = buildLinkedType(
+                serializedParameter.inferredTypeSlot,
+                _currentTypeParameterizedElement) ??
+            buildType(
+                serializedParameter.type, _currentTypeParameterizedElement);
       }
       parameterElement.hasImplicitType = serializedParameter.type == null;
     }
     buildVariableInitializer(parameterElement, serializedParameter.initializer);
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
       case UnlinkedParamKind.required:
         parameterElement.parameterKind = ParameterKind.REQUIRED;
         break;
     }
     if (serializedParameter.visibleOffset != 0) {
       parameterElement.setVisibleRange(
           serializedParameter.visibleOffset, serializedParameter.visibleLength);
     }
     return parameterElement;
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildPropertyIntroducingElementCommonParts(
       PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     buildVariableCommonParts(element, serializedVariable);
-    element.propagatedType =
-        buildLinkedType(serializedVariable.propagatedTypeSlot);
+    element.propagatedType = buildLinkedType(
+        serializedVariable.propagatedTypeSlot,
+        _currentTypeParameterizedElement);
   }
 
   /**
    * Build a [DartType] object based on a [EntityRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
-  DartType buildType(EntityRef type,
+  DartType buildType(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
-      return getTypeParameterFromScope(type.paramReference);
+      return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       FunctionElementImpl element = new FunctionElementImpl('', -1);
       element.synthetic = true;
       element.parameters = type.syntheticParams
           .map((UnlinkedParam param) => buildParameter(param, synthetic: true))
           .toList();
-      element.returnType = buildType(type.syntheticReturnType);
+      element.returnType =
+          buildType(type.syntheticReturnType, typeParameterContext);
       FunctionTypeImpl result = new FunctionTypeImpl.elementWithNameAndArgs(
           element, null, null, false);
       element.type = result;
       return result;
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
-          return buildType(type.typeArguments[i]);
+          return buildType(type.typeArguments[i], typeParameterContext);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
       _ReferenceInfo referenceInfo = getReferenceInfo(type.reference);
       return referenceInfo.buildType(
           instantiateToBoundsAllowed,
           type.typeArguments.length,
           getTypeArgument,
           type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     FunctionTypeAliasElementImpl functionTypeAliasElement =
-        new FunctionTypeAliasElementImpl.forSerialized(serializedTypedef);
+        new FunctionTypeAliasElementImpl.forSerialized(
+            _resynthesizerContext, serializedTypedef);
     functionTypeAliasElement.typeParameters =
         buildTypeParameters(serializedTypedef.typeParameters);
     functionTypeAliasElement.parameters =
         serializedTypedef.parameters.map(buildParameter).toList();
-    functionTypeAliasElement.returnType =
-        buildType(serializedTypedef.returnType);
+    functionTypeAliasElement.returnType = buildType(
+        serializedTypedef.returnType, _currentTypeParameterizedElement);
     functionTypeAliasElement.type =
         new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
     buildAnnotations(functionTypeAliasElement, serializedTypedef.annotations);
     unitHolder.addTypeAlias(functionTypeAliasElement);
     currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
@@ skipping 71 matching lines @@
       buildImplicitAccessors(element, holder);
       fields[element.name] = element;
     }
   }
 
   /**
    * Handle the parts that are common to variables.
    */
   void buildVariableCommonParts(
       VariableElementImpl element, UnlinkedVariable serializedVariable) {
-    element.type = buildLinkedType(serializedVariable.inferredTypeSlot) ??
-        buildType(serializedVariable.type);
+    element.type = buildLinkedType(serializedVariable.inferredTypeSlot,
+            _currentTypeParameterizedElement) ??
+        buildType(serializedVariable.type, _currentTypeParameterizedElement);
     element.const3 = serializedVariable.isConst;
     element.final2 = serializedVariable.isFinal;
     element.hasImplicitType = serializedVariable.type == null;
     buildVariableInitializer(element, serializedVariable.initializer);
     buildDocumentation(element, serializedVariable.documentationComment);
     buildAnnotations(element, serializedVariable.annotations);
     buildCodeRange(element, serializedVariable.codeRange);
   }
 
   /**
@@ skipping 10 matching lines @@
     initializerElement.synthetic = true;
     variable.initializer = initializerElement;
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
-      typeParameterElement.bound = buildType(serializedTypeParameter.bound,
+      typeParameterElement.bound = buildType(
+          serializedTypeParameter.bound, _currentTypeParameterizedElement,
           instantiateToBoundsAllowed: false);
     }
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters],
    * skipping the innermost [skipLevels] nesting levels.
    *
    * Type parameters are listed in nesting order from innermost to outermost,
    * and then in declaration order.  So for instance if we are resynthesizing a
@@ skipping 218 matching lines @@
   }
 
   /**
    * Return the defining type for a [ConstructorElement] by applying
    * [typeArgumentRefs] to the given linked [info].
    */
   InterfaceType _createConstructorDefiningType(
       _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {
     bool isClass = info.element is ClassElement;
     _ReferenceInfo classInfo = isClass ? info : info.enclosing;
-    List<DartType> typeArguments = typeArgumentRefs.map(buildType).toList();
+    List<DartType> typeArguments = typeArgumentRefs
+        .map((t) => buildType(t, _currentTypeParameterizedElement))
+        .toList();
     return classInfo.buildType(true, typeArguments.length, (i) {
       if (i < typeArguments.length) {
         return typeArguments[i];
       } else {
         return DynamicTypeImpl.instance;
       }
     }, const <int>[]);
   }
 
   /**
@@ skipping 23 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }