Store FunctionType(s) of local functions by value.

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 203 matching lines @@
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
     if (element is FunctionTypeAliasElementForLink) {
       result.reference = compilationUnit.addReference(element);
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
-    if (element is FunctionElement && element.enclosingElement == null) {
-      // Element is a synthetic function element that was generated on the fly
-      // to represent a type that has no associated source code location.
-      result.syntheticReturnType = _createLinkedType(
-          element.returnType, compilationUnit, typeParameterContext);
-      result.entityKind =
-          element.returnType?.element is GenericFunctionTypeElement
-              ? EntityRefKind.genericFunctionType
-              : EntityRefKind.syntheticFunction;
+    if (element is FunctionElementImpl) {
+      // Element is a local function, or a synthetic function element that was
+      // generated on the fly to represent a type that has no associated source
+      // code location. Store it as value.
+      result.syntheticReturnType =
+          _createLinkedType(element.returnType, compilationUnit, element);
+      result.entityKind = EntityRefKind.syntheticFunction;
       result.syntheticParams = element.parameters
-          .map((ParameterElement param) => _serializeSyntheticParam(
-              param, compilationUnit, typeParameterContext))
+          .map((ParameterElement param) =>
+              _serializeSyntheticParam(param, compilationUnit, element))
+          .toList();
+      result.typeParameters = element.typeParameters
+          .map((TypeParameterElement e) =>
+              _serializeSyntheticTypeParameter(e, compilationUnit, element))
           .toList();
       return result;
     }
-    if (element is FunctionElement) {
-      // Element is a local function inside another executable.
-      result.reference = compilationUnit.addReference(element);
-      // TODO(paulberry): do I need to store type arguments?
-      return result;
-    }
     if (element is GenericFunctionTypeElement) {
       result.entityKind = EntityRefKind.genericFunctionType;
       result.syntheticReturnType = _createLinkedType(
           type.returnType, compilationUnit, typeParameterContext);
       result.syntheticParams = type.parameters
           .map((ParameterElement param) => _serializeSyntheticParam(
               param, compilationUnit, typeParameterContext))
           .toList();
       return result;
     }
@@ skipping 45 matching lines @@
               parameter, compilationUnit, typeParameterContext))
           .toList();
     } else {
       b.type = _createLinkedType(type, compilationUnit, typeParameterContext);
     }
   }
   return b;
 }
 
 /**
+ * Create an [UnlinkedTypeParamBuilder] representing the given [typeParameter],
+ * which should be a type parameter of a synthetic function type (e.g. one
+ * produced during type inference as a result of computing the least upper
+ * bound of two function types).
+ */
+UnlinkedTypeParamBuilder _serializeSyntheticTypeParameter(
+    TypeParameterElement typeParameter,
+    CompilationUnitElementInBuildUnit compilationUnit,
+    TypeParameterizedElementMixin typeParameterContext) {
+  TypeParameterElementImpl impl = typeParameter as TypeParameterElementImpl;
+  EntityRefBuilder boundBuilder = typeParameter.bound != null
+      ? _createLinkedType(
+          typeParameter.bound, compilationUnit, typeParameterContext)
+      : null;
+  CodeRangeBuilder codeRangeBuilder =
+      new CodeRangeBuilder(offset: impl.codeOffset, length: impl.codeLength);
+  return new UnlinkedTypeParamBuilder(
+      name: typeParameter.name,
+      nameOffset: typeParameter.nameOffset,
+      bound: boundBuilder,
+      codeRange: codeRangeBuilder);
+}
+
+/**
  * Store the given [typeArguments] in [encodedType], using [compilationUnit] and
  * [typeParameterContext] to serialize them.
  */
 void _storeTypeArguments(
     List<DartType> typeArguments,
     EntityRefBuilder encodedType,
     CompilationUnitElementInBuildUnit compilationUnit,
     TypeParameterizedElementMixin typeParameterContext) {
   int count = typeArguments.length;
   List<EntityRefBuilder> encodedTypeArguments =
@@ skipping 729 matching lines @@
       LinkedReference linkedReference = _linkedUnit.references[index];
       String name = unlinkedReference == null
           ? linkedReference.name
           : unlinkedReference.name;
       int containingReference = unlinkedReference == null
           ? linkedReference.containingReference
           : unlinkedReference.prefixReference;
       if (containingReference != 0 &&
           _linkedUnit.references[containingReference].kind !=
               ReferenceKind.prefix) {
-        if (linkedReference.kind == ReferenceKind.function) {
-          // Local function
-          _references[index] = resolveRef(containingReference)
-                  .getLocalFunction(linkedReference.localIndex) ??
-              UndefinedElementForLink.instance;
-        } else {
-          _references[index] =
-              resolveRef(containingReference).getContainedName(name);
-        }
+        _references[index] =
+            resolveRef(containingReference).getContainedName(name);
       } else if (linkedReference.dependency == 0) {
         if (linkedReference.kind == ReferenceKind.unresolved) {
           _references[index] = UndefinedElementForLink.instance;
         } else if (name == 'void') {
           _references[index] = enclosingElement._linker.voidElement;
         } else if (name == '*bottom*') {
           _references[index] = enclosingElement._linker.bottomElement;
         } else if (name == 'dynamic') {
           _references[index] = enclosingElement._linker.dynamicElement;
         } else {
@@ skipping 19 matching lines @@
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (entity.paramReference != 0) {
       return context.typeParameterContext
           .getTypeParameterType(entity.paramReference);
     } else if (entity.entityKind == EntityRefKind.genericFunctionType) {
       return new GenericFunctionTypeElementForLink(this, context, entity).type;
     } else if (entity.syntheticReturnType != null) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
+      FunctionElementImpl element =
+          new FunctionElementForLink_Synthetic(this, context, entity);
+      return element.type;
     } else if (entity.implicitFunctionTypeIndices.isNotEmpty) {
       DartType type = resolveRef(entity.reference).asStaticType;
       for (int index in entity.implicitFunctionTypeIndices) {
         type = (type as FunctionType).parameters[index].type;
       }
       return type;
     } else {
       ReferenceableElementForLink element = resolveRef(entity.reference);
 
       DartType getTypeArgument(int i) {
@@ skipping 46 matching lines @@
    * If this compilation unit already has a reference in its references table
    * matching [dependency], [name], [numTypeParameters], [unitNum],
    * [containingReference], and [kind], return its index.  Otherwise add a new reference to
    * the table and return its index.
    */
   int addRawReference(String name,
       {int dependency: 0,
       int numTypeParameters: 0,
       int unitNum: 0,
       int containingReference: 0,
-      int localIndex: 0,
       ReferenceKind kind: ReferenceKind.classOrEnum}) {
     List<LinkedReferenceBuilder> linkedReferences = _linkedUnit.references;
     List<UnlinkedReference> unlinkedReferences = _unlinkedUnit.references;
     for (int i = 0; i < linkedReferences.length; i++) {
       LinkedReferenceBuilder linkedReference = linkedReferences[i];
       int candidateContainingReference = i < unlinkedReferences.length
           ? unlinkedReferences[i].prefixReference
           : linkedReference.containingReference;
       if (candidateContainingReference != 0 &&
           linkedReferences[candidateContainingReference].kind ==
               ReferenceKind.prefix) {
         // We don't need to match containing references when they are prefixes,
         // since the relevant information is in linkedReference.dependency.
         candidateContainingReference = 0;
       }
       if (linkedReference.dependency == dependency &&
           (i < unlinkedReferences.length
                   ? unlinkedReferences[i].name
                   : linkedReference.name) ==
               name &&
           linkedReference.numTypeParameters == numTypeParameters &&
           linkedReference.unit == unitNum &&
           candidateContainingReference == containingReference &&
-          linkedReference.kind == kind &&
-          linkedReference.localIndex == localIndex) {
+          linkedReference.kind == kind) {
         return i;
       }
     }
     int result = linkedReferences.length;
     linkedReferences.add(new LinkedReferenceBuilder(
         dependency: dependency,
         name: name,
         numTypeParameters: numTypeParameters,
         unit: unitNum,
         containingReference: containingReference,
-        kind: kind,
-        localIndex: localIndex));
+        kind: kind));
     return result;
   }
 
   /**
    * If this compilation unit already has a reference in its references table
    * to [element], return its index.  Otherwise add a new reference to the table
    * and return its index.
    */
   int addReference(Element element) {
     if (element is ClassElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           numTypeParameters: element.typeParameters.length,
           unitNum: element.enclosingElement.unitNum);
     } else if (element is FunctionTypeAliasElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           numTypeParameters: element.typeParameters.length,
           unitNum: element.enclosingElement.unitNum,
           kind: ReferenceKind.typedef);
     } else if (element is FunctionElementForLink_Initializer) {
       return addRawReference('',
           containingReference: addReference(element.enclosingElement),
-          kind: ReferenceKind.function,
-          localIndex: 0);
-    } else if (element is FunctionElementForLink_Local_NonSynthetic) {
-      ExecutableElementForLink parent = element.enclosingElement;
-      int localIndex = parent.functions.indexOf(element);
-      assert(localIndex != -1);
-      return addRawReference(element.name,
-          containingReference: addReference(parent),
-          kind: ReferenceKind.function,
-          localIndex: localIndex);
+          kind: ReferenceKind.function);
     } else if (element is ExecutableElementForLink_NonLocal) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       ReferenceKind kind;
       switch (element._unlinkedExecutable.kind) {
         case UnlinkedExecutableKind.functionOrMethod:
           kind = enclosingClass != null
               ? ReferenceKind.method
               : ReferenceKind.topLevelFunction;
           break;
         case UnlinkedExecutableKind.setter:
@@ skipping 1633 matching lines @@
     if (_implicitFunctionTypeIndices == null) {
       _implicitFunctionTypeIndices = enclosingElement
           .enclosingElement.implicitFunctionTypeIndices
           .toList();
       _implicitFunctionTypeIndices.add(enclosingElement._parameterIndex);
     }
     return _implicitFunctionTypeIndices;
   }
 
   @override
