Why can't I use rule of equality when overriding == operator?

Question

void main() => Foo() == 1;

class Foo {
  @override
  bool operator ==(Object other) {
    print(super == this); // true
//     print(this == super); // Compile error
    
    return super == other;
  }
}

There are 2 questions.

1. Why can't I do this == super?

2. If you look at the return statement return super == other, you can tell the operator == is called on the Object class, so is the entire == implementation not a call which has been delegated to the Object class?

Let me explain the 2nd question further if it wasn't clear. Let's say I check for

Foo() == 1

The == operator defined in Foo class will be invoked and there all I'm doing is return super == other that means Object's == operator is being invoked and the other is int, so where the Foo instance in above code is? Here, it is only Object and int. I think super is doing something else too, not sure what is.

Answer 1

To answer your questions:

1. You can't do this == super because super is not an expression which is explained if you try run the program (the analyzed could give a better explanation):

   bin/stackoverflow.dart:7:19: Error: Can't use 'super' as an expression.
   To delegate a constructor to a super constructor, put the super call as an initializer.
       print(this == super); // Compile error
                     ^^^^^
   

   Which also make sense since super is not an object. It is a concept we can use to specify if we want to refer to fields/methods that are overridden. But we cannot use super as some kind of object since our object is not multiple objects in layers where you can extract a layer and then represent this as another object. Instead, our object is a combined implementation based on how you define your class.

2. Yes, you're basically calling the Object's == operator when you return super == other.

Supplementary example:

But remember, we are just calling the == operator defined in Object. Our object is still a combined data structure which can be illustrated by this example:

class A {
  final int a = 5;

  int getA() => a;
}

class B extends A {
  int get a => 10;

  int getA() {
    return super.getA();
  }
}

void main() {
  print(B().getA()); // 10
}

You can see that even if we call super.getA() we are still operating on a B object where we have overridden the a field but we are calling the A.getA() method.