Make summary format stable when adding getters to idl.

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 187 matching lines @@
     fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_typeArguments;
     if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
       offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
     }
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_implicitFunctionTypeIndices != null) {
-      fbBuilder.addOffset(0, offset_implicitFunctionTypeIndices);
+      fbBuilder.addOffset(4, offset_implicitFunctionTypeIndices);
     }
     if (_paramReference != null && _paramReference != 0) {
-      fbBuilder.addUint32(1, _paramReference);
+      fbBuilder.addUint32(3, _paramReference);
     }
     if (_reference != null && _reference != 0) {
-      fbBuilder.addUint32(2, _reference);
+      fbBuilder.addUint32(0, _reference);
     }
     if (_slot != null && _slot != 0) {
-      fbBuilder.addUint32(3, _slot);
+      fbBuilder.addUint32(2, _slot);
     }
     if (offset_typeArguments != null) {
-      fbBuilder.addOffset(4, offset_typeArguments);
+      fbBuilder.addOffset(1, offset_typeArguments);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _EntityRefReader extends fb.TableReader<_EntityRefImpl> {
   const _EntityRefReader();
 
   @override
   _EntityRefImpl createObject(fb.BufferPointer bp) => new _EntityRefImpl(bp);
 }
 
 class _EntityRefImpl extends Object with _EntityRefMixin implements idl.EntityRef {
   final fb.BufferPointer _bp;
 
   _EntityRefImpl(this._bp);
 
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<idl.EntityRef> _typeArguments;
 
   @override
   List<int> get implicitFunctionTypeIndices {
-    _implicitFunctionTypeIndices ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 0, const <int>[]);
+    _implicitFunctionTypeIndices ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 4, const <int>[]);
     return _implicitFunctionTypeIndices;
   }
 
   @override
   int get paramReference {
-    _paramReference ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _paramReference ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _paramReference;
   }
 
   @override
   int get reference {
-    _reference ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _reference ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _reference;
   }
 
   @override
   int get slot {
-    _slot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _slot ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _slot;
   }
 
   @override
   List<idl.EntityRef> get typeArguments {
-    _typeArguments ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <idl.EntityRef>[]);
+    _typeArguments ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 1, const <idl.EntityRef>[]);
     return _typeArguments;
   }
 }
 
 abstract class _EntityRefMixin implements idl.EntityRef {
   @override
   Map<String, Object> toMap() => {
     "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
     "paramReference": paramReference,
     "reference": reference,
@@ skipping 45 matching lines @@
     fb.Offset offset_parts;
     fb.Offset offset_uri;
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
     fbBuilder.startTable();
     if (offset_parts != null) {
-      fbBuilder.addOffset(0, offset_parts);
+      fbBuilder.addOffset(1, offset_parts);
     }
     if (offset_uri != null) {
-      fbBuilder.addOffset(1, offset_uri);
+      fbBuilder.addOffset(0, offset_uri);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedDependencyReader extends fb.TableReader<_LinkedDependencyImpl> {
   const _LinkedDependencyReader();
 
   @override
   _LinkedDependencyImpl createObject(fb.BufferPointer bp) => new _LinkedDependencyImpl(bp);
 }
 
 class _LinkedDependencyImpl extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
   final fb.BufferPointer _bp;
 
   _LinkedDependencyImpl(this._bp);
 
   List<String> _parts;
   String _uri;
 
   @override
   List<String> get parts {
-    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _parts;
   }
 
   @override
   String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 1, '');
+    _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 }
 
 abstract class _LinkedDependencyMixin implements idl.LinkedDependency {
   @override
   Map<String, Object> toMap() => {
     "parts": parts,
     "uri": uri,
   };
@@ skipping 69 matching lines @@
     _finished = true;
     fb.Offset offset_name;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (_dependency != null && _dependency != 0) {
       fbBuilder.addUint32(0, _dependency);
     }
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
-      fbBuilder.addUint32(1, _kind.index);
+      fbBuilder.addUint32(3, _kind.index);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(2, offset_name);
+      fbBuilder.addOffset(1, offset_name);
     }
     if (_unit != null && _unit != 0) {
-      fbBuilder.addUint32(3, _unit);
+      fbBuilder.addUint32(2, _unit);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedExportNameReader extends fb.TableReader<_LinkedExportNameImpl> {
   const _LinkedExportNameReader();
 
   @override
   _LinkedExportNameImpl createObject(fb.BufferPointer bp) => new _LinkedExportNameImpl(bp);
@@ skipping 10 matching lines @@
   int _unit;
 
   @override
   int get dependency {
     _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _dependency;
   }
 
   @override
   idl.ReferenceKind get kind {
-    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, idl.ReferenceKind.classOrEnum);
+    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 3, idl.ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _name;
   }
 
   @override
   int get unit {
-    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _unit;
   }
 }
 
 abstract class _LinkedExportNameMixin implements idl.LinkedExportName {
   @override
   Map<String, Object> toMap() => {
     "dependency": dependency,
     "kind": kind,
     "name": name,
@@ skipping 119 matching lines @@
       offset_importDependencies = fbBuilder.writeListUint32(_importDependencies);
     }
     if (!(_units == null || _units.isEmpty)) {
       offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_dependencies != null) {
       fbBuilder.addOffset(0, offset_dependencies);
     }
     if (offset_exportNames != null) {
-      fbBuilder.addOffset(1, offset_exportNames);
+      fbBuilder.addOffset(4, offset_exportNames);
     }
     if (offset_importDependencies != null) {
-      fbBuilder.addOffset(2, offset_importDependencies);
+      fbBuilder.addOffset(1, offset_importDependencies);
     }
     if (_numPrelinkedDependencies != null && _numPrelinkedDependencies != 0) {
-      fbBuilder.addUint32(3, _numPrelinkedDependencies);
+      fbBuilder.addUint32(2, _numPrelinkedDependencies);
     }
     if (offset_units != null) {
-      fbBuilder.addOffset(4, offset_units);
+      fbBuilder.addOffset(3, offset_units);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.LinkedLibrary readLinkedLibrary(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _LinkedLibraryReader().read(rootRef);
 }
 
@@ skipping 16 matching lines @@
   List<idl.LinkedUnit> _units;
 
   @override
   List<idl.LinkedDependency> get dependencies {
     _dependencies ??= const fb.ListReader<idl.LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 0, const <idl.LinkedDependency>[]);
     return _dependencies;
   }
 
   @override
   List<idl.LinkedExportName> get exportNames {
-    _exportNames ??= const fb.ListReader<idl.LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 1, const <idl.LinkedExportName>[]);
+    _exportNames ??= const fb.ListReader<idl.LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 4, const <idl.LinkedExportName>[]);
     return _exportNames;
   }
 
   @override
   List<int> get importDependencies {
-    _importDependencies ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 2, const <int>[]);
+    _importDependencies ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 1, const <int>[]);
     return _importDependencies;
   }
 
   @override
   int get numPrelinkedDependencies {
-    _numPrelinkedDependencies ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _numPrelinkedDependencies ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _numPrelinkedDependencies;
   }
 
   @override
   List<idl.LinkedUnit> get units {
-    _units ??= const fb.ListReader<idl.LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 4, const <idl.LinkedUnit>[]);
+    _units ??= const fb.ListReader<idl.LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 3, const <idl.LinkedUnit>[]);
     return _units;
   }
 }
 
 abstract class _LinkedLibraryMixin implements idl.LinkedLibrary {
   @override
   Map<String, Object> toMap() => {
     "dependencies": dependencies,
     "exportNames": exportNames,
     "importDependencies": importDependencies,
@@ skipping 114 matching lines @@
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (_containingReference != null && _containingReference != 0) {
-      fbBuilder.addUint32(0, _containingReference);
+      fbBuilder.addUint32(5, _containingReference);
     }
     if (_dependency != null && _dependency != 0) {
       fbBuilder.addUint32(1, _dependency);
     }
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
       fbBuilder.addUint32(2, _kind.index);
     }
     if (offset_name != null) {
       fbBuilder.addOffset(3, offset_name);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addUint32(4, _numTypeParameters);
     }
     if (_unit != null && _unit != 0) {
-      fbBuilder.addUint32(5, _unit);
+      fbBuilder.addUint32(0, _unit);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedReferenceReader extends fb.TableReader<_LinkedReferenceImpl> {
   const _LinkedReferenceReader();
 
   @override
   _LinkedReferenceImpl createObject(fb.BufferPointer bp) => new _LinkedReferenceImpl(bp);
 }
 
 class _LinkedReferenceImpl extends Object with _LinkedReferenceMixin implements idl.LinkedReference {
   final fb.BufferPointer _bp;
 
   _LinkedReferenceImpl(this._bp);
 
   int _containingReference;
   int _dependency;
   idl.ReferenceKind _kind;
   String _name;
   int _numTypeParameters;
   int _unit;
 
   @override
   int get containingReference {
-    _containingReference ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    _containingReference ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
     return _containingReference;
   }
 
   @override
   int get dependency {
     _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _dependency;
   }
 
   @override
   idl.ReferenceKind get kind {
     _kind ??= const _ReferenceKindReader().vTableGet(_bp, 2, idl.ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 3, '');
     return _name;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 4, 0);
     return _numTypeParameters;
   }
 
   @override
   int get unit {
-    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _unit;
   }
 }
 
 abstract class _LinkedReferenceMixin implements idl.LinkedReference {
   @override
   Map<String, Object> toMap() => {
     "containingReference": containingReference,
     "dependency": dependency,
     "kind": kind,
@@ skipping 469 matching lines @@
       offset_name = fbBuilder.writeString(_name);
     }
     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(0, offset_annotations);
+      fbBuilder.addOffset(5, offset_annotations);
     }
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(1, offset_documentationComment);
+      fbBuilder.addOffset(6, offset_documentationComment);
     }
     if (offset_executables != null) {
       fbBuilder.addOffset(2, offset_executables);
     }
     if (offset_fields != null) {
-      fbBuilder.addOffset(3, offset_fields);
+      fbBuilder.addOffset(4, offset_fields);
     }
     if (_hasNoSupertype == true) {
-      fbBuilder.addBool(4, true);
+      fbBuilder.addBool(12, true);
     }
     if (offset_interfaces != null) {
-      fbBuilder.addOffset(5, offset_interfaces);
+      fbBuilder.addOffset(7, offset_interfaces);
     }
     if (_isAbstract == true) {
-      fbBuilder.addBool(6, true);
+      fbBuilder.addBool(8, true);
     }
     if (_isMixinApplication == true) {
-      fbBuilder.addBool(7, true);
+      fbBuilder.addBool(11, true);
     }
     if (offset_mixins != null) {
-      fbBuilder.addOffset(8, offset_mixins);
+      fbBuilder.addOffset(10, offset_mixins);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(9, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(10, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_supertype != null) {
-      fbBuilder.addOffset(11, offset_supertype);
+      fbBuilder.addOffset(3, offset_supertype);
     }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(12, offset_typeParameters);
+      fbBuilder.addOffset(9, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedClassReader extends fb.TableReader<_UnlinkedClassImpl> {
   const _UnlinkedClassReader();
 
   @override
   _UnlinkedClassImpl createObject(fb.BufferPointer bp) => new _UnlinkedClassImpl(bp);
@@ skipping 13 matching lines @@
   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, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 5, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    _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, 3, const <idl.UnlinkedVariable>[]);
+    _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 4, const <idl.UnlinkedVariable>[]);
     return _fields;
   }
 
   @override
   bool get hasNoSupertype {
-    _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    _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, 5, const <idl.EntityRef>[]);
+    _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 7, const <idl.EntityRef>[]);
     return _interfaces;
   }
 
   @override
   bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 8, false);
     return _isAbstract;
   }
 
   @override
   bool get isMixinApplication {
-    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _isMixinApplication;
   }
 
   @override
   List<idl.EntityRef> get mixins {
-    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 8, const <idl.EntityRef>[]);
+    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 10, const <idl.EntityRef>[]);
     return _mixins;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 9, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 10, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   idl.EntityRef get supertype {
-    _supertype ??= const _EntityRefReader().vTableGet(_bp, 11, null);
+    _supertype ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _supertype;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 12, const <idl.UnlinkedTypeParam>[]);
+    _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> toMap() => {
     "annotations": annotations,
     "documentationComment": documentationComment,
     "executables": executables,
@@ skipping 48 matching lines @@
     fb.Offset offset_hides;
     fb.Offset offset_shows;
     if (!(_hides == null || _hides.isEmpty)) {
       offset_hides = fbBuilder.writeList(_hides.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_shows == null || _shows.isEmpty)) {
       offset_shows = fbBuilder.writeList(_shows.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
     if (offset_hides != null) {
-      fbBuilder.addOffset(0, offset_hides);
+      fbBuilder.addOffset(1, offset_hides);
     }
     if (offset_shows != null) {
-      fbBuilder.addOffset(1, offset_shows);
+      fbBuilder.addOffset(0, offset_shows);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedCombinatorReader extends fb.TableReader<_UnlinkedCombinatorImpl> {
   const _UnlinkedCombinatorReader();
 
   @override
   _UnlinkedCombinatorImpl createObject(fb.BufferPointer bp) => new _UnlinkedCombinatorImpl(bp);
 }
 
 class _UnlinkedCombinatorImpl extends Object with _UnlinkedCombinatorMixin implements idl.UnlinkedCombinator {
   final fb.BufferPointer _bp;
 
   _UnlinkedCombinatorImpl(this._bp);
 
   List<String> _hides;
   List<String> _shows;
 
   @override
   List<String> get hides {
-    _hides ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    _hides ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _hides;
   }
 
   @override
   List<String> get shows {
-    _shows ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
+    _shows ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
     return _shows;
   }
 }
 
 abstract class _UnlinkedCombinatorMixin implements idl.UnlinkedCombinator {
   @override
   Map<String, Object> toMap() => {
     "hides": hides,
     "shows": shows,
   };
@@ skipping 110 matching lines @@
       offset_operations = fbBuilder.writeListUint32(_operations.map((b) => b.index).toList());
     }
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_strings == null || _strings.isEmpty)) {
       offset_strings = fbBuilder.writeList(_strings.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
     if (offset_doubles != null) {
-      fbBuilder.addOffset(0, offset_doubles);
+      fbBuilder.addOffset(4, offset_doubles);
     }
     if (offset_ints != null) {
       fbBuilder.addOffset(1, offset_ints);
     }
     if (_isInvalid == true) {
-      fbBuilder.addBool(2, true);
+      fbBuilder.addBool(5, true);
     }
     if (offset_operations != null) {
-      fbBuilder.addOffset(3, offset_operations);
+      fbBuilder.addOffset(0, offset_operations);
     }
     if (offset_references != null) {
-      fbBuilder.addOffset(4, offset_references);
+      fbBuilder.addOffset(2, offset_references);
     }
     if (offset_strings != null) {
-      fbBuilder.addOffset(5, offset_strings);
+      fbBuilder.addOffset(3, offset_strings);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstReader extends fb.TableReader<_UnlinkedConstImpl> {
   const _UnlinkedConstReader();
 
   @override
   _UnlinkedConstImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstImpl(bp);
 }
 
 class _UnlinkedConstImpl extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstImpl(this._bp);
 
   List<double> _doubles;
   List<int> _ints;
   bool _isInvalid;
   List<idl.UnlinkedConstOperation> _operations;
   List<idl.EntityRef> _references;
   List<String> _strings;
 
   @override
   List<double> get doubles {
-    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 0, const <double>[]);
+    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 4, const <double>[]);
     return _doubles;
   }
 
   @override
   List<int> get ints {
     _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 1, const <int>[]);
     return _ints;
   }
 
   @override
   bool get isInvalid {
-    _isInvalid ??= const fb.BoolReader().vTableGet(_bp, 2, false);
+    _isInvalid ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isInvalid;
   }
 
   @override
   List<idl.UnlinkedConstOperation> get operations {
-    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 3, const <idl.UnlinkedConstOperation>[]);
+    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 0, const <idl.UnlinkedConstOperation>[]);
     return _operations;
   }
 
   @override
   List<idl.EntityRef> get references {
-    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <idl.EntityRef>[]);
+    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 2, const <idl.EntityRef>[]);
     return _references;
   }
 
   @override
   List<String> get strings {
-    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 5, const <String>[]);
+    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 3, const <String>[]);
     return _strings;
   }
 }
 
 abstract class _UnlinkedConstMixin implements idl.UnlinkedConst {
   @override
   Map<String, Object> toMap() => {
     "doubles": doubles,
     "ints": ints,
     "isInvalid": isInvalid,
@@ skipping 76 matching lines @@
       offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_expression != null) {
       offset_expression = _expression.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (offset_arguments != null) {
-      fbBuilder.addOffset(0, offset_arguments);
+      fbBuilder.addOffset(3, offset_arguments);
     }
     if (offset_expression != null) {
       fbBuilder.addOffset(1, offset_expression);
     }
     if (_kind != null && _kind != idl.UnlinkedConstructorInitializerKind.field) {
       fbBuilder.addUint32(2, _kind.index);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(3, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstructorInitializerReader extends fb.TableReader<_UnlinkedConstructorInitializerImpl> {
   const _UnlinkedConstructorInitializerReader();
 
   @override
   _UnlinkedConstructorInitializerImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstructorInitializerImpl(bp);
 }
 
 class _UnlinkedConstructorInitializerImpl extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstructorInitializerImpl(this._bp);
 
   List<idl.UnlinkedConst> _arguments;
   idl.UnlinkedConst _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
 
   @override
   List<idl.UnlinkedConst> get arguments {
-    _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
     return _arguments;
   }
 
   @override
   idl.UnlinkedConst get expression {
     _expression ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
     return _expression;
   }
 
   @override
   idl.UnlinkedConstructorInitializerKind get kind {
     _kind ??= const _UnlinkedConstructorInitializerKindReader().vTableGet(_bp, 2, idl.UnlinkedConstructorInitializerKind.field);
     return _kind;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 3, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 }
 
 abstract class _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   @override
   Map<String, Object> toMap() => {
     "arguments": arguments,
     "expression": expression,
     "kind": kind,
@@ skipping 57 matching lines @@
     _finished = true;
     fb.Offset offset_text;
     if (_text != null) {
       offset_text = fbBuilder.writeString(_text);
     }
     fbBuilder.startTable();
     if (_length != null && _length != 0) {
       fbBuilder.addUint32(0, _length);
     }
     if (_offset != null && _offset != 0) {
-      fbBuilder.addUint32(1, _offset);
+      fbBuilder.addUint32(2, _offset);
     }
     if (offset_text != null) {
-      fbBuilder.addOffset(2, offset_text);
+      fbBuilder.addOffset(1, offset_text);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedDocumentationCommentReader extends fb.TableReader<_UnlinkedDocumentationCommentImpl> {
   const _UnlinkedDocumentationCommentReader();
 
   @override
   _UnlinkedDocumentationCommentImpl createObject(fb.BufferPointer bp) => new _UnlinkedDocumentationCommentImpl(bp);
 }
 
 class _UnlinkedDocumentationCommentImpl extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   final fb.BufferPointer _bp;
 
   _UnlinkedDocumentationCommentImpl(this._bp);
 
   int _length;
   int _offset;
   String _text;
 
   @override
   int get length {
     _length ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _length;
   }
 
   @override
   int get offset {
-    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _offset;
   }
 
   @override
   String get text {
-    _text ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _text ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _text;
   }
 }
 
 abstract class _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   @override
   Map<String, Object> toMap() => {
     "length": length,
     "offset": offset,
     "text": text,
@@ skipping 87 matching lines @@
       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(0, offset_annotations);
+      fbBuilder.addOffset(4, offset_annotations);
     }
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(1, offset_documentationComment);
+      fbBuilder.addOffset(3, offset_documentationComment);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(2, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(3, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_values != null) {
-      fbBuilder.addOffset(4, offset_values);
+      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;
   idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedEnumValue> _values;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 3, null);
     return _documentationComment;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _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, 4, const <idl.UnlinkedEnumValue>[]);
+    _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> toMap() => {
     "annotations": annotations,
     "documentationComment": documentationComment,
     "name": name,
@@ skipping 55 matching lines @@
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(0, offset_documentationComment);
+      fbBuilder.addOffset(2, offset_documentationComment);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(1, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(2, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedEnumValueReader extends fb.TableReader<_UnlinkedEnumValueImpl> {
   const _UnlinkedEnumValueReader();
 
   @override
   _UnlinkedEnumValueImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumValueImpl(bp);
 }
 
 class _UnlinkedEnumValueImpl extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumValueImpl(this._bp);
 
   idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 0, null);
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 }
 
 abstract class _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   @override
   Map<String, Object> toMap() => {
     "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
@@ skipping 299 matching lines @@
       offset_redirectedConstructorName = fbBuilder.writeString(_redirectedConstructorName);
     }
     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(0, offset_annotations);
+      fbBuilder.addOffset(6, offset_annotations);
     }
     if (offset_constantInitializers != null) {
-      fbBuilder.addOffset(1, offset_constantInitializers);
+      fbBuilder.addOffset(14, offset_constantInitializers);
     }
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
+      fbBuilder.addOffset(7, offset_documentationComment);
     }
     if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
-      fbBuilder.addUint32(3, _inferredReturnTypeSlot);
+      fbBuilder.addUint32(5, _inferredReturnTypeSlot);
     }
     if (_isAbstract == true) {
-      fbBuilder.addBool(4, true);
+      fbBuilder.addBool(10, true);
     }
     if (_isConst == true) {
-      fbBuilder.addBool(5, true);
+      fbBuilder.addBool(12, true);
     }
     if (_isExternal == true) {
-      fbBuilder.addBool(6, true);
+      fbBuilder.addBool(11, true);
     }
     if (_isFactory == true) {
-      fbBuilder.addBool(7, true);
+      fbBuilder.addBool(8, true);
     }
     if (_isRedirectedConstructor == true) {
-      fbBuilder.addBool(8, true);
+      fbBuilder.addBool(13, true);
     }
     if (_isStatic == true) {
       fbBuilder.addBool(9, true);
     }
     if (_kind != null && _kind != idl.UnlinkedExecutableKind.functionOrMethod) {
-      fbBuilder.addUint32(10, _kind.index);
+      fbBuilder.addUint32(4, _kind.index);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(11, offset_name);
+      fbBuilder.addOffset(1, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(12, _nameOffset);
+      fbBuilder.addUint32(0, _nameOffset);
     }
     if (offset_parameters != null) {
-      fbBuilder.addOffset(13, offset_parameters);
+      fbBuilder.addOffset(2, offset_parameters);
     }
     if (offset_redirectedConstructor != null) {
-      fbBuilder.addOffset(14, offset_redirectedConstructor);
+      fbBuilder.addOffset(15, offset_redirectedConstructor);
     }
     if (offset_redirectedConstructorName != null) {
-      fbBuilder.addOffset(15, offset_redirectedConstructorName);
+      fbBuilder.addOffset(17, offset_redirectedConstructorName);
     }
     if (offset_returnType != null) {
-      fbBuilder.addOffset(16, offset_returnType);
+      fbBuilder.addOffset(3, offset_returnType);
     }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(17, offset_typeParameters);
+      fbBuilder.addOffset(16, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
@@ skipping 18 matching lines @@
   String _name;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _redirectedConstructor;
   String _redirectedConstructorName;
   idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 6, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   List<idl.UnlinkedConstructorInitializer> get constantInitializers {
-    _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 1, const <idl.UnlinkedConstructorInitializer>[]);
+    _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 14, const <idl.UnlinkedConstructorInitializer>[]);
     return _constantInitializers;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 7, null);
     return _documentationComment;
   }
 
   @override
   int get inferredReturnTypeSlot {
-    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
     return _inferredReturnTypeSlot;
   }
 
   @override
   bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 10, false);
     return _isAbstract;
   }
 
   @override
   bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _isConst;
   }
 
   @override
   bool get isExternal {
-    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _isExternal;
   }
 
   @override
   bool get isFactory {
-    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 8, false);
     return _isFactory;
   }
 
   @override
   bool get isRedirectedConstructor {
-    _isRedirectedConstructor ??= const fb.BoolReader().vTableGet(_bp, 8, false);
+    _isRedirectedConstructor ??= const fb.BoolReader().vTableGet(_bp, 13, false);
     return _isRedirectedConstructor;
   }
 
   @override
   bool get isStatic {
     _isStatic ??= const fb.BoolReader().vTableGet(_bp, 9, false);
     return _isStatic;
   }
 
   @override
   idl.UnlinkedExecutableKind get kind {
-    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 10, idl.UnlinkedExecutableKind.functionOrMethod);
+    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 4, idl.UnlinkedExecutableKind.functionOrMethod);
     return _kind;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 11, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 12, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _nameOffset;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 13, const <idl.UnlinkedParam>[]);
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 2, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
   idl.EntityRef get redirectedConstructor {
-    _redirectedConstructor ??= const _EntityRefReader().vTableGet(_bp, 14, null);
+    _redirectedConstructor ??= const _EntityRefReader().vTableGet(_bp, 15, null);
     return _redirectedConstructor;
   }
 
   @override
   String get redirectedConstructorName {
-    _redirectedConstructorName ??= const fb.StringReader().vTableGet(_bp, 15, '');
+    _redirectedConstructorName ??= const fb.StringReader().vTableGet(_bp, 17, '');
     return _redirectedConstructorName;
   }
 
   @override
   idl.EntityRef get returnType {
-    _returnType ??= const _EntityRefReader().vTableGet(_bp, 16, null);
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _returnType;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 17, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 16, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "constantInitializers": constantInitializers,
     "documentationComment": documentationComment,
@@ skipping 80 matching lines @@
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
-      fbBuilder.addOffset(0, offset_annotations);
+      fbBuilder.addOffset(3, offset_annotations);
     }
     if (_offset != null && _offset != 0) {
-      fbBuilder.addUint32(1, _offset);
+      fbBuilder.addUint32(0, _offset);
     }
     if (_uriEnd != null && _uriEnd != 0) {
-      fbBuilder.addUint32(2, _uriEnd);
+      fbBuilder.addUint32(1, _uriEnd);
     }
     if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(3, _uriOffset);
+      fbBuilder.addUint32(2, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExportNonPublicReader extends fb.TableReader<_UnlinkedExportNonPublicImpl> {
   const _UnlinkedExportNonPublicReader();
 
   @override
   _UnlinkedExportNonPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportNonPublicImpl(bp);
 }
 
 class _UnlinkedExportNonPublicImpl extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportNonPublicImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
   int _offset;
   int _uriEnd;
   int _uriOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   int get offset {
-    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _offset;
   }
 
   @override
   int get uriEnd {
-    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _uriEnd;
   }
 
   @override
   int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _uriOffset;
   }
 }
 
 abstract class _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "offset": offset,
     "uriEnd": uriEnd,
@@ skipping 39 matching lines @@
     fb.Offset offset_combinators;
     fb.Offset offset_uri;
     if (!(_combinators == null || _combinators.isEmpty)) {
       offset_combinators = fbBuilder.writeList(_combinators.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
     fbBuilder.startTable();
     if (offset_combinators != null) {
-      fbBuilder.addOffset(0, offset_combinators);
+      fbBuilder.addOffset(1, offset_combinators);
     }
     if (offset_uri != null) {
-      fbBuilder.addOffset(1, offset_uri);
+      fbBuilder.addOffset(0, offset_uri);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExportPublicReader extends fb.TableReader<_UnlinkedExportPublicImpl> {
   const _UnlinkedExportPublicReader();
 
   @override
   _UnlinkedExportPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportPublicImpl(bp);
 }
 
 class _UnlinkedExportPublicImpl extends Object with _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportPublicImpl(this._bp);
 
   List<idl.UnlinkedCombinator> _combinators;
   String _uri;
 
   @override
   List<idl.UnlinkedCombinator> get combinators {
-    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 0, const <idl.UnlinkedCombinator>[]);
+    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 1, const <idl.UnlinkedCombinator>[]);
     return _combinators;
   }
 
   @override
   String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 1, '');
+    _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 }
 
 abstract class _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   @override
   Map<String, Object> toMap() => {
     "combinators": combinators,
     "uri": uri,
   };
@@ skipping 157 matching lines @@
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_combinators == null || _combinators.isEmpty)) {
       offset_combinators = fbBuilder.writeList(_combinators.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
-      fbBuilder.addOffset(0, offset_annotations);
+      fbBuilder.addOffset(8, offset_annotations);
     }
     if (offset_combinators != null) {
-      fbBuilder.addOffset(1, offset_combinators);
+      fbBuilder.addOffset(4, offset_combinators);
     }
     if (_isDeferred == true) {
-      fbBuilder.addBool(2, true);
+      fbBuilder.addBool(9, true);
     }
     if (_isImplicit == true) {
-      fbBuilder.addBool(3, true);
+      fbBuilder.addBool(5, true);
     }
     if (_offset != null && _offset != 0) {
-      fbBuilder.addUint32(4, _offset);
+      fbBuilder.addUint32(0, _offset);
     }
     if (_prefixOffset != null && _prefixOffset != 0) {
-      fbBuilder.addUint32(5, _prefixOffset);
+      fbBuilder.addUint32(6, _prefixOffset);
     }
     if (_prefixReference != null && _prefixReference != 0) {
-      fbBuilder.addUint32(6, _prefixReference);
+      fbBuilder.addUint32(7, _prefixReference);
     }
     if (offset_uri != null) {
-      fbBuilder.addOffset(7, offset_uri);
+      fbBuilder.addOffset(1, offset_uri);
     }
     if (_uriEnd != null && _uriEnd != 0) {
-      fbBuilder.addUint32(8, _uriEnd);
+      fbBuilder.addUint32(2, _uriEnd);
     }
     if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(9, _uriOffset);
+      fbBuilder.addUint32(3, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedImportReader extends fb.TableReader<_UnlinkedImportImpl> {
   const _UnlinkedImportReader();
 
   @override
   _UnlinkedImportImpl createObject(fb.BufferPointer bp) => new _UnlinkedImportImpl(bp);
@@ skipping 10 matching lines @@
   bool _isImplicit;
   int _offset;
   int _prefixOffset;
   int _prefixReference;
   String _uri;
   int _uriEnd;
   int _uriOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 8, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   List<idl.UnlinkedCombinator> get combinators {
-    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 1, const <idl.UnlinkedCombinator>[]);
+    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 4, const <idl.UnlinkedCombinator>[]);
     return _combinators;
   }
 
   @override
   bool get isDeferred {
-    _isDeferred ??= const fb.BoolReader().vTableGet(_bp, 2, false);
+    _isDeferred ??= const fb.BoolReader().vTableGet(_bp, 9, false);
     return _isDeferred;
   }
 
   @override
   bool get isImplicit {
-    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 3, false);
+    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isImplicit;
   }
 
   @override
   int get offset {
-    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 4, 0);
+    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _offset;
   }
 
   @override
   int get prefixOffset {
-    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
     return _prefixOffset;
   }
 
   @override
   int get prefixReference {
-    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
+    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
     return _prefixReference;
   }
 
   @override
   String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    _uri ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _uri;
   }
 
   @override
   int get uriEnd {
-    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _uriEnd;
   }
 
   @override
   int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _uriOffset;
   }
 }
 
 abstract class _UnlinkedImportMixin implements idl.UnlinkedImport {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "combinators": combinators,
     "isDeferred": isDeferred,
@@ skipping 176 matching lines @@
       offset_name = fbBuilder.writeString(_name);
     }
     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(0, offset_annotations);
+      fbBuilder.addOffset(9, offset_annotations);
     }
     if (offset_defaultValue != null) {
-      fbBuilder.addOffset(1, offset_defaultValue);
+      fbBuilder.addOffset(7, offset_defaultValue);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
       fbBuilder.addUint32(2, _inferredTypeSlot);
     }
     if (_isFunctionTyped == true) {
-      fbBuilder.addBool(3, true);
+      fbBuilder.addBool(5, true);
     }
     if (_isInitializingFormal == true) {
-      fbBuilder.addBool(4, true);
+      fbBuilder.addBool(6, true);
     }
     if (_kind != null && _kind != idl.UnlinkedParamKind.required) {
-      fbBuilder.addUint32(5, _kind.index);
+      fbBuilder.addUint32(4, _kind.index);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(6, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(7, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_parameters != null) {
       fbBuilder.addOffset(8, offset_parameters);
     }
     if (offset_type != null) {
-      fbBuilder.addOffset(9, offset_type);
+      fbBuilder.addOffset(3, offset_type);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
@@ skipping 10 matching lines @@
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _type;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 9, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.UnlinkedConst get defaultValue {
-    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
+    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 7, null);
     return _defaultValue;
   }
 
   @override
   int get inferredTypeSlot {
     _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _inferredTypeSlot;
   }
 
   @override
   bool get isFunctionTyped {
-    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 3, false);
+    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isFunctionTyped;
   }
 
   @override
   bool get isInitializingFormal {
-    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isInitializingFormal;
   }
 
   @override
   idl.UnlinkedParamKind get kind {
-    _kind ??= const _UnlinkedParamKindReader().vTableGet(_bp, 5, idl.UnlinkedParamKind.required);
+    _kind ??= const _UnlinkedParamKindReader().vTableGet(_bp, 4, idl.UnlinkedParamKind.required);
     return _kind;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 6, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
     _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 8, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
   idl.EntityRef get type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 9, null);
+    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _type;
   }
 }
 
 abstract class _UnlinkedParamMixin implements idl.UnlinkedParam {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "defaultValue": defaultValue,
     "inferredTypeSlot": inferredTypeSlot,
@@ skipping 58 matching lines @@
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
-      fbBuilder.addOffset(0, offset_annotations);
+      fbBuilder.addOffset(2, offset_annotations);
     }
     if (_uriEnd != null && _uriEnd != 0) {
-      fbBuilder.addUint32(1, _uriEnd);
+      fbBuilder.addUint32(0, _uriEnd);
     }
     if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(2, _uriOffset);
+      fbBuilder.addUint32(1, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedPartReader extends fb.TableReader<_UnlinkedPartImpl> {
   const _UnlinkedPartReader();
 
   @override
   _UnlinkedPartImpl createObject(fb.BufferPointer bp) => new _UnlinkedPartImpl(bp);
 }
 
 class _UnlinkedPartImpl extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
   final fb.BufferPointer _bp;
 
   _UnlinkedPartImpl(this._bp);
 
   List<idl.UnlinkedConst> _annotations;
   int _uriEnd;
   int _uriOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   int get uriEnd {
-    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _uriEnd;
   }
 
   @override
   int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _uriOffset;
   }
 }
 
 abstract class _UnlinkedPartMixin implements idl.UnlinkedPart {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "uriEnd": uriEnd,
     "uriOffset": uriOffset,
@@ skipping 71 matching lines @@
     fb.Offset offset_members;
     fb.Offset offset_name;
     if (!(_members == null || _members.isEmpty)) {
       offset_members = fbBuilder.writeList(_members.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
-      fbBuilder.addUint32(0, _kind.index);
+      fbBuilder.addUint32(1, _kind.index);
     }
     if (offset_members != null) {
-      fbBuilder.addOffset(1, offset_members);
+      fbBuilder.addOffset(2, offset_members);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(2, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addUint32(3, _numTypeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedPublicNameReader extends fb.TableReader<_UnlinkedPublicNameImpl> {
   const _UnlinkedPublicNameReader();
 
   @override
   _UnlinkedPublicNameImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNameImpl(bp);
 }
 
 class _UnlinkedPublicNameImpl extends Object with _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNameImpl(this._bp);
 
   idl.ReferenceKind _kind;
   List<idl.UnlinkedPublicName> _members;
   String _name;
   int _numTypeParameters;
 
   @override
   idl.ReferenceKind get kind {
-    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 0, idl.ReferenceKind.classOrEnum);
+    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, idl.ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
   List<idl.UnlinkedPublicName> get members {
-    _members ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 1, const <idl.UnlinkedPublicName>[]);
+    _members ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 2, const <idl.UnlinkedPublicName>[]);
     return _members;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
 }
 
@@ skipping 70 matching lines @@
       offset_exports = fbBuilder.writeList(_exports.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_names == null || _names.isEmpty)) {
       offset_names = fbBuilder.writeList(_names.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
     if (offset_exports != null) {
-      fbBuilder.addOffset(0, offset_exports);
+      fbBuilder.addOffset(2, offset_exports);
     }
     if (offset_names != null) {
-      fbBuilder.addOffset(1, offset_names);
+      fbBuilder.addOffset(0, offset_names);
     }
     if (offset_parts != null) {
-      fbBuilder.addOffset(2, offset_parts);
+      fbBuilder.addOffset(1, offset_parts);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.UnlinkedPublicNamespace readUnlinkedPublicNamespace(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _UnlinkedPublicNamespaceReader().read(rootRef);
 }
 
 class _UnlinkedPublicNamespaceReader extends fb.TableReader<_UnlinkedPublicNamespaceImpl> {
   const _UnlinkedPublicNamespaceReader();
 
   @override
   _UnlinkedPublicNamespaceImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNamespaceImpl(bp);
 }
 
 class _UnlinkedPublicNamespaceImpl extends Object with _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNamespaceImpl(this._bp);
 
   List<idl.UnlinkedExportPublic> _exports;
   List<idl.UnlinkedPublicName> _names;
   List<String> _parts;
 
   @override
   List<idl.UnlinkedExportPublic> get exports {
-    _exports ??= const fb.ListReader<idl.UnlinkedExportPublic>(const _UnlinkedExportPublicReader()).vTableGet(_bp, 0, const <idl.UnlinkedExportPublic>[]);
+    _exports ??= const fb.ListReader<idl.UnlinkedExportPublic>(const _UnlinkedExportPublicReader()).vTableGet(_bp, 2, const <idl.UnlinkedExportPublic>[]);
     return _exports;
   }
 
   @override
   List<idl.UnlinkedPublicName> get names {
-    _names ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 1, const <idl.UnlinkedPublicName>[]);
+    _names ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 0, const <idl.UnlinkedPublicName>[]);
     return _names;
   }
 
   @override
   List<String> get parts {
-    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
+    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _parts;
   }
 }
 
 abstract class _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
   @override
   Map<String, Object> toMap() => {
     "exports": exports,
     "names": names,
     "parts": parts,
@@ skipping 214 matching lines @@
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     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(0, offset_annotations);
+      fbBuilder.addOffset(4, offset_annotations);
     }
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(1, offset_documentationComment);
+      fbBuilder.addOffset(6, offset_documentationComment);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(2, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(3, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_parameters != null) {
-      fbBuilder.addOffset(4, offset_parameters);
+      fbBuilder.addOffset(3, offset_parameters);
     }
     if (offset_returnType != null) {
-      fbBuilder.addOffset(5, offset_returnType);
+      fbBuilder.addOffset(2, offset_returnType);
     }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(6, offset_typeParameters);
+      fbBuilder.addOffset(5, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
   const _UnlinkedTypedefReader();
 
   @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;
   idl.UnlinkedDocumentationComment _documentationComment;
   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, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 6, null);
     return _documentationComment;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedParam>[]);
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 3, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
   idl.EntityRef get returnType {
-    _returnType ??= const _EntityRefReader().vTableGet(_bp, 5, null);
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 2, null);
     return _returnType;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedTypeParam>[]);
+    _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> toMap() => {
     "annotations": annotations,
     "documentationComment": documentationComment,
     "name": name,
@@ skipping 74 matching lines @@
       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(0, offset_annotations);
+      fbBuilder.addOffset(3, offset_annotations);
     }
     if (offset_bound != null) {
-      fbBuilder.addOffset(1, offset_bound);
+      fbBuilder.addOffset(2, offset_bound);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(2, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(3, _nameOffset);
+      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;
   String _name;
   int _nameOffset;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _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, 1, null);
+    _bound ??= const _EntityRefReader().vTableGet(_bp, 2, null);
     return _bound;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 }
 
 abstract class _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "bound": bound,
     "name": name,
@@ skipping 268 matching lines @@
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     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(0, offset_classes);
+      fbBuilder.addOffset(2, offset_classes);
     }
     if (offset_enums != null) {
-      fbBuilder.addOffset(1, offset_enums);
+      fbBuilder.addOffset(12, offset_enums);
     }
     if (offset_executables != null) {
-      fbBuilder.addOffset(2, offset_executables);
+      fbBuilder.addOffset(4, offset_executables);
     }
     if (offset_exports != null) {
-      fbBuilder.addOffset(3, offset_exports);
+      fbBuilder.addOffset(13, offset_exports);
     }
     if (offset_imports != null) {
-      fbBuilder.addOffset(4, offset_imports);
+      fbBuilder.addOffset(5, offset_imports);
     }
     if (offset_libraryAnnotations != null) {
-      fbBuilder.addOffset(5, offset_libraryAnnotations);
+      fbBuilder.addOffset(14, offset_libraryAnnotations);
     }
     if (offset_libraryDocumentationComment != null) {
-      fbBuilder.addOffset(6, offset_libraryDocumentationComment);
+      fbBuilder.addOffset(9, offset_libraryDocumentationComment);
     }
     if (offset_libraryName != null) {
-      fbBuilder.addOffset(7, offset_libraryName);
+      fbBuilder.addOffset(6, offset_libraryName);
     }
     if (_libraryNameLength != null && _libraryNameLength != 0) {
-      fbBuilder.addUint32(8, _libraryNameLength);
+      fbBuilder.addUint32(7, _libraryNameLength);
     }
     if (_libraryNameOffset != null && _libraryNameOffset != 0) {
-      fbBuilder.addUint32(9, _libraryNameOffset);
+      fbBuilder.addUint32(8, _libraryNameOffset);
     }
     if (offset_parts != null) {
-      fbBuilder.addOffset(10, offset_parts);
+      fbBuilder.addOffset(11, offset_parts);
     }
     if (offset_publicNamespace != null) {
-      fbBuilder.addOffset(11, offset_publicNamespace);
+      fbBuilder.addOffset(0, offset_publicNamespace);
     }
     if (offset_references != null) {
-      fbBuilder.addOffset(12, offset_references);
+      fbBuilder.addOffset(1, offset_references);
     }
     if (offset_typedefs != null) {
-      fbBuilder.addOffset(13, offset_typedefs);
+      fbBuilder.addOffset(10, offset_typedefs);
     }
     if (offset_variables != null) {
-      fbBuilder.addOffset(14, offset_variables);
+      fbBuilder.addOffset(3, offset_variables);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.UnlinkedUnit readUnlinkedUnit(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _UnlinkedUnitReader().read(rootRef);
 }
 
@@ skipping 20 matching lines @@
   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, 0, const <idl.UnlinkedClass>[]);
+    _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 2, const <idl.UnlinkedClass>[]);
     return _classes;
   }
 
   @override
   List<idl.UnlinkedEnum> get enums {
-    _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 1, const <idl.UnlinkedEnum>[]);
+    _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, 2, const <idl.UnlinkedExecutable>[]);
+    _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, 3, const <idl.UnlinkedExportNonPublic>[]);
+    _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 13, const <idl.UnlinkedExportNonPublic>[]);
     return _exports;
   }
 
   @override
   List<idl.UnlinkedImport> get imports {
-    _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 4, const <idl.UnlinkedImport>[]);
+    _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, 5, const <idl.UnlinkedConst>[]);
+    _libraryAnnotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 14, const <idl.UnlinkedConst>[]);
     return _libraryAnnotations;
   }
 
   @override
   idl.UnlinkedDocumentationComment get libraryDocumentationComment {
-    _libraryDocumentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 6, null);
+    _libraryDocumentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 9, null);
     return _libraryDocumentationComment;
   }
 
   @override
   String get libraryName {
-    _libraryName ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    _libraryName ??= const fb.StringReader().vTableGet(_bp, 6, '');
     return _libraryName;
   }
 
   @override
   int get libraryNameLength {
-    _libraryNameLength ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    _libraryNameLength ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
     return _libraryNameLength;
   }
 
   @override
   int get libraryNameOffset {
-    _libraryNameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    _libraryNameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
     return _libraryNameOffset;
   }
 
   @override
   List<idl.UnlinkedPart> get parts {
-    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 10, const <idl.UnlinkedPart>[]);
+    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 11, const <idl.UnlinkedPart>[]);
     return _parts;
   }
 
   @override
   idl.UnlinkedPublicNamespace get publicNamespace {
-    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 11, null);
+    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 0, null);
     return _publicNamespace;
   }
 
   @override
   List<idl.UnlinkedReference> get references {
-    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 12, const <idl.UnlinkedReference>[]);
+    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 1, const <idl.UnlinkedReference>[]);
     return _references;
   }
 
   @override
   List<idl.UnlinkedTypedef> get typedefs {
-    _typedefs ??= const fb.ListReader<idl.UnlinkedTypedef>(const _UnlinkedTypedefReader()).vTableGet(_bp, 13, const <idl.UnlinkedTypedef>[]);
+    _typedefs ??= const fb.ListReader<idl.UnlinkedTypedef>(const _UnlinkedTypedefReader()).vTableGet(_bp, 10, const <idl.UnlinkedTypedef>[]);
     return _typedefs;
   }
 
   @override
   List<idl.UnlinkedVariable> get variables {
-    _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 14, const <idl.UnlinkedVariable>[]);
+    _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> toMap() => {
     "classes": classes,
     "enums": enums,
     "executables": executables,
@@ skipping 197 matching lines @@
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     fbBuilder.startTable();
     if (offset_annotations != null) {
-      fbBuilder.addOffset(0, offset_annotations);
+      fbBuilder.addOffset(8, offset_annotations);
     }
     if (offset_constExpr != null) {
-      fbBuilder.addOffset(1, offset_constExpr);
+      fbBuilder.addOffset(5, offset_constExpr);
     }
     if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
+      fbBuilder.addOffset(10, offset_documentationComment);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
-      fbBuilder.addUint32(3, _inferredTypeSlot);
+      fbBuilder.addUint32(9, _inferredTypeSlot);
     }
     if (_isConst == true) {
+      fbBuilder.addBool(6, true);
+    }
+    if (_isFinal == true) {
+      fbBuilder.addBool(7, true);
+    }
+    if (_isStatic == true) {
       fbBuilder.addBool(4, true);
     }
-    if (_isFinal == true) {
-      fbBuilder.addBool(5, true);
-    }
-    if (_isStatic == true) {
-      fbBuilder.addBool(6, true);
-    }
     if (offset_name != null) {
-      fbBuilder.addOffset(7, offset_name);
+      fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(8, _nameOffset);
+      fbBuilder.addUint32(1, _nameOffset);
     }
     if (_propagatedTypeSlot != null && _propagatedTypeSlot != 0) {
-      fbBuilder.addUint32(9, _propagatedTypeSlot);
+      fbBuilder.addUint32(2, _propagatedTypeSlot);
     }
     if (offset_type != null) {
-      fbBuilder.addOffset(10, offset_type);
+      fbBuilder.addOffset(3, offset_type);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
@@ skipping 11 matching lines @@
   bool _isConst;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   idl.EntityRef _type;
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 8, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   idl.UnlinkedConst get constExpr {
-    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
+    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 5, null);
     return _constExpr;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 10, null);
     return _documentationComment;
   }
 
   @override
   int get inferredTypeSlot {
-    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _inferredTypeSlot;
   }
 
   @override
   bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isConst;
   }
 
   @override
   bool get isFinal {
-    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _isFinal;
   }
 
   @override
   bool get isStatic {
-    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 4, false);
     return _isStatic;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   int get propagatedTypeSlot {
-    _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _propagatedTypeSlot;
   }
 
   @override
   idl.EntityRef get type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 10, null);
+    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _type;
   }
 }
 
 abstract class _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "constExpr": constExpr,
     "documentationComment": documentationComment,
     "inferredTypeSlot": inferredTypeSlot,
     "isConst": isConst,
     "isFinal": isFinal,
     "isStatic": isStatic,
     "name": name,
     "nameOffset": nameOffset,
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
   };
 }