Add propagated types to summary files.

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 417 matching lines @@
   };
 }
 
 class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements LinkedLibrary {
   bool _finished = false;
 
   List<LinkedUnitBuilder> _units;
   List<LinkedDependencyBuilder> _dependencies;
   List<int> _importDependencies;
   List<LinkedExportNameBuilder> _exportNames;
+  int _numPrelinkedDependencies;
 
   @override
   List<LinkedUnit> get units => _units ?? const <LinkedUnit>[];
 
   /**
    * The linked summary of all the compilation units constituting the
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
    * declarations in the defining compilation unit.
    */
   void set units(List<LinkedUnitBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
   @override
   List<LinkedDependency> get dependencies => _dependencies ?? const <LinkedDependency>[];
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
-   * representing the library itself (it is also used for "dynamic").
+   * representing the library itself (it is also used for "dynamic").  This is
+   * followed by elements representing "prelinked" dependencies (direct imports
+   * and the transitive closure of exports).  After the prelinked dependencies
+   * are elements represent "linked" dependencies.
    *
-   * TODO(paulberry): consider removing this entirely and just using
-   * [UnlinkedLibrary.imports].
+   * A library is only included as a "linked" dependency if it is a true
+   * dependency (e.g. a propagated or inferred type or constant value
+   * implicitly refers to an element declared in the library) or
+   * anti-dependency (e.g. the result of type propagation or type inference
+   * depends on the lack of a certain declaration in the library).
    */
   void set dependencies(List<LinkedDependencyBuilder> _value) {
     assert(!_finished);
     _dependencies = _value;
   }
 
   @override
   List<int> get importDependencies => _importDependencies ?? const <int>[];
 
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
-   *
-   * TODO(paulberry): if [dependencies] is removed, this can be removed as
-   * well, since there will effectively be a one-to-one mapping.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     _importDependencies = _value;
   }
 
   @override
   List<LinkedExportName> get exportNames => _exportNames ?? const <LinkedExportName>[];
 
   /**
    * Information about entities in the export namespace of the library that are
    * not in the public namespace of the library (that is, entities that are
    * brought into the namespace via `export` directives).
    *
    * Sorted by name.
    */
   void set exportNames(List<LinkedExportNameBuilder> _value) {
     assert(!_finished);
     _exportNames = _value;
   }
 
-  LinkedLibraryBuilder({List<LinkedUnitBuilder> units, List<LinkedDependencyBuilder> dependencies, List<int> importDependencies, List<LinkedExportNameBuilder> exportNames})
+  @override
+  int get numPrelinkedDependencies => _numPrelinkedDependencies ?? 0;
+
+  /**
+   * The number of elements in [dependencies] which are not "linked"
+   * dependencies (that is, the number of libraries in the direct imports plus
+   * the transitive closure of exports, plus the library itself).
+   */
+  void set numPrelinkedDependencies(int _value) {
+    assert(!_finished);
+    _numPrelinkedDependencies = _value;
+  }
+
+  LinkedLibraryBuilder({List<LinkedUnitBuilder> units, List<LinkedDependencyBuilder> dependencies, List<int> importDependencies, List<LinkedExportNameBuilder> exportNames, int numPrelinkedDependencies})
     : _units = units,
       _dependencies = dependencies,
       _importDependencies = importDependencies,
-      _exportNames = exportNames;
+      _exportNames = exportNames,
+      _numPrelinkedDependencies = numPrelinkedDependencies;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_units;
@@ skipping 18 matching lines @@
     }
     if (offset_dependencies != null) {
       fbBuilder.addOffset(1, offset_dependencies);
     }
     if (offset_importDependencies != null) {
       fbBuilder.addOffset(2, offset_importDependencies);
     }
     if (offset_exportNames != null) {
       fbBuilder.addOffset(3, offset_exportNames);
     }
+    if (_numPrelinkedDependencies != null && _numPrelinkedDependencies != 0) {
+      fbBuilder.addInt32(4, _numPrelinkedDependencies);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Linked summary of a library.
  */
 abstract class LinkedLibrary extends base.SummaryClass {
   factory LinkedLibrary.fromBuffer(List<int> buffer) {
     fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
     return const _LinkedLibraryReader().read(rootRef);
   }
 
   /**
    * The linked summary of all the compilation units constituting the
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
    * declarations in the defining compilation unit.
    */
   List<LinkedUnit> get units;
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
-   * representing the library itself (it is also used for "dynamic").
+   * representing the library itself (it is also used for "dynamic").  This is
+   * followed by elements representing "prelinked" dependencies (direct imports
+   * and the transitive closure of exports).  After the prelinked dependencies
+   * are elements represent "linked" dependencies.
    *
-   * TODO(paulberry): consider removing this entirely and just using
-   * [UnlinkedLibrary.imports].
+   * A library is only included as a "linked" dependency if it is a true
+   * dependency (e.g. a propagated or inferred type or constant value
+   * implicitly refers to an element declared in the library) or
+   * anti-dependency (e.g. the result of type propagation or type inference
+   * depends on the lack of a certain declaration in the library).
    */
   List<LinkedDependency> get dependencies;
 
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
-   *
-   * TODO(paulberry): if [dependencies] is removed, this can be removed as
-   * well, since there will effectively be a one-to-one mapping.
    */
   List<int> get importDependencies;
 
   /**
    * Information about entities in the export namespace of the library that are
    * not in the public namespace of the library (that is, entities that are
    * brought into the namespace via `export` directives).
    *
    * Sorted by name.
    */
   List<LinkedExportName> get exportNames;
+
+  /**
+   * The number of elements in [dependencies] which are not "linked"
+   * dependencies (that is, the number of libraries in the direct imports plus
+   * the transitive closure of exports, plus the library itself).
+   */
+  int get numPrelinkedDependencies;
 }
 
 class _LinkedLibraryReader extends fb.TableReader<_LinkedLibraryImpl> {
   const _LinkedLibraryReader();
 
   @override
   _LinkedLibraryImpl createObject(fb.BufferPointer bp) => new _LinkedLibraryImpl(bp);
 }
 
 class _LinkedLibraryImpl extends Object with _LinkedLibraryMixin implements LinkedLibrary {
   final fb.BufferPointer _bp;
 
   _LinkedLibraryImpl(this._bp);
 
   List<LinkedUnit> _units;
   List<LinkedDependency> _dependencies;
   List<int> _importDependencies;
   List<LinkedExportName> _exportNames;
+  int _numPrelinkedDependencies;
 
   @override
   List<LinkedUnit> get units {
     _units ??= const fb.ListReader<LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 0, const <LinkedUnit>[]);
     return _units;
   }
 
   @override
   List<LinkedDependency> get dependencies {
     _dependencies ??= const fb.ListReader<LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 1, const <LinkedDependency>[]);
     return _dependencies;
   }
 
   @override
   List<int> get importDependencies {
     _importDependencies ??= const fb.ListReader<int>(const fb.Int32Reader()).vTableGet(_bp, 2, const <int>[]);
     return _importDependencies;
   }
 
   @override
   List<LinkedExportName> get exportNames {
     _exportNames ??= const fb.ListReader<LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 3, const <LinkedExportName>[]);
     return _exportNames;
   }
+
+  @override
+  int get numPrelinkedDependencies {
+    _numPrelinkedDependencies ??= const fb.Int32Reader().vTableGet(_bp, 4, 0);
+    return _numPrelinkedDependencies;
+  }
 }
 
 abstract class _LinkedLibraryMixin implements LinkedLibrary {
   @override
   Map<String, Object> toMap() => {
     "units": units,
     "dependencies": dependencies,
     "importDependencies": importDependencies,
     "exportNames": exportNames,
+    "numPrelinkedDependencies": numPrelinkedDependencies,
   };
 }
 
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements LinkedReference {
   bool _finished = false;
 
   int _dependency;
   ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
+  String _name;
 
   @override
   int get dependency => _dependency ?? 0;
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   void set dependency(int _value) {
     assert(!_finished);
@@ skipping 31 matching lines @@
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     _numTypeParameters = _value;
   }
 
-  LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters})
+  @override
+  String get name => _name ?? '';
+
+  /**
+   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
+   * name of the entity being referred to.  The empty string refers to the
+   * pseudo-type `dynamic`.
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _value;
+  }
+
+  LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters, String name})
     : _dependency = dependency,
       _kind = kind,
       _unit = unit,
-      _numTypeParameters = numTypeParameters;
+      _numTypeParameters = numTypeParameters,
+      _name = name;
 
   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.addInt32(0, _dependency);
     }
     if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addInt32(1, _kind.index);
     }
     if (_unit != null && _unit != 0) {
       fbBuilder.addInt32(2, _unit);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addInt32(3, _numTypeParameters);
     }
+    if (offset_name != null) {
+      fbBuilder.addOffset(4, offset_name);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Information about the resolution of an [UnlinkedReference].
  */
 abstract class LinkedReference extends base.SummaryClass {
 
   /**
@@ skipping 14 matching lines @@
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
    */
   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.  The empty string refers to the
+   * pseudo-type `dynamic`.
+   */
+  String get name;
 }
 
 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;
 
   @override
   int get dependency {
     _dependency ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _dependency;
   }
 
   @override
   ReferenceKind get kind {
     _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
   int get unit {
     _unit ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _unit;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Int32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
+
+  @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 4, '');
+    return _name;
+  }
 }
 
 abstract class _LinkedReferenceMixin implements LinkedReference {
   @override
   Map<String, Object> toMap() => {
     "dependency": dependency,
     "kind": kind,
     "unit": unit,
     "numTypeParameters": numTypeParameters,
+    "name": name,
   };
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
+  List<TypeRefBuilder> _types;
 
   @override
   List<LinkedReference> get references => _references ?? const <LinkedReference>[];
 
   /**
-   * For each reference in [UnlinkedUnit.references], information about how
-   * that reference is resolved.
+   * Information about the resolution of references within the compilation
+   * unit.  Each element of [UnlinkedUnit.references] has a corresponding
+   * element in this list (at the same index).  If this list has additional
+   * elements beyond the number of elements in [UnlinkedUnit.references], those
+   * additional elements are references that are only referred to implicitly
+   * (e.g. elements involved in inferred or propagated types).
    */
   void set references(List<LinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
-  LinkedUnitBuilder({List<LinkedReferenceBuilder> references})
-    : _references = references;
+  @override
+  List<TypeRef> get types => _types ?? const <TypeRef>[];
+
+  /**
+   * List associating slot ids found inside the unlinked summary for the
+   * compilation unit with propagated and inferred types.
+   */
+  void set types(List<TypeRefBuilder> _value) {
+    assert(!_finished);
+    _types = _value;
+  }
+
+  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<TypeRefBuilder> types})
+    : _references = references,
+      _types = types;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_references;
+    fb.Offset offset_types;
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_types == null || _types.isEmpty)) {
+      offset_types = fbBuilder.writeList(_types.map((b) => b.finish(fbBuilder)).toList());
+    }
     fbBuilder.startTable();
     if (offset_references != null) {
       fbBuilder.addOffset(0, offset_references);
     }
+    if (offset_types != null) {
+      fbBuilder.addOffset(1, offset_types);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Linked summary of a compilation unit.
  */
 abstract class LinkedUnit extends base.SummaryClass {
 
   /**
-   * For each reference in [UnlinkedUnit.references], information about how
-   * that reference is resolved.
+   * Information about the resolution of references within the compilation
+   * unit.  Each element of [UnlinkedUnit.references] has a corresponding
+   * element in this list (at the same index).  If this list has additional
+   * elements beyond the number of elements in [UnlinkedUnit.references], those
+   * additional elements are references that are only referred to implicitly
+   * (e.g. elements involved in inferred or propagated types).
    */
   List<LinkedReference> get references;
+
+  /**
+   * List associating slot ids found inside the unlinked summary for the
+   * compilation unit with propagated and inferred types.
+   */
+  List<TypeRef> get types;
 }
 
 class _LinkedUnitReader extends fb.TableReader<_LinkedUnitImpl> {
   const _LinkedUnitReader();
 
   @override
   _LinkedUnitImpl createObject(fb.BufferPointer bp) => new _LinkedUnitImpl(bp);
 }
 
 class _LinkedUnitImpl extends Object with _LinkedUnitMixin implements LinkedUnit {
   final fb.BufferPointer _bp;
 
   _LinkedUnitImpl(this._bp);
 
   List<LinkedReference> _references;
+  List<TypeRef> _types;
 
   @override
   List<LinkedReference> get references {
     _references ??= const fb.ListReader<LinkedReference>(const _LinkedReferenceReader()).vTableGet(_bp, 0, const <LinkedReference>[]);
     return _references;
   }
+
+  @override
+  List<TypeRef> get types {
+    _types ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 1, const <TypeRef>[]);
+    return _types;
+  }
 }
 
 abstract class _LinkedUnitMixin implements LinkedUnit {
   @override
   Map<String, Object> toMap() => {
     "references": references,
+    "types": types,
   };
 }
 
 class SdkBundleBuilder extends Object with _SdkBundleMixin implements SdkBundle {
   bool _finished = false;
 
   List<String> _linkedLibraryUris;
   List<LinkedLibraryBuilder> _linkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnitBuilder> _unlinkedUnits;
@@ skipping 167 matching lines @@
     "linkedLibraryUris": linkedLibraryUris,
     "linkedLibraries": linkedLibraries,
     "unlinkedUnitUris": unlinkedUnitUris,
     "unlinkedUnits": unlinkedUnits,
   };
 }
 
 class TypeRefBuilder extends Object with _TypeRefMixin implements TypeRef {
   bool _finished = false;
 
+  int _slot;
   int _reference;
   int _paramReference;
   List<TypeRefBuilder> _typeArguments;
 
   @override
+  int get slot => _slot ?? 0;
+
+  /**
+   * If this [TypeRef] 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 [TypeRef] is asociated.
+   *
+   * Otherwise zero.
+   */
+  void set slot(int _value) {
+    assert(!_finished);
+    _slot = _value;
+  }
+
+  @override
   int get reference => _reference ?? 0;
 
   /**
    * Index into [UnlinkedUnit.references] for the type being referred to, or
    * zero if this is a reference to a type parameter.
    *
    * Note that since zero is also a valid index into
    * [UnlinkedUnit.references], we cannot distinguish between references to
    * type parameters and references to types by checking [reference] against
    * zero.  To distinguish between references to type parameters and references
@@ skipping 36 matching lines @@
 
   /**
    * If this is an instantiation of a generic type, the type arguments used to
    * instantiate it.  Trailing type arguments of type `dynamic` are omitted.
    */
   void set typeArguments(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _typeArguments = _value;
   }
 
-  TypeRefBuilder({int reference, int paramReference, List<TypeRefBuilder> typeArguments})
-    : _reference = reference,
+  TypeRefBuilder({int slot, int reference, int paramReference, List<TypeRefBuilder> typeArguments})
+    : _slot = slot,
+      _reference = reference,
       _paramReference = paramReference,
       _typeArguments = typeArguments;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_typeArguments;
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (_slot != null && _slot != 0) {
+      fbBuilder.addInt32(0, _slot);
+    }
     if (_reference != null && _reference != 0) {
-      fbBuilder.addInt32(0, _reference);
+      fbBuilder.addInt32(1, _reference);
     }
     if (_paramReference != null && _paramReference != 0) {
-      fbBuilder.addInt32(1, _paramReference);
+      fbBuilder.addInt32(2, _paramReference);
     }
     if (offset_typeArguments != null) {
-      fbBuilder.addOffset(2, offset_typeArguments);
+      fbBuilder.addOffset(3, offset_typeArguments);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Summary information about a reference to a type.
  */
 abstract class TypeRef extends base.SummaryClass {
 
   /**
+   * If this [TypeRef] 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 [TypeRef] is asociated.
+   *
+   * Otherwise zero.
+   */
+  int get slot;
+
+  /**
    * Index into [UnlinkedUnit.references] for the type being referred to, or
    * zero if this is a reference to a type parameter.
    *
    * Note that since zero is also a valid index into
    * [UnlinkedUnit.references], we cannot distinguish between references to
    * type parameters and references to types by checking [reference] against
    * zero.  To distinguish between references to type parameters and references
    * to types, check whether [paramReference] is zero.
    */
   int get reference;
@@ skipping 31 matching lines @@
 
   @override
   _TypeRefImpl createObject(fb.BufferPointer bp) => new _TypeRefImpl(bp);
 }
 
 class _TypeRefImpl extends Object with _TypeRefMixin implements TypeRef {
   final fb.BufferPointer _bp;
 
   _TypeRefImpl(this._bp);
 
+  int _slot;
   int _reference;
   int _paramReference;
   List<TypeRef> _typeArguments;
 
   @override
+  int get slot {
+    _slot ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
+    return _slot;
+  }
+
+  @override
   int get reference {
-    _reference ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
+    _reference ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _reference;
   }
 
   @override
   int get paramReference {
-    _paramReference ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
+    _paramReference ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _paramReference;
   }
 
   @override
   List<TypeRef> get typeArguments {
-    _typeArguments ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 2, const <TypeRef>[]);
+    _typeArguments ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 3, const <TypeRef>[]);
     return _typeArguments;
   }
 }
 
 abstract class _TypeRefMixin implements TypeRef {
   @override
   Map<String, Object> toMap() => {
+    "slot": slot,
     "reference": reference,
     "paramReference": paramReference,
     "typeArguments": typeArguments,
   };
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements UnlinkedClass {
   bool _finished = false;
 
   String _name;
@@ skipping 3941 matching lines @@
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   TypeRefBuilder _type;
   UnlinkedConstBuilder _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
+  int _propagatedTypeSlot;
 
   @override
   String get name => _name ?? '';
 
   /**
    * Name of the variable.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 87 matching lines @@
   bool get hasImplicitType => _hasImplicitType ?? false;
 
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   void set hasImplicitType(bool _value) {
     assert(!_finished);
     _hasImplicitType = _value;
   }
 
-  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, TypeRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType})
+  @override
+  int get propagatedTypeSlot => _propagatedTypeSlot ?? 0;
+
+  /**
+   * If this variable is propagable, nonzero slot id identifying which entry in
+   * [LinkedLibrary.types] contains the propagated type for this variable.  If
+   * there is no matching entry in [LinkedLibrary.types], then this variable's
+   * propagated type is the same as its declared type.
+   *
+   * Non-propagable variables have a [propagatedTypeSlot] of zero.
+   */
+  void set propagatedTypeSlot(int _value) {
+    assert(!_finished);
+    _propagatedTypeSlot = _value;
+  }
+
+  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, TypeRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType, int propagatedTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _type = type,
       _constExpr = constExpr,
       _isStatic = isStatic,
       _isFinal = isFinal,
       _isConst = isConst,
-      _hasImplicitType = hasImplicitType;
+      _hasImplicitType = hasImplicitType,
+      _propagatedTypeSlot = propagatedTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
     fb.Offset offset_type;
     fb.Offset offset_constExpr;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
@@ skipping 28 matching lines @@
     }
     if (_isFinal == true) {
       fbBuilder.addBool(6, true);
     }
     if (_isConst == true) {
       fbBuilder.addBool(7, true);
     }
     if (_hasImplicitType == true) {
       fbBuilder.addBool(8, true);
     }
+    if (_propagatedTypeSlot != null && _propagatedTypeSlot != 0) {
+      fbBuilder.addInt32(9, _propagatedTypeSlot);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 abstract class UnlinkedVariable extends base.SummaryClass {
 
@@ skipping 41 matching lines @@
 
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   bool get isConst;
 
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   bool get hasImplicitType;
+
+  /**
+   * If this variable is propagable, nonzero slot id identifying which entry in
+   * [LinkedLibrary.types] contains the propagated type for this variable.  If
+   * there is no matching entry in [LinkedLibrary.types], then this variable's
+   * propagated type is the same as its declared type.
+   *
+   * Non-propagable variables have a [propagatedTypeSlot] of zero.
+   */
+  int get propagatedTypeSlot;
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
 }
 
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   TypeRef _type;
   UnlinkedConst _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
+  int _propagatedTypeSlot;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
@@ skipping 34 matching lines @@
   bool get isConst {
     _isConst ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _isConst;
   }
 
   @override
   bool get hasImplicitType {
     _hasImplicitType ??= const fb.BoolReader().vTableGet(_bp, 8, false);
     return _hasImplicitType;
   }
+
+  @override
+  int get propagatedTypeSlot {
+    _propagatedTypeSlot ??= const fb.Int32Reader().vTableGet(_bp, 9, 0);
+    return _propagatedTypeSlot;
+  }
 }
 
 abstract class _UnlinkedVariableMixin implements UnlinkedVariable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
+    "propagatedTypeSlot": propagatedTypeSlot,
   };
 }