1 /*
   2  * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 import java.lang.annotation.*;
  24 import static java.lang.annotation.ElementType.*;
  25 import static java.lang.annotation.RetentionPolicy.*;
  26 
  27 import java.util.*;
  28 import java.io.*;
  29 
  30 /*
  31  * @test
  32  * @summary compiler accepts all values
  33  * @author Mahmood Ali
  34  * @author Yuri Gaevsky
  35  * @compile TargetTypes.java
  36  */
  37 
  38 @Target({TYPE_USE, TYPE_PARAMETER, TYPE})
  39 @Retention(RetentionPolicy.RUNTIME)
  40 @interface A {}
  41 
  42 /** wildcard bound */
  43 class T0x1C {
  44     void m0x1C(List<? extends @A String> lst) {}
  45 }
  46 
  47 /** wildcard bound generic/array */
  48 class T0x1D<T> {
  49     void m0x1D(List<? extends @A List<int[]>> lst) {}
  50 }
  51 
  52 /** typecast */
  53 class T0x00 {
  54     void m0x00(Long l1) {
  55         Object l2 = (@A Long) l1;
  56     }
  57 }
  58 
  59 /** typecast generic/array */
  60 class T0x01<T> {
  61     void m0x01(List<T> list) {
  62         List<T> l = (List<@A T>) list;
  63     }
  64 }
  65 
  66 /** instanceof */
  67 class T0x02 {
  68     boolean m0x02(String s) {
  69         return (s instanceof @A String);
  70     }
  71 }
  72 
  73 /** object creation (new) */
  74 class T0x04 {
  75     void m0x04() {
  76         new @A ArrayList<String>();
  77     }
  78 }
  79 
  80 /** local variable */
  81 class T0x08 {
  82     void m0x08() {
  83       @A String s = null;
  84     }
  85 }
  86 
  87 /** method parameter generic/array */
  88 class T0x0D {
  89     void m0x0D(HashMap<@A Object, List<@A List<@A Class>>> s1) {}
  90 }
  91 
  92 /** method receiver */
  93 class T0x06 {
  94     void m0x06(@A T0x06 this) {}
  95 }
  96 
  97 /** method return type generic/array */
  98 class T0x0B {
  99     Class<@A Object> m0x0B() { return null; }
 100 }
 101 
 102 /** field generic/array */
 103 class T0x0F {
 104     HashMap<@A Object, @A Object> c1;
 105 }
 106 
 107 /** method type parameter */
 108 class T0x20<T, U> {
 109     <@A T, @A U> void m0x20() {}
 110 }
 111 
 112 /** class type parameter */
 113 class T0x22<@A T, @A U> {
 114 }
 115 
 116 /** class type parameter bound */
 117 class T0x10<T extends @A Object> {
 118 }
 119 
 120 /** method type parameter bound */
 121 class T0x12<T> {
 122     <T extends @A Object> void m0x12() {}
 123 }
 124 
 125 /** class type parameter bound generic/array */
 126 class T0x11<T extends List<@A T>> {
 127 }
 128 
 129 
 130 /** method type parameter bound generic/array */
 131 class T0x13 {
 132     static <T extends Comparable<@A T>> T m0x13() {
 133         return null;
 134     }
 135 }
 136 
 137 /** class extends/implements generic/array */
 138 class T0x15<T> extends ArrayList<@A T> {
 139 }
 140 
 141 /** type test (instanceof) generic/array */
 142 class T0x03<T> {
 143     void m0x03(T typeObj, Object obj) {
 144         boolean ok = obj instanceof String @A [];
 145     }
 146 }
 147 
 148 /** object creation (new) generic/array */
 149 class T0x05<T> {
 150     void m0x05() {
 151         new ArrayList<@A T>();
 152     }
 153 }
 154 
 155 /** local variable generic/array */
 156 class T0x09<T> {
 157     void g() {
 158         List<@A String> l = null;
 159     }
 160 
 161     void a() {
 162         String @A [] as = null;
 163     }
 164 }
 165 
 166 /** type argument in constructor call generic/array */
 167 class T0x19 {
 168     <T> T0x19() {}
 169 
 170     void g() {
 171        new <List<@A String>> T0x19();
 172     }
 173 }
 174 
 175 /** type argument in method call generic/array */
 176 class T0x1B<T> {
 177     void m0x1B() {
 178         Collections.<T @A []>emptyList();
 179     }
 180 }
 181 
 182 /** type argument in constructor call */
 183 class T0x18<T> {
 184     <T> T0x18() {}
 185 
 186     void m() {
 187         new <@A Integer> T0x18();
 188     }
 189 }
 190 
 191 /** type argument in method call */
 192 class T0x1A<T,U> {
 193     public static <T, U> T m() { return null; }
 194     static void m0x1A() {
 195         T0x1A.<@A Integer, @A Short>m();
 196     }
 197 }
 198 
 199 /** class extends/implements */
 200 class T0x14 extends @A Object implements @A Serializable, @A Cloneable {
 201 }
 202 
 203 /** exception type in throws */
 204 class T0x16 {
 205     void m0x16() throws @A Exception {}
 206 }