Bug findings with Type Erasure Mutation

Groovy

#1 Local variable inference leads to incorrect type when having a complex parameterized type
Link: https://issues.apache.org/jira/browse/GROOVY-11087
Date found: 2023-06-08
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final void test() {
    Class<Class<Number>> d = null;
    var x = d.cast("");
    m(x);
  }
  static void m(Class<?> x) {}
}
```
Test Case Characteristics: Variable type inference, Parameterized type, Parameterized class
#2 Incompatible generic argument when mixing diamond operator and "super" wildcard
Link: https://issues.apache.org/jira/browse/GROOVY-11082
Date found: 2023-06-06
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
class Foo<T> {
  Foo(Supplier<? super T> x) {}
}
class Main {
  static final void test() {
    Supplier<CharSequence> func = null;
    Foo<StringBuffer> x = new Foo<>(func);
  }
}
```
Test Case Characteristics: Subtyping, Inheritance / Implementation of multiple interfaces, Wildcard type, Parameterized type, Parameterized class, Type argument inference
#3 Imprecise type for parameterized method when involving subtyping
Link: https://issues.apache.org/jira/browse/GROOVY-11074
Date found: 2023-05-26
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final void test() {
    Number x = 1;
    List<Number> y = m(x, 1);
  }
  static <T> List<T> m(T x, T y) { return null; }
}
```
Test Case Characteristics: Subtyping, Inheritance / Implementation of multiple interfaces, Parameterized function, Type argument inference
#4 Cannot infer type of parameterized method when dealing with arrays -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11073
Date found: 2023-05-26
Status: Closed
Resolution: Fixed
Resolution date: 2023-05-31
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final void test() {
    double[] x = Tuple.tuple(org.codehaus.groovy.runtime.ArrayGroovyMethods.max((double[][]) null, { -> 1 })).getV1();
  }
}
```
Test Case Characteristics: Array type, Overloading, Single Abstract Method (SAM), Lambda, Parameterized function, Type argument inference

#5 STC takes the instantiation of a wrong type variable

Link: https://issues.apache.org/jira/browse/GROOVY-11065
Date found: 2023-05-18
Status: Open
Symptom: Unexpected compile-time error
Test case:


import java.util.*
import java.util.function.*;
class LockVisitor<X> {
  <T> T applyWriteLocked(Function<X, T> func) {return null;}
}
class Main {
  static final <X>void test() {
    Function<PropertyPermission, Collection<? extends X>> func = null;
    LockVisitor<PropertyPermission> rec = null;
    var x = rec.applyWriteLocked(func);
    X arg = null;
    TreeSet<X> y = new java.util.TreeSet<>(x)
    y.floor(arg)
  }
}

Test Case Characteristics: Parameterized type, Parameterized class, Type argument inference, Variable type inference, Wildcard type, Parameterized function

#6 Unable to construct Map with repeating key/value entries
Link: https://issues.apache.org/jira/browse/GROOVY-11050
Date found: 2023-05-10
Status: In Progress
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final <V> void test() {
    V key = null;
    CharSequence value = null;
    java.util.Map.of(key, value); // succeeds
    java.util.Map.of(key, value, key, value); // fails
  }
}
```
Test Case Characteristics: Parameterized function, Type argument inference
#7 NPE when checking compatibility of method reference -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11026
Date found: 2023-04-26
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-29
Symptom: Crash
Test case:
```
import java.util.function.*;
import java.util.List;
class Main {
  static final void test() {
        List<String> x = null;
        m(x::set);
  }
  static final <T, R> void m(BiFunction<T, R, R> y) {}
}
```
Test Case Characteristics: Function reference, Single Abstract Method (SAM), Parameterized type, Parameterized class, Parameterized function, Type argument inference
#8 NullPointerException in instruction selection when calling parameterized function whose type parameter has an upper bound corresponding to a SAM type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11020
Date found: 2023-04-19
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-19
Symptom: Crash
Test case:
```
import java.util.*;
import java.util.function.*;
class Main {
  static final void test(ArrayDeque<String> y) {
    m(y::addFirst);
  }
  static <C extends Consumer<String>> void m(C cl) {}
}
```
Test Case Characteristics: Single Abstract Method (SAM), Function reference, Parameterized type, Parameterized class, Parameterized function, Bounded type parameter, Type argument inference
#9 Ambiguous method reference when expecting a SAM type
Link: https://issues.apache.org/jira/browse/GROOVY-11010
Date found: 2023-04-13
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
class Main {
  static final void test() {
    from(Main::m);
  }
  static <K, V> void from(Function<K, V> f) {}
  static <V> void from(Supplier<V> f) {}
  static int m(String x) { return 1; }
}
```
Test Case Characteristics: Overloading, Parameterized function, Single Abstract Method (SAM), Parameterized type, Parameterized class, Type argument inference, Function reference
#10 Incompatible generic argument types when mixing diamond operator in parameterized function
Link: https://issues.apache.org/jira/browse/GROOVY-11004
Date found: 2023-04-07
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
class Main {
  static final void test() {
    Map<Number, String> x = null;
    Map<Number, String> y = Collections.unmodifiableNavigableMap(new TreeMap<>(x));
  }
}
```
Test Case Characteristics: Parameterized function, Type argument inference, Parameterized type, Parameterized class
#11 Cannot find method with variable arguments when using fully qualified class names -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11003
Date found: 2023-04-07
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-11
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final void test(java.util.List<Integer> p) {
    m(1, p);
  }
  static <T> void m(Integer x, java.util.List<T>... items) { }
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Parameterized function, Variable argument
#12 Unexpected type mismatch when using super on a bounded type parameter
Link: https://issues.apache.org/jira/browse/GROOVY-10997
Date found: 2023-03-31
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.stream.*;
import java.util.function.*;
class Main {
  static final <Y, I extends Y> void test() {
    Stream<I> x = null;
    Consumer<Y> y = null;
    x.forEach(y);
  }
}
```
Test Case Characteristics: Parameterized function, Parameterized type, Parameterized class, Wildcard type, Bounded type parameter, Type argument inference
#13 Unexpected type mismatch when calling a parameterized function with a bounded type parameter
Link: https://issues.apache.org/jira/browse/GROOVY-10992
Date found: 2023-03-28
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
import java.util.function.BinaryOperator;
import java.util.stream.Stream;
class Main {
  static final <X extends Number> void test() {
    Supplier<Stream<X>> x = null;
    X y = null;
    BinaryOperator<X> z = null;
    X result = x.get().reduce(y, z);
  }
}
```
Test Case Characteristics: Bounded type parameter, Parameterized type, Parameterized class, Parameterized function, Type argument inference
#14 STC rejects program when passing method reference in parameterized function -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10975
Date found: 2023-03-14
Status: Closed
Resolution: Fixed
Resolution date: 2023-08-25
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
class Main {
  static final void test() {
    Collection<Integer> x = null;
    WeakHashMap<Integer, Integer> y = null;
    new Hashtable<java.lang.IllegalStateException, Boolean>(Collections.min(x, y::put));
  }
}
```
Test Case Characteristics: Function reference, Parameterized type, Parameterized class, Parameterized function, Type argument inference

#15 Type checking fails when casting method references

Link: https://issues.apache.org/jira/browse/GROOVY-10959
Date found: 2023-03-03
Status: Open
Symptom: Unexpected compile-time error
Test case:


import java.util.function.*;
import java.util.stream.*;
class Main {
  static final void test() {
    Foo<Object, String> x = null;
    Foo<String, String> y = null;
    BinaryOperator<String> z = null;
    final Object powdery = java.util.stream.Collectors.toConcurrentMap(
        x::m as Function<Object, String>,
        y::m as Function<String, String>,
        z
    );
  }
}
interface Foo<T1, T2> {
  T2 m(T1 x);
}

Test Case Characteristics: Function reference, Parameterized function, Type argument inference, Single Abstract Method (SAM), Parameterized type, Parameterized class, Wildcard type

#16 Type inference yields a wrong type even if the type of the associated variable is given
Link: https://issues.apache.org/jira/browse/GROOVY-10913
Date found: 2023-01-22
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
import java.util.stream.*;
class Test {
    void test() {
      Stream<Number> x = Arrays.stream(new Integer[]{1}).flatMap((y) ->
        Arrays.stream(new Long[]{(long) 1}));
    }
}
```
Test Case Characteristics: Subtyping, Inheritance / Implementation of multiple interfaces, Parameterized function, Type argument inference
#17 Fail to infer type argument of parameterized function
Link: https://issues.apache.org/jira/browse/GROOVY-10870
Date found: 2022-12-14
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Foo<X> {}
class Test {
  static void test() {
    m(false, new Foo<>());
  }
  static <T> void m(T x1, Foo<T> x2) {}
}
```
Test Case Characteristics: Type argument inference, Parameterized function, Parameterized type, Parameterized class
#18 NullPointerException in instruction selection phase when having parameterized method -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10869
Date found: 2022-12-14
Status: Closed
Resolution: Fixed
Resolution date: 2022-12-17
Symptom: Crash
Test case:
```
class Foo<T> {
  Foo(T x) {}
  <T extends Short> T m(T x) {
    x
  }
}
class Test {
  static final void test() {
    Foo<Integer> tmp = new Foo<Integer>(-76);
    boolean cond = 5.0 > tmp.m(new Foo<Integer>(95).m(null));
  }
}
```
Test Case Characteristics: Bounded type parameter, Parameterized function, Type argument inference
#19 Crash with arity generics parameter mismatch during the instruction selection phase -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10847
Date found: 2022-11-18
Status: Closed
Resolution: Fixed
Resolution date: 2022-11-19
Symptom: Crash
Test case:
```
class A<D, I> {}
class B {
  <T extends A<Character, Boolean>, X extends T>void m(T p1, X p2) {}
}
public class Test {
  void test() {
    A<Character, Boolean> x = null;
    (new B()).m(x, new A<>());
  }
}
```
Test Case Characteristics: Parameterized function, Type argument inference, Parameterized type, Parameterized class, Bounded type parameter
#20 Incompatible generic argument types when using wildcards -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10754
Date found: 2022-09-08
Status: Resolved
Resolution: Fixed
Resolution date: 2023-04-28
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class B extends A<Boolean> {}
class C<T extends A<Boolean>, U extends T> {
  C(T x, U v) {}
}
class Test {
  void test(B x, B y) {
    C<? extends B, ? extends B> z = new C<>(x, y);
  }
}
```
Test Case Characteristics: Wildcard type, Parameterized type, Parameterized class, Type argument inference, Bounded type parameter
#21 Resolving wrong overloaded method? -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10720
Date found: 2022-08-08
Status: Closed
Resolution: Fixed
Resolution date: 2022-08-08
Symptom: Unexpected compile-time error
Test case:
```
import java.util.Arrays;
class Test {
    void test() {
      Double[] x = null;
      var y = Arrays.stream(x).map(d -> "fda").findFirst();
    }
}
```
Test Case Characteristics: Overloading, Array type, Primitive type, Parameterized function
#22 Incompatible generic argument types when using wildcards
Link: https://issues.apache.org/jira/browse/GROOVY-10754
Date found: 2022-09-08
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class B extends A<Boolean> {}
class C<T extends A<Boolean>, U extends T> {
  C(T x, U v) {}
}
class Test {
  void test(B x, B y) {
    C<? extends B, ? extends B> z = new C<>(x, y);
  }
}
```
Test Case Characteristics: Type argument inference, Parameterized class, Parameterized type, Bounded type parameter, Inheritance / Implementation of multiple interfaces

#23 Unable to infer type argument from the parameter type of a lambda -- Fixed

Link: https://issues.apache.org/jira/browse/GROOVY-10699
Date found: 2022-07-21
Status: Resolved
Resolution: Fixed
Resolution date: 2022-07-24
Symptom: Unexpected compile-time error
Test case:


import java.util.function.Function;
import java.util.function.Consumer;
import java.util.function.Supplier;
class A<T> {
  A(C<T> x) {}
}
class C<T> {
  C(T x ) {}
}
class B<X> {
  B(Consumer<X> x) {}
}
class D<X> {
  D(Supplier<X> x) {}
}
class Test {
  void test() {
    A<String> x = new A<>(new C<>("str")); // type inference works (type inferred based on the constant "str")
    D<String> z = new D<>(() -> "fda"); // type inference works (type inferred based on the return type of the lambda)
    B<String> y = new B<>((String e) -> {return;} ); // type inference doesn't work
  }
}

Test Case Characteristics: Type argument inference, Parameterized class, Lambda, Single Abstract Method (SAM), Parameterized type

#24 Fail to infer the type argument when using nested diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10698
Date found: 2022-07-21
Status: Resolved
Resolution: Fixed
Resolution date: 2022-07-24
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  A(T x, B<T> y) {}
}
class B<X> {}
class Test {
  void test() {
    new A<>("fda", new B<>())
  }
}
```
Test Case Characteristics: Type argument inference, Parameterized class, Parameterized type
#25 STC crashes when combining use-site variance with bounded polymorphism -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10674
Date found: 2022-06-29
Status: Resolved
Resolution: Fixed
Resolution date: 2022-07-24
Symptom: Crash
Test case:
```
class Main {
  static Foo<Bar<Byte, Byte>, ? super Bar<Byte, Byte>> foo = new Foo<>(new Bar<>())
}
class Bar<T extends Number, S extends T> {}
class Foo<M extends Bar<Byte, ? extends Byte>, D extends M> {
  D x
  public Foo(D x) {
    this.x = x
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Use-site variance, Type argument inference
#26 Fail to substitute type variable when encountering conflicting type parameter with a bound -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10662
Date found: 2022-06-20
Status: Closed
Resolution: Fixed
Resolution date: 2022-06-21
Symptom: Unexpected compile-time error
Test case:
```
class A<X, T> {
  A(T p1, X p2) {}
  void foo(X x) {}
}
class B<T extends Number> {
  void test() {
    T x = (T) null;
    Character y = (Character) 'd';
    new A<>(y, x).foo((T) null);
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference, Bounded type parameter
#27 Invalid type substitution when encountering bounded type parameter and the diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10633
Date found: 2022-05-20
Status: Closed
Resolution: Fixed
Resolution date: 2022-06-21
Symptom: Unexpected compile-time error
Test case:
```
class A<T, Y> {
  B<Y> f;
  A(B<Y> x, T y) {}
}
class B<T> {
  void m(T x) {}
}
class Test {
  <T extends Number> void test() {
    def x = new B<T>();
    new A<>(x, "").f.m((T) null);
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Bounded type parameter, Type argument inference
#28 Nested diamond operators do not work correctly although the expected type argument is known -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10624
Date found: 2022-05-13
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-17
Symptom: Unexpected compile-time error
Test case:
```
class C<T> {
  C(D<T> x) {}
}
class D<T> {}
class Test {
  void test() {
    C<Float> x = new C<>(new D<>()); // type variables are instantiated with type Float because of the left-hand side.
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference
#29 Type mismatch when encountering unconditional flow typing and null -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10623
Date found: 2022-05-13
Status: Resolved
Resolution: Fixed
Resolution date: 2022-05-15
Symptom: Unexpected compile-time error
Test case:
```
class A {}
class Test {
  void test() {
    def x = new A() // type of x is A
    x = null; // type of x becomes Object
    A y = x
  }
  void test2() {
    def x = new A()
    if (true) {
      x = null
    }
    A y = x // compiles as expected
  }
}
```
Test Case Characteristics: Flow typing
#30 Fail to infer the correct type argument when having conditionals and diamond operator
Link: https://issues.apache.org/jira/browse/GROOVY-10614
Date found: 2022-04-30
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {}
class Test {
  public static void test() {
    foo((true) ? new Foo<Boolean>() : new Foo<>());
  }
  public static void foo(Foo<Boolean> x) {}
}
```
Test Case Characteristics: Conditionals, Type argument inference, Parameterized class, Parameterized type
#31 Incomplete type variable substitution when using wildcard type and diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10499
Date found: 2022-02-17
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-13
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
  Foo(T x) {}
}
class Bar<T> {
  Bar(Foo<? extends T> foo, T p) {
  }
  T m(T x) {
    return null;
  }
}
public class Test<T>  {
  void test() {
    T x = null;
    new Bar<>(new Foo<T>(x), x).m(x);
  }  
}
```
Test Case Characteristics: Bounded type parameter, Parameterized type, Parameterized class, Type argument inference
#32 Closure that assigns null to object changes the type of variable
Link: https://issues.apache.org/jira/browse/GROOVY-10480
Date found: 2022-02-15
Status: Closed
Resolution: Duplicate
Resolution date: 2022-02-15
Symptom: Unexpected compile-time error
Test case:
```
class Foo {
  void foo() {}
}
class Main  {
  static void bar() {
    def x = new Foo();
    if (false) {
      x = null;
    }
    x.foo(); // works
  }
  static void baz() {
    def x  = new Foo();
    def clos = { -> {
      x = null;
    }}
    x.foo(); // fails
  }
}
```
Test Case Characteristics: Flow typing, Lambda, Variable type inference
#33 STC fails to instantiate type variable when using diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10368
Date found: 2021-11-15
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-15
Symptom: Unexpected compile-time error
Test case:
```
class A<T extends Number> {
  A(String x) {}
}
class B {
  void m(A<Integer> x) {}
}
class Test {
  void test() {
    B x = new B();
    x.m(new A<>(""));
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Type argument inference
#34 STC fails to infer the correct type for type variable in the presence of the diamond operator and bounded polymorphism -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10367
Date found: 2021-11-15
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-15
Symptom: Unexpected compile-time error
Test case:
```
class A<Z, P extends Z> {
  Z f;
  A(Z f) {}
}
class B<Z extends Number> {
  Z f;
  void test() {
    f = new A<>((Z) null).f;
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Type argument inference
#35 STC changes the inferred type of variable in the presence of flow typing -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10356
Date found: 2021-11-10
Status: Resolved
Resolution: Fixed
Resolution date: 2022-05-15
Symptom: Unexpected compile-time error
Test case:
```
interface A {
  void a();
}
class Test {
  void test_closure() {
    def a = (A) null;
    def x = { ->
      a = null;
    }
    a.a();
  }
}
```
Test Case Characteristics: Variable type inference, Flow typing, Lambda
#36 Wrong type argument is inferred on combining use-site variance and diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10351
Date found: 2021-11-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-09
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  A(T f, B<T, ? extends T> x){  } 
}
class B<T1, T2> {}
class Test {
  void test() {
    B<Integer, ? extends Integer> x = null;
    A<Integer> y = new A<>(1, x);
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Type argument inference
#37 STC crashes when bound has two wildcard types as type arguments -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10344
Date found: 2021-11-03
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-04
Symptom: Crash
Test case:
```
@groovy.transform.CompileStatic
class Main {
  public static final void main() {
    final def x = ((B) null).foo(new A<>(), new A<>())
  }
}
class A<O, S> {}
interface B {
  abstract <F_P extends A<? extends Number, ? extends Number>> void foo(F_P y, F_P z)
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Variable type inference, Type argument inference, Parameterized function, Bounded type parameter, Use-site variance
#38 STC fails to infer dependent type variable -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10343
Date found: 2021-11-03
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-16
Symptom: Unexpected compile-time error
Test case:
```
class A<T1, T2 extends T1> {
  T1 f;
  A(T1 f) {
    this.f = f;
  }
  T2 foo() { return null; }
}
class Test {
  void test() {
    Integer x = 1;
    var y = new A<>(x).foo();
    Integer z = y;
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Variable type inference, Parameterized type, Type argument inference
#39 STC is unable to infer type parameter of parameterized method call -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10342
Date found: 2021-11-03
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-19
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T f;
}
class Test {
  static <T> T m() { return null; }
  static <T extends Number> void test() {
    String x = m(); // works
    A<String> y = new A<>();
    y.f = m(); // works
    A<T> z = new A<T>();
    z.f = m(); // does not work
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized function, Bounded type parameter, Parameterized type, Type argument inference
#40 STC is unable to infer type variable when combining parameterized types and the diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10324
Date found: 2021-10-21
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-01
Symptom: Unexpected compile-time error
Test case:
```
class A {
  <T> T foo(C<T> t) { return null; }
}
class C<T> {}
class B {
  void test() {
    C<String> x = (new A()).foo(new C<>());
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Type argument inference
#41 Type variable inference does not work properly in nested diamond operators -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10316
Date found: 2021-10-18
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-17
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T f;
  A(T f) {
    this.f = f;
  }
}
class B<T> {
  A<T> f;
  B(A<T> f) {
    this.f = f;
  }
}
class Test {
  void test() {
    def x = new  B<>(new A<>((long) 1)).f;
    A<Long> y = x;
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference, Variable type inference
#42 STC is unable to call parameterized function -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10310
Date found: 2021-10-15
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-02
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T f;
  A(T f) {
    this.f = f;
  }
  A() {}
}
class B<T> {}
class Test {
  static <T> A<T> test(T x, B<? extends T> z) {
    return new A<>(x);
  }
  public static void main(String[] args) {
    var d = "d";
    test(d, new B<>());
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Use-site variance, Type argument inference
#43 SC incorrectly reports "access to Object#field" is forbidden -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10308
Date found: 2021-10-15
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-24
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T p
}
@groovy.transform.CompileStatic
void test() {
  def x = { -> new A<String>() }
  def y = x()
  def z = y.p
  y = null // changes inferred type
}
test()
```
Test Case Characteristics: Parameterized class, Parameterized type, Lambda, Variable type inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/72c791402f
#44 Variable's inferred type is upcasted to an Object -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10294
Date found: 2021-10-11
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-31
Symptom: Unexpected compile-time error
Test case:
```
class A {
  A foo() {
    def x = new A()
    if (false) {
      x = null
    }
    x
  }
}
```
Test Case Characteristics: Variable type inference, Flow typing
#45 STC fails to substitute type variable when using the diamond operator and calling a closure -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10291
Date found: 2021-10-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-02
Symptom: Unexpected compile-time error
Test case:
```
class A<X> {
  X x;
  A(X x) {
    this.x = x
  }
}
class Test<T> {
  void foo() {
    def closure = { T p -> "" }
    T y = null
    bar(new A<>(y).x) // works
    closure(new A<>(y).x) // fails
  }
  void bar(T x) {} 
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Lambda, Type argument inference, Variable type inference
#46 STC: Stackoverflow Error when passing function reference to closure -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10269
Date found: 2021-09-28
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-12
Symptom: Crash
Test case:
```
import java.util.function.Consumer;
@groovy.transform.TypeChecked
class Test {
  static final void foo(Integer y) {}
  static final void bar(Consumer<Integer> x) {}
  public static void main () {
    def qux = { Consumer<Integer> x -> }
    Test.bar(Test::foo) // OK
    qux(Test::foo) // Crashes
  }
}
```
Test Case Characteristics: Function type, Function reference, Variable type inference, Lambda
Fix Commit(s):
- https://github.com/apache/groovy/commit/5864765e58
#47 The diamond operator does not work when passing a value whose type is a type variable -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10266
Date found: 2021-09-27
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-18
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  void foo() {
    T z = null;
    T x = new B<>(z).f // does not work
    String y = ""
    String k = new B<>(y).f // works
  }
}
class B<X> {
  X f;
  B(X f) {
    this.f = f;
  }
}
```
Test Case Characteristics: Parameterized class, Type argument inference, Parameterized type
#48 STC is unable to resolve variable in closure
Link: https://issues.apache.org/jira/browse/GROOVY-10265
Date found: 2021-09-27
Status: Closed
Resolution: Information Provided
Resolution date: 2021-10-31
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
class B {
  Supplier<Integer> m2() {
    final def x = 1
    { -> x + 1 }
  }
}
```
Test Case Characteristics: Function type, Variable type inference, Lambda
#49 Issue with the diamond operator and conditional
Link: https://issues.apache.org/jira/browse/GROOVY-10264
Date found: 2021-09-27
Status: Closed
Resolution: Duplicate
Resolution date: 2021-09-27
Symptom: Unexpected compile-time error
Test case:
```
class A<T extends Number> {
  T foo() {
    T x = null;
    (true) ?
      new B<>(x).f: new B<>(x).f
  }
}
class B<X> {
  X f;
  B(X x) {
    this.f = f;
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Conditionals, Type argument inference
#50 STC fails to substitute type variable in the presence of the diamond operator and a function call -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10228
Date found: 2021-09-13
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-02
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T x;  A(T x) {
    this.x = x;
  }
  T getX() {
    return x;
  }
}
class B {}
class Main {
  public static void m1() {
    def x = new B();
    m2(new A<>(x).getX());
  }  public static void m2(B x) {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference
#51 Unexpected compile-time error when combining closures and bounded type parameters -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10221
Date found: 2021-09-10
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Unexpected compile-time error
Test case:
```
class A<T1, T2 extends T1> {
  void foo() {
    def cls1 = { T2 x -> "" }
    Closure<T2> cls2 = { T2 x -> x }
    cls1(cls2((T2) null))
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Function type, Lambda, Variable type inference

#52 Wrong type argument inference when using the result of ternary operator directly. -- Fixed

Link: https://issues.apache.org/jira/browse/GROOVY-10114
Date found: 2021-05-27
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-15
Symptom: Unexpected compile-time error
Test case:


@groovy.transform.TypeChecked
class Test {
  public static void main(String[] args) {
    def x = ((false) ? new B<>(new A()) : new B<>(new A()))
    x.bar.foo()
    ((false) ? new B<A>(new A()) : new B<>(new A())).bar.foo()
    ((false) ? new B<>(new A()) : new B<>(new A())).bar.foo()
  }
}
final class A {
  public A() {
  }
  final Character foo() {
    (Character) 'g'
  }
}
class B<V> {
  public V bar
  public B(V bar) {
    this.bar = bar
  }
}

Test Case Characteristics: Type argument inference, Conditionals, Parameterized type, Parameterized class

#53 Closure with type argument inference does not work as expected -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10080
Date found: 2021-05-11
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-11
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
public class Main {
  public static void main(String[] args) {
    def closure = {
      new Bar<>(new Foo<Long>());
    }
    closure().f.m(new BigDecimal[0]) // this doesn't work
    // the following works
    // Bar<Foo<Long>> x = closure()
    // x.f.m(new BigDecimal[0]);
  }
}
class Foo<X> {
  void m(Object[] x) {}
}
class Bar<X> {
  X f;
  Bar(X f) {
    this.f = f;
  }
}
class Baz {}
```
Test Case Characteristics: Type argument inference, Lambda, Parameterized class, Parameterized type, Array, Subtyping
Fix Commit(s):
- https://github.com/apache/groovy/commit/ad29de380a
#54 Combining flow typing and type argument inference does not work as expected -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10011
Date found: 2021-04-05
Status: Closed
Resolution: Fixed
Resolution date: 2021-04-10
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T f;
  public A(T f) {
    this.f = f;
  }
}
class Foo {}
class Bar extends Foo {}
public class Main {
  public static void bar(Foo x) {
    if (x instanceof Bar) {
      A<Bar> a = new A<>(x)
    }
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Type argument inference, Flow typing
Fix Commit(s):
- https://github.com/apache/groovy/commit/131728feed
#55 Cannot infer correct type argument when using subtyping -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9996
Date found: 2021-03-22
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-25
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
public class Main {
  public static void main(String[] args) {
    Foo foo = new Bar()
    def x = new A<>(foo)
    bar(x)
  }
  public static void bar(A<Foo> f) {}
}
class A<T> {
  T f;
  public A(T f) {
    this.f = f;
  }
}
class Foo {}
class Bar extends Foo {}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference, Inheritance / Implementation of multiple interfaces, Variable type inference, Subtyping
Fix Commit(s):
- https://github.com/apache/groovy/commit/f75622b77e
#56 Wrong inference inside closure when having a bounded type parameter -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9995
Date found: 2021-03-22
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-24
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
public class Main {
  public static void main(String[] args) {
    Closure<A<Long>> closure =  { -> {
      final x = (Long) 1;
      new A<>(x);
    }}
    // If I remove 'extends Number' in class A, the following code
    // works as expected.
    final Long y = closure().f;
  }
}
class A<T extends Number> {
  T f;
  public A(T f) {
    this.f = f;
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Type argument inference, Lambda, Function type
Fix Commit(s):
- https://github.com/apache/groovy/commit/39422ed19b
#57 Wrong type inference when passing null -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9984
Date found: 2021-03-15
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-21
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
public class Main {
  public static void main(String[] args) {
    final A<Integer> x = new A<>(null);
    baz(x);
  }
  public static void baz(A<Integer> x) {}
}
class A<T> {
  T f;
  public A(T f) {
    this.f = f;
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/734ea3bdc3
#58 Type argument inference does not work in ternary operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9983
Date found: 2021-03-15
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-16
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
public class Test {
  public static void main(String[] args) {
      final A<B> x = (true ? new A<>(new B()): new A<>(new C()))
      bar(x) // compiles
      bar((true ? new A<>(new B()): new A<>(new C()))) // does not compile
  }
  public static void bar(A<B> x) {}
}
class A<T> {
  T f;
  public A(T f) {
    this.f = f;
  }
}
class B {}
class C extends B{}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Subtyping, Type argument inference, Conditionals
Fix Commit(s):
- https://github.com/apache/groovy/commit/3e279e5d8e
#59 LUB does not work correctly in case of ternary operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9972
Date found: 2021-03-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-15
Symptom: Unexpected compile-time error
Test case:
```
class Foo {
  public String x = "f";
}
class A<T> {
  public T f;
  A(T f) {
    this.f = f;
  }
}
public class Main {
  public static void foo() {
    def temp;
    if (true) {
      temp = new A<>(new Foo());
    } else {
      temp = new A<>(new Foo());
    }
    temp.f.x.toLowerCase() // works  fine
  }
  public static void bar() {
    A<Foo> temp = true ? new A<>(new Foo()) : new A<>(new Foo())
    temp.f.x // does not compile;
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference, Conditionals
Fix Commit(s):
- https://github.com/apache/groovy/commit/5591f88592
- https://github.com/apache/groovy/commit/49a6aa5849
#60 Type argument inference does not work in closure -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9970
Date found: 2021-03-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-15
Symptom: Unexpected compile-time error
Test case:
```
class Foo {}
final class A<T extends Foo> {
  public T x;
  A(T x) {
    this.x = x;
  }
}
@groovy.transform.CompileStatic
public class C<T extends Number> {
  public void foo(T args) {
    final A<Foo> x = new A<>(new Foo()); // compiles
    def closure = p -> {
        final A<Foo> y = new A<>(new Foo()); // does not compile
    }
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Lambda, Type argument inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/818f3d8842
#61 Generic type of field is not instantiated -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9963
Date found: 2021-03-03
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-07
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  T x;
  A(T x) {
    this.x = x;
  }
}
public class Main {
  public static void main(String[] args) {
    bar((new A<>("")).x);
  }
  public static void bar(String x) {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/2a27ee8df0
#62 Cannot infer correct type argument when passing a subtype of the declared type argument -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9956
Date found: 2021-02-26
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-03
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
    T f;
    Foo (T f) {
      this.f = f;
    }
}
interface Bar{}
class Baz<T> implements Bar {}
@groovy.transform.TypeChecked
class Main  {
  public static void main(String[] args) {
    Foo<Bar> x1 = new Foo<Bar>(new Baz<Integer>()) // Compiles
    Foo<Bar> x2 = new Foo<>(new Baz<Integer>()) // Does not compile
  }
}
```
Test Case Characteristics: Parameterized class, Subtyping, Inheritance / Implementation of multiple interfaces, Parameterized type, Type argument inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/715c34edc8
- https://github.com/apache/groovy/commit/d1b28b0ab9
#63 Type from flow typing is not propagated in variable assignments -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9953
Date found: 2021-02-24
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
class A {}
@groovy.transform.CompileStatic
class Main {
  static A bar(Object x) {
    if (x instanceof A) {
      def y = x // Inferred Object and not A
      y
    } else {
      new A()
    }
  }
}
```
Test Case Characteristics: Variable type inference, Flow typing, Conditionals
Fix Commit(s):
- https://github.com/apache/groovy/commit/3a3d5b70bd
#64 Cannot infer the correct type in the presence of diamond operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9948
Date found: 2021-02-17
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
    T f;
    Foo (T f) {
      this.f = f;
    }
}
class Main  {
  public static void main(String[] args) {
      Foo<Integer> x = new Foo<>(1);
      assert x.f < 10 == true; // does not compile
      m(x);
  }  public static void m(Foo<Integer> x) {
      assert x.f < 10 == true; // compiles fine
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Type argument inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/566c832c02
#65 int reference seems to not use its wrapper class -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9935
Date found: 2021-02-10
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Foo {
  static Number foo() {
    def i = 10  // If I use: `Integer i = 10` it works
    return i
  }
}
```
Test Case Characteristics: Variable type inference, Subtyping
Fix Commit(s):
- https://github.com/apache/groovy/commit/da47adb15b
#66 Bounded type parameter is not captured by closure -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9934
Date found: 2021-02-09
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
class Bar {}
class Foo<T extends Bar> {
  public T method(T x) {
    def bar = {x}
    return bar()
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Variable type inference, Lambda
#67 Type tracked from instanceof condition is not captured in closure -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9907
Date found: 2021-01-25
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Test {
  public static void main(String[] args) {
    println(foo(10));
  }
  static Integer foo(Object x) {
    if (x instanceof Integer) {
      def bar = {x};
      return bar();
    }
    return 100;
  }
}
```
Test Case Characteristics: Lambda, Flow typing, Variable type inference
Fix Commit(s):
- https://github.com/apache/groovy/commit/967c81c31e

Kotlin

#68 Unexpected callable reference ambiguity when having a private overloading method
Link: https://youtrack.jetbrains.com/issue/KT-58776
Date found: 2023-05-18
Status:
Resolution: As Designed
Resolution date: 2023-05-22
Symptom: Unexpected compile-time error
Test case:
```
kt
//     implementation("com.google.guava:guava:31.1-jre")
fun test(): Unit
{
  val x: List<String> = TODO()
  val map: com.google.common.collect.HashBiMap<String, String> = TODO()
  val res = x.reduceRight(map::put)
}
```
Test Case Characteristics: Function reference, Overloading, Access modifier, Parameterized function, Type argument inference
#69 Type mismatch when resolving wrong overloaded function
Link: https://youtrack.jetbrains.com/issue/KT-57596
Date found: 2023-03-27
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
kt
fun test() {
    val tmp: Iterable<HashSet<Number>> = TODO()
    val p: HashSet<Number> = TODO()
    val x: List<HashSet<Number>> = tmp - p
}
```
Test Case Characteristics: Operator, Overloading, Parameterized function, Parameterized type, Parameterized class, Type argument inference
#70 Condition adds covariance to inferred type argument and leads to type mismatch error
Link: https://youtrack.jetbrains.com/issue/KT-57226
Date found: 2023-03-09
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
kt
import java.util.function.*;
import java.util.stream.*;
fun test(x: ToIntFunction<String>, y: ToIntFunction<Any>): Unit 
{
    val z: Collector<String, *, Double?> = Collectors.averagingInt(
        if (false) x else y)
}
```
Test Case Characteristics: Conditionals, Wildcard type, Parameterized type, Parameterized class, Parameterized function
#71 No smart cast when returning function closures with captured smart-cast variable
Link: https://youtrack.jetbrains.com/issue/KT-43846
Date found: 2020-12-09
Status: Submitted
Symptom: Unexpected compile-time error
Test case:
```
fun foo(x: Any): String {
    if (x is String) {
        val thunk = {x}
        return thunk()
    }
    return "str"
}
```
Test Case Characteristics: Flow typing, Variable type inference, Lambda
#72 AssertionError: Variance conflict: type parameter variance 'out' and projection kind 'in' cannot be combined
Link: https://youtrack.jetbrains.com/issue/KT-49024
Date found: 2021-09-30
Status: Open
Symptom: Crash
Test case:
```
class Foo
class Bar<T1: Foo, out T2>
class Baz<T1, T2: Bar<Foo, out T2>>
class Qux<T1, T2: Baz<T2, Bar<Foo, T2>>>(var f: T2)
class Quux<T> {
  fun test(): Unit {
      val x: Qux<in T, Baz<T, Bar<Foo, in T>>> = TODO()
      x.f = TODO()
  }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Declaration-site variance, Variable type inference, Use-site variance

#73 NI: Compile-time error when combining anonymous function and lambda in a conditional

Link: https://youtrack.jetbrains.com/issue/KT-48764
Date found: 2021-09-15
Status: Open
Symptom: Unexpected compile-time error
Test case:


fun test(x: Function<Any>): Unit {}
fun main() {
    val x: Function<Any> = (
        if (true) {x: String, y: String -> x + y}
        else fun(x: String) = x
    ) // this works
    test(
        if (true) { x: String, y: String -> x + y}
        else fun(x: String) = x
    ) // this does not work
}

Test Case Characteristics: Function type, Lambda, Return type inference, Subtyping

#74 NI: Can not infer type of an if expression when passed in a function call and used a type parameter variable
Link: https://youtrack.jetbrains.com/issue/KT-47184
Date found: 2021-06-08
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Test<T: Byte> {
    fun test(z: T) {
        val y: Byte = if (true) z else 1 // works
        val x = bar(if (true) z else 1) // fails
    }
    fun bar(x: Byte) {}
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Variable type inference
#75 Wrong java.io.Serializable inferred
Link: https://youtrack.jetbrains.com/issue/KT-44742
Date found: 2021-02-05
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
fun main() {
    val x = if (true) 1 as Number else false // inferred type is java.io.Serializable
    x == 1
}
```
Test Case Characteristics: Subtyping, Conditionals
#76 Can not infer type of overridden function
Link: https://youtrack.jetbrains.com/issue/KT-44082
Date found: 2020-12-24
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
interface R<T>
interface W
interface J
open class A
open class B: A(), R<W>
open class E: A(), R<J>
open class C {
    open fun foo(): A = B()
}
class D: C() {
    override fun foo() = if (true) B() else E()
}
val x = if (true) B() else E() // Inferred type of x is Any
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Subtyping, Return type inference, Overriding, Conditionals
#77 JVM: ArrayIndexOutOfBoundsException on compiling call with `if` expression and TODO() arguments -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-49092
Date found: 2021-10-05
Status: Closed
Resolution: Fixed
Resolution date: 2021-12-22
Symptom: Crash
Test case:
```
class A {
    fun foo(x: Any, y: CharArray): Boolean = true
}
val x: A = A()
val y: Boolean = true
val z: Long = -61
val k = x.foo((if (y) z else Any()), TODO())
```
Test Case Characteristics: Array, Conditionals, Variable type inference
#78 ClassCastException caused by parent and child class in if-else -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-45118
Date found: 2021-02-22
Status: Closed
Resolution: Fixed
Resolution date: 2021-09-29
Symptom: Crash
Test case:
```
open class Foo(open val x: Boolean)
class Bar: Foo(false)
fun contract(x: Foo) =
  x
val temp = if (true) contract(Bar()) else Bar()
```
Test Case Characteristics: Return type inference, Inheritance / Implementation of multiple interfaces, Conditionals, Subtyping
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/b5661ccabd8
#79 Cannot infer type of overridden function with generic
Link: https://youtrack.jetbrains.com/issue/KT-44595
Date found: 2021-01-28
Status: Closed
Resolution: As Designed
Resolution date: 2021-09-08
Symptom: Unexpected compile-time error
Test case:
```
class X<T> (val x: T)
open class A {
    open fun foo(): X<A> =
       X(A())
} 
class B: A() {
    override fun foo() =
      X(B())
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Overriding, Type argument inference, Return type inference
#80 Imprecise type is inferred in an if expression
Link: https://youtrack.jetbrains.com/issue/KT-44551
Date found: 2021-01-26
Status: Closed
Resolution: As Designed
Resolution date: 2021-09-08
Symptom: Unexpected compile-time error
Test case:
```
   open class A
   open class B: A()
   class X<T: A>(val x: T)
   fun foo(x: X<A>) = {}
   val tmp = if (true) X<A>(A()) else X(B())
   fun main() {
       foo(tmp)
   }
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Bounded type parameter, Subtyping, Conditionals, Type argument inference, Variable type inference
#81 ClassCastException when calling a function with a nullable generic vararg parameter
Link: https://youtrack.jetbrains.com/issue/KT-46684
Date found: 2021-05-14
Status: Closed
Resolution: Duplicate
Resolution date: 2021-05-14
Symptom: Crash
Test case:
```
class Test {
    fun foo() {
        m("str", null);
    }
    fun <T: Number> m(obj: Any, vararg t: T?) {
        println("here")
    }
}
fun main() {
    Test().foo()
}
```
Test Case Characteristics: Bounded type parameter, Parameterized function, Type argument inference, Variable argument
#82 JVM / IR: "IllegalStateException: Illegal type substitutor" with if-else inside class constructor argument inside another if-else -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-44651
Date found: 2021-02-01
Status: Closed
Resolution: Fixed
Resolution date: 2021-02-11
Symptom: Crash
Test case:
```
class X<T: Number>(val y: Any, val x: T)
fun main() {
  val num: Long = -10
  val num2: Int = 20
  val obj = if (true)
      X(Any(), if (true) num else num2)
    else
      X(Any(), -25)
   val f = obj.y
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Parameterized type, Type argument inference, Variable type inference, Conditionals
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/f797ee78035

Scala

#83 Conversion of function type to SAM results in unexpected type mismatch
Link: https://github.com/lampepfl/dotty/issues/17348
Date found: 2023-04-25
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
def m[U](p: java.util.function.IntFunction[? <: U]): Unit = {}
def test(): Unit = {
  val y = "d"
  m((p) => y.asInstanceOf[Any])
}
```
Test Case Characteristics: Single Abstract Method (SAM), Lambda, Wildcard type, Parameterized type, Parameterized class, Parameterized function, Type argument inference
#84 The inferred type is not precise when omitting type argument in the receiver expression
Link: https://github.com/lampepfl/dotty/issues/17311
Date found: 2023-04-19
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
import java.util.Comparator
class Foo[E](x: java.util.Comparator[? >: E]) {
  def first(): E = ???
}
class Bar {
  def m(): String = ""
}
def test(): Unit =
{
  val x: java.util.Comparator[Bar] = ???
  val y = new Foo(x)
  val z = y.first()
  z.m() // succeeds
  val k = new Foo(x).first()
  k.m() // fails
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Wildcard type, Type argument inference
#85 Unexpected error when boxing LongStream and using reduce
Link: https://github.com/lampepfl/dotty/issues/17207
Date found: 2023-04-04
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
import java.util.stream._;
import java.util.function._;
def test(): Unit = {
  val x: BinaryOperator[Long] = ???
  val y: LongFunction[Long] = ???
  val rec: LongStream = ???
  rec.mapToObj(y).reduce(43, x) // fails
  val z = rec.mapToObj(y) 
  z.reduce(43, x) // succeeds
}
```
Test Case Characteristics: Single Abstract Method (SAM), Parameterized function, Parameterized type, Parameterized class, Type argument inference, Primitive type

Java

#86 Wrong Type-Argument inference in presence of bounds and use-site variance

Link: https://bugs.openjdk.java.net/browse/JDK-8269737
Date found: 2021-06-28
Status: Closed
Resolution: Not an Issue
Resolution date: 2021-07-01
Symptom: Unexpected compile-time error
Test case:


abstract class Cls<T1> {
  public Cls() {}
}
abstract class Cls2<T2> extends Cls<T2> {
  public Cls2() {}
}
abstract class Cls3<T3 extends Float> extends Cls2<T3> {
  public Cls3() {}
}
abstract class Cls4<T4 extends Cls3<? super Float>> {
  public Cls4() {}
}
final class Cls5 {
  public Cls5() {}
  public final Cls4<? extends Cls3<Float>> foo() {
    Cls4<? extends Cls3<Float>> y = (Cls4<? extends Cls3<Float>>) null;
    var x = y;
    // Cls4<? extends Cls3<Float>> x = y; // This works
    return x;
  }
}

Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Use-site variance, Inheritance / Implementation of multiple interfaces, Variable type inference

#87 Imprecise type inference in the presence of ternary operator and wildcard
Link: https://bugs.openjdk.java.net/browse/JDK-8269386
Date found: 2021-06-24
Status: Closed
Resolution: Not an Issue
Resolution date: 2021-06-28
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
  public A() {}
  public B<? super T> foo() {
    var x = (true) ? new B<T>() : (B<? super T>) null;
    return x;
    //return (true) ? new B<T>() : (B<? super T>) null;  // This works
  }
}
class B<T> {
  public B() {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Conditionals, Variable type inference
#88 Wrong type inference in presence of a generic with bound to Double
Link: https://bugs.openjdk.java.net/browse/JDK-8269348
Date found: 2021-06-23
Status: Resolved
Resolution: Not an Issue
Resolution date: 2021-06-30
Symptom: Unexpected compile-time error
Test case:
```
class Test<T extends Double, K extends T> {
  public T test() {
    T foo = (T) null;
    final var v = ((true) ?
      foo :
       (K) null);
    return v;
  }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Conditionals, Variable type inference