Add summary support for annotations.

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 1159 matching lines @@
     "unlinkedUnits": unlinkedUnits,
   };
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   EntityRefBuilder _supertype;
   List<EntityRefBuilder> _mixins;
   List<EntityRefBuilder> _interfaces;
   List<UnlinkedVariableBuilder> _fields;
   List<UnlinkedExecutableBuilder> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
@@ skipping 26 matching lines @@
   /**
    * Documentation comment for the class, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this class.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
@@ skipping 81 matching lines @@
 
   /**
    * Indicates whether this class is the core "Object" class (and hence has no
    * supertype)
    */
   void set hasNoSupertype(bool _value) {
     assert(!_finished);
     _hasNoSupertype = _value;
   }
 
-  UnlinkedClassBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder supertype, List<EntityRefBuilder> mixins, List<EntityRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype})
+  UnlinkedClassBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder supertype, List<EntityRefBuilder> mixins, List<EntityRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
+      _annotations = annotations,
       _typeParameters = typeParameters,
       _supertype = supertype,
       _mixins = mixins,
       _interfaces = interfaces,
       _fields = fields,
       _executables = executables,
       _isAbstract = isAbstract,
       _isMixinApplication = isMixinApplication,
       _hasNoSupertype = hasNoSupertype;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
+    fb.Offset offset_annotations;
     fb.Offset offset_typeParameters;
     fb.Offset offset_supertype;
     fb.Offset offset_mixins;
     fb.Offset offset_interfaces;
     fb.Offset offset_fields;
     fb.Offset offset_executables;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_supertype != null) {
       offset_supertype = _supertype.finish(fbBuilder);
     }
     if (!(_mixins == null || _mixins.isEmpty)) {
       offset_mixins = fbBuilder.writeList(_mixins.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_interfaces == null || _interfaces.isEmpty)) {
       offset_interfaces = fbBuilder.writeList(_interfaces.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_fields == null || _fields.isEmpty)) {
       offset_fields = fbBuilder.writeList(_fields.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_executables == null || _executables.isEmpty)) {
       offset_executables = fbBuilder.writeList(_executables.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(3, offset_typeParameters);
+      fbBuilder.addOffset(4, offset_typeParameters);
     }
     if (offset_supertype != null) {
-      fbBuilder.addOffset(4, offset_supertype);
+      fbBuilder.addOffset(5, offset_supertype);
     }
     if (offset_mixins != null) {
-      fbBuilder.addOffset(5, offset_mixins);
+      fbBuilder.addOffset(6, offset_mixins);
     }
     if (offset_interfaces != null) {
-      fbBuilder.addOffset(6, offset_interfaces);
+      fbBuilder.addOffset(7, offset_interfaces);
     }
     if (offset_fields != null) {
-      fbBuilder.addOffset(7, offset_fields);
+      fbBuilder.addOffset(8, offset_fields);
     }
     if (offset_executables != null) {
-      fbBuilder.addOffset(8, offset_executables);
+      fbBuilder.addOffset(9, offset_executables);
     }
     if (_isAbstract == true) {
-      fbBuilder.addBool(9, true);
+      fbBuilder.addBool(10, true);
     }
     if (_isMixinApplication == true) {
-      fbBuilder.addBool(10, true);
+      fbBuilder.addBool(11, true);
     }
     if (_hasNoSupertype == true) {
-      fbBuilder.addBool(11, true);
+      fbBuilder.addBool(12, true);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedClassReader extends fb.TableReader<_UnlinkedClassImpl> {
   const _UnlinkedClassReader();
 
   @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);
 
   String _name;
   int _nameOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedConst> _annotations;
   List<idl.UnlinkedTypeParam> _typeParameters;
   idl.EntityRef _supertype;
   List<idl.EntityRef> _mixins;
   List<idl.EntityRef> _interfaces;
   List<idl.UnlinkedVariable> _fields;
   List<idl.UnlinkedExecutable> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   @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
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
   idl.EntityRef get supertype {
-    _supertype ??= const _EntityRefReader().vTableGet(_bp, 4, null);
+    _supertype ??= const _EntityRefReader().vTableGet(_bp, 5, null);
     return _supertype;
   }
 
   @override
   List<idl.EntityRef> get mixins {
-    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 5, const <idl.EntityRef>[]);
+    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 6, const <idl.EntityRef>[]);
     return _mixins;
   }
 
   @override
   List<idl.EntityRef> get interfaces {
-    _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 6, const <idl.EntityRef>[]);
+    _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 7, const <idl.EntityRef>[]);
     return _interfaces;
   }
 
   @override
   List<idl.UnlinkedVariable> get fields {
-    _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 7, const <idl.UnlinkedVariable>[]);
+    _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 8, const <idl.UnlinkedVariable>[]);
     return _fields;
   }
 
   @override
   List<idl.UnlinkedExecutable> get executables {
-    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 8, const <idl.UnlinkedExecutable>[]);
+    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 9, const <idl.UnlinkedExecutable>[]);
     return _executables;
   }
 
   @override
   bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 9, false);
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 10, false);
     return _isAbstract;
   }
 
   @override
   bool get isMixinApplication {
-    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 10, false);
+    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _isMixinApplication;
   }
 
   @override
   bool get hasNoSupertype {
-    _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 11, false);
+    _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _hasNoSupertype;
   }
 }
 
 abstract class _UnlinkedClassMixin implements idl.UnlinkedClass {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
+    "annotations": annotations,
     "typeParameters": typeParameters,
     "supertype": supertype,
     "mixins": mixins,
     "interfaces": interfaces,
     "fields": fields,
     "executables": executables,
     "isAbstract": isAbstract,
     "isMixinApplication": isMixinApplication,
     "hasNoSupertype": hasNoSupertype,
   };
@@ skipping 386 matching lines @@
     "length": length,
   };
 }
 
 class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedEnumValueBuilder> _values;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the enum type.
    */
   void set name(String _value) {
     assert(!_finished);
@@ skipping 18 matching lines @@
   /**
    * Documentation comment for the enum, or `null` if there is no documentation
    * comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this enum.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   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({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedEnumValueBuilder> values})
+  UnlinkedEnumBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedEnumValueBuilder> values})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
+      _annotations = annotations,
       _values = values;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
+    fb.Offset offset_annotations;
     fb.Offset offset_values;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_values == null || _values.isEmpty)) {
       offset_values = fbBuilder.writeList(_values.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     if (offset_values != null) {
-      fbBuilder.addOffset(3, offset_values);
+      fbBuilder.addOffset(4, 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);
 
   String _name;
   int _nameOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedConst> _annotations;
   List<idl.UnlinkedEnumValue> _values;
 
   @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
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   List<idl.UnlinkedEnumValue> get values {
-    _values ??= const fb.ListReader<idl.UnlinkedEnumValue>(const _UnlinkedEnumValueReader()).vTableGet(_bp, 3, const <idl.UnlinkedEnumValue>[]);
+    _values ??= const fb.ListReader<idl.UnlinkedEnumValue>(const _UnlinkedEnumValueReader()).vTableGet(_bp, 4, const <idl.UnlinkedEnumValue>[]);
     return _values;
   }
 }
 
 abstract class _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
+    "annotations": annotations,
     "values": values,
   };
 }
 
 class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
@@ skipping 106 matching lines @@
     "documentationComment": documentationComment,
   };
 }
 
 class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
   idl.UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
   int _inferredReturnTypeSlot;
@@ skipping 32 matching lines @@
   /**
    * Documentation comment for the executable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this executable.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
@@ skipping 103 matching lines @@
    * return type.  If there is no matching entry in [LinkedLibrary.types], then
    * no return type was inferred for this variable, so its static type is
    * `dynamic`.
    */
   void set inferredReturnTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredReturnTypeSlot = _value;
   }
 
-  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, idl.UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot})
+  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, idl.UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
+      _annotations = annotations,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters,
       _kind = kind,
       _isAbstract = isAbstract,
       _isStatic = isStatic,
       _isConst = isConst,
       _isFactory = isFactory,
       _isExternal = isExternal,
       _inferredReturnTypeSlot = inferredReturnTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
+    fb.Offset offset_annotations;
     fb.Offset offset_typeParameters;
     fb.Offset offset_returnType;
     fb.Offset offset_parameters;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_returnType != null) {
       offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(3, offset_typeParameters);
+      fbBuilder.addOffset(4, offset_typeParameters);
     }
     if (offset_returnType != null) {
-      fbBuilder.addOffset(4, offset_returnType);
+      fbBuilder.addOffset(5, offset_returnType);
     }
     if (offset_parameters != null) {
-      fbBuilder.addOffset(5, offset_parameters);
+      fbBuilder.addOffset(6, offset_parameters);
     }
     if (_kind != null && _kind != idl.UnlinkedExecutableKind.functionOrMethod) {
-      fbBuilder.addUint32(6, _kind.index);
+      fbBuilder.addUint32(7, _kind.index);
     }
     if (_isAbstract == true) {
-      fbBuilder.addBool(7, true);
+      fbBuilder.addBool(8, true);
     }
     if (_isStatic == true) {
-      fbBuilder.addBool(8, true);
+      fbBuilder.addBool(9, true);
     }
     if (_isConst == true) {
-      fbBuilder.addBool(9, true);
+      fbBuilder.addBool(10, true);
     }
     if (_isFactory == true) {
-      fbBuilder.addBool(10, true);
+      fbBuilder.addBool(11, true);
     }
     if (_isExternal == true) {
-      fbBuilder.addBool(11, true);
+      fbBuilder.addBool(12, true);
     }
     if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
-      fbBuilder.addUint32(12, _inferredReturnTypeSlot);
+      fbBuilder.addUint32(13, _inferredReturnTypeSlot);
     }
     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);
 
   String _name;
   int _nameOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedConst> _annotations;
   List<idl.UnlinkedTypeParam> _typeParameters;
   idl.EntityRef _returnType;
   List<idl.UnlinkedParam> _parameters;
   idl.UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
   int _inferredReturnTypeSlot;
@@ skipping 10 matching lines @@
     return _nameOffset;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
   idl.EntityRef get returnType {
-    _returnType ??= const _EntityRefReader().vTableGet(_bp, 4, null);
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 5, null);
     return _returnType;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 5, const <idl.UnlinkedParam>[]);
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
   idl.UnlinkedExecutableKind get kind {
-    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 6, idl.UnlinkedExecutableKind.functionOrMethod);
+    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 7, idl.UnlinkedExecutableKind.functionOrMethod);
     return _kind;
   }
 
   @override
   bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 8, false);
     return _isAbstract;
   }
 
   @override
   bool get isStatic {
-    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 8, false);
+    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 9, false);
     return _isStatic;
   }
 
   @override
   bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 9, false);
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 10, false);
     return _isConst;
   }
 
   @override
   bool get isFactory {
-    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 10, false);
+    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _isFactory;
   }
 
   @override
   bool get isExternal {
-    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 11, false);
+    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _isExternal;
   }
 
   @override
   int get inferredReturnTypeSlot {
-    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 12, 0);
+    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 13, 0);
     return _inferredReturnTypeSlot;
   }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
+    "annotations": annotations,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
     "kind": kind,
     "isAbstract": isAbstract,
     "isStatic": isStatic,
     "isConst": isConst,
     "isFactory": isFactory,
     "isExternal": isExternal,
     "inferredReturnTypeSlot": inferredReturnTypeSlot,
   };
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   bool _finished = false;
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
+  List<UnlinkedConstBuilder> _annotations;
 
   @override
   int get offset => _offset ??= 0;
 
   /**
    * Offset of the "export" keyword.
    */
   void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
@@ skipping 19 matching lines @@
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
 
-  UnlinkedExportNonPublicBuilder({int offset, int uriOffset, int uriEnd})
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this export directive.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  UnlinkedExportNonPublicBuilder({int offset, int uriOffset, int uriEnd, List<UnlinkedConstBuilder> annotations})
     : _offset = offset,
       _uriOffset = uriOffset,
-      _uriEnd = uriEnd;
+      _uriEnd = uriEnd,
+      _annotations = annotations;
 
   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 != null && _offset != 0) {
       fbBuilder.addUint32(0, _offset);
     }
     if (_uriOffset != null && _uriOffset != 0) {
       fbBuilder.addUint32(1, _uriOffset);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(2, _uriEnd);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     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);
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
+  List<idl.UnlinkedConst> _annotations;
 
   @override
   int get offset {
     _offset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _offset;
   }
 
   @override
   int get uriOffset {
     _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _uriOffset;
   }
 
   @override
   int get uriEnd {
     _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _uriEnd;
   }
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
 }
 
 abstract class _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   @override
   Map<String, Object> toMap() => {
     "offset": offset,
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
+    "annotations": annotations,
   };
 }
 
 class UnlinkedExportPublicBuilder extends Object with _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   bool _finished = false;
 
   String _uri;
   List<UnlinkedCombinatorBuilder> _combinators;
 
   @override
@@ skipping 78 matching lines @@
     "uri": uri,
     "combinators": combinators,
   };
 }
 
 class UnlinkedImportBuilder extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
   bool _finished = false;
 
   String _uri;
   int _offset;
+  List<UnlinkedConstBuilder> _annotations;
   int _prefixReference;
   List<UnlinkedCombinatorBuilder> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
   int _prefixOffset;
 
   @override
   String get uri => _uri ??= '';
@@ skipping 13 matching lines @@
    * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
    * is true, zero.
    */
   void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this import declaration.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   int get prefixReference => _prefixReference ??= 0;
 
   /**
    * Index into [UnlinkedUnit.references] of the prefix declared by this
    * import declaration, or zero if this import declaration declares no prefix.
    *
    * Note that multiple imports can declare the same prefix.
    */
   void set prefixReference(int _value) {
     assert(!_finished);
@@ skipping 66 matching lines @@
   /**
    * Offset of the prefix name relative to the beginning of the file, or zero
    * if there is no prefix.
    */
   void set prefixOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _prefixOffset = _value;
   }
 
-  UnlinkedImportBuilder({String uri, int offset, int prefixReference, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int uriOffset, int uriEnd, int prefixOffset})
+  UnlinkedImportBuilder({String uri, int offset, List<UnlinkedConstBuilder> annotations, int prefixReference, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int uriOffset, int uriEnd, int prefixOffset})
     : _uri = uri,
       _offset = offset,
+      _annotations = annotations,
       _prefixReference = prefixReference,
       _combinators = combinators,
       _isDeferred = isDeferred,
       _isImplicit = isImplicit,
       _uriOffset = uriOffset,
       _uriEnd = uriEnd,
       _prefixOffset = prefixOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_uri;
