Rename TypeRef to EntityRef.

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 399 matching lines @@
   @override
   int get size => 4;
 
   @override
   UnlinkedParamKind read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return UnlinkedParamKind.values[index];
   }
 }
 
+class EntityRefBuilder extends Object with _EntityRefMixin implements EntityRef {
+  bool _finished = false;
+
+  int _slot;
+  int _reference;
+  int _paramReference;
+  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.
+   *
+   * Otherwise zero.
+   */
+  void set slot(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _slot = _value;
+  }
+
+  @override
+  int get reference => _reference ??= 0;
+
+  /**
+   * Index into [UnlinkedUnit.references] for the entity 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 other entities by checking [reference]
+   * against zero.  To distinguish between references to type parameters and
+   * references to other entities, check whether [paramReference] is zero.
+   */
+  void set reference(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _reference = _value;
+  }
+
+  @override
+  int get paramReference => _paramReference ??= 0;
+
+  /**
+   * If this is a reference to a type parameter, one-based index into the list
+   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
+   * Bruijn index conventions; that is, innermost parameters come first, and
+   * if a class or method has multiple parameters, they are indexed from right
+   * to left.  So for instance, if the enclosing declaration is
+   *
+   *     class C<T,U> {
+   *       m<V,W> {
+   *         ...
+   *       }
+   *     }
+   *
+   * 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.
+   */
+  void set paramReference(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _paramReference = _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})
+    : _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.addUint32(0, _slot);
+    }
+    if (_reference != null && _reference != 0) {
+      fbBuilder.addUint32(1, _reference);
+    }
+    if (_paramReference != null && _paramReference != 0) {
+      fbBuilder.addUint32(2, _paramReference);
+    }
+    if (offset_typeArguments != null) {
+      fbBuilder.addOffset(3, 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 {
+
+  /**
+   * 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.
+   *
+   * Otherwise zero.
+   */
+  int get slot;
+
+  /**
+   * Index into [UnlinkedUnit.references] for the entity 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 other entities by checking [reference]
+   * against zero.  To distinguish between references to type parameters and
+   * references to other entities, check whether [paramReference] is zero.
+   */
+  int get reference;
+
+  /**
+   * If this is a reference to a type parameter, one-based index into the list
+   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
+   * Bruijn index conventions; that is, innermost parameters come first, and
+   * if a class or method has multiple parameters, they are indexed from right
+   * to left.  So for instance, if the enclosing declaration is
+   *
+   *     class C<T,U> {
+   *       m<V,W> {
+   *         ...
+   *       }
+   *     }
+   *
+   * 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 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<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<EntityRef> get typeArguments {
+    _typeArguments ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 3, const <EntityRef>[]);
+    return _typeArguments;
+  }
+}
+
+abstract class _EntityRefMixin implements EntityRef {
+  @override
+  Map<String, Object> toMap() => {
+    "slot": slot,
+    "reference": reference,
+    "paramReference": paramReference,
+    "typeArguments": typeArguments,
+  };
+}
+
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements LinkedDependency {
   bool _finished = false;
 
   String _uri;
   List<String> _parts;
 
   @override
   String get uri => _uri ??= '';
 
   /**
@@ skipping 738 matching lines @@
     "unit": unit,
     "numTypeParameters": numTypeParameters,
     "name": name,
   };
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
-  List<TypeRefBuilder> _types;
+  List<EntityRefBuilder> _types;
 
   @override
   List<LinkedReferenceBuilder> get references => _references ??= <LinkedReferenceBuilder>[];
 
   /**
    * 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;
   }
 
   @override
-  List<TypeRefBuilder> get types => _types ??= <TypeRefBuilder>[];
+  List<EntityRefBuilder> get types => _types ??= <EntityRefBuilder>[];
 
   /**
    * List associating slot ids found inside the unlinked summary for the
    * compilation unit with propagated and inferred types.
    */
-  void set types(List<TypeRefBuilder> _value) {
+  void set types(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _types = _value;
   }
 
-  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<TypeRefBuilder> types})
+  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<EntityRefBuilder> 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());
@@ skipping 24 matching lines @@
    * 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;
+  List<EntityRef> 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;
+  List<EntityRef> _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>[]);
+  List<EntityRef> get types {
+    _types ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 1, const <EntityRef>[]);
     return _types;
   }
 }
 
 abstract class _LinkedUnitMixin implements LinkedUnit {
   @override
   Map<String, Object> toMap() => {
     "references": references,
     "types": types,
   };
@@ skipping 173 matching lines @@
 abstract class _SdkBundleMixin implements SdkBundle {
   @override
   Map<String, Object> toMap() => {
     "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 associated.
-   *
-   * Otherwise zero.
-   */
-  void set slot(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _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
-   * to types, check whether [paramReference] is zero.
-   */
-  void set reference(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _reference = _value;
-  }
-
-  @override
-  int get paramReference => _paramReference ??= 0;
-
-  /**
-   * If this is a reference to a type parameter, one-based index into the list
-   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
-   * Bruijn index conventions; that is, innermost parameters come first, and
-   * if a class or method has multiple parameters, they are indexed from right
-   * to left.  So for instance, if the enclosing declaration is
-   *
-   *     class C<T,U> {
-   *       m<V,W> {
-   *         ...
-   *       }
-   *     }
-   *
-   * 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.
-   */
-  void set paramReference(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _paramReference = _value;
-  }
-
-  @override
-  List<TypeRefBuilder> get typeArguments => _typeArguments ??= <TypeRefBuilder>[];
-
-  /**
-   * 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 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.addUint32(0, _slot);
-    }
-    if (_reference != null && _reference != 0) {
-      fbBuilder.addUint32(1, _reference);
-    }
-    if (_paramReference != null && _paramReference != 0) {
-      fbBuilder.addUint32(2, _paramReference);
-    }
-    if (offset_typeArguments != null) {
-      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 associated.
-   *
-   * 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;
-
-  /**
-   * If this is a reference to a type parameter, one-based index into the list
-   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
-   * Bruijn index conventions; that is, innermost parameters come first, and
-   * if a class or method has multiple parameters, they are indexed from right
-   * to left.  So for instance, if the enclosing declaration is
-   *
-   *     class C<T,U> {
-   *       m<V,W> {
-   *         ...
-   *       }
-   *     }
-   *
-   * 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 an instantiation of a generic type, the type arguments used to
-   * instantiate it.  Trailing type arguments of type `dynamic` are omitted.
-   */
-  List<TypeRef> get typeArguments;
-}
-
-class _TypeRefReader extends fb.TableReader<_TypeRefImpl> {
-  const _TypeRefReader();
-
-  @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.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<TypeRef> get typeArguments {
-    _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;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  TypeRefBuilder _supertype;
-  List<TypeRefBuilder> _mixins;
-  List<TypeRefBuilder> _interfaces;
+  EntityRefBuilder _supertype;
+  List<EntityRefBuilder> _mixins;
+  List<EntityRefBuilder> _interfaces;
   List<UnlinkedVariableBuilder> _fields;
   List<UnlinkedExecutableBuilder> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   @override
   String get name => _name ??= '';
 
   /**
@@ skipping 33 matching lines @@
 
   /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRefBuilder get supertype => _supertype;
+  EntityRefBuilder get supertype => _supertype;
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
-  void set supertype(TypeRefBuilder _value) {
+  void set supertype(EntityRefBuilder _value) {
     assert(!_finished);
     _supertype = _value;
   }
 
   @override
-  List<TypeRefBuilder> get mixins => _mixins ??= <TypeRefBuilder>[];
+  List<EntityRefBuilder> get mixins => _mixins ??= <EntityRefBuilder>[];
 
   /**
    * Mixins appearing in a `with` clause, if any.
    */
-  void set mixins(List<TypeRefBuilder> _value) {
+  void set mixins(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _mixins = _value;
   }
 
   @override
-  List<TypeRefBuilder> get interfaces => _interfaces ??= <TypeRefBuilder>[];
+  List<EntityRefBuilder> get interfaces => _interfaces ??= <EntityRefBuilder>[];
 
   /**
    * Interfaces appearing in an `implements` clause, if any.
    */
-  void set interfaces(List<TypeRefBuilder> _value) {
+  void set interfaces(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _interfaces = _value;
   }
 
   @override
   List<UnlinkedVariableBuilder> get fields => _fields ??= <UnlinkedVariableBuilder>[];
 
   /**
    * Field declarations contained in the class.
    */
@@ skipping 40 matching lines @@
 
   /**
    * Indicates whether this class is the core "Object" class (and hence has no
    * supertype)
    */
   void set hasNoSupertype(bool _value) {
     assert(!_finished);
     _hasNoSupertype = _value;
   }
 
-  UnlinkedClassBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, TypeRefBuilder supertype, List<TypeRefBuilder> mixins, List<TypeRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype})
+  UnlinkedClassBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder supertype, List<EntityRefBuilder> mixins, List<EntityRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _typeParameters = typeParameters,
       _supertype = supertype,
       _mixins = mixins,
       _interfaces = interfaces,
       _fields = fields,
       _executables = executables,
       _isAbstract = isAbstract,
@@ skipping 100 matching lines @@
   /**
    * Type parameters of the class, if any.
    */
   List<UnlinkedTypeParam> get typeParameters;
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
-  TypeRef get supertype;
+  EntityRef get supertype;
 
   /**
    * Mixins appearing in a `with` clause, if any.
    */
-  List<TypeRef> get mixins;
+  List<EntityRef> get mixins;
 
   /**
    * Interfaces appearing in an `implements` clause, if any.
    */
-  List<TypeRef> get interfaces;
+  List<EntityRef> get interfaces;
 
   /**
    * Field declarations contained in the class.
    */
   List<UnlinkedVariable> get fields;
 
   /**
    * Executable objects (methods, getters, and setters) contained in the class.
    */
   List<UnlinkedExecutable> get executables;
@@ skipping 24 matching lines @@
 
 class _UnlinkedClassImpl extends Object with _UnlinkedClassMixin implements UnlinkedClass {
   final fb.BufferPointer _bp;
 
   _UnlinkedClassImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
-  TypeRef _supertype;
-  List<TypeRef> _mixins;
-  List<TypeRef> _interfaces;
+  EntityRef _supertype;
+  List<EntityRef> _mixins;
+  List<EntityRef> _interfaces;
   List<UnlinkedVariable> _fields;
   List<UnlinkedExecutable> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
@@ skipping 11 matching lines @@
     return _documentationComment;
   }
 
   @override
   List<UnlinkedTypeParam> get typeParameters {
     _typeParameters ??= const fb.ListReader<UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
-  TypeRef get supertype {
-    _supertype ??= const _TypeRefReader().vTableGet(_bp, 4, null);
+  EntityRef get supertype {
+    _supertype ??= const _EntityRefReader().vTableGet(_bp, 4, null);
     return _supertype;
   }
 
   @override
-  List<TypeRef> get mixins {
-    _mixins ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 5, const <TypeRef>[]);
+  List<EntityRef> get mixins {
+    _mixins ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 5, const <EntityRef>[]);
     return _mixins;
   }
 
   @override
-  List<TypeRef> get interfaces {
-    _interfaces ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 6, const <TypeRef>[]);
+  List<EntityRef> get interfaces {
+    _interfaces ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 6, const <EntityRef>[]);
     return _interfaces;
   }
 
   @override
   List<UnlinkedVariable> get fields {
     _fields ??= const fb.ListReader<UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 7, const <UnlinkedVariable>[]);
     return _fields;
   }
 
   @override
@@ skipping 146 matching lines @@
   };
 }
 
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements UnlinkedConst {
   bool _finished = false;
 
   List<UnlinkedConstOperation> _operations;
   List<int> _ints;
   List<double> _doubles;
   List<String> _strings;
-  List<TypeRefBuilder> _references;
+  List<EntityRefBuilder> _references;
 
   @override
   List<UnlinkedConstOperation> get operations => _operations ??= <UnlinkedConstOperation>[];
 
   /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   void set operations(List<UnlinkedConstOperation> _value) {
     assert(!_finished);
@@ skipping 31 matching lines @@
   /**
    * Sequence of strings consumed by the operations `pushString` and
    * `invokeConstructor`.
    */
   void set strings(List<String> _value) {
     assert(!_finished);
     _strings = _value;
   }
 
   @override
-  List<TypeRefBuilder> get references => _references ??= <TypeRefBuilder>[];
+  List<EntityRefBuilder> get references => _references ??= <EntityRefBuilder>[];
 
   /**
    * Sequence of language constructs consumed by the operations
    * `pushReference`, `invokeConstructor`, `makeList`, and `makeMap`.  Note
    * that in the case of `pushReference` (and sometimes `invokeConstructor` the
    * actual entity being referred to may be something other than a type.
    */
-  void set references(List<TypeRefBuilder> _value) {
+  void set references(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
-  UnlinkedConstBuilder({List<UnlinkedConstOperation> operations, List<int> ints, List<double> doubles, List<String> strings, List<TypeRefBuilder> references})
+  UnlinkedConstBuilder({List<UnlinkedConstOperation> operations, List<int> ints, List<double> doubles, List<String> strings, List<EntityRefBuilder> references})
     : _operations = operations,
       _ints = ints,
       _doubles = doubles,
       _strings = strings,
       _references = references;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_operations;
@@ skipping 71 matching lines @@
    * `invokeConstructor`.
    */
   List<String> get strings;
 
   /**
    * Sequence of language constructs consumed by the operations
    * `pushReference`, `invokeConstructor`, `makeList`, and `makeMap`.  Note
    * that in the case of `pushReference` (and sometimes `invokeConstructor` the
    * actual entity being referred to may be something other than a type.
    */
-  List<TypeRef> get references;
+  List<EntityRef> get references;
 }
 
 class _UnlinkedConstReader extends fb.TableReader<_UnlinkedConstImpl> {
   const _UnlinkedConstReader();
 
   @override
   _UnlinkedConstImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstImpl(bp);
 }
 
 class _UnlinkedConstImpl extends Object with _UnlinkedConstMixin implements UnlinkedConst {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstImpl(this._bp);
 
   List<UnlinkedConstOperation> _operations;
   List<int> _ints;
   List<double> _doubles;
   List<String> _strings;
-  List<TypeRef> _references;
+  List<EntityRef> _references;
 
   @override
   List<UnlinkedConstOperation> get operations {
     _operations ??= const fb.ListReader<UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 0, const <UnlinkedConstOperation>[]);
     return _operations;
   }
 
   @override
   List<int> get ints {
     _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 1, const <int>[]);
     return _ints;
   }
 
   @override
   List<double> get doubles {
     _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 2, const <double>[]);
     return _doubles;
   }
 
   @override
   List<String> get strings {
     _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 3, const <String>[]);
     return _strings;
   }
 
   @override
-  List<TypeRef> get references {
-    _references ??= const fb.ListReader<TypeRef>(const _TypeRefReader()).vTableGet(_bp, 4, const <TypeRef>[]);
+  List<EntityRef> get references {
+    _references ??= const fb.ListReader<EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <EntityRef>[]);
     return _references;
   }
 }
 
 abstract class _UnlinkedConstMixin implements UnlinkedConst {
   @override
   Map<String, Object> toMap() => {
     "operations": operations,
     "ints": ints,
     "doubles": doubles,
@@ skipping 453 matching lines @@
   };
 }
 
 class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements UnlinkedExecutable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  TypeRefBuilder _returnType;
+  EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   @override
@@ skipping 42 matching lines @@
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRefBuilder get returnType => _returnType;
+  EntityRefBuilder get returnType => _returnType;
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void` or the executable is a constructor.  Note that when strong mode is
    * enabled, the actual return type may be different due to type inference.
    */
-  void set returnType(TypeRefBuilder _value) {
+  void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * Parameters of the executable, if any.  Note that getters have no
    * parameters (hence this will be the empty list), and setters have a single
@@ skipping 80 matching lines @@
   bool get isExternal => _isExternal ??= false;
 
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
-  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, TypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType, bool isExternal})
+  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType, bool isExternal})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters,
       _kind = kind,
       _isAbstract = isAbstract,
       _isStatic = isStatic,
       _isConst = isConst,
@@ skipping 99 matching lines @@
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> get typeParameters;
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void` or the executable is a constructor.  Note that when strong mode is
    * enabled, the actual return type may be different due to type inference.
    */
-  TypeRef get returnType;
+  EntityRef get returnType;
 
   /**
    * Parameters of the executable, if any.  Note that getters have no
    * parameters (hence this will be the empty list), and setters have a single
    * parameter.
    */
   List<UnlinkedParam> get parameters;
 
   /**
    * The kind of the executable (function/method, getter, setter, or
@@ skipping 46 matching lines @@
 
 class _UnlinkedExecutableImpl extends Object with _UnlinkedExecutableMixin implements UnlinkedExecutable {
   final fb.BufferPointer _bp;
 
   _UnlinkedExecutableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
-  TypeRef _returnType;
+  EntityRef _returnType;
   List<UnlinkedParam> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   @override
@@ skipping 14 matching lines @@
     return _documentationComment;
   }
 
   @override
   List<UnlinkedTypeParam> get typeParameters {
     _typeParameters ??= const fb.ListReader<UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
-  TypeRef get returnType {
-    _returnType ??= const _TypeRefReader().vTableGet(_bp, 4, null);
+  EntityRef get returnType {
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 4, null);
     return _returnType;
   }
 
   @override
   List<UnlinkedParam> get parameters {
     _parameters ??= const fb.ListReader<UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 5, const <UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
@@ skipping 626 matching lines @@
     "uriEnd": uriEnd,
     "prefixOffset": prefixOffset,
   };
 }
 
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
-  TypeRefBuilder _type;
+  EntityRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   @override
   String get name => _name ??= '';
 
   /**
@@ skipping 10 matching lines @@
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
-  TypeRefBuilder get type => _type;
+  EntityRefBuilder get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
-  void set type(TypeRefBuilder _value) {
+  void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
@@ skipping 41 matching lines @@
 
   /**
    * Indicates whether this parameter lacks an explicit type declaration.
    * Always false for a function-typed parameter.
    */
   void set hasImplicitType(bool _value) {
     assert(!_finished);
     _hasImplicitType = _value;
   }
 
-  UnlinkedParamBuilder({String name, int nameOffset, TypeRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, bool hasImplicitType})
+  UnlinkedParamBuilder({String name, int nameOffset, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, bool hasImplicitType})
     : _name = name,
       _nameOffset = nameOffset,
       _type = type,
       _parameters = parameters,
       _kind = kind,
       _isFunctionTyped = isFunctionTyped,
       _isInitializingFormal = isInitializingFormal,
       _hasImplicitType = hasImplicitType;
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 55 matching lines @@
    */
   int get nameOffset;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
-  TypeRef get type;
+  EntityRef get type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> get parameters;
 
   /**
    * Kind of the parameter.
    */
   UnlinkedParamKind get kind;
@@ skipping 23 matching lines @@
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
 class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
-  TypeRef _type;
+  EntityRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
-  TypeRef get type {
-    _type ??= const _TypeRefReader().vTableGet(_bp, 2, null);
+  EntityRef get type {
+    _type ??= const _EntityRefReader().vTableGet(_bp, 2, null);
     return _type;
   }
 
   @override
   List<UnlinkedParam> get parameters {
     _parameters ??= const fb.ListReader<UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 3, const <UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
@@ skipping 556 matching lines @@
   };
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements UnlinkedTypedef {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  TypeRefBuilder _returnType;
+  EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the typedef.
    */
   void set name(String _value) {
     assert(!_finished);
@@ skipping 29 matching lines @@
 
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRefBuilder get returnType => _returnType;
+  EntityRefBuilder get returnType => _returnType;
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
-  void set returnType(TypeRefBuilder _value) {
+  void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
-  UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, TypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
+  UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
@@ skipping 62 matching lines @@
   UnlinkedDocumentationComment get documentationComment;
 
   /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> get typeParameters;
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
-  TypeRef get returnType;
+  EntityRef get returnType;
 
   /**
    * Parameters of the executable, if any.
    */
   List<UnlinkedParam> get parameters;
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
   const _UnlinkedTypedefReader();
 
   @override
   _UnlinkedTypedefImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypedefImpl(bp);
 }
 
 class _UnlinkedTypedefImpl extends Object with _UnlinkedTypedefMixin implements UnlinkedTypedef {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypedefImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
-  TypeRef _returnType;
+  EntityRef _returnType;
   List<UnlinkedParam> _parameters;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
   List<UnlinkedTypeParam> get typeParameters {
     _typeParameters ??= const fb.ListReader<UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
-  TypeRef get returnType {
-    _returnType ??= const _TypeRefReader().vTableGet(_bp, 4, null);
+  EntityRef get returnType {
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 4, null);
     return _returnType;
   }
 
   @override
   List<UnlinkedParam> get parameters {
     _parameters ??= const fb.ListReader<UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 5, const <UnlinkedParam>[]);
     return _parameters;
   }
 }
 
 abstract class _UnlinkedTypedefMixin implements UnlinkedTypedef {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
   };
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
-  TypeRefBuilder _bound;
+  EntityRefBuilder _bound;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the type parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
   int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
-  TypeRefBuilder get bound => _bound;
+  EntityRefBuilder get bound => _bound;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
-  void set bound(TypeRefBuilder _value) {
+  void set bound(EntityRefBuilder _value) {
     assert(!_finished);
     _bound = _value;
   }
 
-  UnlinkedTypeParamBuilder({String name, int nameOffset, TypeRefBuilder bound})
+  UnlinkedTypeParamBuilder({String name, int nameOffset, EntityRefBuilder bound})
     : _name = name,
       _nameOffset = nameOffset,
       _bound = bound;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_bound;
     if (_name != null) {
@@ skipping 28 matching lines @@
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   int get nameOffset;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
-  TypeRef get bound;
+  EntityRef get bound;
 }
 
 class _UnlinkedTypeParamReader extends fb.TableReader<_UnlinkedTypeParamImpl> {
   const _UnlinkedTypeParamReader();
 
   @override
   _UnlinkedTypeParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypeParamImpl(bp);
 }
 
 class _UnlinkedTypeParamImpl extends Object with _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypeParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
-  TypeRef _bound;
+  EntityRef _bound;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
-  TypeRef get bound {
-    _bound ??= const _TypeRefReader().vTableGet(_bp, 2, null);
+  EntityRef get bound {
+    _bound ??= const _EntityRefReader().vTableGet(_bp, 2, null);
     return _bound;
   }
 }
 
 abstract class _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "bound": bound,
@@ skipping 516 matching lines @@
     "variables": variables,
   };
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
-  TypeRefBuilder _type;
+  EntityRefBuilder _type;
   UnlinkedConstBuilder _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
   int _propagatedTypeSlot;
 
   @override
   String get name => _name ??= '';
 
@@ skipping 23 matching lines @@
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  TypeRefBuilder get type => _type;
+  EntityRefBuilder get type => _type;
 
   /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
-  void set type(TypeRefBuilder _value) {
+  void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
   UnlinkedConstBuilder get constExpr => _constExpr;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.
@@ skipping 61 matching lines @@
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   void set propagatedTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _propagatedTypeSlot = _value;
   }
 
-  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, TypeRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType, int propagatedTypeSlot})
+  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, EntityRefBuilder 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,
       _propagatedTypeSlot = propagatedTypeSlot;
@@ skipping 71 matching lines @@
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   UnlinkedDocumentationComment get documentationComment;
 
   /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
-  TypeRef get type;
+  EntityRef get type;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.
    */
   UnlinkedConst get constExpr;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
@@ skipping 37 matching lines @@
 }
 
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
-  TypeRef _type;
+  EntityRef _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.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
-  TypeRef get type {
-    _type ??= const _TypeRefReader().vTableGet(_bp, 3, null);
+  EntityRef get type {
+    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _type;
   }
 
   @override
   UnlinkedConst get constExpr {
     _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 4, null);
     return _constExpr;
   }
 
   @override
@@ skipping 36 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }