fix generic override behavior

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/EliminateGenerics.java

@@ -967,7 +967,13 @@ public void visit(ImFunctionCall f) {
             @Override
             public void visit(ImMethodCall mc) {
                 super.visit(mc);
-                if (!mc.getTypeArguments().isEmpty()) {
+                ImMethod method = mc.getMethod();
+                boolean hasTypeArgs = !mc.getTypeArguments().isEmpty();
+                // Interface/base dispatch methods can be non-generic but still require specialization
+                // when they dispatch to generic implementors.
+                boolean needsDispatchSpecialization =
+                    methodImplementationIsGeneric(method) || hasGenericSubmethodImplementation(method);
+                if (hasTypeArgs || needsDispatchSpecialization) {
                     dbg("COLLECT GenericMethodCall: method=" + mc.getMethod().getName() + " " + id(mc.getMethod())
                         + " impl=" + (mc.getMethod().getImplementation() == null ? "null" : (mc.getMethod().getImplementation().getName() + " " + id(mc.getMethod().getImplementation())))
                         + " owningClass=" + (mc.getMethod().attrClass() == null ? "null" : (mc.getMethod().attrClass().getName() + " " + id(mc.getMethod().attrClass())))
@@ -1109,6 +1115,30 @@ public void visit(ImTypeIdOfClass f) {
         });
     }
 
+    private boolean methodImplementationIsGeneric(ImMethod method) {
+        ImFunction implementation = method.getImplementation();
+        return implementation != null && !implementation.getTypeVariables().isEmpty();
+    }
+
+    private boolean hasGenericSubmethodImplementation(ImMethod method) {
+        return hasGenericSubmethodImplementation(method, Collections.newSetFromMap(new IdentityHashMap<>()));
+    }
+
+    private boolean hasGenericSubmethodImplementation(ImMethod method, Set<ImMethod> visited) {
+        if (!visited.add(method)) {
+            return false;
+        }
+        for (ImMethod subMethod : method.getSubMethods()) {
+            if (methodImplementationIsGeneric(subMethod)) {
+                return true;
+            }
+            if (hasGenericSubmethodImplementation(subMethod, visited)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     static boolean isGenericType(ImType type) {
         return type.match(new ImType.Matcher<Boolean>() {
             @Override

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/GenericsWithTypeclassesTests.java

@@ -2093,6 +2093,11 @@ public void fullArrayListTest() throws IOException {
         assertFalse(compiled.contains("ArrayList_nextFreeIndex_"));
     }
 
+    @Test
+    public void fullReactiveGenericDispatchTest() throws IOException {
+        test().withStdLib().executeProg().executeTests().file(new File(TEST_DIR + "reactiveGenericsDispatch.wurst"));
+    }
+
     @Test
     public void genericNullComparison() {
         testAssertOkLinesWithStdLib(true,

de.peeeq.wurstscript/testscripts/concept/reactiveGenericsDispatch.wurst

@@ -0,0 +1,92 @@
+package ReactiveGenericDispatchRegression
+import NoWurst
+import Integer
+import Wurstunit
+
+interface ReactiveSource
+    function subscribe(Observer observer)
+    function unsubscribe(Observer observer)
+
+class Observer
+    int dependencyChanges = 0
+
+    function trackSource(ReactiveSource source)
+        source.subscribe(this)
+
+    function untrackSource(ReactiveSource source)
+        source.unsubscribe(this)
+
+    function onDependencyChanged()
+        dependencyChanges += 1
+
+
+class Signal<T:> implements ReactiveSource
+    private T value
+    private Observer subscriber = null
+
+    construct(T initial)
+        value = initial
+
+    function set(T newValue)
+        value = newValue
+        if subscriber != null
+            subscriber.onDependencyChanged()
+
+    function subscriberCount() returns int
+        return subscriber == null ? 0 : 1
+
+    override function subscribe(Observer observer)
+        subscriber = observer
+
+    override function unsubscribe(Observer observer)
+        if subscriber == observer
+            subscriber = null
+
+
+class PlainSource implements ReactiveSource
+    private Observer subscriber = null
+
+    function fire()
+        if subscriber != null
+            subscriber.onDependencyChanged()
+
+    function subscriberCount() returns int
+        return subscriber == null ? 0 : 1
+
+    override function subscribe(Observer observer)
+        subscriber = observer
+
+    override function unsubscribe(Observer observer)
+        if subscriber == observer
+            subscriber = null
+
+init
+    let genericObserver = new Observer()
+    let genericSignal = new Signal<int>(0)
+    genericObserver.trackSource(genericSignal)
+    if genericSignal.subscriberCount() != 1
+        testFail("generic subscribe dispatch failed")
+    genericSignal.set(1)
+    if genericObserver.dependencyChanges != 1
+        testFail("generic notify dispatch failed")
+    genericObserver.untrackSource(genericSignal)
+    if genericSignal.subscriberCount() != 0
+        testFail("generic unsubscribe dispatch failed")
+
+    let plainObserver = new Observer()
+    let plainSource = new PlainSource()
+    plainObserver.trackSource(plainSource)
+    if plainSource.subscriberCount() != 1
+        testFail("plain subscribe dispatch failed")
+    plainSource.fire()
+    if plainObserver.dependencyChanges != 1
+        testFail("plain notify dispatch failed")
+    plainObserver.untrackSource(plainSource)
+    if plainSource.subscriberCount() != 0
+        testFail("plain unsubscribe dispatch failed")
+
+    destroy genericSignal
+    destroy genericObserver
+    destroy plainSource
+    destroy plainObserver
+    testSuccess()