+    fb.Offset offset_annotations;
     fb.Offset offset_combinators;
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      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());
     }
     fbBuilder.startTable();
     if (offset_uri != null) {
       fbBuilder.addOffset(0, offset_uri);
     }
     if (_offset != null && _offset != 0) {
       fbBuilder.addUint32(1, _offset);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(2, offset_annotations);
+    }
     if (_prefixReference != null && _prefixReference != 0) {
-      fbBuilder.addUint32(2, _prefixReference);
+      fbBuilder.addUint32(3, _prefixReference);
     }
     if (offset_combinators != null) {
-      fbBuilder.addOffset(3, offset_combinators);
+      fbBuilder.addOffset(4, offset_combinators);
     }
     if (_isDeferred == true) {
-      fbBuilder.addBool(4, true);
+      fbBuilder.addBool(5, true);
     }
     if (_isImplicit == true) {
-      fbBuilder.addBool(5, true);
+      fbBuilder.addBool(6, true);
     }
     if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(6, _uriOffset);
+      fbBuilder.addUint32(7, _uriOffset);
     }
     if (_uriEnd != null && _uriEnd != 0) {
-      fbBuilder.addUint32(7, _uriEnd);
+      fbBuilder.addUint32(8, _uriEnd);
     }
     if (_prefixOffset != null && _prefixOffset != 0) {
-      fbBuilder.addUint32(8, _prefixOffset);
+      fbBuilder.addUint32(9, _prefixOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedImportReader extends fb.TableReader<_UnlinkedImportImpl> {
   const _UnlinkedImportReader();
 
   @override
   _UnlinkedImportImpl createObject(fb.BufferPointer bp) => new _UnlinkedImportImpl(bp);
 }
 
 class _UnlinkedImportImpl extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
   final fb.BufferPointer _bp;
 
   _UnlinkedImportImpl(this._bp);
 
   String _uri;
   int _offset;
+  List<idl.UnlinkedConst> _annotations;
   int _prefixReference;
   List<idl.UnlinkedCombinator> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
   int _prefixOffset;
 
   @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 
   @override
   int get offset {
     _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _offset;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   int get prefixReference {
-    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _prefixReference;
   }
 
   @override
   List<idl.UnlinkedCombinator> get combinators {
-    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 3, 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, 4, false);
+    _isDeferred ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isDeferred;
   }
 
   @override
   bool get isImplicit {
-    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isImplicit;
   }
 
   @override
   int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
     return _uriOffset;
   }
 
   @override
   int get uriEnd {
-    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
+    _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
     return _uriEnd;
   }
 
   @override
   int get prefixOffset {
-    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _prefixOffset;
   }
 }
 
 abstract class _UnlinkedImportMixin implements idl.UnlinkedImport {
   @override
   Map<String, Object> toMap() => {
     "uri": uri,
     "offset": offset,
+    "annotations": annotations,
     "prefixReference": prefixReference,
     "combinators": combinators,
     "isDeferred": isDeferred,
     "isImplicit": isImplicit,
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
     "prefixOffset": prefixOffset,
   };
 }
 
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
+  List<UnlinkedConstBuilder> _annotations;
   EntityRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   idl.UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   int _inferredTypeSlot;
   UnlinkedConstBuilder _defaultValue;
 
   @override
   String get name => _name ??= '';
@@ skipping 12 matching lines @@
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this parameter.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   EntityRefBuilder get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if the type is
    * implicit.
    */
   void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
@@ skipping 69 matching lines @@
 
   /**
    * If the parameter has a default value the constant expression in the
    * default value.
    */
   void set defaultValue(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _defaultValue = _value;
   }
 
-  UnlinkedParamBuilder({String name, int nameOffset, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot, UnlinkedConstBuilder defaultValue})
+  UnlinkedParamBuilder({String name, int nameOffset, List<UnlinkedConstBuilder> annotations, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot, UnlinkedConstBuilder defaultValue})
     : _name = name,
       _nameOffset = nameOffset,
+      _annotations = annotations,
       _type = type,
       _parameters = parameters,
       _kind = kind,
       _isFunctionTyped = isFunctionTyped,
       _isInitializingFormal = isInitializingFormal,
       _inferredTypeSlot = inferredTypeSlot,
       _defaultValue = defaultValue;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
+    fb.Offset offset_annotations;
     fb.Offset offset_type;
     fb.Offset offset_parameters;
     fb.Offset offset_defaultValue;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_defaultValue != null) {
       offset_defaultValue = _defaultValue.finish(fbBuilder);
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(2, offset_annotations);
+    }
     if (offset_type != null) {
-      fbBuilder.addOffset(2, offset_type);
+      fbBuilder.addOffset(3, offset_type);
     }
     if (offset_parameters != null) {
-      fbBuilder.addOffset(3, offset_parameters);
+      fbBuilder.addOffset(4, offset_parameters);
     }
     if (_kind != null && _kind != idl.UnlinkedParamKind.required) {
-      fbBuilder.addUint32(4, _kind.index);
+      fbBuilder.addUint32(5, _kind.index);
     }
     if (_isFunctionTyped == true) {
-      fbBuilder.addBool(5, true);
+      fbBuilder.addBool(6, true);
     }
     if (_isInitializingFormal == true) {
-      fbBuilder.addBool(6, true);
+      fbBuilder.addBool(7, true);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
-      fbBuilder.addUint32(7, _inferredTypeSlot);
+      fbBuilder.addUint32(8, _inferredTypeSlot);
     }
     if (offset_defaultValue != null) {
-      fbBuilder.addOffset(8, offset_defaultValue);
+      fbBuilder.addOffset(9, offset_defaultValue);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @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);
 
   String _name;
   int _nameOffset;
+  List<idl.UnlinkedConst> _annotations;
   idl.EntityRef _type;
   List<idl.UnlinkedParam> _parameters;
   idl.UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   int _inferredTypeSlot;
   idl.UnlinkedConst _defaultValue;
 
   @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.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   idl.EntityRef get type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 2, null);
+    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _type;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 3, const <idl.UnlinkedParam>[]);
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 
   @override
   idl.UnlinkedParamKind get kind {
-    _kind ??= const _UnlinkedParamKindReader().vTableGet(_bp, 4, idl.UnlinkedParamKind.required);
+    _kind ??= const _UnlinkedParamKindReader().vTableGet(_bp, 5, idl.UnlinkedParamKind.required);
     return _kind;
   }
 
   @override
   bool get isFunctionTyped {
-    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isFunctionTyped;
   }
 
   @override
   bool get isInitializingFormal {
-    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _isInitializingFormal;
   }
 
   @override
   int get inferredTypeSlot {
-    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
     return _inferredTypeSlot;
   }
 
   @override
   idl.UnlinkedConst get defaultValue {
-    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 8, null);
+    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 9, null);
     return _defaultValue;
   }
 }
 
 abstract class _UnlinkedParamMixin implements idl.UnlinkedParam {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
+    "annotations": annotations,
     "type": type,
     "parameters": parameters,
     "kind": kind,
     "isFunctionTyped": isFunctionTyped,
     "isInitializingFormal": isInitializingFormal,
     "inferredTypeSlot": inferredTypeSlot,
     "defaultValue": defaultValue,
   };
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
   bool _finished = false;
 
   int _uriOffset;
   int _uriEnd;
+  List<UnlinkedConstBuilder> _annotations;
 
   @override
   int get uriOffset => _uriOffset ??= 0;
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
    */
   void set uriOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriOffset = _value;
   }
 
   @override
   int get uriEnd => _uriEnd ??= 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
 
-  UnlinkedPartBuilder({int uriOffset, int uriEnd})
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this part declaration.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  UnlinkedPartBuilder({int uriOffset, int uriEnd, List<UnlinkedConstBuilder> annotations})
     : _uriOffset = uriOffset,
-      _uriEnd = uriEnd;
+      _uriEnd = uriEnd,
+      _annotations = annotations;
 
   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 (_uriOffset != null && _uriOffset != 0) {
       fbBuilder.addUint32(0, _uriOffset);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(1, _uriEnd);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(2, offset_annotations);
+    }
     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);
 
   int _uriOffset;
   int _uriEnd;
+  List<idl.UnlinkedConst> _annotations;
 
   @override
   int get uriOffset {
     _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
     return _uriOffset;
   }
 
   @override
   int get uriEnd {
     _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _uriEnd;
   }
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
 }
 
 abstract class _UnlinkedPartMixin implements idl.UnlinkedPart {
   @override
   Map<String, Object> toMap() => {
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
+    "annotations": annotations,
   };
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
   idl.ReferenceKind _kind;
   int _numTypeParameters;
   List<UnlinkedPublicNameBuilder> _constMembers;
@@ skipping 355 matching lines @@
     "prefixReference": prefixReference,
   };
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the typedef.
    */
