The parameter of synthetic setters should inherit 'covariant'.

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 3049 matching lines @@
    */
   void set constCycles(List<int> value) {
     assert(value == null || value.every((e) => e >= 0));
     this._constCycles = value;
   }
 
   @override
   List<int> get parametersInheritingCovariant => _parametersInheritingCovariant ??= <int>[];
 
   /**
-   * List of slot ids (referring to [UnlinkedParam.inheritsCovariantSlot])
-   * corresponding to parameters that inherit `@covariant` behavior from a base
-   * class.
+   * List of slot ids (referring to [UnlinkedParam.inheritsCovariantSlot] or
+   * [UnlinkedVariable.inheritsCovariantSlot]) corresponding to parameters
+   * that inherit `@covariant` behavior from a base class.
    */
   void set parametersInheritingCovariant(List<int> value) {
     assert(value == null || value.every((e) => e >= 0));
     this._parametersInheritingCovariant = value;
   }
 
   @override
   List<LinkedReferenceBuilder> get references => _references ??= <LinkedReferenceBuilder>[];
 
   /**
@@ skipping 4827 matching lines @@
     "isValidConst": isValidConst,
     "operations": operations,
     "references": references,
     "strings": strings,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
+class UnlinkedGenericFunctionTypeBuilder extends Object with _UnlinkedGenericFunctionTypeMixin implements idl.UnlinkedGenericFunctionType {
+  int _offset;
+  List<UnlinkedParamBuilder> _parameters;
+  EntityRefBuilder _returnType;
+  List<UnlinkedTypeParamBuilder> _typeParameters;
+
+  @override
+  int get offset => _offset ??= 0;
+
+  /**
+   * The offset of the return type.
+   */
+  void set offset(int value) {
+    assert(value == null || value >= 0);
+    this._offset = value;
+  }
+
+  @override
+  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
+
+  /**
+   * Parameters of the function type, if any.
+   */
+  void set parameters(List<UnlinkedParamBuilder> value) {
+    this._parameters = value;
+  }
+
+  @override
+  EntityRefBuilder get returnType => _returnType;
+
+  /**
+   * Declared return type of the function type. Absent if the return type is
+   * implicit.
+   */
+  void set returnType(EntityRefBuilder value) {
+    this._returnType = value;
+  }
+
+  @override
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
+
+  /**
+   * Type parameters of the function type, if any.
+   */
+  void set typeParameters(List<UnlinkedTypeParamBuilder> value) {
+    this._typeParameters = value;
+  }
+
+  UnlinkedGenericFunctionTypeBuilder({int offset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
+    : _offset = offset,
+      _parameters = parameters,
+      _returnType = returnType,
+      _typeParameters = typeParameters;
+
+  /**
+   * Flush [informative] data recursively.
+   */
+  void flushInformative() {
+    _offset = null;
+    _parameters?.forEach((b) => b.flushInformative());
+    _returnType?.flushInformative();
+    _typeParameters?.forEach((b) => b.flushInformative());
+  }
+
+  /**
+   * Accumulate non-[informative] data into [signature].
+   */
+  void collectApiSignature(api_sig.ApiSignature signature) {
+    signature.addBool(this._returnType != null);
+    this._returnType?.collectApiSignature(signature);
+    if (this._typeParameters == null) {
+      signature.addInt(0);
+    } else {
+      signature.addInt(this._typeParameters.length);
+      for (var x in this._typeParameters) {
+        x?.collectApiSignature(signature);
+      }
+    }
+    if (this._parameters == null) {
+      signature.addInt(0);
+    } else {
+      signature.addInt(this._parameters.length);
+      for (var x in this._parameters) {
+        x?.collectApiSignature(signature);
+      }
+    }
+  }
+
+  fb.Offset finish(fb.Builder fbBuilder) {
+    fb.Offset offset_parameters;
+    fb.Offset offset_returnType;
+    fb.Offset offset_typeParameters;
+    if (!(_parameters == null || _parameters.isEmpty)) {
+      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_returnType != null) {
+      offset_returnType = _returnType.finish(fbBuilder);
+    }
+    if (!(_typeParameters == null || _typeParameters.isEmpty)) {
+      offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
+    }
+    fbBuilder.startTable();
+    if (_offset != null && _offset != 0) {
+      fbBuilder.addUint32(0, _offset);
+    }
+    if (offset_parameters != null) {
+      fbBuilder.addOffset(3, offset_parameters);
+    }
+    if (offset_returnType != null) {
+      fbBuilder.addOffset(1, offset_returnType);
+    }
+    if (offset_typeParameters != null) {
+      fbBuilder.addOffset(2, offset_typeParameters);
+    }
+    return fbBuilder.endTable();
+  }
+}
+
+class _UnlinkedGenericFunctionTypeReader extends fb.TableReader<_UnlinkedGenericFunctionTypeImpl> {
+  const _UnlinkedGenericFunctionTypeReader();
+
+  @override
+  _UnlinkedGenericFunctionTypeImpl createObject(fb.BufferContext bc, int offset) => new _UnlinkedGenericFunctionTypeImpl(bc, offset);
+}
+
+class _UnlinkedGenericFunctionTypeImpl extends Object with _UnlinkedGenericFunctionTypeMixin implements idl.UnlinkedGenericFunctionType {
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  _UnlinkedGenericFunctionTypeImpl(this._bc, this._bcOffset);
+
+  int _offset;
+  List<idl.UnlinkedParam> _parameters;
+  idl.EntityRef _returnType;
+  List<idl.UnlinkedTypeParam> _typeParameters;
+
+  @override
+  int get offset {
+    _offset ??= const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 0, 0);
+    return _offset;
+  }
+
+  @override
+  List<idl.UnlinkedParam> get parameters {
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bc, _bcOffset, 3, const <idl.UnlinkedParam>[]);
+    return _parameters;
+  }
+
+  @override
+  idl.EntityRef get returnType {
+    _returnType ??= const _EntityRefReader().vTableGet(_bc, _bcOffset, 1, null);
+    return _returnType;
+  }
+
+  @override
+  List<idl.UnlinkedTypeParam> get typeParameters {
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bc, _bcOffset, 2, const <idl.UnlinkedTypeParam>[]);
+    return _typeParameters;
+  }
+}
+
+abstract class _UnlinkedGenericFunctionTypeMixin implements idl.UnlinkedGenericFunctionType {
+  @override
+  Map<String, Object> toJson() {
+    Map<String, Object> _result = <String, Object>{};
+    if (offset != 0) _result["offset"] = offset;
+    if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
+    if (returnType != null) _result["returnType"] = returnType.toJson();
+    if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
+    return _result;
+  }
+
+  @override
+  Map<String, Object> toMap() => {
+    "offset": offset,
+    "parameters": parameters,
+    "returnType": returnType,
+    "typeParameters": typeParameters,
+  };
+
+  @override
+  String toString() => convert.JSON.encode(toJson());
+}
+
 class UnlinkedImportBuilder extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
   List<UnlinkedExprBuilder> _annotations;
   List<UnlinkedCombinatorBuilder> _combinators;
   List<UnlinkedConfigurationBuilder> _configurations;
   bool _isDeferred;
   bool _isImplicit;
   int _offset;
   int _prefixOffset;
   int _prefixReference;
   String _uri;
@@ skipping 2936 matching lines @@
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   List<UnlinkedExprBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   int _inferredTypeSlot;
+  int _inheritsCovariantSlot;
   UnlinkedExecutableBuilder _initializer;
   bool _isConst;
   bool _isCovariant;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   EntityRefBuilder _type;
   int _visibleLength;
@@ skipping 38 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(value == null || value >= 0);
     this._inferredTypeSlot = value;
   }
 
   @override
+  int get inheritsCovariantSlot => _inheritsCovariantSlot ??= 0;
+
+  /**
+   * If this is an instance non-final field, a nonzero slot id which is unique
+   * within this compilation unit.  If this id is found in
+   * [LinkedUnit.parametersInheritingCovariant], then the parameter of the
+   * synthetic setter inherits `@covariant` behavior from a base class.
+   *
+   * Otherwise, zero.
+   */
+  void set inheritsCovariantSlot(int value) {
+    assert(value == null || value >= 0);
+    this._inheritsCovariantSlot = value;
+  }
+
+  @override
   UnlinkedExecutableBuilder get initializer => _initializer;
 
   /**
    * The synthetic initializer function of the variable.  Absent if the variable
    * does not have an initializer.
    */
   void set initializer(UnlinkedExecutableBuilder value) {
     this._initializer = value;
   }
 
@@ skipping 104 matching lines @@
   int get visibleOffset => _visibleOffset ??= 0;
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int value) {
     assert(value == null || value >= 0);
     this._visibleOffset = value;
   }
 
-  UnlinkedVariableBuilder({List<UnlinkedExprBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isConst, bool isCovariant, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type, int visibleLength, int visibleOffset})
+  UnlinkedVariableBuilder({List<UnlinkedExprBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, int inferredTypeSlot, int inheritsCovariantSlot, UnlinkedExecutableBuilder initializer, bool isConst, bool isCovariant, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type, int visibleLength, int visibleOffset})
     : _annotations = annotations,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _inferredTypeSlot = inferredTypeSlot,
+      _inheritsCovariantSlot = inheritsCovariantSlot,
       _initializer = initializer,
       _isConst = isConst,
       _isCovariant = isCovariant,
       _isFinal = isFinal,
       _isStatic = isStatic,
       _name = name,
       _nameOffset = nameOffset,
       _propagatedTypeSlot = propagatedTypeSlot,
       _type = type,
       _visibleLength = visibleLength,
@@ skipping 29 matching lines @@
     } else {
       signature.addInt(this._annotations.length);
       for (var x in this._annotations) {
         x?.collectApiSignature(signature);
       }
     }
     signature.addInt(this._inferredTypeSlot ?? 0);
     signature.addBool(this._initializer != null);
     this._initializer?.collectApiSignature(signature);
     signature.addBool(this._isCovariant == true);
+    signature.addInt(this._inheritsCovariantSlot ?? 0);
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_documentationComment;
     fb.Offset offset_initializer;
     fb.Offset offset_name;
     fb.Offset offset_type;
     if (!(_annotations == null || _annotations.isEmpty)) {
@@ skipping 20 matching lines @@
     }
     if (offset_codeRange != null) {
       fbBuilder.addOffset(5, offset_codeRange);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(10, offset_documentationComment);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
       fbBuilder.addUint32(9, _inferredTypeSlot);
     }
+    if (_inheritsCovariantSlot != null && _inheritsCovariantSlot != 0) {
+      fbBuilder.addUint32(15, _inheritsCovariantSlot);
+    }
     if (offset_initializer != null) {
       fbBuilder.addOffset(13, offset_initializer);
     }
     if (_isConst == true) {
       fbBuilder.addBool(6, true);
     }
     if (_isCovariant == true) {
       fbBuilder.addBool(14, true);
     }
     if (_isFinal == true) {
@@ skipping 34 matching lines @@
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   final fb.BufferContext _bc;
   final int _bcOffset;
 
   _UnlinkedVariableImpl(this._bc, this._bcOffset);
 
   List<idl.UnlinkedExpr> _annotations;
   idl.CodeRange _codeRange;
   idl.UnlinkedDocumentationComment _documentationComment;
   int _inferredTypeSlot;
+  int _inheritsCovariantSlot;
   idl.UnlinkedExecutable _initializer;
   bool _isConst;
   bool _isCovariant;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   idl.EntityRef _type;
   int _visibleLength;
@@ skipping 17 matching lines @@
     return _documentationComment;
   }
 
   @override
   int get inferredTypeSlot {
     _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 9, 0);
     return _inferredTypeSlot;
   }
 
   @override
+  int get inheritsCovariantSlot {
+    _inheritsCovariantSlot ??= const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 15, 0);
+    return _inheritsCovariantSlot;
+  }
+
+  @override
   idl.UnlinkedExecutable get initializer {
     _initializer ??= const _UnlinkedExecutableReader().vTableGet(_bc, _bcOffset, 13, null);
     return _initializer;
   }
 
   @override
   bool get isConst {
     _isConst ??= const fb.BoolReader().vTableGet(_bc, _bcOffset, 6, false);
     return _isConst;
   }
@@ skipping 54 matching lines @@
 }
 
 abstract class _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
     if (codeRange != null) _result["codeRange"] = codeRange.toJson();
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
     if (inferredTypeSlot != 0) _result["inferredTypeSlot"] = inferredTypeSlot;
+    if (inheritsCovariantSlot != 0) _result["inheritsCovariantSlot"] = inheritsCovariantSlot;
     if (initializer != null) _result["initializer"] = initializer.toJson();
     if (isConst != false) _result["isConst"] = isConst;
     if (isCovariant != false) _result["isCovariant"] = isCovariant;
     if (isFinal != false) _result["isFinal"] = isFinal;
     if (isStatic != false) _result["isStatic"] = isStatic;
     if (name != '') _result["name"] = name;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (propagatedTypeSlot != 0) _result["propagatedTypeSlot"] = propagatedTypeSlot;
     if (type != null) _result["type"] = type.toJson();
     if (visibleLength != 0) _result["visibleLength"] = visibleLength;
     if (visibleOffset != 0) _result["visibleOffset"] = visibleOffset;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "codeRange": codeRange,
     "documentationComment": documentationComment,
     "inferredTypeSlot": inferredTypeSlot,
+    "inheritsCovariantSlot": inheritsCovariantSlot,
     "initializer": initializer,
     "isConst": isConst,
     "isCovariant": isCovariant,
     "isFinal": isFinal,
     "isStatic": isStatic,
     "name": name,
     "nameOffset": nameOffset,
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }