Bug findings with Program Generator

Groovy

#1 STC chooses to call a non-polymorphic method although explicit type arguments are given
Link: https://issues.apache.org/jira/browse/GROOVY-11129
Date found: 2023-07-19
Status: Closed
Resolution: Duplicate
Resolution date: 2023-07-20
Symptom: Unexpected compile-time error
Test case:
```
import java.util.concurrent.*;
class Main {
 static final void test() {
 ExecutorService z = null;
 Future<CharSequence> future = z.<CharSequence>submit(() -> "fd");
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Overloading, Lambda, Parameterized function, Single Abstract Method (SAM)
#2 unexpected error when having overloaded methods, one of which receiving an Iterable
Link: https://issues.apache.org/jira/browse/GROOVY-11121
Date found: 2023-07-09
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
class Foo<T> {
 static <T> Foo<T> of(Iterable<T> values) { return null; }
 static <T> Foo<T> of(T values) { return null; }
}
class Main {
 static final void test() {
 Foo.<IntUnaryOperator>of((int s) -> s + 1);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Overloading, Single Abstract Method (SAM), Lambda
#3 Unexpected error when using static method of class with lower case
Link: https://issues.apache.org/jira/browse/GROOVY-11120
Date found: 2023-07-09
Status: Closed
Resolution: Won't Fix
Resolution date: 2023-07-10
Symptom: Unexpected compile-time error
Test case:
```
package bar;
public class foo {
  public static void create(String x) {}
}
// client code
class Main {
  static final void test() {
    bar.foo.create("fda");
  }
}
```
Test Case Characteristics: Static method

#4 Fail to find method reference in case of chain of polymorphic method calls

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


import java.util.*;
import java.util.concurrent.*;
class Foo<K, V> {
  V apply(K p) { return null; }
}
class Main {
  static final void test(Foo<Map.Entry<Number, Boolean>, String> p) {
    ConcurrentHashMap.KeySetView<Number, Boolean> x = null;
    ConcurrentHashMap<Number, Boolean> y = x.getMap();
    y.<String>reduceEntries(19, p::apply, null); // works
    x.getMap().<String>reduceEntries(19, p::apply, null); // fails
  }
}

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

#5 STC mixes names of bounded type parameters
Link: https://issues.apache.org/jira/browse/GROOVY-11110
Date found: 2023-06-22
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.stream.*;
class Main {
 static final <T extends Number>void test() {
 java.util.function.BiConsumer<T, T> func = null;
 Stream<String> stream = null;
 T res = stream.<T>collect(() -> (T) null, (T finisher, String hijacking) -> { }, func);
 }
}
```
Test Case Characteristics: Bounded type parameter, Parameterized function, Parameterized type, Parameterized class, Wildcard type, Single Abstract Method (SAM)
#6 Unable to initialize generic class with an array
Link: https://issues.apache.org/jira/browse/GROOVY-11109
Date found: 2023-06-22
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
 Foo(T[] x) {}
}
class Main {
 static final void test() {
 Byte[][] arg = null;
 Foo<Byte[]> res = new Foo<Byte[]>(arg)
 }
}
```
Test Case Characteristics: Array type, Parameterized type, Parameterized class

#7 SAM types not working well along with overloading

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


import java.util.*;
import java.util.function.*;
class Bar {
  LinkedList<String> collect(Supplier<String> function) { }
        List<String> collect(String x, int y, int z) { }
}
class Main {
  static final void test() {
    Bar x = null;
    LinkedList<String> d = x.collect(() -> "fda");
  }
}

Test Case Characteristics: Overloading, Single Abstract Method (SAM)

#8 Wrong method is chosen when having overloaded methods with bounded type parameters
Link: https://issues.apache.org/jira/browse/GROOVY-11086
Date found: 2023-06-08
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
class Foo<T> {}
class Bar<T> {}
class Main {
 static final void test() {
 LinkedList<Number> x = null;
 Foo<Iterable<Number>> y = Main.<Number, Iterable<Number>>m(x);
 }
 static <X, T extends Iterable<X>> Foo<T> m(Iterable<X> x) {return null;}
 static <X, T extends List<X>> Bar<T> m(List<X> x) { return null; }
}
```
Test Case Characteristics: Overloading, Parameterized function, Bounded type parameter, Subtyping, Inheritance / Implementation of multiple interfaces, Parameterized type, Parameterized class
#9 STC overconstraints lambda's parameter types when expecting a SAM that involves wildcards
Link: https://issues.apache.org/jira/browse/GROOVY-11077
Date found: 2023-06-02
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Test {
 void test() {
 m((Integer x, Integer y) -> 1);
 }
 void m(java.util.Comparator<? extends Object> x) {}
}
```
Test Case Characteristics: Single Abstract Method (SAM), Lambda, Wildcard type, Parameterized type, Parameterized class
#10 Unable to call parameterized function that contains type variables with recursive bounds
Link: https://issues.apache.org/jira/browse/GROOVY-11066
Date found: 2023-05-18
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
 static final void test() {
 String arg1 = null;
 Number arg2 = null;
 com.google.common.collect.ImmutableSortedMap.<String, Number>of(arg1, arg2);
 }
}
```
Test Case Characteristics: Bounded type parameter, Recursive upper bound, Wildcard type, Parameterized function, Parameterized type, Parameterized class
#11 Method ambiguity error when having methods with primitive arrays and varargs -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11053
Date found: 2023-05-11
Status: Closed
Resolution: Fixed
Resolution date: 2023-05-29
Symptom: Unexpected compile-time error
Test case:
```
class Main {
  static final void test() {
    final byte[] vetting = new byte[1];
    final byte[] grafting = org.apache.commons.lang3.ArrayUtils.removeAll(vetting); // works 
    final byte[] grafting = org.apache.commons.lang3.ArrayUtils.removeAll(vetting, 0); // fails 
  }
}
```
Test Case Characteristics: Overloading, Variable argument, Array type, Primitive type
#12 Better diagnostic message instead of stacktrace?
Link: https://issues.apache.org/jira/browse/GROOVY-11046
Date found: 2023-05-05
Status: Open
Symptom: Crash
Test case:
```
class Test {
    void test() {
        org.apache.logging.log4j.core.async.AsyncLogger d = null;
    }
}
```
#13 Wrong method is chosen from the Groovy runtime
Link: https://issues.apache.org/jira/browse/GROOVY-11042
Date found: 2023-05-02
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
 static final void test() {
 String[] p1 = new String[]{"v2"};
 String[] p2 = new String[]{"v1"};
 java.util.TreeMap<String[], Number> x = null;
 x.subMap(p1, p2);
 }
}
```
Test Case Characteristics: Overloading, Array type, Parameterized function, Parameterized type, Parameterized class
#14 Inferred type is Object when having a complex inheritance chain of interfaces
Link: https://issues.apache.org/jira/browse/GROOVY-11035
Date found: 2023-04-28
Status: Resolved
Resolution: Duplicate
Resolution date: 2023-04-30
Symptom: Unexpected compile-time error
Test case:
```
@Grab('org.apache.commons:commons-collections4:4.4')
import org.apache.commons.collections4.iterators.*;
class Main {
 @groovy.transform.TypeChecked test() {
 EmptyListIterator<Number> tmp = null
 Number x = tmp.next()
 }
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Bridge method
#15 Conficts between type parameter names result in unexpected type error
Link: https://issues.apache.org/jira/browse/GROOVY-11025
Date found: 2023-04-26
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.Map;
import java.util.List;
class Main {
 static <K, V> void m(Map<K, V> map, K key, V value) {}
 static final <K>void test() {
 Map<List<K>, K> map = null;
 List<K> key = null;
 K value = null;
 Main.m(map, key, value);
 }
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Parameterized function
#16 StackOverflowError when having parameterized function with recursive bounds
Link: https://issues.apache.org/jira/browse/GROOVY-11022
Date found: 2023-04-24
Status: Open
Symptom: Crash
Test case:
```
class Test<K, V> {
 public static <K extends Comparable<? super K>, V> Test<K, V> m(K k1, V v1) {
 return new Test<K, V>()
 }
}
class Main {
 @groovy.transform.TypeChecked test() {
 Test.<Object, Integer>m(null, 1)
 }
}
```
Test Case Characteristics: Wildcard type, Parameterized function, Parameterized type, Parameterized class, Recursive upper bound, Bounded type parameter

#17 Resolving wrong overloaded method when having variable arguments

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


import java.util.Comparator;
class Foo<T> {}
class Bar<T> {
  static <T> Bar<T> concat(Bar<? extends T>... x)  { return null; }
  static <T> Bar<T> concat(Bar<? extends Bar<? extends T>> x)  { return null; }
  void toSortedSet(Comparator<? super T> x) {}
}
class Main {
  static final void test() {
    Bar<Foo<Number>> x = null;
    Comparator<Foo<Number>> y = null;
    Bar.concat(x).toSortedSet(y);
  }
}

Test Case Characteristics: Overloading, Parameterized function, Variable argument, Subtyping, Inheritance / Implementation of multiple interfaces, Wildcard type, Parameterized type, Parameterized class

#18 Fail to substitute type when having SAM type with generics -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11013
Date found: 2023-04-14
Status: Closed
Resolution: Fixed
Resolution date: 2023-05-26
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
@FunctionalInterface
interface Foo<T> {
 int m(List<T> x);
}
class Main {
 static final void test() {
 Foo<String> p = (List<String> x) -> 1;
 }
}
```
Test Case Characteristics: Single Abstract Method (SAM), Lambda, Parameterized type, Parameterized class
#19 Wrong type is inferred when calling method defined in the parent class -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11012
Date found: 2023-04-13
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-30
Symptom: Unexpected compile-time error
Test case:
```
interface Bar<V> {
 default V get(Object x, Object y) { return null; }
}
class Foo<V> implements Bar<V> {
 static <V> Foo<V> create() { return null; }
}
class Main {
 static final void test() {
 Number x = Foo.<Number>create().get(null, null);
 }
}
```
Test Case Characteristics: Default method, Parameterized function, Parameterized type, Parameterized class
#20 STC resolves wrong method reference -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-11009
Date found: 2023-04-11
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-18
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
class Main {
 static final void test() {
 final Function<Double, Double> x = Main::clone;
 }
 public static <T> T clone(T x) { return x; }
}
```
Test Case Characteristics: Function reference, Single Abstract Method (SAM), Parameterized type, Parameterized class, Static method
#21 Unexpected type mismatch when having overloaded methods with variable arguments
Link: https://issues.apache.org/jira/browse/GROOVY-11002
Date found: 2023-04-07
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
class Main {
 static final void test() {
 Main.<String>m(() -> "df", "fdaf");
 }
 static <T> void m(Supplier<T> x, T... y) {}
 static <T extends Comparable<? extends T>> void m(T...y) {}
}
```
Test Case Characteristics: Overloading, Variable argument, Single Abstract Method (SAM), Parameterized type, Parameterized class, Parameterized function, Lambda, Recursive upper bound, Bounded type parameter
#22 Unexpected type mismatch when having bounded type parameters
Link: https://issues.apache.org/jira/browse/GROOVY-10999
Date found: 2023-04-04
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
 static final void test() {
 def x = java.util.Collections.<H, H>emptyNavigableMap().ceilingKey((H) null);
 }
}
```
Test Case Characteristics: Bounded type parameter, Parameterized function
#23 Fail to resolve method reference with generics -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10994
Date found: 2023-03-28
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-11
Symptom: Unexpected compile-time error
Test case:
```
import java.util.List;
import java.util.function.Predicate;
class Main {
 static final <T> void test() {
 List<T> x = null;
 Predicate<? super T> y = x::add;
 }
}
```
Test Case Characteristics: Function reference, Wildcard type, Single Abstract Method (SAM), Parameterized type, Parameterized class

#24 Unexpected parser error when having fully qualified classes and constructor references

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


import java.util.function.Supplier;
import java.util.PriorityQueue;
class Main {
  static final void test() {
    java.util.function.Supplier<java.util.PriorityQueue<Number>> x = java.util.PriorityQueue<Number>::new; // parsing error
    Supplier<PriorityQueue<Number>> y = PriorityQueue<Number>::new; // no error
  }
}

Test Case Characteristics: Function reference, Parameterized type, Parameterized class

#25 Cannot provide method reference to a type parameter instantiated with a SAM type

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


import java.util.function.*;
import java.util.stream.*;
public class Test {
    public static void test() {
      Stream<Number> x = null;
      BiFunction<Function<String, Integer>, Number, Function<String, Integer>> y = null;
      BinaryOperator<Function<String, Integer>> z = null;
      x.<Function<String, Integer>>reduce(Test::m, y, z);  // fails
      x.reduce(Test::m, y, z);   // fails
      x.reduce((d) -> 1, y, z);   // works
    }
    public static Integer m(String x) { return 1; }
}

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

#26 Fail to perform SAM conversion using method references -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10974
Date found: 2023-03-14
Status: Closed
Resolution: Fixed
Resolution date: 2023-08-31
Symptom: Unexpected compile-time error
Test case:
```
import java.util.*;
import java.util.stream.*;
import java.util.function.*;
class Main {
 static final void test(DoubleStream x, ObjDoubleConsumer<Boolean> y,
 BiConsumer<Boolean, Boolean> z) {
 Spliterator.OfDouble d = null;
 StreamSupport.doubleStream(d, x.collect(
 () -> true, y::accept, z::accept));
 }
}
```
Test Case Characteristics: Function reference, Single Abstract Method (SAM), Parameterized type, Parameterized class
#27 STC is looking for the wrong constructor reference -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10971
Date found: 2023-03-09
Status: Closed
Resolution: Fixed
Resolution date: 2023-04-12
Symptom: Unexpected compile-time error
Test case:
```
class Foo {
  Foo(String d) {}
}
class Main {
  static final void test() {
        def x = java.util.stream.Collectors.groupingBy(Main::m) // works;
        def y = java.util.stream.Collectors.groupingBy(Foo::new) // fails;
  }
  static Foo m(String x) { return null; }
}
```
Test Case Characteristics: Function reference, Single Abstract Method (SAM), Parameterized function
#28 STC rejects program when having SAM types and conditionals
Link: https://issues.apache.org/jira/browse/GROOVY-10961
Date found: 2023-03-06
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
import java.util.Deque;
class Main {
 static final void test(Deque<Integer> p1, Supplier<Integer> p2) {
 Supplier<Integer> x = (true) ? p1::peek : p2;
 }
}
```
Test Case Characteristics: Conditionals, Single Abstract Method (SAM), Parameterized type, Parameterized class, Function reference

#29 Initialization of non-static inner class fails

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


class Foo {
    public class Bar {
        Bar() {}
    }
}
public class Test {
    void test() {
        Foo.Bar x = new Foo().new Bar(); // works
        Foo y = new Foo();
        Foo.Bar z = y.new Bar(); // doesn't work
    }
}

Test Case Characteristics: Inner class

#30 Method ambiguity error even if the given argument has an explicit type
Link: https://issues.apache.org/jira/browse/GROOVY-10914
Date found: 2023-01-24
Status: Closed
Resolution: Information Provided
Resolution date: 2023-02-04
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.*;
class Main {
  static final void test() {
    String str = "foo"
    LongConsumer y = str.chars().asLongStream().summaryStatistics();
    str.chars().asLongStream().summaryStatistics().andThen(y); // Does not work
    str.chars().asLongStream().summaryStatistics().andThen((LongConsumer) y); // it works
  }
}
```
Test Case Characteristics: Overloading, Subtyping, Inheritance / Implementation of multiple interfaces

#31 Inconsistency in the treatment of primitives values when passed as call arguments

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


class Test {
    void test() {
      char c = 'c' // works
      double e = 10.0; // works
      Character v = Character.valueOf('c'); // 'c' is treated as String
      Double d = Double.valueOf(10.0);  // 10.0 is treated as BigDecimal
    }
}

#32 Unable to resolve field from a bounded type parameter -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10846
Date found: 2022-11-18
Status: Closed
Resolution: Fixed
Resolution date: 2022-11-18
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
class A {
 public String x;
}
public class B<T extends A, X extends Supplier<T>> {
 void test(T p) {
 p.x = "str";
 } 
}
```
Test Case Characteristics: Single Abstract Method (SAM), Parameterized type, Parameterized class, Parameterized function, Bounded type parameter
#33 NullPointerException in instruction selection phase when having conditionals with lambdas and function references -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10701
Date found: 2022-07-22
Status: Resolved
Resolution: Fixed
Resolution date: 2022-07-22
Symptom: Crash
Test case:
```
import java.util.function.Function;
class Test {
 <T> void m1(Function<T, T> x) {}
 double m2(double x) {
 return x;
 }
 void m3() {
 m1((true) ? (Double x) -> x : this::m2);
 }
}
```
Test Case Characteristics: Conditionals, Function reference, Single Abstract Method (SAM), Parameterized function
#34 LUB does not work properly when mixing type parameter names and using wildcards -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10688
Date found: 2022-07-15
Status: Resolved
Resolution: Fixed
Resolution date: 2022-07-25
Symptom: Unexpected compile-time error
Test case:
```
class A<T, X> {
}
class Test<T> {
 void test(A<Double, ? extends T> x) {
 A<Double, ? extends T> y = x;
 A<Double, ? extends T> z = (true) ? y : x;
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Conditionals, Use-site variance
#35 Cannot resolve type in the presence of use-site contravariance
Link: https://issues.apache.org/jira/browse/GROOVY-10670
Date found: 2022-06-28
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Main {
 static final Bar<? super Short> bar = new Bar<Short>((Short) -94)
 static final short foo = Main.bar.x
}
class Bar {
 public final P x
 public Bar(P x) { 
 this.x = x 
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance
#36 Unable to infer type parameter of recursive method
Link: https://issues.apache.org/jira/browse/GROOVY-10632
Date found: 2022-05-20
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class B<T extends A<String>> {
 B(T x) {}
}
class Test {
 <T extends A<String>> T test() {
 new B<T>(test());
 return null;
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Bounded type parameter
#37 Unable to instantiate type parameter of method with a valid type
Link: https://issues.apache.org/jira/browse/GROOVY-10631
Date found: 2022-05-20
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class Test {
 static <T> T m(T x, T y) { return null; }
 static void test() {
 A<? extends Object> x = m(new A<Boolean>(), new A<String>());
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized function, Parameterized type, Use-site variance, Subtyping
#38 Subtyping does not work properly when having bounded type parameter and closure
Link: https://issues.apache.org/jira/browse/GROOVY-10630
Date found: 2022-05-20
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class B<X, Y extends X> {
 void test() {
 Closure<String> clos = { X x -> x.toString() }
 clos((Y) null);
 }
}
```
Test Case Characteristics: Lambda, Bounded type parameter, Parameterized class
#39 Subtyping does not work properly when having two bounded type parameters
Link: https://issues.apache.org/jira/browse/GROOVY-10629
Date found: 2022-05-20
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
 void m(T x) {}
}
class B<X extends Number, Y extends X> {
 void test() {
 A<X> x = new A<X>();
 x.m((Y) null);
 }
}
```
Test Case Characteristics: Bounded type parameter, Parameterized class, Parameterized type
#40 Wrong type is inferred when involving a bounded type parameter in a parameterized method call -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10622
Date found: 2022-05-13
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-15
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
 T m() {
 return null;
 }
}
class B {
 B(byte x) {}
}
class C<T> {
 T x;
 C(T x) {
 this.x = x;
 }
}
class Test {
 <T extends A<Byte>> void test() {
 C<T> a = new C<T>(null);
 T x = a.x;
 new B(x.m()); // should type check
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized function, Parameterized type, Primitive type
#41 LUB operation returns incorrect result -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10603
Date found: 2022-04-28
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-17
Symptom: Unexpected compile-time error
Test case:
```
interface Foo {}
class Bar implements Foo {}
interface Baz extends Foo {}
class Qux implements Baz {}
class Test {
  public static Foo test() {
    Qux  x = new Qux();
    return (true) ? x : (Bar) null;
  }
}
```
Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Conditionals, Subtyping
#42 Compiler crash in class generation when combining lambdas and default args
Link: https://issues.apache.org/jira/browse/GROOVY-10602
Date found: 2022-04-28
Status: Open
Symptom: Crash
Test case:
```
import java.util.function.Supplier;
class Test {
 public static void test(Closure<Byte> x = {Byte v -> { Closure<Byte> y = { Supplier<Byte> d = { -> v } -> d.get() }; y() }}) {
 null
 }
}
```
Test Case Characteristics: Lambda, Single Abstract Method (SAM), Named arguments
#43 Incompatible generic argument type when combining conditionals and bounded type parameters -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10601
Date found: 2022-04-28
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-18
Symptom: Unexpected compile-time error
Test case:
```
class Foo<X> {}
class Test {
 public static <T extends Foo<Number>> T test() {
 T x = (T) null;
 T y = (true) ? x : (T) null;
 y
 }
}
```
Test Case Characteristics: Conditionals, Bounded type parameter, Parameterized class, Parameterized type
#44 Incorrect inference of type argument of parameterized method call -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10482
Date found: 2022-02-15
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-12
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
 Foo(T x) {}
}
class Main {
 static <T> void bar() {
 new Foo<T>(baz());
 }
 static <Z> Z baz() {
 return null;
 }
}
```
Test Case Characteristics: Parameterized function, Parameterized class
#45 STC cannot compile program with multiple bounded type parameters -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10373
Date found: 2021-11-17
Status: Resolved
Resolution: Fixed
Resolution date: 2022-05-16
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
class Main> {
 void main() {
 C x = (C) null
 x.foo().bar(null)
 }
}
class A<I, E extends I> {
 void bar(E y) {}
}
class B<T> {}
class C<S extends B<Character>> {
 A<S, ? extends S> foo() { (A<S, ? extends S>) null}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Bounded type parameter
#46 STC does not perform boxing when overriding method using a parameterized class with bounded type parameters -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10365
Date found: 2021-11-12
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-17
Symptom: Unexpected compile-time error
Test case:
```
interface I {
 double m(Integer x);
}
class A<T extends Number, Y> implements I {
 public double m(Integer x) {
 return 10.0;
 }
}
class B<T extends I> {
 public int f;
 double m2(A<Float, ? extends T> x) {
 return x.m(f);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Use-site variance, Bounded type parameter, Primitive type, Overriding
#47 STC does not type check method call when using bounded type parameter as a type argument -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10364
Date found: 2021-11-12
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-17
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
 void m(B<T> x, T y) {}
}
class B<T> {}
class Test<X, Y extends X> {
 void m() {
 A<Y> x = new A<Y>();
 x.m(new B<Y>(), (Y) null);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter
#48 STC produces compile-time error on encoutering bounded type parameter with conditional -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10363
Date found: 2021-11-12
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-16
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
class A {
 static final <X extends Supplier<Number>> X m(X x, X y) {
 X z = (true) ? x : y
 z
 }
}
```
Test Case Characteristics: Parameterized type, Use-site variance, Parameterized function, Bounded type parameter, Conditionals

#49 STC reports an unexpected method ambiguity

Link: https://issues.apache.org/jira/browse/GROOVY-10362
Date found: 2021-11-11
Status: Open
Symptom: Unexpected compile-time error
Test case:


interface I<W, Y, B extends W> {
  Y m(Y x, B y);
}
interface I2<S extends Boolean, M> extends I<S, S, S> {}
interface I3<J> extends I2<Boolean, J> {}
interface I4<X extends Number> extends I3<X> {}
class B implements I4<Number> {
  public Boolean m(Boolean x, Boolean y) {
    return false;
  }
}
abstract class C<T1 extends Integer, T2 extends T1> extends B {}
public class Test {
  void test() {
    B x = bar();
    x.m(true, false);
  }
  C<Integer, Integer> bar() {
    return null;
  }
}

Test Case Characteristics: Parameterized class, Bounded type parameter, Inheritance / Implementation of multiple interfaces, Overriding, Subtyping, Parameterized type

#50 Unable to resolve method after LUB operator -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10358
Date found: 2021-11-10
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Unexpected compile-time error
Test case:
```
interface I {
 int m(int x);
}
abstract class A implements I {
}
class B<T> extends A {
 public int m(int x) {
 return x + 1;
 }
}
public class C<T> extends A {
 public int m(int x) {
 return x - 1;
 }
}
class Test {
 void test() {
 C<String> x = null;
 int y = 1;
 ((true) ? x : new B<String>()).m(y);
 }
}
```
Test Case Characteristics: Overriding, Inheritance / Implementation of multiple interfaces, Parameterized class, Parameterized type, Primitive type, Conditionals
#51 STC crashes on compiling an abstract method with default arguments and lambda -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10357
Date found: 2021-11-10
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Crash
Test case:
```
import java.util.function.Function;
abstract class A {
 abstract Long m(Function<Boolean, Integer> x = { Boolean x -> x ? 10: -10})
}
```
Test Case Characteristics: Lambda, Function type, Conditionals
#52 STC rejects program on compiling constructor initialization with a wildcard type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10337
Date found: 2021-11-01
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-03
Symptom: Unexpected compile-time error
Test case:
```
class A<T1, T2> {
 A(A<T2, ? extends T2> y) {}
}
class Test<T> {
 void test() {
 A<Number, T> x = new A<Number, T>((A<T, T>) null);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance

#53 STC crashes when passing method reference to an inner closure -- Fixed

Link: https://issues.apache.org/jira/browse/GROOVY-10336
Date found: 2021-10-31
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-01
Symptom: Crash
Test case:


import java.util.function.Function;
import java.util.function.Supplier;
abstract class Test {
  void test() {
    Supplier<Long> keystone = () -> {
      Closure<Long> inner = (Object evolve, Supplier<Integer> x) -> null 
      inner(new Object(), new B()::m).f
    }
  }
}
class A {
  Long f
}
class B {
  Integer m() {1}
}

Test Case Characteristics: Function type, Function reference, Lambda

#54 STC instantiates type variable with a wrong type when calling an instance method of the same class -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10330
Date found: 2021-10-26
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-30
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Function;
class A<T> {
 T y;
 void foo(T x, Function<T, T> func) {
 foo((true) ? x : y, func)
 }
}
```
Test Case Characteristics: Conditionals, Parameterized class, Parameterized type
#55 Compiler crash when combining closure with function reference -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10327
Date found: 2021-10-22
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-30
Symptom: Crash
Test case:
```
import java.util.function.Function;
@groovy.transform.TypeChecked
class A<X, Y> {
 void a() {
 Closure<Integer> x = { Function<Integer, Integer> x -> 1};
 B b = new B();
 x(b::b);
 }
}
class B {
 Integer b(Integer x) { return null; }
}
```
Test Case Characteristics: Parameterized class, Lambda, Function reference, Function type
#56 Compiler crashes on parameterized function with duplicate type variables -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10323
Date found: 2021-10-21
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-30
Symptom: Crash
Test case:
```
class A {
 <T, T> T foo(T t) { return t; }
}
class C<T> {}
class B {
 void test() {
 (new A()).foo(new C<String>());
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function
#57 Type variable of function does not shadow the corresponding type variable of class -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10322
Date found: 2021-10-21
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-04
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
 <T> T foo(T t) { return t; }
}
class B {
 void bar(int x) {}
 void test() {
 int x = (new A<String>()).foo(1);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Type argument inference
#58 Type variable substitution does not work properly on parameterized function's return type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10317
Date found: 2021-10-19
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-01
Symptom: Unexpected compile-time error
Test case:
```
class A<T1, T2> {
 void m1(T1 x) {}
 void test() {
 var x = new B();
 T2 y = null;
 (new A<T2, T2>()).m1(x.m2(y));
 }
}
class B {
 <X, Y> X m2(Y x) { return null; }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function
#59 Unable to infer type variable of parameterized function that expects two parameters -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10315
Date found: 2021-10-18
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-01
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {
 void m(T x) {}
 <T2> T m2() {
 return null;
 }
}
class Main {
 <T> void m1() {
 A<T> x = new A<T>();
 m3(m2(), x.m2()); // does not work
 }
 <T> T m2() {
 return null;
 }
 <T> void m3(T x, T y) {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function
#60 Improper type variable substitution when involving type parameters with conficting names -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10309
Date found: 2021-10-15
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-01
Symptom: Unexpected compile-time error
Test case:
```
class A<T, Y> {
 T f1;
 Y f2;
 A(T f1, Y f2) {
 this.f1 = f1;
 this.f2 = f2;
 }
}
class C<T, X> {
 void test() {
 A<X, T> x = new A<X, T>((X) null, (T) null);
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type
#61 STC rejects program when assigning a closure that returns a class field -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10306
Date found: 2021-10-14
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-30
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
class Main {
 byte x = 1;
 void foo() {
 Supplier<Number> y = () -> x;
 }
}
```
Test Case Characteristics: Lambda, Function type, Subtyping, Primitive type
#62 Cannot assign type parameter whose bound is a parameterized type that takes a wildcard -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10283
Date found: 2021-10-05
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-10
Symptom: Unexpected compile-time error
Test case:
```
class A<T1, T2> {}
class B<T1 extends Number, T2 extends A<C, ? extends T1>> {
 T2 f;
 B(T2 f) {
 this.f = f;
 }
}
class C {}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Bounded type parameter
#63 Type variable substitution does not work well when running into chain of field accesses -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10280
Date found: 2021-10-04
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-10
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {
 T foo() {
 new Bar<T>().f1.f2.f3;
 }
}
class Bar<Y> {
 Baz<Y> f1;
}
class Baz<T> {
 Qux<T> f2;
}
class Qux<X> {
 X f3;
}
```
Test Case Characteristics: Parameterized class, Parameterized type
Fix Commit(s):
- https://github.com/apache/groovy/commit/a3ab384dbb
- https://github.com/apache/groovy/commit/ad74b73d9e

#64 Wrong inference when using ternary operator with lambdas -- Fixed

Link: https://issues.apache.org/jira/browse/GROOVY-10272
Date found: 2021-09-29
Status: Resolved
Resolution: Fixed
Resolution date: 2022-05-19
Symptom: Unexpected compile-time error
Test case:


import java.util.function.Function;
@groovy.transform.TypeChecked
class Main {
    public static final void main() {
        Function<Long, Double> x
        // Works
        if (true) {
            x = {Long a -> (Double) a}
        } else {
            x = {Long b -> (Double) b}
        }
        // Fails
        Function<Long, Double> y = ((true) ? {Long a -> (Double) a} : {Long b -> (Double) b})
    }
}

Test Case Characteristics: Function type, Conditionals, Lambda

#65 Wrong inference when using ternary operator with closure and variable -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10271
Date found: 2021-09-29
Status: Resolved
Resolution: Fixed
Resolution date: 2022-05-19
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Supplier;
@groovy.transform.TypeChecked
class Main {
 static final void foo(Supplier<Integer> x) {}
 public static final void main() {
 Supplier<Integer> y = { -> 5 }
 Supplier<Integer> z = (true) ? y : {-> 5}
 }
}
```
Test Case Characteristics: Lambda, Function type, Conditionals

#66 Cannot initialize parameterized class with lambda without cast

Link: https://issues.apache.org/jira/browse/GROOVY-10270
Date found: 2021-09-29
Status: Open
Symptom: Unexpected compile-time error
Test case:


import java.util.function.Function;
@groovy.transform.TypeChecked
class Main {
   static final void foo(Function<Short, Byte> x) {}
   public static final void main() {
     foo({Short y -> (Byte) y}) // works
     Cls cls = new Cls({Short y -> (Byte) y}) // works
     PCls<Function<Short, Byte>> pcls1 = new PCls<Function<Short, Byte>>({Short y -> (Byte) y} as Function<Short, Byte>) // works
     PCls<Function<Short, Byte>> pcls2 = new PCls<Function<Short, Byte>>({Short y -> (Byte) y}) // fails
   }
}
class Cls {
  public Function<Short, Byte> f
  public Cls(Function<Short, Byte> f) {
     this.f = f
  }
}
class PCls <T> {
   public T f
   public PCls(T f) {
      this.f = f
   }
}

Test Case Characteristics: Function type, Lambda, Parameterized class, Parameterized type

#67 Unable to assign variable in parameterized class with bounded polymorphism
Link: https://issues.apache.org/jira/browse/GROOVY-10268
Date found: 2021-09-28
Status: Closed
Resolution: Duplicate
Resolution date: 2021-09-28
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Cls<T, Z extends T> {
 public final Z foo
 public Upbeat(Z foo) {
 this.foo = foo
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
#68 STC reports wrong message when encoutering wildcard types -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10267
Date found: 2021-09-27
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-01
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class B {
 A<? extends Object> test() {
 return test2();
 } A<? extends Object> test2() {
 return null;
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance

#69 STC: cannot return closure from method without casting -- Fixed

Link: https://issues.apache.org/jira/browse/GROOVY-10254
Date found: 2021-09-23
Status: Closed
Resolution: Fixed
Resolution date: 2021-09-26
Symptom: Unexpected compile-time error
Test case:


import java.util.function.Supplier;
@groovy.transform.TypeChecked
public class Main {
    public static Supplier<Integer> foo() {
        { -> 10} as Supplier<Integer> // works
    }
    public static Supplier<Integer> bar() {
        { -> 10} //fails
    }
    public static void main(String[] args) {
        Supplier<Integer> v1 = { -> 10} as Supplier<Integer> // works
        Supplier<Integer> v2 = { -> 10} // works
        Supplier<Integer> v3 = foo()
        Supplier<Integer> v4 = bar()
    }
}

Test Case Characteristics: Function type, Lambda
Fix Commit(s):

https://github.com/apache/groovy/commit/1ee6f66a56

#70 Unexpected generics parameter arity mismatch in the "instruction selection" phase -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10230
Date found: 2021-09-13
Status: Closed
Resolution: Fixed
Resolution date: 2021-11-04
Symptom: Crash
Test case:
```
class Foo<T1, T2> {}
class A {
 <T extends Foo<Number, Number>> T m(T x) {
 x
 }
}
class B extends A {
 <T extends Foo<Number, Number>> T m(T x) {
 T z = null;
 super.m((true) ? z : z)
 }
}
```
Test Case Characteristics: Parameterized function, Parameterized class, Parameterized type, Bounded type parameter, Inheritance / Implementation of multiple interfaces, Overriding, Conditionals
#71 STC computes an imprecise LUB when involving two parameterized types implementing the same interface -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10227
Date found: 2021-09-13
Status: Closed
Resolution: Fixed
Resolution date: 2022-05-18
Symptom: Unexpected compile-time error
Test case:
```
class A {
 void foo(I x) {}
}
interface I {}
interface I2 extends I {}
class B<T> implements I2 {}
class C<T> implements I {}
class Main {
 public static void main(String[] args) {
 (new A()).foo((true) ? new B<String>() : new C<String>());
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Subtyping, Conditionals
#72 LUB is computed incorrectly when involving bounded type variables -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10226
Date found: 2021-09-13
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {}class Main {
 static final <T extends Foo<String>> T test() {
 final T x = null;
 true ? (T) null: x
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized function, Bounded type parameter, Parameterized type, Conditionals
#73 Unexpected NullPointerException during the "instruction selection" phase -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10225
Date found: 2021-09-13
Status: Closed
Resolution: Fixed
Resolution date: 2021-09-27
Symptom: Crash
Test case:
```
class Foo<Z> {
 final Z foo(Z x) {
 null;
 }
}
final class Bar<Y> { final Foo<Y> bar() {
 new Foo<>()
 }
}
class Main {
 static final <F_O extends Number, F_X extends F_O> void test() {
 final F_X x = (F_X) null
 (new Bar<F_O>()).bar().foo(((false) ? x : (F_X) null))
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Parameterized function, Bounded type parameter, Subtyping, Conditionals
Fix Commit(s):
- https://github.com/apache/groovy/commit/9a642c928f
#74 Unable to infer the type parameter of a parameterized function -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10222
Date found: 2021-09-10
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-12
Symptom: Unexpected compile-time error
Test case:
```
class A {
 static <T> T foo() {
 return null;
 }
}
class Test<T> {
 void bar() {
 T x = A.foo();
 }
}
```
Test Case Characteristics: Parameterized function, Parameterized class
Fix Commit(s):
- https://github.com/apache/groovy/commit/4d5c95d3c3
#75 Unexpected type mismatch when having conflicting type parameter names -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10220
Date found: 2021-09-10
Status: Closed
Resolution: Fixed
Resolution date: 2021-09-21
Symptom: Unexpected compile-time error
Test case:
```
class A<X, T extends Number> {}
class B<T> {
 A<? extends T, Number> x;
 B(A<? extends T, Number> x) {
 this.x = x;
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Use-site variance, Parameterized type
Fix Commit(s):
- https://github.com/apache/groovy/commit/f1c912b53b
#76 Unexpected type mismatch when combining conditional and bounded type parameter -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10158
Date found: 2021-06-30
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Unexpected compile-time error
Test case:
```
class A<T> {}
class B<T extends A<String>> {
 T m() {
 final T x = null;
 final T y = null;
 (true) ? y : x
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Conditionals
#77 STC: cannot combine use-variance with bounded polymorphism -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10153
Date found: 2021-06-28
Status: Closed
Resolution: Fixed
Resolution date: 2022-06-23
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Test {
 public void m() {
 Foo<? super C> x = new Foo();
 }
}
class A {}
class B extends A {}
class C extends B {}
class Foo<T extends A> {
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Bounded type parameter, Inheritance / Implementation of multiple interfaces, Subtyping
#78 Flow typing does not work when && is combinded with instanceof -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10130
Date found: 2021-06-08
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-15
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Test {
  public void foo(Foo x) {
    ((true && x instanceof Bar)) ? new Bar[]{x} : null
  }
}
class Foo {}
class Bar extends Foo {}
```
Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Subtyping, Flow typing, Conditionals, Array
#79 Cannot assign closure with long as return type to java.util.function.Function -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10128
Date found: 2021-06-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-10-30
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Function;
@groovy.transform.TypeChecked
class Main {
 public static void main(String[] args) {
 Function<String, Number> x = { y ->
 final long d = 1;
 return d;
 };
 }
}
```
Test Case Characteristics: Function type, Primitive type, Subtyping, Lambda
#80 FP Cycle detected in type parameter that extends another type parameter -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10125
Date found: 2021-06-07
Status: Closed
Resolution: Fixed
Resolution date: 2021-06-07
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Test<X, Y extends X> {}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
Fix Commit(s):
- https://github.com/apache/groovy/commit/f48bb0938e
#81 STC: error when passing a type parameter in type constructor -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10116
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<T> {
 public void foo() {
 Foo<T, Long> x = new Foo<T, Long>(new Bar<T, Long>());
 }
}
class Foo<X, T> {
 public Foo(Bar<X, T> y) {}
}
class Bar<X, T> {}
```
Test Case Characteristics: Parameterized class, Parameterized type
#82 STC: compiler error when using type parameter with extends -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10115
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 Bar<L, T extends L> {
 T x;
 public Bar(T x) {
 this.x = x;
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
#83 StackOverflowError in STC -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10113
Date found: 2021-05-27
Status: Closed
Resolution: Fixed
Resolution date: 2021-06-06
Symptom: Crash
Test case:
```
@groovy.transform.TypeChecked
class Test<T extends T> {}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
Fix Commit(s):
- https://github.com/apache/groovy/commit/eef2a82ec7
#84 compiler crash during canonicalization -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10111
Date found: 2021-05-26
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-26
Symptom: Crash
Test case:
```
class Foo<X, Y> {}
class Bar<X extends Foo<Number, String>> {
 X[] m() {
 new X[]{new Foo<Number, String>()}
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Subtyping, Array
Fix Commit(s):
- https://github.com/apache/groovy/commit/1265acad6e
#85 Cannot assign null to a variable with a bounded generic type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10107
Date found: 2021-05-25
Status: Closed
Resolution: Fixed
Resolution date: 2021-06-04
Symptom: Crash
Test case:
```
final class Test<T extends Number> {
 final void m() {
 T v = null;
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
Fix Commit(s):
- https://github.com/apache/groovy/commit/0bdad7618f
#86 groovyc infers the wrong type when using a method reference of a function with varargs -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10100
Date found: 2021-05-20
Status: Closed
Resolution: Fixed
Resolution date: 2022-03-14
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Function;
class Foo<T> {
 public T method(Object... args) {
 return null;
 }
}
class Bar {
 public static <T extends Number> void test(T a) {
 Foo<T> x = new Foo<>();
 Function<String[], T> b = x::method;
 T y = b.apply(new String[] {"str"});
 }
}
public class Main {
 public static void main(String[] args) {
 Bar.test(1);
 }
}
```
Test Case Characteristics: Parameterized class, Variable argument, Parameterized function, Bounded type parameter, Function reference, Function type, Array
#87 Unexpected behaviour when the return type of a closure is a type parameter -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10098
Date found: 2021-05-19
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-20
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T extends Number> {
 T f Foo(T f) {
 this.f = f
 }
 T foo() {
 Closure<T> clos = { -> f}
 clos()
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter, Function type, Lambda
Fix Commit(s):
- https://github.com/apache/groovy/commit/7855eb2d4e
#88 Incompatible generic argument types on closure's return type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10091
Date found: 2021-05-17
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-18
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T> {}
class Bar<T> extends Foo<Integer> {}
class Baz extends Foo<Integer> {}
public class Main {
 public static void main(String[] args) {
 Closure<Foo<Integer>> z = { -> new Baz()} // this works
 Closure<Foo<Integer>> f = { -> new Bar<String>()} // this doesn't work
 } 
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Subtyping, Lambda, Function type
Fix Commit(s):
- https://github.com/apache/groovy/commit/f3d030afaa
#89 STC does not perform boxing on chars when encountering assignment and function call -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10087
Date found: 2021-05-13
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-16
Symptom: Unexpected compile-time error
Test case:
```
public class Main {
    public static void main(String[] args) {
      Character c = foo();
    }
    public static char foo() {
      'd' as char
    }
}
```
Test Case Characteristics: Primitive type
Fix Commit(s):
- https://github.com/apache/groovy/commit/0cb74ad876
#90 Incompatible generic argument types when combining subtyping and closures -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10082
Date found: 2021-05-12
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-15
Symptom: Unexpected compile-time error
Test case:
```
class A {}
class B extends A {}
class Main {
 public static void main(String[] args) {
 Closure<A> cls = { -> {
 final A x = new B()
 x
 }}
 }
}
```
Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Subtyping, Lambda, Function type
Fix Commit(s):
- https://github.com/apache/groovy/commit/0484437c0c

#91 Conversion from int to byte does not work in case of ternary operator

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


@groovy.transform.CompileStatic
public class Main {
  static byte x = 1;
  public static byte foo() {
    1
  }
  public static void main(String[] args) {
    x = (true) ? 0 : foo() // this does not work
    // the following works
    if (true) {
      x = 0
    } else {
      x = foo()
    }
    byte y = (true) ? 0 : foo() // this doesn't work as well
  }
}

Test Case Characteristics: Primitive type, Conditionals

#92 groovyc does not perform unboxing on Character type -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10079
Date found: 2021-05-10
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-11
Symptom: Unexpected compile-time error
Test case:
```
public class Main {
  public static char foo() {
    return (Character) 'd';
  }
}
```
Test Case Characteristics: Primitive type
Fix Commit(s):
- https://github.com/apache/groovy/commit/01d70022ff
#93 Compiler crash when encountering function reference on nested class -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-10033
Date found: 2021-04-12
Status: Closed
Resolution: Fixed
Resolution date: 2021-04-26
Symptom: Crash
Test case:
```
class Foo {
 protected Foo(Closure<Foo, Bar> x) {}
}
class Bar {
 Bar(Foo x) {}
}
public class X extends Foo {
 public X() {
 super(Y::new);
 }
 private class Y extends Bar {
 Y(Foo x) {
 super(x);
 }
 }
}
```
Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Function reference, Function type
Fix Commit(s):

#94 Inconsistency in handling of numeric types

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


public class Main {
  public static void foo() {
    final Byte f = (Float) 32.3 // possible loss of precision
    baz((Float) 13.3) // cannot find matching method
  }
  public static Byte bar() {
    return (Float) 4324141.4 // does not report error.
  }
  public static void baz(Byte x) {}
}

#95 STC: Access to field/property is forbidden after instanceof. -- Fixed

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


class Test {
  static void main(String[] args) {
    println(C.func4(new B()))
  }
}
class A {}
class B extends A {
  // It has the same behavior if f is a field instead of a property.
  String f = "foo"
}
@groovy.transform.CompileStatic
class C {
  static String func1(Object x) {
    (x instanceof String) ? x : "foo" // Compiles
  }
  static String func2(B x) {
    x.f // Compiles
  }
  static String func3(B x) {
    (x instanceof B) ? x.f : "foo" // Compiles
  }
  static String func4(A x) {
    (x instanceof B) ? x.f : "foo" // Does not compile
  }
}

Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Subtyping, Flow typing
Fix Commit(s):

https://github.com/apache/groovy/commit/56ca15ee7d

#96 Cannot pass numeric constant to a method with a generic type
Link: https://issues.apache.org/jira/browse/GROOVY-9947
Date found: 2021-02-16
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.TypeChecked
class Main {
 public static final void main(String[] args) {
 final A<Float> a = new A<Float>()
 a.foo(10)
 a.bar(10) // Fails here
 }
}
final class A<T> {
 final void foo(Float x) {}
 final void bar(T x) {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type
#97 STC: Cannot find matching method when using Generics -- Fixed
Link: https://issues.apache.org/jira/browse/GROOVY-9945
Date found: 2021-02-16
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-02
Symptom: Unexpected compile-time error
Test case:
```
interface I1<X, Y> {}
interface I2 extends I1<Character, Character> {}
class Foo<X, Y> implements I2 {
 public void foo(X x, Y y) {}
}
class Bar<X, Y> extends Foo<X, Y> {}
@groovy.transform.TypeChecked
class Main {
 public static void foo() {
 new Bar<Float, Integer>().foo((Float) 1.4, -1)
 }
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces
Fix Commit(s):
- https://github.com/apache/groovy/commit/8b87f7c65a
#98 !instanceof inference does not work
Link: https://issues.apache.org/jira/browse/GROOVY-9931
Date found: 2021-02-08
Status: Closed
Resolution: Duplicate
Resolution date: 2022-05-18
Symptom: Unexpected compile-time error
Test case:
```
@groovy.transform.CompileStatic
class Main {
    static Integer bar(Object o) {
        if (o !instanceof Integer) {
            return 0
        } else {
            return o
        }
    }
}
```
Test Case Characteristics: Flow typing

Kotlin

#99 K1: IllegalArgumentException: fromIndex(0) > toIndex(-1) when wrapping receiver with backticks
Link: https://youtrack.jetbrains.com/issue/KT-60597
Date found: 2023-07-21
Status: Open
Symptom: Crash
Test case:
```
fun test(): Unit 
{
  `java.lang.Short.TYPE`.getConstructor(TODO())
}
```

#100 Compilation performance regression when handling nested polymorphic types

Link: https://youtrack.jetbrains.com/issue/KT-59759
Date found: 2023-06-29
Status: Open
Symptom: Compilation performance issue
Test case:


kt
import org.apache.commons.collections4.*;
import org.apache.commons.collections4.keyvalue.*;
import org.apache.commons.collections4.map.*;
import org.apache.commons.collections4.iterators.*;
import org.apache.commons.collections4.functors.*;
import org.apache.commons.collections4.set.*;
import org.apache.commons.collections4.collection.*;
import org.apache.commons.collections4.trie.*;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
typealias A = EmptyIterator<String>
typealias B = AbstractCollectionDecorator<UnmodifiableBoundedCollection<A>>
typealias C = LazySortedMap<String, Stack<MultiSet<NullIsTruePredicate<ToDoubleFunction<B>>>>>
typealias D = EmptyIterator<SkippingIterator<ZippingIterator<IteratorEnumeration<C>>>>
typealias F = List<ExceptionPredicate<Iterator<Stream<D>>>>
fun test(): Unit 
{
  val res = (TODO() as AbstractKeyValue<Spliterators.AbstractSpliterator<FixedSizeMap<Spliterators.AbstractLongSpliterator, HashedMap<ZippingIterator<AbstractMap.SimpleEntry<String, Comparable<ToDoubleBiFunction<String, MapBackedSet<Iterator<CompositeCollection<Trie<Function0<List<F>>, String>>>, String>>>>>, String>>>, String>)
}

Test Case Characteristics: Parameterized class, Parameterized type

#101 "AssertionError: Resolution error of this type shouldn't occur for resolve if as a call" caused by reflective access of function

Link: https://youtrack.jetbrains.com/issue/KT-59574
Date found: 2023-06-22
Status: Open
Symptom: Crash
Test case:


kt
import com.google.common.collect.ImmutableSortedMap
 //     implementation("com.google.guava:guava:32.0.1-jre")
@Suppress("UNREACHABLE_CODE")
fun test(): Unit 
{
  val y: java.util.Comparator<Double> = TODO()
  val res: (Double, Double) -> Int = if (true)
      com.google.common.collect.ImmutableSortedMap.of(10.0, y).get(10.0)::compare // Type mismatch. Required: Comparator<Double> Found: Comparator<Double>?
    else TODO())
}

Test Case Characteristics: Conditionals, Function reference, Parameterized type, Parameterized class, Nullable type

#102 Nullability checks are not ignored when "-Xnullability-annotations=@javax.annotation:ignore" is provided
Link: https://youtrack.jetbrains.com/issue/KT-57940
Date found: 2023-04-12
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
kt
// implementation ("com.google.guava:guava:31.1-android")
fun test(): Unit 
{
 val x: com.google.common.collect.ForwardingConcurrentMap<Char, Int> = TODO()
 val y: Int = x.replace('d', 1)
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Nullable type

#103 "NoSuchElementException" with Array extension function with cast

Link: https://youtrack.jetbrains.com/issue/KT-57512
Date found: 2023-03-22
Status: Open
Symptom: Crash
Test case:


kt
import java.util.function.*;
fun test(p: LongToDoubleFunction): Unit 
{
    arrayOf(p).reduceRightIndexed(fun (x, y, z): LongToDoubleFunction {
        val local: Function1<kotlin.UInt, LongToDoubleFunction> = (
            TODO() as Grouping<UInt, LongToDoubleFunction>)::keyOf
        return p
  })
}

Test Case Characteristics: Function reference, Single Abstract Method (SAM), Parameterized type, Parameterized class, Array type

#104 False positive CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY for method reference
Link: https://youtrack.jetbrains.com/issue/KT-57518
Date found: 2023-03-22
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
kt
fun test() {
 val y: MutableList<IntIterator> = TODO()
 val d: Function1<Iterator<Int>, Boolean> = TODO()
 m<IntIterator>(if (true) d else y::add) // fails
 val z: Function1<IntIterator, Boolean> = if (true) d else y::add // works
}
fun <T> m(x: (T) -> Boolean) {}
```
Test Case Characteristics: Overloading, Function reference, Conditionals, Parameterized function, Parameterized type, Parameterized class, Single Abstract Method (SAM)
#105 NI: Type mismatch when encountering bounded type parameter and projections -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-54990
Date found: 2022-11-16
Status: Closed
Resolution: Fixed
Resolution date: 2023-02-10
Symptom: Unexpected compile-time error
Test case:
```
kt
class A<T1, T2: B<T1, Double>>
class B<T1, T2>
class C<L>(val x: A<out L, out B<L, Double>>)
fun test() {
 val x: A<out Any, out B<Any, Double>> = A()
 C<Any>(x)
}
```
Test Case Characteristics: Parameterized type, Parameterized class, Wildcard type
#106 TYPE_MISMATCH when using a SAM type with star projection
Link: https://youtrack.jetbrains.com/issue/KT-52307
Date found: 2022-05-06
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
kt
import java.util.function.Function;
class A(val x: Function<*, String>)
fun main() {
 A({ x: String -> x })
}
```
Test Case Characteristics: Wildcard type, Parameterized type, Parameterized class, Single Abstract Method (SAM), Lambda
#107 NI: Unexpected TYPE_MISMATCH when combining nested conditional and contravariant type argument
Link: https://youtrack.jetbrains.com/issue/KT-47530
Date found: 2021-06-30
Status: Open
Resolution date: 2022-07-28
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T>
fun main() {
 val x: Foo<in Long> =
 if (true) Foo<Long>()
 else
 if (true) Foo<Long>()
 else Foo<Number>()
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance, Conditionals, Subtyping
#108 NI: NullPointerException on compiling anonymous function returning a method reference
Link: https://youtrack.jetbrains.com/issue/KT-49583
Date found: 2021-11-06
Status: Open
Resolution date: 2022-07-28
Symptom: Crash
Test case:
```
class Foo(var pickaxe: Function0<Function1<Char, Any>>)
interface I {
 fun m(): Int
}
fun test() {
 val x = Foo({ -> fun (p: Char): Any {
 fun inner_m(): Any {
 val x: I = TODO()
 x::m
 }
 return inner_m()
 }}
 )
}
```
Test Case Characteristics: Single Abstract Method (SAM), Function type, Function reference, Lambda
#109 "Unexpected tokens" when `if` statement contains double parenthesis in variable assignment
Link: https://youtrack.jetbrains.com/issue/KT-43806
Date found: 2020-12-07
Status: Submitted
Resolution date: 2022-06-08
Symptom: Unexpected compile-time error
Test case:
```
 val b = 98 < (if (("bar" > "foo")) 5 else 1)
```
Test Case Characteristics: Conditionals
#110 Support SAM conversions on value parameters inferred into Kotlin functional interface
Link: https://youtrack.jetbrains.com/issue/KT-48838
Date found: 2021-09-21
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
fun interface FI {
 fun foo(i: Int): Int
}
fun test1(x: FI) {}
fun <T> test2(x: T) {}
fun main() {
 test1({x: Int -> x})
 test2<FI>({x: Int -> x}) // error [TYPE_MISMATCH] Type mismatch.
}
```
Test Case Characteristics: Single Abstract Method (SAM), Parameterized function, Lambda
#111 TYPE_MISMATCH when using a SAM type with star projection
Link: https://youtrack.jetbrains.com/issue/KT-52307
Date found: 2022-05-06
Status: Submitted
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Function;
class A(val x: Function<*, String>)
fun main() {
 A({ x: String -> x })
}
```
Test Case Characteristics: Lambda, Single Abstract Method (SAM), Subtyping

#112 Inconsistency in overload resolution when calling a scope function

Link: https://youtrack.jetbrains.com/issue/KT-48958
Date found: 2021-09-28
Status: Submitted
Symptom: Unexpected compile-time error
Test case:


fun run(x: String): Unit  {}
inline fun <R> test(block: () -> R): R = block()
fun test(x: String): Unit {}
fun <T> ret(): T = TODO()
class A {
  fun d() {
    test(ret()) // Calls test(x: String): Unit
    run(ret()) // Calls <R> run(block: () -> R): R
  }
}
fun main() {
    test(ret()) // Calls test(x: String): Unit
    run(ret()) // Calls run(x: String): Unit
}

Test Case Characteristics: Parameterized function, Function type

#113 TYPE_MISMATCH when combining use-site variance with bounded polymorphism
Link: https://youtrack.jetbrains.com/issue/KT-47508
Date found: 2021-06-28
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
open class A
open class B: A()
class C : B()
class Foo<T : A>(val x: T)
fun main() {
 val x: Foo<in C> = TODO()
 val y: A = x.x
}
```
Test Case Characteristics: Inheritance / Implementation of multiple interfaces, Parameterized class, Parameterized type, Use-site variance, Bounded type parameter, Subtyping
#114 NI: Wrong type is inferred on combining conditional and contravariant type argument
Link: https://youtrack.jetbrains.com/issue/KT-47231
Date found: 2021-06-10
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T>
class Bar(val x : Foo<in Float>)
fun main() {
 val x: Foo<in Float> = Foo<Float>()
 val y: Foo<in Float> = Foo<Float>()
 Bar(x) // works
 val z = if (true) x else y
 Bar(z) // works
 Bar(if (true) x else y) // fails
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Use-site variance
#115 False positive "NOTHING_TO_OVERRIDE" when combining varargs with type parameters
Link: https://youtrack.jetbrains.com/issue/KT-46662
Date found: 2021-05-13
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
open class A<T> {
 open fun foo(vararg x: T) {}
}
class B: A<Float>() {
 override fun foo(vararg x: Float) {} // NOTHING_TO_OVERRIDE
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Overriding, Variable argument
#116 JVM IR: "IndexOutOfBoundsException: Cannot pop operand off an empty stack" on compiling unused identity equality of Double literals -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-46864
Date found: 2021-05-21
Status: Closed
Resolution: Fixed
Resolution date: 2021-05-31
Symptom: Crash
Test case:
```
fun m(): Unit
{
  (40.523 !== 62.562)
}
```
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/9091ca7b510
#117 IllegalStateException through `PositioningStrategies$SECONDARY_CONSTRUCTOR_DELEGATION_CALL$1.mark` caused by inner enum -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-45339
Date found: 2021-03-07
Status: Closed
Resolution: Fixed
Resolution date: 2021-03-24
Symptom: Crash
Test case:
```
interface Foo<T> {
 inner enum class Bar : Foo<T>
}
```
Test Case Characteristics: Parameterized class
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/ae4dd80254f
- https://github.com/JetBrains/kotlin/commit/8068a5439fe
#118 JVM / IR: "AssertionError: Primitive array expected: CLASS IR_EXTERNAL_DECLARATION_STUB CLASS" -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-48671
Date found: 2021-09-08
Status: Closed
Resolution: Fixed
Resolution date: 2021-09-11
Symptom: Crash
Test case:
```
val x: Any = arrayOf<Any>(emptyArray<Int>(), intArrayOf(9, 19, -3))
class A
```
Test Case Characteristics: Array, Subtyping
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/23420ecf7a6

#119 SAM conversions by expected type

Link: https://youtrack.jetbrains.com/issue/KT-48840
Date found: 2021-09-21
Status: Closed
Resolution: Duplicate
Resolution date: 2022-01-26
Symptom: Unexpected compile-time error
Test case:


fun interface FI {
  fun foo(p: Double): Long
}
fun bar(fi: FI) {}
class A {
    fun buz(p: Double): Long {
        return p.toLong()
    }
}
fun foo() {
    bar({p: Double -> p.toLong()}) // works
    val v1: FI = FI {p: Double -> p.toLong()} // works
    val a: A = A()
    bar(a::buz) // Works
    val v2: FI = FI a::buz // Fails -- wrong syntax?
    val v3: FI = a::buz // Fails
    val v4: FI = a::buz as FI // Work-around
}

Test Case Characteristics: Single Abstract Method (SAM), Lambda, Function reference, Function type

#120 TYPE_MISMATCH error when applying `fun interface` in the initialization of a type constructor
Link: https://youtrack.jetbrains.com/issue/KT-48858
Date found: 2021-09-22
Status: Closed
Resolution: Duplicate
Resolution date: 2022-01-25
Symptom: Unexpected compile-time error
Test case:
```
fun interface FI {
 fun foo(p: Double): Long
}
class A(val x: FI)
class B<T>(val x: T)
fun foo() {
 val x = {p: Double -> p.toLong()}
 val a1 = A({p: Double -> p.toLong()})
 val a2 = A(x)
 val b1 = B<FI>({p: Double -> p.toLong()}) // [TYPE_MISMATCH] Type mismatch.
 val b2 = B<FI>(x) // [TYPE_MISMATCH] Type mismatch.
}
```
Test Case Characteristics: Single Abstract Method (SAM), Parameterized class, Lambda
#121 JVM IR: "AnalyzerException: Argument 1: expected I, but found R" when assigning an array of numbers to an Any variable
Link: https://youtrack.jetbrains.com/issue/KT-48766
Date found: 2021-09-15
Status: Closed
Resolution: Obsolete
Resolution date: 2021-09-15
Symptom: Crash
Test case:
```
val x: Any = arrayOf<Number>(-74, -43)
```
Test Case Characteristics: Subtyping, Array
#122 JVM IR: "AnalyzerException: Argument 1: expected I, but found R" on compiling a method with a generic default argument whose bound is a primitive -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-47073
Date found: 2021-06-01
Status: Closed
Resolution: Fixed
Resolution date: 2021-06-04
Symptom: Crash
Test case:
```
class Test<T: Char> {
 fun foo(): String {
 fun nested(x: T = TODO()): String {
 return "str"
 }
 return nested()
 }
}
```
Test Case Characteristics: Parameterized class, Bounded type parameter
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/7fd033adaea
#123 JVM IR: ACCIDENTAL_OVERRIDE when overriding a generic field where the type parameter has a primitive bound -- Fixed
Link: https://youtrack.jetbrains.com/issue/KT-44627
Date found: 2021-01-30
Status: Closed
Resolution: Fixed
Resolution date: 2021-02-15
Symptom: Unexpected compile-time error
Test case:
```
open class A<T: Char>(open var x: T)
open class B<T: Char>(open override var x: T): A<T>(x)
class C(override var x: Char): B<Char>('x')
```
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Overriding, Bounded type parameter
Fix Commit(s):
- https://github.com/JetBrains/kotlin/commit/e1a75f82031
- https://github.com/JetBrains/kotlin/commit/b262d09a81b

Scala

#124 AssertionError when loading class file
Link: https://github.com/lampepfl/dotty/issues/18091
Date found: 2023-06-28
Status: Open
Symptom: Crash
Test case:
```
import io.restassured.internal.support.ParameterUpdater;
object Test {
  def test() = {
    val x: ParameterUpdater = null;
  }
}
```
Test Case Characteristics: Inner class
#125 Unexpected type mismatch when referencing an overloaded method
Link: https://github.com/lampepfl/dotty/issues/17540
Date found: 2023-05-19
Status: Closed
Resolution: Duplicate
Symptom: Unexpected compile-time error
Test case:
```
Scala
object Test {
  def test(): Unit = {
    val x: Function1[? >: Int, Int] = Test.m
  }
  def m(x: Int) = 1
  def m(x: Int, y: Char) = false
}
```
Test Case Characteristics: Overloading, Single Abstract Method (SAM), Wildcard type, Function reference
#126 MatchError when calling a public method inherited from a default class -- Fixed
Link: https://github.com/lampepfl/dotty/issues/17391
Date found: 2023-05-02
Status: Closed
Resolution: Fixed
Symptom: Crash
Test case:
```
java
package mypkg;
class Base<E> {
 public void retainAll(String x) {}
}
public class Bar<E> extends Base<E> {}
```
Test Case Characteristics: Access modifier, Parameterized type, Parameterized class
#127 Unexpected overload ambiguity when using type parameter with upper bound
Link: https://github.com/lampepfl/dotty/issues/17412
Date found: 2023-05-04
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
object Foo {
 def test(): Unit = {
 val x: Map[String, String] = ???
 Foo.m[Map[String, String]](x)
 }
 // if we comment the following line, then it compiles
 def m[T](x: Array[T]) = true
 def m[T <: String](x: T) = true
 def m[T <: Map[?, ?]](x: T) = true
}
```
Test Case Characteristics: Overloading, Parameterized function, Parameterized type, Parameterized class, Array type, Bounded type parameter
#128 Fail to assign int constant to Short in the presence of overloaded methods
Link: https://github.com/lampepfl/dotty/issues/17360
Date found: 2023-04-27
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
object Foo {
  def test(): Unit = {
    Foo.m[Short](10)
  }
  def m[T](x: T) = true
  def m[T](x: T*) = true
}
```
Test Case Characteristics: Overloading, Variable argument, Parameterized function
#129 Unexpected overload ambiguity when referencing an overloaded method
Link: https://github.com/lampepfl/dotty/issues/17310
Date found: 2023-04-19
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
Scala
class Foo[T] {
  def m(x: T): Boolean = true
  def m(x: T, y: Int): Boolean = false
}
def test(): Unit = {
  val x: Foo[Float] = new Foo[Float]()
  val y: Function1[? >: Float, Boolean] = x.m _
}
```
Test Case Characteristics: Single Abstract Method (SAM), Function reference, Parameterized type, Parameterized class, Wildcard type, Overloading, Parameterized function
#130 error when pickling tree: assertion failed: method $anonfun
Link: https://github.com/lampepfl/dotty/issues/15786
Date found: 2022-07-29
Status: Open
Symptom: Crash
Test case:
```
Scala
class A(val f: () => Int) {
  def mA(p: Int = 0): Int = p
}
trait B {
  def mB(p1: Int): Unit
}
class C[T](val f1: B, val f2: T)
val f = new A(() => {
  val x: B = null
  C[Int](x, 0).f1.mB(1);
  1
}).mA()
```
Test Case Characteristics: Lambda, Parameterized type, Parameterized class

Java

#131 StackOverflowError on computing the GLB

Link: https://bugs.openjdk.java.net/browse/JDK-8274183
Date found: 2021-09-22
Status: Open
Symptom: Crash
Test case:


class Main {
  static public final C<? super A<Double>> test() {
    final C<? super A<Double>> x = null;
    x.f = null;
    return x;
  }
}
class A<T> {}
abstract class B<F, B extends F> {}
abstract class C<N extends A<Number>> {
  public B<? extends N, ? extends N> f;
}

Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Use-site variance

#132 Cannot assign method reference to Generic Function Interface

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


class Test {
  public static Short foo(Short x) {
      return x;
  }
  public static Short bar() {
      Short x = 1;
      return x;
  }
  public static void main(String[] args) {
    Function0<? extends Number> f = Test::bar;
    Function1<? extends Number, ? extends Number> f1 = (Short x) -> x; // works
    Function1<? extends Number, ? extends Number> f2 = Test::foo; // does not work
  }
}
interface Function0<R> {
  public R apply();
}
interface Function1<P, R> {
  public R apply(P x);
}
  public static Short bar() {
      Short x = 1;
      return x;
  }
  public static void main(String[] args) {
    Function0<? extends Number> f = Test::bar;
    Function1<? extends Number, ? extends Number> f1 = (Short x) -> x; // works
    Function1<? extends Short, ? extends Number> f2 = Test::foo; // does not work
  }
}
interface Function0<R> {
  public R apply();
}
interface Function1<P, R> {
  public R apply(P x);
}

Test Case Characteristics: Single Abstract Method (SAM), Function type, Use-site variance, Lambda, Subtyping, Function reference

#133 AssertionError when combining pattern matching and function closure -- Fixed
Link: https://bugs.openjdk.java.net/browse/JDK-8269738
Date found: 2021-06-30
Status: Resolved
Resolution: Fixed
Resolution date: 2021-07-08
Symptom: Crash
Test case:
```
import java.util.function.Supplier;
class Test {
 static A x = null;
 static char tmp = (
 (Test.x instanceof B b) ? ((Supplier) () -> b).get() : null
 ).field;
}
class A {}
class B extends A {
 char field = 'd';
}
```
Test Case Characteristics: Function type, Flow typing, Lambda
Fix Commit(s):
- https://github.com/openjdk/jdk/commit/9e75f922b17
#134 Compile-time error when using wildcard as type argument
Link: https://bugs.openjdk.java.net/browse/JDK-8269586
Date found: 2021-06-24
Status: Resolved
Resolution: Not an Issue
Resolution date: 2021-09-16
Symptom: Unexpected compile-time error
Test case:
```
abstract class ClsA<M> {
 public ClsA() {}
}
class ClsB<X, Y extends ClsA<? super X>> {
 public ClsB() {
 super();
 }
}
class ClsC {
 public ClsC() {
 super();
 }
 public final void foo(ClsB<? extends Integer, ? extends ClsA<Integer>> bar) {}
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter, Use-site variance
#135 Misleading report with type variables when extending one of the type arguments
Link: https://bugs.openjdk.java.net/browse/JDK-8268159
Date found: 2021-06-02
Status: Open
Symptom: Unexpected compile-time error
Test case:
```
class Foo<T1, T2 extends Number> {}
class Bar<T1, T2> {
 Foo<T1, T1> x;
}
```
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameter
#136 javac crashes at com.sun.tools.javac.code.Types$7.visitType with AssertionError
Link: https://bugs.openjdk.java.net/browse/JDK-8267220
Date found: 2021-05-14
Status: Closed
Resolution: Duplicate
Resolution date: 2021-05-17
Symptom: Crash
Test case:
```
public class Test
{
  static final Double foo() {
    Double bar = 1.1;
    return ((true) ? bar : (Double) (() -> 10.0));
  }
}
```
Test Case Characteristics: Conditionals, Lambda
#137 Unexpected compile-time error when combining generic function and function ref
Link: https://bugs.openjdk.java.net/browse/JDK-8276081
Date found: 2021-10-22
Status: New
Symptom: Unexpected compile-time error
Test case:
```
import java.util.function.Function;
class Foo {
 public static <Y> String m(String x) {
 return x;
 }
}
class Test {
 <T> void foo(String x, Function<T, String> y) {}
 void test() {
 foo("F", Foo::m);
 }
}
```
Test Case Characteristics: Function type, Parameterized function, Function reference