Go to implementation misses some implementations

[sandersn]

From tests/cases/fourslash/goToImplementationInterfaceMethod_01.ts

interface BaseFoo {
  hello(): void;
}
interface Foo extends BaseFoo {
  foo(): void;
}
interface Bar {
  hello(): void;
  bar(): void;
}
class FooImpl implements Foo {
  hello() { }
  foo() { }
}
class FooBaseImpl implements FooBase {
  hello() { } // missing this one!
}
class BarImpl implements Bar {
  hello() { }
  bar() { }
}
class FooBarImpl implements Foo, Bar {
  hello() { }
  foo() { }
  bar() { }
}
let foorbar: Foo | Bar;
foorbar.hello/*1*/();
let foonbar: Foo & Bar;
foonbar.hello/*2*/();

Find all implementations on both 1 and 2 should find the hello method in all classes. But FooBaseImpl.hello doesn't show up. The test incorrectly says that it should not, but it should.

[Andarist]

I analyzed this and I'm not sure if this is really the change that should be done. FooBaseImpl can't even be assigned to both of those variables so I think it would be wrong to find its hello implementation here.

I think that the explicitlyInheritsFrom comment also confirms that:

TypeScript/src/services/findAllReferences.ts

Lines 2284 to 2296 in 4b15830

	* Determines if the parent symbol occurs somewhere in the child's ancestry. If the parent symbol
	* is an interface, determines if some ancestor of the child symbol extends or inherits from it.
	* Also takes in a cache of previous results which makes this slightly more efficient and is
	* necessary to avoid potential loops like so:
	* class A extends B { }
	* class B extends A { }
	*
	* We traverse the AST rather than using the type checker because users are typically only interested
	* in explicit implementations of an interface/class when calling "Go to Implementation". Sibling
	* implementations of types that share a common ancestor with the type whose implementation we are
	* searching for need to be filtered out of the results. The type checker doesn't let us make the
	* distinction between structurally compatible implementations and explicit implementations, so we
	* must use the AST.

As well as the goToImplementationInterfaceMethod_05 test case.

cc @jakebailey