Add the ability to summarize inferred types based on function-typed parameters.

pkg/analyzer/lib/src/summary/format.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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'base.dart' as base;
@@ skipping 433 matching lines @@
     return UnlinkedParamKind.values[index];
   }
 }
 
 class EntityRefBuilder extends Object with _EntityRefMixin implements EntityRef {
   bool _finished = false;
 
   int _slot;
   int _reference;
   int _paramReference;
+  List<int> _implicitFunctionTypeIndices;
   List<EntityRefBuilder> _typeArguments;
 
   @override
   int get slot => _slot ??= 0;
 
   /**
    * If this [EntityRef] is contained within [LinkedUnit.types], slot id (which
    * is unique within the compilation unit) identifying the target of type
    * propagation or type inference with which this [EntityRef] is associated.
    *
@@ skipping 40 matching lines @@
    * If the type being referred to is not a type parameter, [paramReference] is
    * zero.
    */
   void set paramReference(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _paramReference = _value;
   }
 
   @override
+  List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
+
+  /**
+   * If this is a reference to a function type implicitly defined by a
+   * function-typed parameter, a list of zero-based indices indicating the path
+   * from the entity referred to by [reference] to the appropriate type
+   * parameter.  Otherwise the empty list.
+   *
+   * If there are N indices in this list, then the entity being referred to is
+   * the function type implicitly defined by a function-typed parameter of a
+   * function-typed parameter, to N levels of nesting.  The first index in the
+   * list refers to the outermost level of nesting; for example if [reference]
+   * refers to the entity defined by:
+   *
+   *     void f(x, void g(y, z, int h(String w))) { ... }
+   *
+   * Then to refer to the function type implicitly defined by parameter `h`
+   * (which is parameter 2 of parameter 1 of `f`), then
+   * [implicitFunctionTypeIndices] should be [1, 2].
+   *
+   * Note that if the entity being referred to is a generic method inside a
+   * generic class, then the type arguments in [typeArguments] are applied
+   * first to the class and then to the method.
+   */
+  void set implicitFunctionTypeIndices(List<int> _value) {
+    assert(!_finished);
+    assert(_value == null || _value.every((e) => e >= 0));
+    _implicitFunctionTypeIndices = _value;
+  }
+
+  @override
   List<EntityRefBuilder> get typeArguments => _typeArguments ??= <EntityRefBuilder>[];
 
   /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it.  Trailing type arguments of type
    * `dynamic` are omitted.
    */
   void set typeArguments(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _typeArguments = _value;
   }
 
-  EntityRefBuilder({int slot, int reference, int paramReference, List<EntityRefBuilder> typeArguments})
+  EntityRefBuilder({int slot, int reference, int paramReference, List<int> implicitFunctionTypeIndices, List<EntityRefBuilder> typeArguments})
     : _slot = slot,
       _reference = reference,
       _paramReference = paramReference,
+      _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
       _typeArguments = typeArguments;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_typeArguments;
+    if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
+      offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
+    }
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (_slot != null && _slot != 0) {
       fbBuilder.addUint32(0, _slot);
     }
     if (_reference != null && _reference != 0) {
       fbBuilder.addUint32(1, _reference);
     }
     if (_paramReference != null && _paramReference != 0) {
       fbBuilder.addUint32(2, _paramReference);
     }
+    if (offset_implicitFunctionTypeIndices != null) {
+      fbBuilder.addOffset(3, offset_implicitFunctionTypeIndices);
+    }
     if (offset_typeArguments != null) {
-      fbBuilder.addOffset(3, offset_typeArguments);
+      fbBuilder.addOffset(4, offset_typeArguments);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Summary information about a reference to a an entity such as a type, top
  * level executable, or executable within a class.
  */
 abstract class EntityRef extends base.SummaryClass {
@@ skipping 28 matching lines @@
    *
    * Then [paramReference] values of 1, 2, 3, and 4 represent W, V, U, and T,
    * respectively.
    *
    * If the type being referred to is not a type parameter, [paramReference] is
    * zero.
    */
   int get paramReference;
 
   /**
+   * If this is a reference to a function type implicitly defined by a
+   * function-typed parameter, a list of zero-based indices indicating the path
+   * from the entity referred to by [reference] to the appropriate type
+   * parameter.  Otherwise the empty list.
+   *
+   * If there are N indices in this list, then the entity being referred to is
+   * the function type implicitly defined by a function-typed parameter of a
+   * function-typed parameter, to N levels of nesting.  The first index in the
+   * list refers to the outermost level of nesting; for example if [reference]
+   * refers to the entity defined by:
+   *
+   *     void f(x, void g(y, z, int h(String w))) { ... }
+   *
+   * Then to refer to the function type implicitly defined by parameter `h`
+   * (which is parameter 2 of parameter 1 of `f`), then
+   * [implicitFunctionTypeIndices] should be [1, 2].
+   *
+   * Note that if the entity being referred to is a generic method inside a
+   * generic class, then the type arguments in [typeArguments] are applied
+   * first to the class and then to the method.
+   */
+  List<int> get implicitFunctionTypeIndices;
+
+  /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it.  Trailing type arguments of type
    * `dynamic` are omitted.
    */
   List<EntityRef> get typeArguments;
 }
 
 class _EntityRefReader extends fb.TableReader<_EntityRefImpl> {
   const _EntityRefReader();
 
   @override
   _EntityRefImpl createObject(fb.BufferPointer bp) => new _EntityRefImpl(bp);
 }
 
 class _EntityRefImpl extends Object with _EntityRefMixin implements EntityRef {
   final fb.BufferPointer _bp;
 
   _EntityRefImpl(this._bp);
 
   int _slot;
   int _reference;
   int _paramReference;
+  List<int> _implicitFunctionTypeIndices;
   List<EntityRef> _typeArguments;
 
   @override
   int get slot {
     _slot ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _slot;
   }
 
   @override
   int get reference {
     _reference ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _reference;
   }
 
   @override
   int get paramReference {
     _paramReference ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _paramReference;
   }
 
   @override
+  List<int> get implicitFunctionTypeIndices {
+    _implicitFunctionTypeIndices ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 3, const <int>[]);
+    return _implicitFunctionTypeIndices;
+  }
+
+  @override
   List<EntityRef> get typeArguments {
-    _typeArguments ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 3, const <EntityRef>[]);
+    _typeArguments ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <EntityRef>[]);
     return _typeArguments;
   }
 }
 
 abstract class _EntityRefMixin implements EntityRef {
   @override
   Map<String, Object> toMap() => {
     "slot": slot,
     "reference": reference,
     "paramReference": paramReference,
+    "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
     "typeArguments": typeArguments,
   };
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements LinkedDependency {
   bool _finished = false;
 
   String _uri;
   List<String> _parts;
 
@@ skipping 540 matching lines @@
 }
 
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements LinkedReference {
   bool _finished = false;
 
   int _dependency;
   ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
   String _name;
+  int _containingReference;
 
   @override
   int get dependency => _dependency ??= 0;
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
+   *
+   * Zero if this entity is contained within another entity (e.g. a class
+   * member).
    */
   void set dependency(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _dependency = _value;
   }
 
   @override
   ReferenceKind get kind => _kind ??= ReferenceKind.classOrEnum;
 
   /**
    * The kind of the entity being referred to.  For the pseudo-types `dynamic`
    * and `void`, the kind is [ReferenceKind.classOrEnum].
    */
   void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
   int get unit => _unit ??= 0;
 
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
+   *
+   * Zero if this entity is contained within another entity (e.g. a class
+   * member).
    */
   void set unit(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _unit = _value;
   }
 
   @override
   int get numTypeParameters => _numTypeParameters ??= 0;
 
@@ skipping 13 matching lines @@
   /**
    * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
    * name of the entity being referred to.  For the pseudo-type `dynamic`, the
    * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
-  LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters, String name})
+  @override
+  int get containingReference => _containingReference ??= 0;
+
+  /**
+   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
+   * and the entity being referred to is contained within another entity, index
+   * of the containing entity.  This behaves similarly to
+   * [UnlinkedReference.prefixReference], however it is only used for class
+   * members, not for prefixed imports.
+   *
+   * Containing references must always point backward; that is, for all i, if
+   * LinkedUnit.references[i].containingReference != 0, then
+   * LinkedUnit.references[i].containingReference < i.
+   */
+  void set containingReference(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _containingReference = _value;
+  }
+
+  LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters, String name, int containingReference})
     : _dependency = dependency,
       _kind = kind,
       _unit = unit,
       _numTypeParameters = numTypeParameters,
-      _name = name;
+      _name = name,
+      _containingReference = containingReference;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (_dependency != null && _dependency != 0) {
       fbBuilder.addUint32(0, _dependency);
     }
     if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addUint32(1, _kind.index);
     }
     if (_unit != null && _unit != 0) {
       fbBuilder.addUint32(2, _unit);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addUint32(3, _numTypeParameters);
     }
     if (offset_name != null) {
       fbBuilder.addOffset(4, offset_name);
     }
+    if (_containingReference != null && _containingReference != 0) {
+      fbBuilder.addUint32(5, _containingReference);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Information about the resolution of an [UnlinkedReference].
  */
 abstract class LinkedReference extends base.SummaryClass {
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
+   *
+   * Zero if this entity is contained within another entity (e.g. a class
+   * member).
    */
   int get dependency;
 
   /**
    * The kind of the entity being referred to.  For the pseudo-types `dynamic`
    * and `void`, the kind is [ReferenceKind.classOrEnum].
    */
   ReferenceKind get kind;
 
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
+   *
+   * Zero if this entity is contained within another entity (e.g. a class
+   * member).
    */
   int get unit;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int get numTypeParameters;
 
   /**
    * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
    * name of the entity being referred to.  For the pseudo-type `dynamic`, the
    * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   String get name;
+
+  /**
+   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
+   * and the entity being referred to is contained within another entity, index
+   * of the containing entity.  This behaves similarly to
+   * [UnlinkedReference.prefixReference], however it is only used for class
+   * members, not for prefixed imports.
+   *
+   * Containing references must always point backward; that is, for all i, if
+   * LinkedUnit.references[i].containingReference != 0, then
+   * LinkedUnit.references[i].containingReference < i.
+   */
+  int get containingReference;
 }
 
 class _LinkedReferenceReader extends fb.TableReader<_LinkedReferenceImpl> {
   const _LinkedReferenceReader();
 
   @override
   _LinkedReferenceImpl createObject(fb.BufferPointer bp) => new _LinkedReferenceImpl(bp);
 }
 
 class _LinkedReferenceImpl extends Object with _LinkedReferenceMixin implements LinkedReference {
   final fb.BufferPointer _bp;
 
   _LinkedReferenceImpl(this._bp);
 
   int _dependency;
   ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
   String _name;
+  int _containingReference;
 
   @override
   int get dependency {
     _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _dependency;
   }
 
   @override
   ReferenceKind get kind {
     _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, ReferenceKind.classOrEnum);
@@ skipping 10 matching lines @@
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 4, '');
     return _name;
   }
+
+  @override
+  int get containingReference {
+    _containingReference ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    return _containingReference;
+  }
 }
 
 abstract class _LinkedReferenceMixin implements LinkedReference {
   @override
   Map<String, Object> toMap() => {
     "dependency": dependency,
     "kind": kind,
     "unit": unit,
     "numTypeParameters": numTypeParameters,
     "name": name,
+    "containingReference": containingReference,
   };
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
   List<EntityRefBuilder> _types;
 
   @override
@@ skipping 4678 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }