Store the covariant keyword flag for parameters and fields into Kernel and resynthesize in analyzer.

pkg/kernel/lib/ast.dart

 // Copyright (c) 2016, 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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 962 matching lines @@
   DartType type; // Not null. Defaults to DynamicType.
   int flags = 0;
   Expression initializer; // May be null.
 
   /// The uri of the source file this field was loaded from.
   String fileUri;
 
   Field(Name name,
       {this.type: const DynamicType(),
       this.initializer,
+      bool isCovariant: false,
       bool isFinal: false,
       bool isConst: false,
       bool isStatic: false,
       bool hasImplicitGetter,
       bool hasImplicitSetter,
       int transformerFlags: 0,
       this.fileUri,
       Reference reference})
       : super(name, reference) {
     assert(type != null);
     initializer?.parent = this;
+    this.isCovariant = isCovariant;
     this.isFinal = isFinal;
     this.isConst = isConst;
     this.isStatic = isStatic;
     this.hasImplicitGetter = hasImplicitGetter ?? !isStatic;
     this.hasImplicitSetter = hasImplicitSetter ?? (!isStatic && !isFinal);
     this.transformerFlags = transformerFlags;
   }
 
   static const int FlagFinal = 1 << 0; // Must match serialized bit positions.
   static const int FlagConst = 1 << 1;
   static const int FlagStatic = 1 << 2;
   static const int FlagHasImplicitGetter = 1 << 3;
   static const int FlagHasImplicitSetter = 1 << 4;
+  static const int FlagCovariant = 1 << 5;
+
+  /// Whether the field is declared with the `covariant` keyword.
+  bool get isCovariant => flags & FlagCovariant != 0;
 
   bool get isFinal => flags & FlagFinal != 0;
   bool get isConst => flags & FlagConst != 0;
   bool get isStatic => flags & FlagStatic != 0;
 
   /// If true, a getter should be generated for this field.
   ///
   /// If false, there may or may not exist an explicit getter in the same class
   /// with the same name as the field.
   ///
   /// By default, all non-static fields have implicit getters.
   bool get hasImplicitGetter => flags & FlagHasImplicitGetter != 0;
 
   /// If true, a setter should be generated for this field.
   ///
   /// If false, there may or may not exist an explicit setter in the same class
   /// with the same name as the field.
   ///
   /// Final fields never have implicit setters, but a field without an implicit
   /// setter is not necessarily final, as it may be mutated by direct field
   /// access.
   ///
   /// By default, all non-static, non-final fields have implicit setters.
   bool get hasImplicitSetter => flags & FlagHasImplicitSetter != 0;
 
+  void set isCovariant(bool value) {
+    flags = value ? (flags | FlagCovariant) : (flags & ~FlagCovariant);
+  }
+
   void set isFinal(bool value) {
     flags = value ? (flags | FlagFinal) : (flags & ~FlagFinal);
   }
 
   void set isConst(bool value) {
     flags = value ? (flags | FlagConst) : (flags & ~FlagConst);
   }
 
   void set isStatic(bool value) {
     flags = value ? (flags | FlagStatic) : (flags & ~FlagStatic);
@@ skipping 2749 matching lines @@
   /// For parameters, this is the default value.
   ///
   /// Should be null in other cases.
   Expression initializer; // May be null.
 
   VariableDeclaration(this.name,
       {this.initializer,
       this.type: const DynamicType(),
       bool isFinal: false,
       bool isConst: false,
-      bool isFieldFormal: false}) {
+      bool isFieldFormal: false,
+      bool isCovariant: false}) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
     this.isConst = isConst;
     this.isFieldFormal = isFieldFormal;
+    this.isCovariant = isCovariant;
   }
 
   /// Creates a synthetic variable with the given expression as initializer.
   VariableDeclaration.forValue(this.initializer,
       {bool isFinal: true,
       bool isConst: false,
       bool isFieldFormal: false,
       this.type: const DynamicType()}) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
     this.isConst = isConst;
     this.isFieldFormal = isFieldFormal;
   }
 
   static const int FlagFinal = 1 << 0; // Must match serialized bit positions.
   static const int FlagConst = 1 << 1;
   static const int FlagFieldFormal = 1 << 2;
-  static const int FlagInScope = 1 << 3; // Temporary flag used by verifier.
+  static const int FlagCovariant = 1 << 3;
+  static const int FlagInScope = 1 << 4; // Temporary flag used by verifier.
 
   bool get isFinal => flags & FlagFinal != 0;
   bool get isConst => flags & FlagConst != 0;
 
+  /// Whether the parameter is declared with the `covariant` keyword.
+  bool get isCovariant => flags & FlagCovariant != 0;
+
   /// Whether the variable is declared as a field formal parameter of
   /// a constructor.
   @informative
   bool get isFieldFormal => flags & FlagFieldFormal != 0;
 
   void set isFinal(bool value) {
     flags = value ? (flags | FlagFinal) : (flags & ~FlagFinal);
   }
 
   void set isConst(bool value) {
     flags = value ? (flags | FlagConst) : (flags & ~FlagConst);
   }
 
+  void set isCovariant(bool value) {
+    flags = value ? (flags | FlagCovariant) : (flags & ~FlagCovariant);
+  }
+
   @informative
   void set isFieldFormal(bool value) {
     flags = value ? (flags | FlagFieldFormal) : (flags & ~FlagFieldFormal);
   }
 
   accept(StatementVisitor v) => v.visitVariableDeclaration(this);
   accept1(StatementVisitor1 v, arg) => v.visitVariableDeclaration(this, arg);
 
   visitChildren(Visitor v) {
     type?.accept(v);
@@ skipping 890 matching lines @@
   if (typedef_.canonicalName == null) {
     throw '$typedef_ has no canonical name';
   }
   return typedef_.canonicalName;
 }
 
 /// Annotation describing information which is not part of Dart semantics; in
 /// other words, if this information (or any information it refers to) changes,
 /// static analysis and runtime behavior of the library are unaffected.
 const informative = null;