如何强制参数与 static 具有与 object 相同的具体类型？

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, ie 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 (ie other parts of my code) to have to specify the update as a dynamic map, eg 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, eg 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. Ie, 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:

1. 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.

2. 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 .