Extension shadowing warnings.swift

protocol A {
  func foo()
}
extension A {
  default func foo() { … }   // Dynamically dispatched b/c it’s in the protocol
  func bar() { … }           // Statically dispatched b/c it’s not in the protocol
}

// Dynamic shadows static

protocol B: A {
  func bar()
}
extension B {
  func foo() { … }          // Shouldn’t warn, but should this also require `default`? or maybe `override`?
  default func bar() { … }  // Should warn about shadowing A.bar()
}

// Static shadows static

protocol C: A {
}
extension C {
  func foo() { … }  // Should warn about shadowing A.foo()
}

// Static can’t shadow dynamic: anything that implements B will use dynamic dispatch for bar(),
// and any type that tries to separately conform to both B and something else with a static
// extension impl for bar() already gives a compile error:

protocol D {
}
extension D {
  func foo() {  }
}

class E: B, D {  // Already gives a compiler error about conflicting foo() impls
}

// Type implementation shadowing/overriding extensions

class F: A {
  func foo() { … }   // Legit; shouldn’t warn. Should this require `override`?
  func bar() { … }   // Should warn about collision with B.bar()
}