[ 
https://issues.apache.org/jira/browse/GROOVY-12754?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18141666#comment-18141666
 ] 

ASF GitHub Bot commented on GROOVY-12754:
-----------------------------------------

codeconsole opened a new pull request, #3285:
URL: https://github.com/apache/groovy/pull/3285

   https://issues.apache.org/jira/browse/GROOVY-12754
   
   `compatibleConnection` checked an upper-bounded wildcard argument against 
the bound of a method's type parameter the wrong way round, asking whether the 
bound fits within `? extends B`. So static type checking rejected calls that 
javac accepts:
   
   ```groovy
   static <T extends Number> T first(List<T> list) { list.get(0) }
   static <T extends CharSequence> int len(Class<T> type) { 0 }
   
   static Object a(List<? extends Integer> ints) { first(ints) }
   static int b(Class<? extends String> type) { len(type) }
   ```
   
   And it accepted one that javac rejects, `narrow(List<? extends Number>)` for 
`<T extends Integer> T narrow(List<T>)`, where the statically compiled call 
then returned `1` for `1.5`.
   
   The capture of `? extends B` is a subtype of `B` (JLS 5.1.10), so the 
wildcard is now checked as a type argument `B` is, by testing `? super B` 
against the bound. An unbounded wildcard, one bounded by `Object` or by a type 
variable, and a lower-bounded one keep the existing path. Code like `narrow` 
above, which compiled before, is now rejected, as javac rejects it.
   
   `GenericsJavaCompatibilityTest` gets a positive and a negative case checked 
against javac. `GenericsSTCTest`, and so `GenericsStaticCompileTest`, gets the 
Groovy forms, including a `Class<? extends ArrayList>` for `<T extends 
List<Integer>>`. All of them fail without the change.
   
   Please also apply this to GROOVY_6_0_X, where it cherry-picks cleanly. 
GROOVY-12755 depends on it.
   




> STC: an upper-bounded wildcard argument is checked against a type parameter's 
> bound the wrong way round
> -------------------------------------------------------------------------------------------------------
>
>                 Key: GROOVY-12754
>                 URL: https://issues.apache.org/jira/browse/GROOVY-12754
>             Project: Groovy
>          Issue Type: Bug
>          Components: Static Type Checker
>    Affects Versions: 6.0.0
>            Reporter: Scott Murphy Heiberg
>            Priority: Major
>
> Static type checking rejects a call that passes an upper-bounded wildcard, 
> such as {{List<? extends Integer>}}, to a generic method whose type parameter 
> is bounded by a supertype of the wildcard's bound. It accepts the call when 
> the wildcard's bound is wider than the type parameter's. javac does the 
> opposite in both cases.
> {code:groovy}
> @groovy.transform.CompileStatic
> class C {
>     static <T extends Number> T first(List<T> list) { list.get(0) }
>     static <T extends CharSequence> int len(Class<T> type) { 0 }
>     static <T extends Integer> T narrow(List<T> list) { list.get(0) }
>     static Object a(List<? extends Integer> ints) { first(ints) }  // 
> rejected, javac accepts
>     static int b(Class<? extends String> type) { len(type) }       // 
> rejected, javac accepts
>     static Object c(List<? extends Number> nums) { narrow(nums) }  // 
> accepted, javac rejects
> }
> {code}
> {noformat}
> [Static type checking] - Cannot call <T extends java.lang.Number> 
> C#first(java.util.List<T>) with arguments [java.util.List<? extends 
> java.lang.Integer>]
> [Static type checking] - Cannot call <T extends java.lang.CharSequence> 
> C#len(java.lang.Class<T>) with arguments [java.lang.Class<? extends 
> java.lang.String>]
> {noformat}
> The capture of {{? extends B}} is a subtype of {{B}} (JLS 5.1.10), so it is 
> within the bound of {{T}} exactly when {{B}} is. javac reports "inference 
> variable T has incompatible bounds" for {{c}}. Groovy compiles {{c}}, and 
> {{c([1.5d])}} returns {{1}}.
> {{StaticTypeCheckingSupport#compatibleConnection}} tests a wildcard witness 
> with {{connection.isCompatibleWith(bound)}}, which asks whether the type 
> parameter's bound fits within {{? extends B}}. For a type argument {{B}}, it 
> tests {{? super B}} against the bound. An upper-bounded wildcard should take 
> the same test.



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to