First cut at idl changes

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 46 matching lines @@
   @override
   int get size => 1;
 
   @override
   idl.ReferenceKind read(fb.BufferContext bc, int offset) {
     int index = const fb.Uint8Reader().read(bc, offset);
     return index < idl.ReferenceKind.values.length ? idl.ReferenceKind.values[index] : idl.ReferenceKind.classOrEnum;
   }
 }
 
+class _TypedefStyleReader extends fb.Reader<idl.TypedefStyle> {
+  const _TypedefStyleReader() : super();
+
+  @override
+  int get size => 1;
+
+  @override
+  idl.TypedefStyle read(fb.BufferContext bc, int offset) {
+    int index = const fb.Uint8Reader().read(bc, offset);
+    return index < idl.TypedefStyle.values.length ? idl.TypedefStyle.values[index] : idl.TypedefStyle.functionType;
+  }
+}
+
 class _UnlinkedConstructorInitializerKindReader extends fb.Reader<idl.UnlinkedConstructorInitializerKind> {
   const _UnlinkedConstructorInitializerKindReader() : super();
 
   @override
   int get size => 1;
 
   @override
   idl.UnlinkedConstructorInitializerKind read(fb.BufferContext bc, int offset) {
     int index = const fb.Uint8Reader().read(bc, offset);
     return index < idl.UnlinkedConstructorInitializerKind.values.length ? idl.UnlinkedConstructorInitializerKind.values[index] : idl.UnlinkedConstructorInitializerKind.field;
@@ skipping 1711 matching lines @@
 }
 
 class EntityRefBuilder extends Object with _EntityRefMixin implements idl.EntityRef {
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<UnlinkedParamBuilder> _syntheticParams;
   EntityRefBuilder _syntheticReturnType;
   List<EntityRefBuilder> _typeArguments;
+  List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
 
   /**
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type
    * parameter.  Otherwise the empty list.
    *
@@ skipping 102 matching lines @@
   List<EntityRefBuilder> get typeArguments => _typeArguments ??= <EntityRefBuilder>[];
 
   /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it (if any).
    */
   void set typeArguments(List<EntityRefBuilder> value) {
     this._typeArguments = value;
   }
 
-  EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<UnlinkedParamBuilder> syntheticParams, EntityRefBuilder syntheticReturnType, List<EntityRefBuilder> typeArguments})
+  @override
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
+
+  /**
+   * If this is a function type, the type parameters defined for the function
+   * type (if any).
+   */
+  void set typeParameters(List<UnlinkedTypeParamBuilder> value) {
+    this._typeParameters = value;
+  }
+
+  EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<UnlinkedParamBuilder> syntheticParams, EntityRefBuilder syntheticReturnType, List<EntityRefBuilder> typeArguments, List<UnlinkedTypeParamBuilder> typeParameters})
     : _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
       _paramReference = paramReference,
       _reference = reference,
       _slot = slot,
       _syntheticParams = syntheticParams,
       _syntheticReturnType = syntheticReturnType,
-      _typeArguments = typeArguments;
+      _typeArguments = typeArguments,
+      _typeParameters = typeParameters;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _syntheticParams?.forEach((b) => b.flushInformative());
     _syntheticReturnType?.flushInformative();
     _typeArguments?.forEach((b) => b.flushInformative());
+    _typeParameters?.forEach((b) => b.flushInformative());
   }
 
   /**
    * Accumulate non-[informative] data into [signature].
    */
   void collectApiSignature(api_sig.ApiSignature signature) {
     signature.addInt(this._reference ?? 0);
     if (this._typeArguments == null) {
       signature.addInt(0);
     } else {
@@ skipping 15 matching lines @@
     signature.addBool(this._syntheticReturnType != null);
     this._syntheticReturnType?.collectApiSignature(signature);
     if (this._syntheticParams == null) {
       signature.addInt(0);
     } else {
       signature.addInt(this._syntheticParams.length);
       for (var x in this._syntheticParams) {
         x?.collectApiSignature(signature);
       }
     }
+    if (this._typeParameters == null) {
+      signature.addInt(0);
+    } else {
+      signature.addInt(this._typeParameters.length);
+      for (var x in this._typeParameters) {
+        x?.collectApiSignature(signature);
+      }
+    }
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_syntheticParams;
     fb.Offset offset_syntheticReturnType;
     fb.Offset offset_typeArguments;
+    fb.Offset offset_typeParameters;
     if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
       offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
     }
     if (!(_syntheticParams == null || _syntheticParams.isEmpty)) {
       offset_syntheticParams = fbBuilder.writeList(_syntheticParams.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_syntheticReturnType != null) {
       offset_syntheticReturnType = _syntheticReturnType.finish(fbBuilder);
     }
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_typeParameters == null || _typeParameters.isEmpty)) {
+      offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
+    }
     fbBuilder.startTable();
     if (offset_implicitFunctionTypeIndices != null) {
       fbBuilder.addOffset(4, offset_implicitFunctionTypeIndices);
     }
     if (_paramReference != null && _paramReference != 0) {
       fbBuilder.addUint32(3, _paramReference);
     }
     if (_reference != null && _reference != 0) {
       fbBuilder.addUint32(0, _reference);
     }
     if (_slot != null && _slot != 0) {
       fbBuilder.addUint32(2, _slot);
     }
     if (offset_syntheticParams != null) {
       fbBuilder.addOffset(6, offset_syntheticParams);
     }
     if (offset_syntheticReturnType != null) {
       fbBuilder.addOffset(5, offset_syntheticReturnType);
     }
     if (offset_typeArguments != null) {
       fbBuilder.addOffset(1, offset_typeArguments);
     }
+    if (offset_typeParameters != null) {
+      fbBuilder.addOffset(7, offset_typeParameters);
+    }
     return fbBuilder.endTable();
   }
 }
 
 class _EntityRefReader extends fb.TableReader<_EntityRefImpl> {
   const _EntityRefReader();
 
   @override
   _EntityRefImpl createObject(fb.BufferContext bc, int offset) => new _EntityRefImpl(bc, offset);
 }
 
 class _EntityRefImpl extends Object with _EntityRefMixin implements idl.EntityRef {
   final fb.BufferContext _bc;
   final int _bcOffset;
 
   _EntityRefImpl(this._bc, this._bcOffset);
 
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<idl.UnlinkedParam> _syntheticParams;
   idl.EntityRef _syntheticReturnType;
   List<idl.EntityRef> _typeArguments;
+  List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<int> get implicitFunctionTypeIndices {
     _implicitFunctionTypeIndices ??= const fb.Uint32ListReader().vTableGet(_bc, _bcOffset, 4, const <int>[]);
     return _implicitFunctionTypeIndices;
   }
 
   @override
   int get paramReference {
     _paramReference ??= const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 3, 0);
@@ skipping 22 matching lines @@
   idl.EntityRef get syntheticReturnType {
     _syntheticReturnType ??= const _EntityRefReader().vTableGet(_bc, _bcOffset, 5, null);
     return _syntheticReturnType;
   }
 
   @override
   List<idl.EntityRef> get typeArguments {
     _typeArguments ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bc, _bcOffset, 1, const <idl.EntityRef>[]);
     return _typeArguments;
   }
+
+  @override
+  List<idl.UnlinkedTypeParam> get typeParameters {
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bc, _bcOffset, 7, const <idl.UnlinkedTypeParam>[]);
+    return _typeParameters;
+  }
 }
 
 abstract class _EntityRefMixin implements idl.EntityRef {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (implicitFunctionTypeIndices.isNotEmpty) _result["implicitFunctionTypeIndices"] = implicitFunctionTypeIndices;
     if (paramReference != 0) _result["paramReference"] = paramReference;
     if (reference != 0) _result["reference"] = reference;
     if (slot != 0) _result["slot"] = slot;
     if (syntheticParams.isNotEmpty) _result["syntheticParams"] = syntheticParams.map((_value) => _value.toJson()).toList();
     if (syntheticReturnType != null) _result["syntheticReturnType"] = syntheticReturnType.toJson();
     if (typeArguments.isNotEmpty) _result["typeArguments"] = typeArguments.map((_value) => _value.toJson()).toList();
+    if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
     "paramReference": paramReference,
     "reference": reference,
     "slot": slot,
     "syntheticParams": syntheticParams,
     "syntheticReturnType": syntheticReturnType,
     "typeArguments": typeArguments,
+    "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
   List<String> _parts;
   String _uri;
 
@@ skipping 1628 matching lines @@
    */
   void set elementKinds(List<idl.IndexSyntheticElementKind> value) {
     this._elementKinds = value;
   }
 
   @override
   List<int> get elementNameClassMemberIds => _elementNameClassMemberIds ??= <int>[];
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
-   * the identifier of the class member element name, or `null` if the element is
-   * a top-level element.  The list is sorted in ascending order, so that the
+   * the identifier of the class member element name, or `null` if the element
+   * is a top-level element.  The list is sorted in ascending order, so that the
    * client can quickly check whether an element is referenced in this
    * [PackageIndex].
    */
   void set elementNameClassMemberIds(List<int> value) {
     assert(value == null || value.every((e) => e >= 0));
     this._elementNameClassMemberIds = value;
   }
 
   @override
   List<int> get elementNameParameterIds => _elementNameParameterIds ??= <int>[];
@@ skipping 4601 matching lines @@
    */
   void set inheritsCovariantSlot(int value) {
     assert(value == null || value >= 0);
     this._inheritsCovariantSlot = value;
   }
 
   @override
   UnlinkedExecutableBuilder get initializer => _initializer;
 
   /**
-   * The synthetic initializer function of the parameter.  Absent if the variable
-   * does not have an initializer.
+   * The synthetic initializer function of the parameter.  Absent if the
+   * variable does not have an initializer.
    */
   void set initializer(UnlinkedExecutableBuilder value) {
     this._initializer = value;
   }
 
   @override
   bool get isExplicitlyCovariant => _isExplicitlyCovariant ??= false;
 
   /**
    * Indicates whether this parameter is explicitly marked as being covariant.
    */
   void set isExplicitlyCovariant(bool value) {
     this._isExplicitlyCovariant = value;
   }
 
   @override
   bool get isFinal => _isFinal ??= false;
 
   /**
    * Indicates whether the parameter is declared using the `final` keyword.
    */
   void set isFinal(bool value) {
     this._isFinal = value;
   }
 
   @override
   bool get isFunctionTyped => _isFunctionTyped ??= false;
 
   /**
-   * Indicates whether this is a function-typed parameter.
+   * Indicates whether this is a function-typed parameter. A parameter is
+   * function-typed if the declaration of the parameter has explicit formal
+   * parameters
+   * ```
+   * int functionTyped(int p)
+   * ```
+   * but is not function-typed if it does not, even if the type of the parameter
+   * is a function type.
    */
   void set isFunctionTyped(bool value) {
     this._isFunctionTyped = value;
   }
 
   @override
   bool get isInitializingFormal => _isInitializingFormal ??= false;
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
@@ skipping 1022 matching lines @@
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   List<UnlinkedExprBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _returnType;
+  idl.TypedefStyle _style;
   List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<UnlinkedExprBuilder> get annotations => _annotations ??= <UnlinkedExprBuilder>[];
 
   /**
    * Annotations for this typedef.
    */
   void set annotations(List<UnlinkedExprBuilder> value) {
     this._annotations = value;
@@ skipping 48 matching lines @@
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> value) {
     this._parameters = value;
   }
 
   @override
   EntityRefBuilder get returnType => _returnType;
 
   /**
-   * Return type of the typedef.
+   * If [style] is [TypedefStyle.functionType], the return type of the typedef.
+   * If [style] is [TypedefStyle.genericFunctionType], the function type being
+   * defined.
    */
   void set returnType(EntityRefBuilder value) {
     this._returnType = value;
   }
 
   @override
+  idl.TypedefStyle get style => _style ??= idl.TypedefStyle.functionType;
+
+  /**
+   * The style of the typedef.
+   */
+  void set style(idl.TypedefStyle value) {
+    this._style = value;
+  }
+
+  @override
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> value) {
     this._typeParameters = value;
   }
 
-  UnlinkedTypedefBuilder({List<UnlinkedExprBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
+  UnlinkedTypedefBuilder({List<UnlinkedExprBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, idl.TypedefStyle style, List<UnlinkedTypeParamBuilder> typeParameters})
     : _annotations = annotations,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _name = name,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _returnType = returnType,
+      _style = style,
       _typeParameters = typeParameters;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _codeRange = null;
     _documentationComment = null;
     _nameOffset = null;
@@ skipping 26 matching lines @@
       }
     }
     if (this._typeParameters == null) {
       signature.addInt(0);
     } else {
       signature.addInt(this._typeParameters.length);
       for (var x in this._typeParameters) {
         x?.collectApiSignature(signature);
       }
     }
+    signature.addInt(this._style == null ? 0 : this._style.index);
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     fb.Offset offset_parameters;
     fb.Offset offset_returnType;
     fb.Offset offset_typeParameters;
@@ skipping 33 matching lines @@
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_parameters != null) {
       fbBuilder.addOffset(3, offset_parameters);
     }
     if (offset_returnType != null) {
       fbBuilder.addOffset(2, offset_returnType);
     }
+    if (_style != null && _style != idl.TypedefStyle.functionType) {
+      fbBuilder.addUint8(8, _style.index);
+    }
     if (offset_typeParameters != null) {
       fbBuilder.addOffset(5, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
   const _UnlinkedTypedefReader();
 
   @override
   _UnlinkedTypedefImpl createObject(fb.BufferContext bc, int offset) => new _UnlinkedTypedefImpl(bc, offset);
 }
 
 class _UnlinkedTypedefImpl extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   final fb.BufferContext _bc;
   final int _bcOffset;
 
   _UnlinkedTypedefImpl(this._bc, this._bcOffset);
 
   List<idl.UnlinkedExpr> _annotations;
   idl.CodeRange _codeRange;
   idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _returnType;
+  idl.TypedefStyle _style;
   List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<idl.UnlinkedExpr> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedExpr>(const _UnlinkedExprReader()).vTableGet(_bc, _bcOffset, 4, const <idl.UnlinkedExpr>[]);
     return _annotations;
   }
 
   @override
   idl.CodeRange get codeRange {
@@ skipping 25 matching lines @@
     return _parameters;
   }
 
   @override
   idl.EntityRef get returnType {
     _returnType ??= const _EntityRefReader().vTableGet(_bc, _bcOffset, 2, null);
     return _returnType;
   }
 
   @override
+  idl.TypedefStyle get style {
+    _style ??= const _TypedefStyleReader().vTableGet(_bc, _bcOffset, 8, idl.TypedefStyle.functionType);
+    return _style;
+  }
+
+  @override
   List<idl.UnlinkedTypeParam> get typeParameters {
     _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bc, _bcOffset, 5, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 }
 
 abstract class _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
     if (codeRange != null) _result["codeRange"] = codeRange.toJson();
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
     if (returnType != null) _result["returnType"] = returnType.toJson();
+    if (style != idl.TypedefStyle.functionType) _result["style"] = style.toString().split('.')[1];
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "codeRange": codeRange,
     "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
     "parameters": parameters,
     "returnType": returnType,
+    "style": style,
     "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   List<UnlinkedExprBuilder> _annotations;
   EntityRefBuilder _bound;
@@ skipping 1386 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }