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 206 matching lines @@
     }
     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;
-      result.syntheticParams = element.parameters
-          .map((ParameterElement param) => _serializeSyntheticParam(
-              param, compilationUnit, typeParameterContext))
-          .toList();
+      _storeFunctionElementByValue(result, element, compilationUnit);
       return result;
     }
     if (element is FunctionElement) {
       // Element is a local function inside another executable.
       result.reference = compilationUnit.addReference(element);
+      _storeFunctionElementByValue(result, element, compilationUnit);
       // 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))
@@ skipping 48 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 function [element] into the [entity] by value.
+ */
+void _storeFunctionElementByValue(
+    EntityRefBuilder entity,
+    FunctionElement element,
+    CompilationUnitElementInBuildUnit compilationUnit) {
+  // 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.
+  if (element is FunctionElementImpl) {
+    entity.syntheticReturnType =
+        _createLinkedType(element.returnType, compilationUnit, element);
+    entity.entityKind = EntityRefKind.syntheticFunction;
+    entity.syntheticParams = element.parameters
+        .map((ParameterElement param) =>
+            _serializeSyntheticParam(param, compilationUnit, element))
+        .toList();
+    entity.typeParameters = element.typeParameters
+        .map((TypeParameterElement e) =>
+            _serializeSyntheticTypeParameter(e, compilationUnit, element))
+        .toList();
+  }
+}
+
+/**
  * 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 776 matching lines @@
         return VoidTypeImpl.instance;
       } 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) {
+    } else if (entity.syntheticReturnType != null && entity.reference == 0) {
+      // TODO(scheglov): Remove "&& entity.reference == 0" condition after
+      // rolling SDK with this change internally, so that we always store
+      // synthetic and local function types by value.
+
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } 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);
@@ skipping 1757 matching lines @@
 
   @override
   final TypeParameterizedElementMixin typeParameterContext;
 
   @override
   final List<UnlinkedParam> unlinkedParameters;
 
   DartType _returnType;
   List<int> _implicitFunctionTypeIndices;
 
+  @override
+  bool get isSynthetic => true;
+
   FunctionElementForLink_FunctionTypedParam(this.enclosingElement,
       this.typeParameterContext, this.unlinkedParameters);
 
   @override
   List<int> get implicitFunctionTypeIndices {
     if (_implicitFunctionTypeIndices == null) {
       _implicitFunctionTypeIndices = enclosingElement
           .enclosingElement.implicitFunctionTypeIndices
           .toList();
       _implicitFunctionTypeIndices.add(enclosingElement._parameterIndex);
@@ skipping 2513 matching lines @@
 }
 
 /**
  * This exception is thrown when [ExprTypeComputer] cannot inference the type.
  */
 class _InferenceFailedError {
   final String message;
 
   _InferenceFailedError(this.message);
 }