Propertly summarize LUB function types.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 222 matching lines @@
    */
   int unresolvedReferenceIndex = null;
 
   /**
    * Index into the "references table" representing the "bottom" type, if such
    * an index exists.  `null` if no such entry has been made in the references
    * table yet.
    */
   int bottomReferenceIndex = null;
 
+  /**
+   * If `true`, we are currently generating linked references, so new
+   * references will be not stored in [unlinkedReferences].
+   */
+  bool buildingLinkedReferences = false;
+
   _CompilationUnitSerializer(
       this.librarySerializer, this.compilationUnit, this.unitNum);
 
   /**
    * Source object for the compilation unit.
    */
   Source get unitSource => compilationUnit.source;
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
@@ skipping 112 matching lines @@
     unlinkedUnit.references = unlinkedReferences;
     linkedUnit.references = linkedReferences;
     unitUri = compilationUnit.source.uri.toString();
   }
 
   /**
    * Create the [LinkedUnit.types] table based on deferred types that were
    * found during [addCompilationUnitElements].
    */
   void createLinkedTypes() {
+    buildingLinkedReferences = true;
     linkedUnit.types = deferredLinkedTypes
         .map((_SerializeTypeRef closure) => closure())
         .toList();
+    buildingLinkedReferences = false;
   }
 
   /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
   int findTypeParameterIndex(TypeParameterType type, Element context) {
     Element originalContext = context;
     int index = 0;
     while (context != null) {
@@ skipping 388 matching lines @@
   }
 
   /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParam(ParameterElement parameter,
       [Element context]) {
     context ??= parameter;
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
     b.name = parameter.name;
-    b.nameOffset = parameter.nameOffset;
+    b.nameOffset = parameter.nameOffset >= 0 ? parameter.nameOffset : 0;
     switch (parameter.parameterKind) {
       case ParameterKind.REQUIRED:
         b.kind = UnlinkedParamKind.required;
         break;
       case ParameterKind.POSITIONAL:
         b.kind = UnlinkedParamKind.positional;
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
@@ skipping 45 matching lines @@
   /**
    * Serialize the given [prefix] into an index into the references table.
    */
   int serializePrefix(PrefixElement element) {
     return referenceMap.putIfAbsent(element,
         () => serializeUnlinkedReference(element.name, ReferenceKind.prefix));
   }
 
   /**
    * Compute the reference index which should be stored in a [EntityRef].
-   *
-   * If [linked] is true, and a new reference has to be created, the reference
-   * will only be stored in [linkedReferences].
    */
-  int serializeReferenceForType(DartType type, bool linked) {
+  int serializeReferenceForType(DartType type) {
     Element element = type.element;
     LibraryElement dependentLibrary = element?.library;
     if (dependentLibrary == null) {
       if (type.isBottom) {
         // References to the "bottom" type are always implicit, since there is
         // no way to explicitly refer to the "bottom" type.  Therefore they
         // should always be linked.
-        assert(linked);
+        assert(buildingLinkedReferences);
         return serializeBottomReference();
       }
       assert(type.isDynamic || type.isVoid);
       if (type is UndefinedTypeImpl) {
         return serializeUnresolvedReference();
       }
       // Note: for a type which is truly `dynamic` or `void`, fall through to
       // use [_getElementReferenceId].
     }
-    return _getElementReferenceId(element, linked: linked);
+    return _getElementReferenceId(element);
   }
 
   /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
@@ skipping 16 matching lines @@
     b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     b.annotations = serializeAnnotations(typeParameter);
     return b;
   }
 
   /**
    * Serialize the given [type] into a [EntityRef].  If [slot] is provided,
-   * it should be included in the [EntityRef].  If [linked] is true, any
-   * references that are created will be populated into [linkedReferences] but
-   * not [unlinkedReferences].
+   * it should be included in the [EntityRef].
    *
    * [context] is the element within which the [EntityRef] will be
    * interpreted; this is used to serialize type parameters.
    */
   EntityRefBuilder serializeTypeRef(DartType type, Element context,
-      {bool linked: false, int slot}) {
+      {int slot}) {
+    if (slot != null) {
+      assert(buildingLinkedReferences);
+    }
     EntityRefBuilder b = new EntityRefBuilder(slot: slot);
+    Element typeElement = type.element;
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
+    } else if (type is FunctionType &&
+        typeElement is FunctionElement &&
+        typeElement.enclosingElement == null) {
+      b.syntheticReturnType =
+          serializeTypeRef(typeElement.returnType, typeElement);
+      b.syntheticParams = typeElement.parameters
+          .map((ParameterElement param) => serializeParam(param, context))
+          .toList();
     } else {
       if (type is FunctionType &&
-          type.element.enclosingElement is ParameterElement) {
+          typeElement.enclosingElement is ParameterElement) {
         // Code cannot refer to function types implicitly defined by parameters
         // directly, so if we get here, we must be serializing a linked
         // reference from type inference.
-        assert(linked);
-        ParameterElement parameterElement = type.element.enclosingElement;
+        assert(buildingLinkedReferences);
+        ParameterElement parameterElement = typeElement.enclosingElement;
         while (true) {
           Element parent = parameterElement.enclosingElement;
           if (parent is ExecutableElement) {
             Element grandParent = parent.enclosingElement;
             b.implicitFunctionTypeIndices
                 .insert(0, parent.parameters.indexOf(parameterElement));
             if (grandParent is ParameterElement) {
               // Function-typed parameter inside a function-typed parameter.
               parameterElement = grandParent;
               continue;
             } else {
               // Function-typed parameter inside a top level function or method.
-              b.reference = _getElementReferenceId(parent, linked: linked);
+              b.reference = _getElementReferenceId(parent);
               break;
             }
           } else {
             throw new StateError(
                 'Unexpected element enclosing parameter: ${parent.runtimeType}');
           }
         }
       } else {
-        b.reference = serializeReferenceForType(type, linked);
+        b.reference = serializeReferenceForType(type);
       }
       List<DartType> typeArguments = getTypeArguments(type);
       if (typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         int numArgsToSerialize = typeArguments.length;
         while (numArgsToSerialize > 0 &&
             typeArguments[numArgsToSerialize - 1].isDynamic) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
           List<EntityRefBuilder> serializedArguments = <EntityRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
-            serializedArguments.add(
-                serializeTypeRef(typeArguments[i], context, linked: linked));
+            serializedArguments
+                .add(serializeTypeRef(typeArguments[i], context));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
 
   /**
    * Create a new entry in the references table ([UnlinkedLibrary.references]
@@ skipping 98 matching lines @@
    * [linkedTypes] so that once the compilation unit has been fully visited,
    * it will be serialized to [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
    */
   int storeLinkedType(DartType type, Element context) {
     int slot = ++numSlots;
     if (type != null) {
       deferredLinkedTypes
-          .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
+          .add(() => serializeTypeRef(type, context, slot: slot));
     }
     return slot;
   }
 
-  int _getElementReferenceId(Element element, {bool linked: false}) {
+  int _getElementReferenceId(Element element) {
     return referenceMap.putIfAbsent(element, () {
       LibraryElement dependentLibrary = librarySerializer.libraryElement;
       int unit = 0;
       Element enclosingElement;
       if (element != null) {
         enclosingElement = element.enclosingElement;
         if (enclosingElement is CompilationUnitElement) {
           dependentLibrary = enclosingElement.library;
           unit = dependentLibrary.units.indexOf(enclosingElement);
           assert(unit != -1);
         }
       }
       ReferenceKind kind = _getReferenceKind(element);
       String name = element == null ? 'void' : element.name;
       int index;
       LinkedReferenceBuilder linkedReference;
-      if (linked) {
+      if (buildingLinkedReferences) {
         linkedReference =
             new LinkedReferenceBuilder(kind: kind, unit: unit, name: name);
         if (enclosingElement != null &&
             enclosingElement is! CompilationUnitElement) {
           linkedReference.containingReference =
-              _getElementReferenceId(enclosingElement, linked: linked);
+              _getElementReferenceId(enclosingElement);
           if (enclosingElement is ClassElement) {
             // Nothing to do.
           } else if (enclosingElement is ExecutableElement) {
             if (element is FunctionElement) {
               assert(enclosingElement.functions.contains(element));
               linkedReference.localIndex =
                   enclosingElement.functions.indexOf(element);
             } else if (element is LocalVariableElement) {
               assert(enclosingElement.localVariables.contains(element));
               linkedReference.localIndex =
@@ skipping 19 matching lines @@
           // Figure out a prefix that may be used to refer to the given element.
           // TODO(paulberry): to avoid subtle relinking inconsistencies we
           // should use the actual prefix from the AST (a given type may be
           // reachable via multiple prefixes), but sadly, this information is
           // not recorded in the element model.
           PrefixElement prefix = librarySerializer.prefixMap[element];
           if (prefix != null) {
             prefixReference = serializePrefix(prefix);
           }
         } else {
-          prefixReference = _getElementReferenceId(enclosing, linked: linked);
+          prefixReference = _getElementReferenceId(enclosing);
         }
         index = serializeUnlinkedReference(name, kind,
             prefixReference: prefixReference, unit: unit);
         linkedReference = linkedReferences[index];
       }
       linkedReference.dependency =
           librarySerializer.serializeDependency(dependentLibrary);
       if (element is TypeParameterizedElement) {
         linkedReference.numTypeParameters += element.typeParameters.length;
       }
@@ skipping 345 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }