Calls to interface methods/abstract methods should validate that all implementations have it defined

[aldexis]

If an interface defines a new method (or a class defines a new abstract method), this is not an ABI break by default (see #32).

However, if that method then gets called and the instance happens to be on a class that did not implement the method, this will break at runtime.

As such, when an interface method or an abstract method are called, we should validate that all reachable implementations actually implement that method (or it exists in a super class or in some other way).

[aldexis]

See test cases here:

gradle-transitive-abi-checker/abi-check-core/src/test/java/com/palantir/abi/checker/integration/MethodConflictCheckerIntegrationTest.java

Lines 1365 to 1493 in a262824

	@Disabled("https://github.com/palantir/gradle-transitive-abi-checker/issues/33")
	@Test
	public void calling_unimplemented_interface_method_conflicts() {
	JavaFiles.Builder sources = JavaFiles.builder();
	sources.rootSources(
	Set.of(
	file(
	"com.Root",
	// language=java
	"""
	package com;
	public class Root {
	public Root() {
	// Even though MyClass doesn't implement newMethod, it can still be instantiated
	// but calling newMethod will throw an AbstractMethodError
	interact(new MyClass());
	}
	private static void interact(MyInterface myInt) {
	// newMethod only exists in the base interface, but isn't implemented yet in the main dependency
	myInt.newMethod();
	}
	}
	""")));
	sources.reachableDependency(
	"com.MyClass",
	// language=java
	"""
	package com;
	public class MyClass implements MyInterface {}
	""");
	sources.transitiveBeforeDependency(
	"com.MyInterface",
	// language=java
	"""
	package com;
	public interface MyInterface {}
	""");
	sources.transitiveAfterDependency(
	"com.MyInterface",
	// language=java
	"""
	package com;
	public interface MyInterface {
	void newMethod();
	}
	""");
	generateClassFiles(tempDir, sources.build());
	assertThatExceptionOfType(InvocationTargetException.class)
	.isThrownBy(() -> runClassFiles(tempDir))
	.havingCause()
	.isInstanceOf(AbstractMethodError.class)
	.withMessageContainingAll("com.MyInterface", "abstract void newMethod()");
	assertThatMethodNotFound(
	tempDir,
	"com.Root",
	voidMethod("interact", "Lcom/MyInterface;"),
	"com.MyClass",
	voidMethod("newMethod"));
	}
	@Disabled("https://github.com/palantir/gradle-transitive-abi-checker/issues/33")
	@Test
	public void calling_unimplemented_abstract_method_conflicts() {
	JavaFiles.Builder sources = JavaFiles.builder();
	sources.rootSources(
	Set.of(
	file(
	"com.Root",
	// language=java
	"""
	package com;
	public class Root {
	public Root() {
	// Even though MyClass doesn't implement newMethod, it can still be instantiated
	// but calling newMethod will throw an AbstractMethodError
	interact(new MyClass());
	}
	private static void interact(Parent obj) {
	// newMethod only exists in the base interface, but isn't implemented yet in the main dependency
	obj.newMethod();
	}
	}
	""")));
	sources.reachableDependency(
	"com.MyClass",
	// language=java
	"""
	package com;
	public class MyClass extends Parent {}
	""");
	sources.transitiveBeforeDependency(
	"com.Parent",
	// language=java
	"""
	package com;
	public abstract class Parent {}
	""");
	sources.transitiveAfterDependency(
	"com.Parent",
	// language=java
	"""
	package com;
	public abstract class Parent {
	public abstract void newMethod();
	}
	""");
	generateClassFiles(tempDir, sources.build());
	assertThatExceptionOfType(InvocationTargetException.class)
	.isThrownBy(() -> runClassFiles(tempDir))
	.havingCause()
	.isInstanceOf(AbstractMethodError.class)
	.withMessageContainingAll("com.Parent", "abstract void newMethod()");
	assertThatMethodNotFound(
	tempDir, "com.Root", voidMethod("interact", "Lcom/Parent;"), "com.MyClass", voidMethod("newMethod"));
	}