@@ skipping 20 matching lines @@
   /**
    * Documentation comment for the typedef, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this typedef.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
@@ skipping 12 matching lines @@
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
-  UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
+  UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
+      _annotations = annotations,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
+    fb.Offset offset_annotations;
     fb.Offset offset_typeParameters;
     fb.Offset offset_returnType;
     fb.Offset offset_parameters;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_returnType != null) {
       offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(3, offset_typeParameters);
+      fbBuilder.addOffset(4, offset_typeParameters);
     }
     if (offset_returnType != null) {
-      fbBuilder.addOffset(4, offset_returnType);
+      fbBuilder.addOffset(5, offset_returnType);
     }
     if (offset_parameters != null) {
-      fbBuilder.addOffset(5, offset_parameters);
+      fbBuilder.addOffset(6, offset_parameters);
     }
     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);
 
   String _name;
   int _nameOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedConst> _annotations;
   List<idl.UnlinkedTypeParam> _typeParameters;
   idl.EntityRef _returnType;
   List<idl.UnlinkedParam> _parameters;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 3, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 
   @override
   idl.EntityRef get returnType {
-    _returnType ??= const _EntityRefReader().vTableGet(_bp, 4, null);
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 5, null);
     return _returnType;
   }
 
   @override
   List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 5, const <idl.UnlinkedParam>[]);
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedParam>[]);
     return _parameters;
   }
 }
 
 abstract class _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
+    "annotations": annotations,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
   };
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
+  List<UnlinkedConstBuilder> _annotations;
   EntityRefBuilder _bound;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the type parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
   int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
+  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;
   }
 
-  UnlinkedTypeParamBuilder({String name, int nameOffset, EntityRefBuilder bound})
+  UnlinkedTypeParamBuilder({String name, int nameOffset, List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound})
     : _name = name,
       _nameOffset = nameOffset,
+      _annotations = annotations,
       _bound = bound;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
+    fb.Offset offset_annotations;
     fb.Offset offset_bound;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_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);
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(2, offset_annotations);
+    }
     if (offset_bound != null) {
-      fbBuilder.addOffset(2, offset_bound);
+      fbBuilder.addOffset(3, offset_bound);
     }
     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);
 
   String _name;
   int _nameOffset;
+  List<idl.UnlinkedConst> _annotations;
   idl.EntityRef _bound;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
   idl.EntityRef get bound {
-    _bound ??= const _EntityRefReader().vTableGet(_bp, 2, null);
+    _bound ??= const _EntityRefReader().vTableGet(_bp, 3, null);
     return _bound;
   }
 }
 
 abstract class _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
+    "annotations": annotations,
     "bound": bound,
   };
 }
 
 class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   bool _finished = false;
 
   String _libraryName;
   int _libraryNameOffset;
   int _libraryNameLength;
   UnlinkedDocumentationCommentBuilder _libraryDocumentationComment;
+  List<UnlinkedConstBuilder> _libraryAnnotations;
   UnlinkedPublicNamespaceBuilder _publicNamespace;
   List<UnlinkedReferenceBuilder> _references;
   List<UnlinkedClassBuilder> _classes;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
   List<UnlinkedImportBuilder> _imports;
   List<UnlinkedPartBuilder> _parts;
   List<UnlinkedTypedefBuilder> _typedefs;
   List<UnlinkedVariableBuilder> _variables;
@@ skipping 41 matching lines @@
   /**
    * Documentation comment for the library, or `null` if there is no
    * documentation comment.
    */
   void set libraryDocumentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _libraryDocumentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get libraryAnnotations => _libraryAnnotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for the library declaration, or the empty list if there is no
+   * library declaration.
+   */
+  void set libraryAnnotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _libraryAnnotations = _value;
+  }
+
+  @override
   UnlinkedPublicNamespaceBuilder get publicNamespace => _publicNamespace;
 
   /**
    * Unlinked public namespace of this compilation unit.
    */
   void set publicNamespace(UnlinkedPublicNamespaceBuilder _value) {
     assert(!_finished);
     _publicNamespace = _value;
   }
 
