> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Covariant Field
A covariant field in Dart is an instance variable modified by the `covariant` keyword, allowing a subclass to override the field with a stricter (narrower) subtype than the one declared in its superclass. This explicitly bypasses Dart's default static type-checking rules, which normally require setter parameters to be contravariant or invariant.
In Dart, declaring a mutable field implicitly generates both a getter and a setter. According to standard object-oriented subtyping rules, overriding a getter allows for a covariant return type, but overriding a setter requires a contravariant parameter type. Because a field represents both a getter and a setter, overriding a field with a narrower type creates a static type error on the implicit setter.
The `covariant` keyword suppresses this compile-time error on the implicit setter and defers the type validation to runtime.
```dart theme={"dark"}
class SuperType {}
class SubType extends SuperType {}
class BaseClass {
SuperType? myField;
}
class DerivedClass extends BaseClass {
// Narrows the type of myField from SuperType? to SubType?.
// The 'covariant' keyword prevents a static analysis error.
@override
covariant SubType? myField;
}
```
Alternatively, the `covariant` keyword can be applied directly to the field in the base class. This establishes a contract that permits any future subclass to tighten the field's type without needing to redeclare the keyword:
```dart theme={"dark"}
class BaseClass {
// Declares that subclasses may narrow this field's type
covariant SuperType? myField;
}
class DerivedClass extends BaseClass {
@override
SubType? myField; // Valid, covariance was established in the superclass
}
```
**Mechanics and Type Safety**
* **Static Analysis:** When `covariant` is applied, the Dart analyzer permits the narrower type declaration. Within the subclass, the field is statically recognized as the narrower type, allowing direct access to the subtype's specific members without manual casting.
* **Runtime Enforcement:** By using `covariant`, type safety for the implicit setter is shifted from compile-time to runtime. If an instance of the subclass is upcast to the base class, and an incompatible sibling type is assigned to the field, the Dart Virtual Machine will throw a `TypeError` during execution.
```dart theme={"dark"}
BaseClass instance = DerivedClass();
// Compiles successfully due to the BaseClass reference,
// but throws a runtime TypeError because 'instance' is actually
// a DerivedClass, which expects a SubType?, not a base SuperType.
instance.myField = SuperType();
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