+  bool get isSynthetic => true;
+
+  @override
   DartType get returnType {
     if (_returnType == null) {
       if (enclosingElement._unlinkedParam.type == null) {
         _returnType = DynamicTypeImpl.instance;
       } else {
         _returnType = enclosingElement.compilationUnit.resolveTypeRef(
             enclosingElement, enclosingElement._unlinkedParam.type);
       }
     }
     return _returnType;
@@ skipping 249 matching lines @@
 
   @override
   void _setInferredType(DartType type) {
     // TODO(paulberry): store the inferred return type in the summary.
     assert(!_hasTypeBeenInferred);
     _inferredReturnType = _dynamicIfNull(type);
   }
 }
 
 /**
+ * Synthetic function element which is created for local functions.
+ */
+class FunctionElementForLink_Synthetic extends ExecutableElementForLink
+    with ReferenceableElementForLink
+    implements FunctionElementForLink_Local {
+  @override
+  final ExecutableElementForLink enclosingElement;
+
+  final EntityRef _entityRef;
+
+  FunctionElementForLink_Synthetic(
+      CompilationUnitElementForLink compilationUnit,
+      this.enclosingElement,
+      this._entityRef)
+      : super(compilationUnit, null);
+
+  @override
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
+      enclosingElement;
+
+  @override
+  DartType get returnType {
+    return _declaredReturnType ??= enclosingUnit.resynthesizerContext
+        .resolveTypeRef(this, _entityRef.syntheticReturnType);
+  }
+
+  @override
+  List<UnlinkedParam> get unlinkedParameters => _entityRef.syntheticParams;
+
+  @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams => _entityRef.typeParameters;
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with
         TypeParameterizedElementMixin,
         ParameterParentElementForLink,
         ReferenceableElementForLink
     implements FunctionTypeAliasElement, ElementImpl {
   @override
   final CompilationUnitElementForLink enclosingElement;
@@ skipping 2144 matching lines @@
         try {
           new TypeInferenceDependencyWalker().walk(_typeInferenceNode);
           assert(_inferredType != null);
         } finally {
           Linker._initializerTypeInferenceCycle = null;
         }
       } else if (compilationUnit.isInBuildUnit) {
         _inferredType = DynamicTypeImpl.instance;
       } else {
         _inferredType = compilationUnit.getLinkedType(
-            this, unlinkedVariable.inferredTypeSlot);
+            initializer, unlinkedVariable.inferredTypeSlot);
       }
     }
     return _inferredType;
   }
 
   @override
   FunctionElementForLink_Initializer get initializer {
     if (unlinkedVariable.initializer == null) {
       return null;
     } else {
@@ skipping 64 matching lines @@
 }
 
 /**
  * This exception is thrown when [ExprTypeComputer] cannot inference the type.
  */
 class _InferenceFailedError {
   final String message;
 
   _InferenceFailedError(this.message);
 }