@@ skipping 94 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({String libraryName, int libraryNameOffset, int libraryNameLength, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
+  UnlinkedUnitBuilder({String libraryName, int libraryNameOffset, int libraryNameLength, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
     : _libraryName = libraryName,
       _libraryNameOffset = libraryNameOffset,
       _libraryNameLength = libraryNameLength,
       _libraryDocumentationComment = libraryDocumentationComment,
+      _libraryAnnotations = libraryAnnotations,
       _publicNamespace = publicNamespace,
       _references = references,
       _classes = classes,
       _enums = enums,
       _executables = executables,
       _exports = exports,
       _imports = imports,
       _parts = parts,
       _typedefs = typedefs,
       _variables = variables;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_libraryName;
     fb.Offset offset_libraryDocumentationComment;
+    fb.Offset offset_libraryAnnotations;
     fb.Offset offset_publicNamespace;
     fb.Offset offset_references;
     fb.Offset offset_classes;
     fb.Offset offset_enums;
     fb.Offset offset_executables;
     fb.Offset offset_exports;
     fb.Offset offset_imports;
     fb.Offset offset_parts;
     fb.Offset offset_typedefs;
     fb.Offset offset_variables;
     if (_libraryName != null) {
       offset_libraryName = fbBuilder.writeString(_libraryName);
     }
     if (_libraryDocumentationComment != null) {
       offset_libraryDocumentationComment = _libraryDocumentationComment.finish(fbBuilder);
     }
+    if (!(_libraryAnnotations == null || _libraryAnnotations.isEmpty)) {
+      offset_libraryAnnotations = fbBuilder.writeList(_libraryAnnotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_publicNamespace != null) {
       offset_publicNamespace = _publicNamespace.finish(fbBuilder);
     }
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_classes == null || _classes.isEmpty)) {
       offset_classes = fbBuilder.writeList(_classes.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_enums == null || _enums.isEmpty)) {
@@ skipping 23 matching lines @@
     }
     if (_libraryNameOffset != null && _libraryNameOffset != 0) {
       fbBuilder.addUint32(1, _libraryNameOffset);
     }
     if (_libraryNameLength != null && _libraryNameLength != 0) {
       fbBuilder.addUint32(2, _libraryNameLength);
     }
     if (offset_libraryDocumentationComment != null) {
       fbBuilder.addOffset(3, offset_libraryDocumentationComment);
     }
+    if (offset_libraryAnnotations != null) {
+      fbBuilder.addOffset(4, offset_libraryAnnotations);
+    }
     if (offset_publicNamespace != null) {
-      fbBuilder.addOffset(4, offset_publicNamespace);
+      fbBuilder.addOffset(5, offset_publicNamespace);
     }
     if (offset_references != null) {
-      fbBuilder.addOffset(5, offset_references);
+      fbBuilder.addOffset(6, offset_references);
     }
     if (offset_classes != null) {
-      fbBuilder.addOffset(6, offset_classes);
+      fbBuilder.addOffset(7, offset_classes);
     }
     if (offset_enums != null) {
-      fbBuilder.addOffset(7, offset_enums);
+      fbBuilder.addOffset(8, offset_enums);
     }
     if (offset_executables != null) {
-      fbBuilder.addOffset(8, offset_executables);
+      fbBuilder.addOffset(9, offset_executables);
     }
     if (offset_exports != null) {
-      fbBuilder.addOffset(9, offset_exports);
+      fbBuilder.addOffset(10, offset_exports);
     }
     if (offset_imports != null) {
-      fbBuilder.addOffset(10, offset_imports);
+      fbBuilder.addOffset(11, offset_imports);
     }
     if (offset_parts != null) {
-      fbBuilder.addOffset(11, offset_parts);
+      fbBuilder.addOffset(12, offset_parts);
     }
     if (offset_typedefs != null) {
-      fbBuilder.addOffset(12, offset_typedefs);
+      fbBuilder.addOffset(13, offset_typedefs);
     }
     if (offset_variables != null) {
-      fbBuilder.addOffset(13, offset_variables);
+      fbBuilder.addOffset(14, offset_variables);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.UnlinkedUnit readUnlinkedUnit(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _UnlinkedUnitReader().read(rootRef);
 }
 
 class _UnlinkedUnitReader extends fb.TableReader<_UnlinkedUnitImpl> {
   const _UnlinkedUnitReader();
 
   @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);
 
   String _libraryName;
   int _libraryNameOffset;
   int _libraryNameLength;
   idl.UnlinkedDocumentationComment _libraryDocumentationComment;
+  List<idl.UnlinkedConst> _libraryAnnotations;
   idl.UnlinkedPublicNamespace _publicNamespace;
   List<idl.UnlinkedReference> _references;
   List<idl.UnlinkedClass> _classes;
   List<idl.UnlinkedEnum> _enums;
   List<idl.UnlinkedExecutable> _executables;
   List<idl.UnlinkedExportNonPublic> _exports;
   List<idl.UnlinkedImport> _imports;
   List<idl.UnlinkedPart> _parts;
   List<idl.UnlinkedTypedef> _typedefs;
   List<idl.UnlinkedVariable> _variables;
@@ skipping 16 matching lines @@
     return _libraryNameLength;
   }
 
   @override
   idl.UnlinkedDocumentationComment get libraryDocumentationComment {
     _libraryDocumentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 3, null);
     return _libraryDocumentationComment;
   }
 
   @override
+  List<idl.UnlinkedConst> get libraryAnnotations {
+    _libraryAnnotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
+    return _libraryAnnotations;
+  }
+
+  @override
   idl.UnlinkedPublicNamespace get publicNamespace {
-    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 4, null);
+    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 5, null);
     return _publicNamespace;
   }
 
   @override
   List<idl.UnlinkedReference> get references {
-    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 5, const <idl.UnlinkedReference>[]);
+    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 6, const <idl.UnlinkedReference>[]);
     return _references;
   }
 
   @override
   List<idl.UnlinkedClass> get classes {
-    _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 6, const <idl.UnlinkedClass>[]);
+    _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 7, const <idl.UnlinkedClass>[]);
     return _classes;
   }
 
   @override
   List<idl.UnlinkedEnum> get enums {
-    _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 7, const <idl.UnlinkedEnum>[]);
+    _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 8, const <idl.UnlinkedEnum>[]);
     return _enums;
   }
 
   @override
   List<idl.UnlinkedExecutable> get executables {
-    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 8, const <idl.UnlinkedExecutable>[]);
+    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 9, const <idl.UnlinkedExecutable>[]);
     return _executables;
   }
 
   @override
   List<idl.UnlinkedExportNonPublic> get exports {
-    _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 9, const <idl.UnlinkedExportNonPublic>[]);
+    _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 10, const <idl.UnlinkedExportNonPublic>[]);
     return _exports;
   }
 
   @override
   List<idl.UnlinkedImport> get imports {
-    _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 10, const <idl.UnlinkedImport>[]);
+    _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 11, const <idl.UnlinkedImport>[]);
     return _imports;
   }
 
   @override
   List<idl.UnlinkedPart> get parts {
-    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 11, const <idl.UnlinkedPart>[]);
+    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 12, const <idl.UnlinkedPart>[]);
     return _parts;
   }
 
   @override
   List<idl.UnlinkedTypedef> get typedefs {
-    _typedefs ??= const fb.ListReader<idl.UnlinkedTypedef>(const _UnlinkedTypedefReader()).vTableGet(_bp, 12, const <idl.UnlinkedTypedef>[]);
+    _typedefs ??= const fb.ListReader<idl.UnlinkedTypedef>(const _UnlinkedTypedefReader()).vTableGet(_bp, 13, const <idl.UnlinkedTypedef>[]);
     return _typedefs;
   }
 
   @override
   List<idl.UnlinkedVariable> get variables {
-    _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 13, const <idl.UnlinkedVariable>[]);
+    _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 14, const <idl.UnlinkedVariable>[]);
     return _variables;
   }
 }
 
 abstract class _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   @override
   Map<String, Object> toMap() => {
     "libraryName": libraryName,
     "libraryNameOffset": libraryNameOffset,
     "libraryNameLength": libraryNameLength,
     "libraryDocumentationComment": libraryDocumentationComment,
+    "libraryAnnotations": libraryAnnotations,
     "publicNamespace": publicNamespace,
     "references": references,
     "classes": classes,
     "enums": enums,
     "executables": executables,
     "exports": exports,
     "imports": imports,
     "parts": parts,
     "typedefs": typedefs,
     "variables": variables,
   };
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedConstBuilder> _annotations;
   EntityRefBuilder _type;
   UnlinkedConstBuilder _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   int _propagatedTypeSlot;
   int _inferredTypeSlot;
 
   @override
   String get name => _name ??= '';
