¿Hay una opción de GCC para advertir sobre escribir 'this-field `en lugar de`this->field'?

No, this - b está realizando aritmética de puntero en el puntero this, a pesar de que b es un tipo bool (b se convierte implícitamente a int).

(Curiosamente, puede siempre establecer this + b a un puntero donde b es un tipo bool, ya que puede establecer un puntero a uno más allá del final de un escalar! Así que incluso tu observador favorito undefined behaviour lo permitiría.)

La comprobación de límites de matriz siempre ha sido el trabajo de un C++ programador.

Tenga en cuenta también que en sus casos el uso de this es superfluo: así que reducir este uso excesivo es una forma de hacer que el problema desaparezca.

Me gustaría sugerir otra herramienta (aparte de cppcheck propuesto por @arne-vogel), dando una ayuda visual en lugar de la advertencia pidió:

Use clang-format para formatear automáticamente su código. El resultado podría verse así (dependiendo de la configuración), haciendo que el error sea más visible por los espacios agregados alrededor de operator-:

struct A {
  bool b;
  void set(bool b_) { this->b = b_; }
  bool get() const { return this - b; }
};

No, no hay manera de recibir una advertencia. Las conversiones implícitas, aunque perversas, son permitidas por el lenguaje.

Sin embargo, en este caso de uso específico podemos hacerlo mejor - envolviendo el bool en una clase wrapper que tiene conversiones explícitas y no hay operaciones aritméticas definidas.

Esto resulta en un error del compilador cuando se usa incorrectamente lógicamente, lo que normalmente se ve como preferible a una advertencia si el objetivo es la corrección lógica.

Es interesante observar que c++17 desaprueba bool::operator++ ya que esta aritmética es vista como malvada.

Ejemplo:

struct Bool
{
    explicit Bool(bool b) : value_(b) {}
    explicit operator bool() const { return value_; }
private:
    bool value_;

    // define only the operators you actually want
    friend std::ostream& operator<<(std::ostream& os, const Bool& b) {
        return os << b;
    }
};

struct X
{
    bool foo() {
        // compilation failure - no arithemetic operators defined.
        // return bool(this-b);

        // explicit conversion is fine
        return bool(b);
    }

    Bool b { true }; // explicit initialisation fine
};