How to enforce that a parameter is of the same static concrete type as the object? - dart

Question

I have a Flutter app connected to a Firestore database. I have a hierarchy of objects, let's say for example with abstract base class Vehicle, with subclasses such as Car, Truck, etc. Objects of these types are stored in the database. Due to how Firestore works, it is better to make these classes immutable, i.e. to make them essentially represent a snapshot of the conceptual object instead of the mutable object itself.
When I want to update a Vehicle object in the database, I don't want users of Vehicle (i.e. other parts of my code) to have to specify the update as a dynamic map, e.g. vehicle.update({"speed": 42, "color": "red"}), because this disables static checking of field names and types. Instead, I thought that the best way would be to make the users create the new snapshot they want, e.g. car.setInDB(updatedCar). Behind the scenes this just calls .set() on the corresponding document reference in Firestore. Since the implementation would be the same on all subclasses of Vehicle, one could think of adding the method to Vehicle:
abstract class Vehicle {
Future<void> setInDB(Vehicle updated)
=> database.set(this.dbLocation, updated)
}
However, users of this method shouldn't be setting a vehicle of some concrete type with a vehicle of some other concrete type. I.e., a truck can only be updated with another truck snapshot, not a car snaphot. This is already enforced at runtime through Firestore rules, but I'd rather have this checked statically.
These options occur to me:
Use the covariant keyword and make subclasses override the setInDB method with the corresponding type.
abstract class Vehicle {
Future<void> setInDB(covariant Vehicle updated)
=> database.set(this.dbLocation, updated)
}
class Car extends Vehicle {
#override
Future<void> setInDB(Car updated)
=> super.setInDB(updated)
}
The problem with this is I might forget to override the method if I add a new subclass. Also, users could do vehicle.setInDB(otherVehicle), where vehicle has static type Vehicle, and the correctness of otherVehicle would be checked at runtime again.
Only add the setInDB method to concrete subclasses of Vehicle, with the correct type:
abstract class Vehicle {
}
class Car extends Vehicle {
Future<void> setInDB(Car updated)
=> database.set(this.dbLocation, updated)
}
class Truck extends Vehicle {
Future<void> setInDB(Truck updated)
=> database.set(this.dbLocation, updated)
}
Etc. The problem with this approach is the code duplication, since the implementation is the same everywhere.
Are there other options?

Answer 1

Dart 2.19 adds analyzer support for a #mustBeOverridden annotation that you can add to a base class method. The analyzer then will emit a warning if a derived class neglects to override it. (However, as of writing, a new version of package:meta has not been published yet to add that annotation, but presumably it will be published soon.) For more details, see https://github.com/dart-lang/sdk/issues/30175.
Borrow the curiously recurring template pattern from C++ and apply it to Dart generics by making your derived classes extend (or mixin) a generic base class that is parameterized on the derived class. For example, I think that you could do:
abstract class Vehicle<DerivedVehicle extends Vehicle<DerivedVehicle>> {
Future<void> setInDB(DerivedVehicle updated)
=> database.set(this.dbLocation, updated)
}
class Car extends Vehicle<Car> {
}
class Truck extends Vehicle<Truck> {
}
and now Car().setInDB() should require a Car argument, and Truck().setInDB() should expect a Truck.