@@ skipping 24 matching lines @@
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this variable.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
   EntityRefBuilder get type => _type;
 
   /**
    * Declared type of the variable.  Absent if the type is implicit.
    */
   void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
@@ skipping 71 matching lines @@
    * [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);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
-  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, EntityRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, int propagatedTypeSlot, int inferredTypeSlot})
+  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, EntityRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, int propagatedTypeSlot, int inferredTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
+      _annotations = annotations,
       _type = type,
       _constExpr = constExpr,
       _isStatic = isStatic,
       _isFinal = isFinal,
       _isConst = isConst,
       _propagatedTypeSlot = propagatedTypeSlot,
       _inferredTypeSlot = inferredTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
+    fb.Offset offset_annotations;
     fb.Offset offset_type;
     fb.Offset offset_constExpr;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     if (_constExpr != null) {
       offset_constExpr = _constExpr.finish(fbBuilder);
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(3, offset_annotations);
+    }
     if (offset_type != null) {
-      fbBuilder.addOffset(3, offset_type);
+      fbBuilder.addOffset(4, offset_type);
     }
     if (offset_constExpr != null) {
-      fbBuilder.addOffset(4, offset_constExpr);
+      fbBuilder.addOffset(5, offset_constExpr);
     }
     if (_isStatic == true) {
-      fbBuilder.addBool(5, true);
+      fbBuilder.addBool(6, true);
     }
     if (_isFinal == true) {
-      fbBuilder.addBool(6, true);
+      fbBuilder.addBool(7, true);
     }
     if (_isConst == true) {
-      fbBuilder.addBool(7, true);
+      fbBuilder.addBool(8, true);
     }
     if (_propagatedTypeSlot != null && _propagatedTypeSlot != 0) {
-      fbBuilder.addUint32(8, _propagatedTypeSlot);
+      fbBuilder.addUint32(9, _propagatedTypeSlot);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
-      fbBuilder.addUint32(9, _inferredTypeSlot);
+      fbBuilder.addUint32(10, _inferredTypeSlot);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @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);
 
   String _name;
   int _nameOffset;
   idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedConst> _annotations;
   idl.EntityRef _type;
   idl.UnlinkedConst _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   int _propagatedTypeSlot;
   int _inferredTypeSlot;
 
   @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
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @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 type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
+    _type ??= const _EntityRefReader().vTableGet(_bp, 4, null);
     return _type;
   }
 
   @override
   idl.UnlinkedConst get constExpr {
-    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 4, null);
+    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 5, null);
     return _constExpr;
   }
 
   @override
   bool get isStatic {
-    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isStatic;
   }
 
   @override
   bool get isFinal {
-    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _isFinal;
   }
 
   @override
   bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 8, false);
     return _isConst;
   }
 
   @override
   int get propagatedTypeSlot {
-    _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _propagatedTypeSlot;
   }
 
   @override
   int get inferredTypeSlot {
-    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 10, 0);
     return _inferredTypeSlot;
   }
 }
 
 abstract class _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
+    "annotations": annotations,
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }