Resynthesize codeOffset/codeLength properties.

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 'flat_buffers.dart' as fb;
@@ skipping 1119 matching lines @@
     "unit": unit,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
   bool _finished = false;
 
+  List<int> _constCycles;
   List<LinkedReferenceBuilder> _references;
   List<EntityRefBuilder> _types;
-  List<int> _constCycles;
+
+  @override
+  List<int> get constCycles => _constCycles ??= <int>[];
+
+  /**
+   * List of slot ids (referring to [UnlinkedExecutable.constCycleSlot])
+   * corresponding to const constructors that are part of cycles.
+   */
+  void set constCycles(List<int> _value) {
+    assert(!_finished);
+    assert(_value == null || _value.every((e) => e >= 0));
+    _constCycles = _value;
+  }
 
   @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<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<EntityRefBuilder> _value) {
     assert(!_finished);
     _types = _value;
   }
 
-  @override
-  List<int> get constCycles => _constCycles ??= <int>[];
-
-  /**
-   * List of slot ids (referring to [UnlinkedExecutable.constCycleSlot])
-   * corresponding to const constructors that are part of cycles.
-   */
-  void set constCycles(List<int> _value) {
-    assert(!_finished);
-    assert(_value == null || _value.every((e) => e >= 0));
-    _constCycles = _value;
-  }
-
-  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<EntityRefBuilder> types, List<int> constCycles})
-    : _references = references,
-      _types = types,
-      _constCycles = constCycles;
+  LinkedUnitBuilder({List<int> constCycles, List<LinkedReferenceBuilder> references, List<EntityRefBuilder> types})
+    : _constCycles = constCycles,
+      _references = references,
+      _types = types;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_constCycles;
     fb.Offset offset_references;
     fb.Offset offset_types;
-    fb.Offset offset_constCycles;
+    if (!(_constCycles == null || _constCycles.isEmpty)) {
+      offset_constCycles = fbBuilder.writeListUint32(_constCycles);
+    }
     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());
     }
-    if (!(_constCycles == null || _constCycles.isEmpty)) {
-      offset_constCycles = fbBuilder.writeListUint32(_constCycles);
+    fbBuilder.startTable();
+    if (offset_constCycles != null) {
+      fbBuilder.addOffset(2, offset_constCycles);
     }
-    fbBuilder.startTable();
     if (offset_references != null) {
       fbBuilder.addOffset(0, offset_references);
     }
     if (offset_types != null) {
       fbBuilder.addOffset(1, offset_types);
     }
-    if (offset_constCycles != null) {
-      fbBuilder.addOffset(2, offset_constCycles);
-    }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedUnitReader extends fb.TableReader<_LinkedUnitImpl> {
   const _LinkedUnitReader();
 
   @override
   _LinkedUnitImpl createObject(fb.BufferPointer bp) => new _LinkedUnitImpl(bp);
 }
 
 class _LinkedUnitImpl extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
   final fb.BufferPointer _bp;
 
   _LinkedUnitImpl(this._bp);
 
+  List<int> _constCycles;
   List<idl.LinkedReference> _references;
   List<idl.EntityRef> _types;
-  List<int> _constCycles;
+
+  @override
+  List<int> get constCycles {
+    _constCycles ??= const fb.Uint32ListReader().vTableGet(_bp, 2, const <int>[]);
+    return _constCycles;
+  }
 
   @override
   List<idl.LinkedReference> get references {
     _references ??= const fb.ListReader<idl.LinkedReference>(const _LinkedReferenceReader()).vTableGet(_bp, 0, const <idl.LinkedReference>[]);
     return _references;
   }
 
   @override
   List<idl.EntityRef> get types {
     _types ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 1, const <idl.EntityRef>[]);
     return _types;
   }
-
-  @override
-  List<int> get constCycles {
-    _constCycles ??= const fb.Uint32ListReader().vTableGet(_bp, 2, const <int>[]);
-    return _constCycles;
-  }
 }
 
 abstract class _LinkedUnitMixin implements idl.LinkedUnit {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
+    if (constCycles.isNotEmpty) _result["constCycles"] = constCycles;
     if (references.isNotEmpty) _result["references"] = references.map((_value) => _value.toJson()).toList();
     if (types.isNotEmpty) _result["types"] = types.map((_value) => _value.toJson()).toList();
-    if (constCycles.isNotEmpty) _result["constCycles"] = constCycles;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
+    "constCycles": constCycles,
     "references": references,
     "types": types,
-    "constCycles": constCycles,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class PackageBundleBuilder extends Object with _PackageBundleMixin implements idl.PackageBundle {
   bool _finished = false;
 
   List<LinkedLibraryBuilder> _linkedLibraries;
@@ skipping 921 matching lines @@
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedVariableBuilder> _fields;
+  bool _hasCodeRange;
   bool _hasNoSupertype;
   List<EntityRefBuilder> _interfaces;
   bool _isAbstract;
   bool _isMixinApplication;
   List<EntityRefBuilder> _mixins;
   String _name;
   int _nameOffset;
   EntityRefBuilder _supertype;
   List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this class.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the class code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the class code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the class, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
@@ skipping 14 matching lines @@
 
   /**
    * Field declarations contained in the class.
    */
   void set fields(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _fields = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the class has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   bool get hasNoSupertype => _hasNoSupertype ??= false;
 
   /**
    * Indicates whether this class is the core "Object" class (and hence has no
    * supertype)
    */
   void set hasNoSupertype(bool _value) {
     assert(!_finished);
     _hasNoSupertype = _value;
   }
@@ skipping 82 matching lines @@
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
-  UnlinkedClassBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedExecutableBuilder> executables, List<UnlinkedVariableBuilder> fields, bool hasNoSupertype, List<EntityRefBuilder> interfaces, bool isAbstract, bool isMixinApplication, List<EntityRefBuilder> mixins, String name, int nameOffset, EntityRefBuilder supertype, List<UnlinkedTypeParamBuilder> typeParameters})
+  UnlinkedClassBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedExecutableBuilder> executables, List<UnlinkedVariableBuilder> fields, bool hasCodeRange, bool hasNoSupertype, List<EntityRefBuilder> interfaces, bool isAbstract, bool isMixinApplication, List<EntityRefBuilder> mixins, String name, int nameOffset, EntityRefBuilder supertype, List<UnlinkedTypeParamBuilder> typeParameters})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _documentationComment = documentationComment,
       _executables = executables,
       _fields = fields,
+      _hasCodeRange = hasCodeRange,
       _hasNoSupertype = hasNoSupertype,
       _interfaces = interfaces,
       _isAbstract = isAbstract,
       _isMixinApplication = isMixinApplication,
       _mixins = mixins,
       _name = name,
       _nameOffset = nameOffset,
       _supertype = supertype,
       _typeParameters = typeParameters;
 
@@ skipping 33 matching lines @@
     if (_supertype != null) {
       offset_supertype = _supertype.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(5, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(15, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(14, _codeOffset);
+    }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(6, offset_documentationComment);
     }
     if (offset_executables != null) {
       fbBuilder.addOffset(2, offset_executables);
     }
     if (offset_fields != null) {
       fbBuilder.addOffset(4, offset_fields);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(13, true);
+    }
     if (_hasNoSupertype == true) {
       fbBuilder.addBool(12, true);
     }
     if (offset_interfaces != null) {
       fbBuilder.addOffset(7, offset_interfaces);
     }
     if (_isAbstract == true) {
       fbBuilder.addBool(8, true);
     }
     if (_isMixinApplication == true) {
@@ skipping 24 matching lines @@
   @override
   _UnlinkedClassImpl createObject(fb.BufferPointer bp) => new _UnlinkedClassImpl(bp);
 }
 
 class _UnlinkedClassImpl extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
   final fb.BufferPointer _bp;
 
   _UnlinkedClassImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
   List<idl.UnlinkedExecutable> _executables;
   List<idl.UnlinkedVariable> _fields;
+  bool _hasCodeRange;
   bool _hasNoSupertype;
   List<idl.EntityRef> _interfaces;
   bool _isAbstract;
   bool _isMixinApplication;
   List<idl.EntityRef> _mixins;
   String _name;
   int _nameOffset;
   idl.EntityRef _supertype;
   List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 5, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 15, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 14, 0);
+    return _codeOffset;
+  }
+
+  @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 6, null);
     return _documentationComment;
   }
 
   @override
   List<idl.UnlinkedExecutable> get executables {
     _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 2, const <idl.UnlinkedExecutable>[]);
     return _executables;
   }
 
   @override
   List<idl.UnlinkedVariable> get fields {
     _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 4, const <idl.UnlinkedVariable>[]);
     return _fields;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 13, false);
+    return _hasCodeRange;
+  }
+
+  @override
   bool get hasNoSupertype {
     _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _hasNoSupertype;
   }
 
   @override
   List<idl.EntityRef> get interfaces {
     _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 7, const <idl.EntityRef>[]);
     return _interfaces;
   }
@@ skipping 39 matching lines @@
     _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 9, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 }
 
 abstract class _UnlinkedClassMixin implements idl.UnlinkedClass {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
     if (executables.isNotEmpty) _result["executables"] = executables.map((_value) => _value.toJson()).toList();
     if (fields.isNotEmpty) _result["fields"] = fields.map((_value) => _value.toJson()).toList();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (hasNoSupertype != false) _result["hasNoSupertype"] = hasNoSupertype;
     if (interfaces.isNotEmpty) _result["interfaces"] = interfaces.map((_value) => _value.toJson()).toList();
     if (isAbstract != false) _result["isAbstract"] = isAbstract;
     if (isMixinApplication != false) _result["isMixinApplication"] = isMixinApplication;
     if (mixins.isNotEmpty) _result["mixins"] = mixins.map((_value) => _value.toJson()).toList();
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (supertype != null) _result["supertype"] = supertype.toJson();
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "documentationComment": documentationComment,
     "executables": executables,
     "fields": fields,
+    "hasCodeRange": hasCodeRange,
     "hasNoSupertype": hasNoSupertype,
     "interfaces": interfaces,
     "isAbstract": isAbstract,
     "isMixinApplication": isMixinApplication,
     "mixins": mixins,
     "name": name,
     "nameOffset": nameOffset,
     "supertype": supertype,
     "typeParameters": typeParameters,
   };
@@ skipping 664 matching lines @@
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
   List<UnlinkedEnumValueBuilder> _values;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this enum.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the enum code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the enum code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the enum, or `null` if there is no documentation
    * comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the enum has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   String get name => _name ??= '';
 
   /**
    * Name of the enum type.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
@@ skipping 13 matching lines @@
   List<UnlinkedEnumValueBuilder> get values => _values ??= <UnlinkedEnumValueBuilder>[];
 
   /**
    * Values listed in the enum declaration, in declaration order.
    */
   void set values(List<UnlinkedEnumValueBuilder> _value) {
     assert(!_finished);
     _values = _value;
   }
 
-  UnlinkedEnumBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedEnumValueBuilder> values})
+  UnlinkedEnumBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, UnlinkedDocumentationCommentBuilder documentationComment, bool hasCodeRange, String name, int nameOffset, List<UnlinkedEnumValueBuilder> values})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _documentationComment = documentationComment,
+      _hasCodeRange = hasCodeRange,
       _name = name,
       _nameOffset = nameOffset,
       _values = values;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     fb.Offset offset_values;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (!(_values == null || _values.isEmpty)) {
       offset_values = fbBuilder.writeList(_values.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(4, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(7, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(6, _codeOffset);
+    }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(3, offset_documentationComment);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(5, true);
+    }
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_values != null) {
       fbBuilder.addOffset(2, offset_values);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedEnumReader extends fb.TableReader<_UnlinkedEnumImpl> {
   const _UnlinkedEnumReader();
 
   @override
   _UnlinkedEnumImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumImpl(bp);
 }
 
 class _UnlinkedEnumImpl extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedEnumValue> _values;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
+    return _codeOffset;
+  }
+
+  @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 3, null);
     return _documentationComment;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    return _hasCodeRange;
+  }
+
+  @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
   List<idl.UnlinkedEnumValue> get values {
     _values ??= const fb.ListReader<idl.UnlinkedEnumValue>(const _UnlinkedEnumValueReader()).vTableGet(_bp, 2, const <idl.UnlinkedEnumValue>[]);
     return _values;
   }
 }
 
 abstract class _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (values.isNotEmpty) _result["values"] = values.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "documentationComment": documentationComment,
+    "hasCodeRange": hasCodeRange,
     "name": name,
     "nameOffset": nameOffset,
     "values": values,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
@@ skipping 121 matching lines @@
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   List<UnlinkedConstructorInitializerBuilder> _constantInitializers;
+  int _constCycleSlot;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  bool _hasCodeRange;
   int _inferredReturnTypeSlot;
   bool _isAbstract;
   bool _isConst;
   bool _isExternal;
   bool _isFactory;
   bool _isRedirectedConstructor;
   bool _isStatic;
   idl.UnlinkedExecutableKind _kind;
   List<UnlinkedExecutableBuilder> _localFunctions;
   List<UnlinkedLabelBuilder> _localLabels;
   List<UnlinkedVariableBuilder> _localVariables;
   String _name;
   int _nameEnd;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   int _periodOffset;
   EntityRefBuilder _redirectedConstructor;
   String _redirectedConstructorName;
   EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   int _visibleLength;
   int _visibleOffset;
-  int _constCycleSlot;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this executable.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the executable code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the executable code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   List<UnlinkedConstructorInitializerBuilder> get constantInitializers => _constantInitializers ??= <UnlinkedConstructorInitializerBuilder>[];
 
   /**
    * If a constant [UnlinkedExecutableKind.constructor], the constructor
    * initializers.  Otherwise empty.
    */
   void set constantInitializers(List<UnlinkedConstructorInitializerBuilder> _value) {
     assert(!_finished);
     _constantInitializers = _value;
   }
 
   @override
+  int get constCycleSlot => _constCycleSlot ??= 0;
+
+  /**
+   * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
+   * a nonzero slot id which is unique within this compilation unit.  If this id
+   * is found in [LinkedUnit.constCycles], then this constructor is part of a
+   * cycle.
+   *
+   * Otherwise, zero.
+   */
+  void set constCycleSlot(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _constCycleSlot = _value;
+  }
+
+  @override
   UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the executable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the executable has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
 
   /**
    * If this executable's return type is inferable, nonzero slot id
    * identifying which entry in [LinkedUnit.types] contains the inferred
    * return type.  If there is no matching entry in [LinkedUnit.types], then
    * no return type was inferred for this variable, so its static type is
    * `dynamic`.
    */
   void set inferredReturnTypeSlot(int _value) {
@@ skipping 253 matching lines @@
 
   /**
    * If a local function, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
-  @override
-  int get constCycleSlot => _constCycleSlot ??= 0;
-
-  /**
-   * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
-   * a nonzero slot id which is unique within this compilation unit.  If this id
-   * is found in [LinkedUnit.constCycles], then this constructor is part of a
-   * cycle.
-   *
-   * Otherwise, zero.
-   */
-  void set constCycleSlot(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _constCycleSlot = _value;
-  }
-
-  UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, List<UnlinkedConstructorInitializerBuilder> constantInitializers, UnlinkedDocumentationCommentBuilder documentationComment, int inferredReturnTypeSlot, bool isAbstract, bool isConst, bool isExternal, bool isFactory, bool isRedirectedConstructor, bool isStatic, idl.UnlinkedExecutableKind kind, List<UnlinkedExecutableBuilder> localFunctions, List<UnlinkedLabelBuilder> localLabels, List<UnlinkedVariableBuilder> localVariables, String name, int nameEnd, int nameOffset, List<UnlinkedParamBuilder> parameters, int periodOffset, EntityRefBuilder redirectedConstructor, String redirectedConstructorName, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters, int visibleLength, int visibleOffset, int constCycleSlot})
+  UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, List<UnlinkedConstructorInitializerBuilder> constantInitializers, int constCycleSlot, UnlinkedDocumentationCommentBuilder documentationComment, bool hasCodeRange, int inferredReturnTypeSlot, bool isAbstract, bool isConst, bool isExternal, bool isFactory, bool isRedirectedConstructor, bool isStatic, idl.UnlinkedExecutableKind kind, List<UnlinkedExecutableBuilder> localFunctions, List<UnlinkedLabelBuilder> localLabels, List<UnlinkedVariableBuilder> localVariables, String name, int nameEnd, int nameOffset, List<UnlinkedParamBuilder> parameters, int periodOffset, EntityRefBuilder redirectedConstructor, String redirectedConstructorName, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters, int visibleLength, int visibleOffset})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _constantInitializers = constantInitializers,
+      _constCycleSlot = constCycleSlot,
       _documentationComment = documentationComment,
+      _hasCodeRange = hasCodeRange,
       _inferredReturnTypeSlot = inferredReturnTypeSlot,
       _isAbstract = isAbstract,
       _isConst = isConst,
       _isExternal = isExternal,
       _isFactory = isFactory,
       _isRedirectedConstructor = isRedirectedConstructor,
       _isStatic = isStatic,
       _kind = kind,
       _localFunctions = localFunctions,
       _localLabels = localLabels,
       _localVariables = localVariables,
       _name = name,
       _nameEnd = nameEnd,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _periodOffset = periodOffset,
       _redirectedConstructor = redirectedConstructor,
       _redirectedConstructorName = redirectedConstructorName,
       _returnType = returnType,
       _typeParameters = typeParameters,
       _visibleLength = visibleLength,
-      _visibleOffset = visibleOffset,
-      _constCycleSlot = constCycleSlot;
+      _visibleOffset = visibleOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_constantInitializers;
     fb.Offset offset_documentationComment;
     fb.Offset offset_localFunctions;
     fb.Offset offset_localLabels;
     fb.Offset offset_localVariables;
@@ skipping 36 matching lines @@
     if (_returnType != null) {
       offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(6, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(28, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(27, _codeOffset);
+    }
     if (offset_constantInitializers != null) {
       fbBuilder.addOffset(14, offset_constantInitializers);
     }
+    if (_constCycleSlot != null && _constCycleSlot != 0) {
+      fbBuilder.addUint32(25, _constCycleSlot);
+    }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(7, offset_documentationComment);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(26, true);
+    }
     if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
       fbBuilder.addUint32(5, _inferredReturnTypeSlot);
     }
     if (_isAbstract == true) {
       fbBuilder.addBool(10, true);
     }
     if (_isConst == true) {
       fbBuilder.addBool(12, true);
     }
     if (_isExternal == true) {
@@ skipping 46 matching lines @@
     }
     if (offset_typeParameters != null) {
       fbBuilder.addOffset(16, offset_typeParameters);
     }
     if (_visibleLength != null && _visibleLength != 0) {
       fbBuilder.addUint32(20, _visibleLength);
     }
     if (_visibleOffset != null && _visibleOffset != 0) {
       fbBuilder.addUint32(21, _visibleOffset);
     }
-    if (_constCycleSlot != null && _constCycleSlot != 0) {
-      fbBuilder.addUint32(25, _constCycleSlot);
-    }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
 
 class _UnlinkedExecutableImpl extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   final fb.BufferPointer _bp;
 
   _UnlinkedExecutableImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   List<idl.UnlinkedConstructorInitializer> _constantInitializers;
+  int _constCycleSlot;
   idl.UnlinkedDocumentationComment _documentationComment;
+  bool _hasCodeRange;
   int _inferredReturnTypeSlot;
   bool _isAbstract;
   bool _isConst;
   bool _isExternal;
   bool _isFactory;
   bool _isRedirectedConstructor;
   bool _isStatic;
   idl.UnlinkedExecutableKind _kind;
   List<idl.UnlinkedExecutable> _localFunctions;
   List<idl.UnlinkedLabel> _localLabels;
   List<idl.UnlinkedVariable> _localVariables;
   String _name;
   int _nameEnd;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   int _periodOffset;
   idl.EntityRef _redirectedConstructor;
   String _redirectedConstructorName;
   idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
   int _visibleLength;
   int _visibleOffset;
-  int _constCycleSlot;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 6, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 28, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 27, 0);
+    return _codeOffset;
+  }
+
+  @override
   List<idl.UnlinkedConstructorInitializer> get constantInitializers {
     _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 14, const <idl.UnlinkedConstructorInitializer>[]);
     return _constantInitializers;
   }
 
   @override
+  int get constCycleSlot {
+    _constCycleSlot ??= const fb.Uint32Reader().vTableGet(_bp, 25, 0);
+    return _constCycleSlot;
+  }
+
+  @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 7, null);
     return _documentationComment;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 26, false);
+    return _hasCodeRange;
+  }
+
+  @override
   int get inferredReturnTypeSlot {
     _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
     return _inferredReturnTypeSlot;
   }
 
   @override
   bool get isAbstract {
     _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 10, false);
     return _isAbstract;
   }
@@ skipping 110 matching lines @@
   int get visibleLength {
     _visibleLength ??= const fb.Uint32Reader().vTableGet(_bp, 20, 0);
     return _visibleLength;
   }
 
   @override
   int get visibleOffset {
     _visibleOffset ??= const fb.Uint32Reader().vTableGet(_bp, 21, 0);
     return _visibleOffset;
   }
-
-  @override
-  int get constCycleSlot {
-    _constCycleSlot ??= const fb.Uint32Reader().vTableGet(_bp, 25, 0);
-    return _constCycleSlot;
-  }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (constantInitializers.isNotEmpty) _result["constantInitializers"] = constantInitializers.map((_value) => _value.toJson()).toList();
+    if (constCycleSlot != 0) _result["constCycleSlot"] = constCycleSlot;
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (inferredReturnTypeSlot != 0) _result["inferredReturnTypeSlot"] = inferredReturnTypeSlot;
     if (isAbstract != false) _result["isAbstract"] = isAbstract;
     if (isConst != false) _result["isConst"] = isConst;
     if (isExternal != false) _result["isExternal"] = isExternal;
     if (isFactory != false) _result["isFactory"] = isFactory;
     if (isRedirectedConstructor != false) _result["isRedirectedConstructor"] = isRedirectedConstructor;
     if (isStatic != false) _result["isStatic"] = isStatic;
     if (kind != idl.UnlinkedExecutableKind.functionOrMethod) _result["kind"] = kind.toString().split('.')[1];
     if (localFunctions.isNotEmpty) _result["localFunctions"] = localFunctions.map((_value) => _value.toJson()).toList();
     if (localLabels.isNotEmpty) _result["localLabels"] = localLabels.map((_value) => _value.toJson()).toList();
     if (localVariables.isNotEmpty) _result["localVariables"] = localVariables.map((_value) => _value.toJson()).toList();
     if (name != '') _result["name"] = name;
     if (nameEnd != 0) _result["nameEnd"] = nameEnd;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
     if (periodOffset != 0) _result["periodOffset"] = periodOffset;
     if (redirectedConstructor != null) _result["redirectedConstructor"] = redirectedConstructor.toJson();
     if (redirectedConstructorName != '') _result["redirectedConstructorName"] = redirectedConstructorName;
     if (returnType != null) _result["returnType"] = returnType.toJson();
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     if (visibleLength != 0) _result["visibleLength"] = visibleLength;
     if (visibleOffset != 0) _result["visibleOffset"] = visibleOffset;
-    if (constCycleSlot != 0) _result["constCycleSlot"] = constCycleSlot;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "constantInitializers": constantInitializers,
+    "constCycleSlot": constCycleSlot,
     "documentationComment": documentationComment,
+    "hasCodeRange": hasCodeRange,
     "inferredReturnTypeSlot": inferredReturnTypeSlot,
     "isAbstract": isAbstract,
     "isConst": isConst,
     "isExternal": isExternal,
     "isFactory": isFactory,
     "isRedirectedConstructor": isRedirectedConstructor,
     "isStatic": isStatic,
     "kind": kind,
     "localFunctions": localFunctions,
     "localLabels": localLabels,
     "localVariables": localVariables,
     "name": name,
     "nameEnd": nameEnd,
     "nameOffset": nameOffset,
     "parameters": parameters,
     "periodOffset": periodOffset,
     "redirectedConstructor": redirectedConstructor,
     "redirectedConstructorName": redirectedConstructorName,
     "returnType": returnType,
     "typeParameters": typeParameters,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
-    "constCycleSlot": constCycleSlot,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
@@ skipping 709 matching lines @@
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   UnlinkedConstBuilder _defaultValue;
   String _defaultValueCode;
+  bool _hasCodeRange;
   int _inferredTypeSlot;
   UnlinkedExecutableBuilder _initializer;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this parameter.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the parameter code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the parameter code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   UnlinkedConstBuilder get defaultValue => _defaultValue;
 
   /**
    * If the parameter has a default value, the constant expression in the
    * default value.  Note that the presence of this expression does not mean
    * that it is a valid, check [UnlinkedConst.isInvalid].
    */
   void set defaultValue(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _defaultValue = _value;
   }
 
   @override
   String get defaultValueCode => _defaultValueCode ??= '';
 
   /**
    * If the parameter has a default value, the source text of the constant
    * expression in the default value.  Otherwise the empty string.
    */
   void set defaultValueCode(String _value) {
     assert(!_finished);
     _defaultValueCode = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the parameter has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
    * If this parameter's type is inferable, nonzero slot id identifying which
    * entry in [LinkedLibrary.types] contains the inferred type.  If there is no
    * matching entry in [LinkedLibrary.types], then no type was inferred for
    * this variable, so its static type is `dynamic`.
    *
    * Note that although strong mode considers initializing formals to be
    * inferable, they are not marked as such in the summary; if their type is
@@ skipping 116 matching lines @@
 
   /**
    * The beginning of the visible range.
    */
   void set visibleOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
-  UnlinkedParamBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedConstBuilder defaultValue, String defaultValueCode, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isFunctionTyped, bool isInitializingFormal, idl.UnlinkedParamKind kind, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder type, int visibleLength, int visibleOffset})
+  UnlinkedParamBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, UnlinkedConstBuilder defaultValue, String defaultValueCode, bool hasCodeRange, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isFunctionTyped, bool isInitializingFormal, idl.UnlinkedParamKind kind, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder type, int visibleLength, int visibleOffset})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _defaultValue = defaultValue,
       _defaultValueCode = defaultValueCode,
+      _hasCodeRange = hasCodeRange,
       _inferredTypeSlot = inferredTypeSlot,
       _initializer = initializer,
       _isFunctionTyped = isFunctionTyped,
       _isInitializingFormal = isInitializingFormal,
       _kind = kind,
       _name = name,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _type = type,
       _visibleLength = visibleLength,
@@ skipping 27 matching lines @@
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(9, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(16, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(15, _codeOffset);
+    }
     if (offset_defaultValue != null) {
       fbBuilder.addOffset(7, offset_defaultValue);
     }
     if (offset_defaultValueCode != null) {
       fbBuilder.addOffset(13, offset_defaultValueCode);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(14, true);
+    }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
       fbBuilder.addUint32(2, _inferredTypeSlot);
     }
     if (offset_initializer != null) {
       fbBuilder.addOffset(12, offset_initializer);
     }
     if (_isFunctionTyped == true) {
       fbBuilder.addBool(5, true);
     }
     if (_isInitializingFormal == true) {
@@ skipping 30 matching lines @@
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
 class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   idl.UnlinkedConst _defaultValue;
   String _defaultValueCode;
+  bool _hasCodeRange;
   int _inferredTypeSlot;
   idl.UnlinkedExecutable _initializer;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 9, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 16, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 15, 0);
+    return _codeOffset;
+  }
+
+  @override
   idl.UnlinkedConst get defaultValue {
     _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 7, null);
     return _defaultValue;
   }
 
   @override
   String get defaultValueCode {
     _defaultValueCode ??= const fb.StringReader().vTableGet(_bp, 13, '');
     return _defaultValueCode;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 14, false);
+    return _hasCodeRange;
+  }
+
+  @override
   int get inferredTypeSlot {
     _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _inferredTypeSlot;
   }
 
   @override
   idl.UnlinkedExecutable get initializer {
     _initializer ??= const _UnlinkedExecutableReader().vTableGet(_bp, 12, null);
     return _initializer;
   }
@@ skipping 51 matching lines @@
     _visibleOffset ??= const fb.Uint32Reader().vTableGet(_bp, 11, 0);
     return _visibleOffset;
   }
 }
 
 abstract class _UnlinkedParamMixin implements idl.UnlinkedParam {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (defaultValue != null) _result["defaultValue"] = defaultValue.toJson();
     if (defaultValueCode != '') _result["defaultValueCode"] = defaultValueCode;
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (inferredTypeSlot != 0) _result["inferredTypeSlot"] = inferredTypeSlot;
     if (initializer != null) _result["initializer"] = initializer.toJson();
     if (isFunctionTyped != false) _result["isFunctionTyped"] = isFunctionTyped;
     if (isInitializingFormal != false) _result["isInitializingFormal"] = isInitializingFormal;
     if (kind != idl.UnlinkedParamKind.required) _result["kind"] = kind.toString().split('.')[1];
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
     if (type != null) _result["type"] = type.toJson();
     if (visibleLength != 0) _result["visibleLength"] = visibleLength;
     if (visibleOffset != 0) _result["visibleOffset"] = visibleOffset;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "defaultValue": defaultValue,
     "defaultValueCode": defaultValueCode,
+    "hasCodeRange": hasCodeRange,
     "inferredTypeSlot": inferredTypeSlot,
     "initializer": initializer,
     "isFunctionTyped": isFunctionTyped,
     "isInitializingFormal": isInitializingFormal,
     "kind": kind,
     "name": name,
     "nameOffset": nameOffset,
     "parameters": parameters,
     "type": type,
     "visibleLength": visibleLength,
@@ skipping 533 matching lines @@
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this typedef.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the typedef code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the typedef code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the typedef, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the typedef has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   String get name => _name ??= '';
 
   /**
    * Name of the typedef.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
@@ skipping 35 matching lines @@
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
-  UnlinkedTypedefBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
+  UnlinkedTypedefBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, UnlinkedDocumentationCommentBuilder documentationComment, bool hasCodeRange, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _documentationComment = documentationComment,
+      _hasCodeRange = hasCodeRange,
       _name = name,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _returnType = returnType,
       _typeParameters = typeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
@@ skipping 17 matching lines @@
     if (_returnType != null) {
       offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(4, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(9, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(8, _codeOffset);
+    }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(6, offset_documentationComment);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(7, true);
+    }
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_parameters != null) {
       fbBuilder.addOffset(3, offset_parameters);
     }
     if (offset_returnType != null) {
@@ skipping 12 matching lines @@
   @override
   _UnlinkedTypedefImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypedefImpl(bp);
 }
 
 class _UnlinkedTypedefImpl extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypedefImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    return _codeOffset;
+  }
+
+  @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 6, null);
     return _documentationComment;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    return _hasCodeRange;
+  }
+
+  @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;
   }
@@ skipping 15 matching lines @@
     _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 5, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 }
 
 abstract class _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
     if (returnType != null) _result["returnType"] = returnType.toJson();
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "documentationComment": documentationComment,
+    "hasCodeRange": hasCodeRange,
     "name": name,
     "nameOffset": nameOffset,
     "parameters": parameters,
     "returnType": returnType,
     "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
   EntityRefBuilder _bound;
+  int _codeLength;
+  int _codeOffset;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this type parameter.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
   EntityRefBuilder get bound => _bound;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   void set bound(EntityRefBuilder _value) {
     assert(!_finished);
     _bound = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the type parameter code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the type parameter code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the parameter has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @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;
   }
 
-  UnlinkedTypeParamBuilder({List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound, String name, int nameOffset})
+  UnlinkedTypeParamBuilder({List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound, int codeLength, int codeOffset, bool hasCodeRange, String name, int nameOffset})
     : _annotations = annotations,
       _bound = bound,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
+      _hasCodeRange = hasCodeRange,
       _name = name,
       _nameOffset = nameOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_bound;
     fb.Offset offset_name;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_bound != null) {
       offset_bound = _bound.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(3, offset_annotations);
     }
     if (offset_bound != null) {
       fbBuilder.addOffset(2, offset_bound);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(6, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(5, _codeOffset);
+    }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(4, true);
+    }
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedTypeParamReader extends fb.TableReader<_UnlinkedTypeParamImpl> {
   const _UnlinkedTypeParamReader();
 
   @override
   _UnlinkedTypeParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypeParamImpl(bp);
 }
 
 class _UnlinkedTypeParamImpl extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypeParamImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
   idl.EntityRef _bound;
+  int _codeLength;
+  int _codeOffset;
+  bool _hasCodeRange;
   String _name;
   int _nameOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.EntityRef get bound {
     _bound ??= const _EntityRefReader().vTableGet(_bp, 2, null);
     return _bound;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    return _codeOffset;
+  }
+
+  @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    return _hasCodeRange;
+  }
+
+  @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;
   }
 }
 
 abstract class _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
     if (bound != null) _result["bound"] = bound.toJson();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "bound": bound,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
+    "hasCodeRange": hasCodeRange,
     "name": name,
     "nameOffset": nameOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   bool _finished = false;
 
   List<UnlinkedClassBuilder> _classes;
+  int _codeLength;
+  int _codeOffset;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
+  bool _hasCodeRange;
   List<UnlinkedImportBuilder> _imports;
   List<UnlinkedConstBuilder> _libraryAnnotations;
   UnlinkedDocumentationCommentBuilder _libraryDocumentationComment;
   String _libraryName;
   int _libraryNameLength;
   int _libraryNameOffset;
   List<UnlinkedPartBuilder> _parts;
   UnlinkedPublicNamespaceBuilder _publicNamespace;
   List<UnlinkedReferenceBuilder> _references;
   List<UnlinkedTypedefBuilder> _typedefs;
   List<UnlinkedVariableBuilder> _variables;
 
   @override
   List<UnlinkedClassBuilder> get classes => _classes ??= <UnlinkedClassBuilder>[];
 
   /**
    * Classes declared in the compilation unit.
    */
   void set classes(List<UnlinkedClassBuilder> _value) {
     assert(!_finished);
     _classes = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the unit code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the unit code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   List<UnlinkedEnumBuilder> get enums => _enums ??= <UnlinkedEnumBuilder>[];
 
   /**
    * Enums declared in the compilation unit.
    */
   void set enums(List<UnlinkedEnumBuilder> _value) {
     assert(!_finished);
     _enums = _value;
   }
 
@@ skipping 14 matching lines @@
 
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportNonPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the unit has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   List<UnlinkedImportBuilder> get imports => _imports ??= <UnlinkedImportBuilder>[];
 
   /**
    * Import declarations in the compilation unit.
    */
   void set imports(List<UnlinkedImportBuilder> _value) {
     assert(!_finished);
     _imports = _value;
   }
 
@@ skipping 110 matching lines @@
   List<UnlinkedVariableBuilder> get variables => _variables ??= <UnlinkedVariableBuilder>[];
 
   /**
    * Top level variables declared in the compilation unit.
    */
   void set variables(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _variables = _value;
   }
 
-  UnlinkedUnitBuilder({List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, String libraryName, int libraryNameLength, int libraryNameOffset, List<UnlinkedPartBuilder> parts, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
+  UnlinkedUnitBuilder({List<UnlinkedClassBuilder> classes, int codeLength, int codeOffset, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, bool hasCodeRange, List<UnlinkedImportBuilder> imports, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, String libraryName, int libraryNameLength, int libraryNameOffset, List<UnlinkedPartBuilder> parts, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
     : _classes = classes,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _enums = enums,
       _executables = executables,
       _exports = exports,
+      _hasCodeRange = hasCodeRange,
       _imports = imports,
       _libraryAnnotations = libraryAnnotations,
       _libraryDocumentationComment = libraryDocumentationComment,
       _libraryName = libraryName,
       _libraryNameLength = libraryNameLength,
       _libraryNameOffset = libraryNameOffset,
       _parts = parts,
       _publicNamespace = publicNamespace,
       _references = references,
       _typedefs = typedefs,
@@ skipping 56 matching lines @@
     if (!(_typedefs == null || _typedefs.isEmpty)) {
       offset_typedefs = fbBuilder.writeList(_typedefs.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_variables == null || _variables.isEmpty)) {
       offset_variables = fbBuilder.writeList(_variables.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_classes != null) {
       fbBuilder.addOffset(2, offset_classes);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(17, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(16, _codeOffset);
+    }
     if (offset_enums != null) {
       fbBuilder.addOffset(12, offset_enums);
     }
     if (offset_executables != null) {
       fbBuilder.addOffset(4, offset_executables);
     }
     if (offset_exports != null) {
       fbBuilder.addOffset(13, offset_exports);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(15, true);
+    }
     if (offset_imports != null) {
       fbBuilder.addOffset(5, offset_imports);
     }
     if (offset_libraryAnnotations != null) {
       fbBuilder.addOffset(14, offset_libraryAnnotations);
     }
     if (offset_libraryDocumentationComment != null) {
       fbBuilder.addOffset(9, offset_libraryDocumentationComment);
     }
     if (offset_libraryName != null) {
@@ skipping 35 matching lines @@
   @override
   _UnlinkedUnitImpl createObject(fb.BufferPointer bp) => new _UnlinkedUnitImpl(bp);
 }
 
 class _UnlinkedUnitImpl extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   final fb.BufferPointer _bp;
 
   _UnlinkedUnitImpl(this._bp);
 
   List<idl.UnlinkedClass> _classes;
+  int _codeLength;
+  int _codeOffset;
   List<idl.UnlinkedEnum> _enums;
   List<idl.UnlinkedExecutable> _executables;
   List<idl.UnlinkedExportNonPublic> _exports;
+  bool _hasCodeRange;
   List<idl.UnlinkedImport> _imports;
   List<idl.UnlinkedConst> _libraryAnnotations;
   idl.UnlinkedDocumentationComment _libraryDocumentationComment;
   String _libraryName;
   int _libraryNameLength;
   int _libraryNameOffset;
   List<idl.UnlinkedPart> _parts;
   idl.UnlinkedPublicNamespace _publicNamespace;
   List<idl.UnlinkedReference> _references;
   List<idl.UnlinkedTypedef> _typedefs;
   List<idl.UnlinkedVariable> _variables;
 
   @override
   List<idl.UnlinkedClass> get classes {
     _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 2, const <idl.UnlinkedClass>[]);
     return _classes;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 17, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 16, 0);
+    return _codeOffset;
+  }
+
+  @override
   List<idl.UnlinkedEnum> get enums {
     _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 12, const <idl.UnlinkedEnum>[]);
     return _enums;
   }
 
   @override
   List<idl.UnlinkedExecutable> get executables {
     _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 4, const <idl.UnlinkedExecutable>[]);
     return _executables;
   }
 
   @override
   List<idl.UnlinkedExportNonPublic> get exports {
     _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 13, const <idl.UnlinkedExportNonPublic>[]);
     return _exports;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 15, false);
+    return _hasCodeRange;
+  }
+
+  @override
   List<idl.UnlinkedImport> get imports {
     _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 5, const <idl.UnlinkedImport>[]);
     return _imports;
   }
 
   @override
   List<idl.UnlinkedConst> get libraryAnnotations {
     _libraryAnnotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 14, const <idl.UnlinkedConst>[]);
     return _libraryAnnotations;
   }
@@ skipping 51 matching lines @@
     _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 3, const <idl.UnlinkedVariable>[]);
     return _variables;
   }
 }
 
 abstract class _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (classes.isNotEmpty) _result["classes"] = classes.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (enums.isNotEmpty) _result["enums"] = enums.map((_value) => _value.toJson()).toList();
     if (executables.isNotEmpty) _result["executables"] = executables.map((_value) => _value.toJson()).toList();
     if (exports.isNotEmpty) _result["exports"] = exports.map((_value) => _value.toJson()).toList();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (imports.isNotEmpty) _result["imports"] = imports.map((_value) => _value.toJson()).toList();
     if (libraryAnnotations.isNotEmpty) _result["libraryAnnotations"] = libraryAnnotations.map((_value) => _value.toJson()).toList();
     if (libraryDocumentationComment != null) _result["libraryDocumentationComment"] = libraryDocumentationComment.toJson();
     if (libraryName != '') _result["libraryName"] = libraryName;
     if (libraryNameLength != 0) _result["libraryNameLength"] = libraryNameLength;
     if (libraryNameOffset != 0) _result["libraryNameOffset"] = libraryNameOffset;
     if (parts.isNotEmpty) _result["parts"] = parts.map((_value) => _value.toJson()).toList();
     if (publicNamespace != null) _result["publicNamespace"] = publicNamespace.toJson();
     if (references.isNotEmpty) _result["references"] = references.map((_value) => _value.toJson()).toList();
     if (typedefs.isNotEmpty) _result["typedefs"] = typedefs.map((_value) => _value.toJson()).toList();
     if (variables.isNotEmpty) _result["variables"] = variables.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "classes": classes,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "enums": enums,
     "executables": executables,
     "exports": exports,
+    "hasCodeRange": hasCodeRange,
     "imports": imports,
     "libraryAnnotations": libraryAnnotations,
     "libraryDocumentationComment": libraryDocumentationComment,
     "libraryName": libraryName,
     "libraryNameLength": libraryNameLength,
     "libraryNameOffset": libraryNameOffset,
     "parts": parts,
     "publicNamespace": publicNamespace,
     "references": references,
     "typedefs": typedefs,
     "variables": variables,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
+  int _codeLength;
+  int _codeOffset;
   UnlinkedConstBuilder _constExpr;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  bool _hasCodeRange;
   int _inferredTypeSlot;
   UnlinkedExecutableBuilder _initializer;
   bool _isConst;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   EntityRefBuilder _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this variable.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
+  int get codeLength => _codeLength ??= 0;
+
+  /**
+   * Length of the variable code.
+   */
+  void set codeLength(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeLength = _value;
+  }
+
+  @override
+  int get codeOffset => _codeOffset ??= 0;
+
+  /**
+   * Offset of the variable code relative to the beginning of the file.
+   */
+  void set codeOffset(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _codeOffset = _value;
+  }
+
+  @override
   UnlinkedConstBuilder get constExpr => _constExpr;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.  Note that the presence of this expression
    * does not mean that it is a valid, check [UnlinkedConst.isInvalid].
    */
   void set constExpr(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _constExpr = _value;
   }
 
   @override
   UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  bool get hasCodeRange => _hasCodeRange ??= false;
+
+  /**
+   * Indicates whether the variable has the code range.
+   */
+  void set hasCodeRange(bool _value) {
+    assert(!_finished);
+    _hasCodeRange = _value;
+  }
+
+  @override
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
    * If this variable is inferable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the inferred type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then no type was
    * inferred for this variable, so its static type is `dynamic`.
    */
   void set inferredTypeSlot(int _value) {
     assert(!_finished);
@@ skipping 118 matching lines @@
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
-  UnlinkedVariableBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedConstBuilder constExpr, UnlinkedDocumentationCommentBuilder documentationComment, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isConst, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type, int visibleLength, int visibleOffset})
+  UnlinkedVariableBuilder({List<UnlinkedConstBuilder> annotations, int codeLength, int codeOffset, UnlinkedConstBuilder constExpr, UnlinkedDocumentationCommentBuilder documentationComment, bool hasCodeRange, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isConst, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type, int visibleLength, int visibleOffset})
     : _annotations = annotations,
+      _codeLength = codeLength,
+      _codeOffset = codeOffset,
       _constExpr = constExpr,
       _documentationComment = documentationComment,
+      _hasCodeRange = hasCodeRange,
       _inferredTypeSlot = inferredTypeSlot,
       _initializer = initializer,
       _isConst = isConst,
       _isFinal = isFinal,
       _isStatic = isStatic,
       _name = name,
       _nameOffset = nameOffset,
       _propagatedTypeSlot = propagatedTypeSlot,
       _type = type,
       _visibleLength = visibleLength,
@@ skipping 23 matching lines @@
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
       fbBuilder.addOffset(8, offset_annotations);
     }
+    if (_codeLength != null && _codeLength != 0) {
+      fbBuilder.addUint32(16, _codeLength);
+    }
+    if (_codeOffset != null && _codeOffset != 0) {
+      fbBuilder.addUint32(15, _codeOffset);
+    }
     if (offset_constExpr != null) {
       fbBuilder.addOffset(5, offset_constExpr);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(10, offset_documentationComment);
     }
+    if (_hasCodeRange == true) {
+      fbBuilder.addBool(14, true);
+    }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
       fbBuilder.addUint32(9, _inferredTypeSlot);
     }
     if (offset_initializer != null) {
       fbBuilder.addOffset(13, offset_initializer);
     }
     if (_isConst == true) {
       fbBuilder.addBool(6, true);
     }
     if (_isFinal == true) {
@@ skipping 30 matching lines @@
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
 }
 
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
+  int _codeLength;
+  int _codeOffset;
   idl.UnlinkedConst _constExpr;
   idl.UnlinkedDocumentationComment _documentationComment;
+  bool _hasCodeRange;
   int _inferredTypeSlot;
   idl.UnlinkedExecutable _initializer;
   bool _isConst;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   idl.EntityRef _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 8, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
+  int get codeLength {
+    _codeLength ??= const fb.Uint32Reader().vTableGet(_bp, 16, 0);
+    return _codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    _codeOffset ??= const fb.Uint32Reader().vTableGet(_bp, 15, 0);
+    return _codeOffset;
+  }
+
+  @override
   idl.UnlinkedConst get constExpr {
     _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 5, null);
     return _constExpr;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 10, null);
     return _documentationComment;
   }
 
   @override
+  bool get hasCodeRange {
+    _hasCodeRange ??= const fb.BoolReader().vTableGet(_bp, 14, false);
+    return _hasCodeRange;
+  }
+
+  @override
   int get inferredTypeSlot {
     _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _inferredTypeSlot;
   }
 
   @override
   idl.UnlinkedExecutable get initializer {
     _initializer ??= const _UnlinkedExecutableReader().vTableGet(_bp, 13, null);
     return _initializer;
   }
@@ skipping 51 matching lines @@
     _visibleOffset ??= const fb.Uint32Reader().vTableGet(_bp, 12, 0);
     return _visibleOffset;
   }
 }
 
 abstract class _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
+    if (codeLength != 0) _result["codeLength"] = codeLength;
+    if (codeOffset != 0) _result["codeOffset"] = codeOffset;
     if (constExpr != null) _result["constExpr"] = constExpr.toJson();
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
+    if (hasCodeRange != false) _result["hasCodeRange"] = hasCodeRange;
     if (inferredTypeSlot != 0) _result["inferredTypeSlot"] = inferredTypeSlot;
     if (initializer != null) _result["initializer"] = initializer.toJson();
     if (isConst != false) _result["isConst"] = isConst;
     if (isFinal != false) _result["isFinal"] = isFinal;
     if (isStatic != false) _result["isStatic"] = isStatic;
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (propagatedTypeSlot != 0) _result["propagatedTypeSlot"] = propagatedTypeSlot;
     if (type != null) _result["type"] = type.toJson();
     if (visibleLength != 0) _result["visibleLength"] = visibleLength;
     if (visibleOffset != 0) _result["visibleOffset"] = visibleOffset;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
+    "codeLength": codeLength,
+    "codeOffset": codeOffset,
     "constExpr": constExpr,
     "documentationComment": documentationComment,
+    "hasCodeRange": hasCodeRange,
     "inferredTypeSlot": inferredTypeSlot,
     "initializer": initializer,
     "isConst": isConst,
     "isFinal": isFinal,
     "isStatic": isStatic,
     "name": name,
     "nameOffset": nameOffset,
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }