1 /* 2 * Copyright (c) 1999, 2023, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.tools.javac.code; 27 28 import java.lang.annotation.Annotation; 29 import java.util.ArrayDeque; 30 import java.util.Collections; 31 import java.util.EnumMap; 32 import java.util.Map; 33 import java.util.Optional; 34 import java.util.function.Function; 35 import java.util.function.Predicate; 36 37 import javax.lang.model.type.*; 38 39 import com.sun.tools.javac.code.Symbol.*; 40 import com.sun.tools.javac.code.TypeMetadata.Annotations; 41 import com.sun.tools.javac.code.TypeMetadata.ConstantValue; 42 import com.sun.tools.javac.code.Types.TypeMapping; 43 import com.sun.tools.javac.code.Types.UniqueType; 44 import com.sun.tools.javac.comp.Infer.IncorporationAction; 45 import com.sun.tools.javac.jvm.ClassFile; 46 import com.sun.tools.javac.jvm.PoolConstant; 47 import com.sun.tools.javac.util.*; 48 import com.sun.tools.javac.util.DefinedBy.Api; 49 50 import static com.sun.tools.javac.code.BoundKind.*; 51 import static com.sun.tools.javac.code.Flags.*; 52 import static com.sun.tools.javac.code.Kinds.Kind.*; 53 import static com.sun.tools.javac.code.TypeTag.*; 54 55 /** This class represents Java types. The class itself defines the behavior of 56 * the following types: 57 * <pre> 58 * base types (tags: BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, BOOLEAN), 59 * type `void' (tag: VOID), 60 * the bottom type (tag: BOT), 61 * the missing type (tag: NONE). 62 * </pre> 63 * <p>The behavior of the following types is defined in subclasses, which are 64 * all static inner classes of this class: 65 * <pre> 66 * class types (tag: CLASS, class: ClassType), 67 * array types (tag: ARRAY, class: ArrayType), 68 * method types (tag: METHOD, class: MethodType), 69 * package types (tag: PACKAGE, class: PackageType), 70 * type variables (tag: TYPEVAR, class: TypeVar), 71 * type arguments (tag: WILDCARD, class: WildcardType), 72 * generic method types (tag: FORALL, class: ForAll), 73 * the error type (tag: ERROR, class: ErrorType). 74 * </pre> 75 * 76 * <p><b>This is NOT part of any supported API. 77 * If you write code that depends on this, you do so at your own risk. 78 * This code and its internal interfaces are subject to change or 79 * deletion without notice.</b> 80 * 81 * @see TypeTag 82 */ 83 public abstract class Type extends AnnoConstruct implements TypeMirror, PoolConstant { 84 85 /** 86 * Type metadata, Should be {@code null} for the default value. 87 * 88 * Note: it is an invariant that for any {@code TypeMetadata} 89 * class, a given {@code Type} may have at most one metadata array 90 * entry of that class. 91 */ 92 protected final List<TypeMetadata> metadata; 93 94 /** Constant type: no type at all. */ 95 public static final JCNoType noType = new JCNoType() { 96 @Override @DefinedBy(Api.LANGUAGE_MODEL) 97 public String toString() { 98 return "none"; 99 } 100 }; 101 102 /** Constant type: special type to be used during recovery of deferred expressions. */ 103 public static final JCNoType recoveryType = new JCNoType(){ 104 @Override @DefinedBy(Api.LANGUAGE_MODEL) 105 public String toString() { 106 return "recovery"; 107 } 108 }; 109 110 /** Constant type: special type to be used for marking stuck trees. */ 111 public static final JCNoType stuckType = new JCNoType() { 112 @Override @DefinedBy(Api.LANGUAGE_MODEL) 113 public String toString() { 114 return "stuck"; 115 } 116 }; 117 118 /** If this switch is turned on, the names of type variables 119 * and anonymous classes are printed with hashcodes appended. 120 */ 121 public static boolean moreInfo = false; 122 123 /** The defining class / interface / package / type variable. 124 */ 125 public TypeSymbol tsym; 126 127 @Override 128 public int poolTag() { 129 throw new AssertionError("Invalid pool entry"); 130 } 131 132 @Override 133 public Object poolKey(Types types) { 134 return new UniqueType(this, types); 135 } 136 137 /** 138 * Checks if the current type tag is equal to the given tag. 139 * @return true if tag is equal to the current type tag. 140 */ 141 public boolean hasTag(TypeTag tag) { 142 return tag == getTag(); 143 } 144 145 /** 146 * Returns the current type tag. 147 * @return the value of the current type tag. 148 */ 149 public abstract TypeTag getTag(); 150 151 public boolean isNumeric() { 152 return false; 153 } 154 155 public boolean isIntegral() { 156 return false; 157 } 158 159 public boolean isPrimitive() { 160 return false; 161 } 162 163 public boolean isPrimitiveOrVoid() { 164 return false; 165 } 166 167 public boolean isReference() { 168 return false; 169 } 170 171 public boolean isNullOrReference() { 172 return false; 173 } 174 175 public boolean isPartial() { 176 return false; 177 } 178 179 /** 180 * The constant value of this type, null if this type does not 181 * have a constant value attribute. Only primitive types and 182 * strings (ClassType) can have a constant value attribute. 183 * @return the constant value attribute of this type 184 */ 185 public Object constValue() { 186 return getMetadata(TypeMetadata.ConstantValue.class, ConstantValue::value, null); 187 } 188 189 /** Is this a constant type whose value is false? 190 */ 191 public boolean isFalse() { 192 return false; 193 } 194 195 /** Is this a constant type whose value is true? 196 */ 197 public boolean isTrue() { 198 return false; 199 } 200 201 /** 202 * Get the representation of this type used for modelling purposes. 203 * By default, this is itself. For ErrorType, a different value 204 * may be provided. 205 */ 206 public Type getModelType() { 207 return this; 208 } 209 210 public static List<Type> getModelTypes(List<Type> ts) { 211 ListBuffer<Type> lb = new ListBuffer<>(); 212 for (Type t: ts) 213 lb.append(t.getModelType()); 214 return lb.toList(); 215 } 216 217 /**For ErrorType, returns the original type, otherwise returns the type itself. 218 */ 219 public Type getOriginalType() { 220 return this; 221 } 222 223 public <R,S> R accept(Type.Visitor<R,S> v, S s) { return v.visitType(this, s); } 224 225 /** Define a type given its tag, type symbol, and type annotations 226 */ 227 228 public Type(TypeSymbol tsym, List<TypeMetadata> metadata) { 229 Assert.checkNonNull(metadata); 230 this.tsym = tsym; 231 this.metadata = metadata; 232 } 233 234 /** 235 * A subclass of {@link Types.TypeMapping} which applies a mapping recursively to the subterms 236 * of a given type expression. This mapping returns the original type is no changes occurred 237 * when recursively mapping the original type's subterms. 238 */ 239 public abstract static class StructuralTypeMapping<S> extends Types.TypeMapping<S> { 240 241 @Override 242 public Type visitClassType(ClassType t, S s) { 243 Type outer = t.getEnclosingType(); 244 Type outer1 = visit(outer, s); 245 List<Type> typarams = t.getTypeArguments(); 246 List<Type> typarams1 = visit(typarams, s); 247 if (outer1 == outer && typarams1 == typarams) return t; 248 else return new ClassType(outer1, typarams1, t.tsym, t.metadata) { 249 @Override 250 protected boolean needsStripping() { 251 return true; 252 } 253 }; 254 } 255 256 @Override 257 public Type visitWildcardType(WildcardType wt, S s) { 258 Type t = wt.type; 259 if (t != null) 260 t = visit(t, s); 261 if (t == wt.type) 262 return wt; 263 else 264 return new WildcardType(t, wt.kind, wt.tsym, wt.bound, wt.metadata) { 265 @Override 266 protected boolean needsStripping() { 267 return true; 268 } 269 }; 270 } 271 272 @Override 273 public Type visitArrayType(ArrayType t, S s) { 274 Type elemtype = t.elemtype; 275 Type elemtype1 = visit(elemtype, s); 276 if (elemtype1 == elemtype) return t; 277 else return new ArrayType(elemtype1, t.tsym, t.metadata) { 278 @Override 279 protected boolean needsStripping() { 280 return true; 281 } 282 }; 283 } 284 285 @Override 286 public Type visitMethodType(MethodType t, S s) { 287 List<Type> argtypes = t.argtypes; 288 Type restype = t.restype; 289 List<Type> thrown = t.thrown; 290 List<Type> argtypes1 = visit(argtypes, s); 291 Type restype1 = visit(restype, s); 292 List<Type> thrown1 = visit(thrown, s); 293 if (argtypes1 == argtypes && 294 restype1 == restype && 295 thrown1 == thrown) return t; 296 else return new MethodType(argtypes1, restype1, thrown1, t.tsym) { 297 @Override 298 protected boolean needsStripping() { 299 return true; 300 } 301 }; 302 } 303 304 @Override 305 public Type visitForAll(ForAll t, S s) { 306 return visit(t.qtype, s); 307 } 308 } 309 310 /** map a type function over all immediate descendants of this type 311 */ 312 public <Z> Type map(TypeMapping<Z> mapping, Z arg) { 313 return mapping.visit(this, arg); 314 } 315 316 /** map a type function over all immediate descendants of this type (no arg version) 317 */ 318 public <Z> Type map(TypeMapping<Z> mapping) { 319 return mapping.visit(this, null); 320 } 321 322 /** Define a constant type, of the same kind as this type 323 * and with given constant value 324 */ 325 public Type constType(Object constValue) { 326 throw new AssertionError(); 327 } 328 329 /** 330 * If this is a constant type, return its underlying type. 331 * Otherwise, return the type itself. 332 */ 333 public Type baseType() { 334 return this; 335 } 336 337 /** 338 * Returns the original version of this type, before metadata were added. This routine is meant 339 * for internal use only (i.e. {@link Type#equalsIgnoreMetadata(Type)}, {@link Type#stripMetadata}); 340 * it should not be used outside this class. 341 */ 342 protected Type typeNoMetadata() { 343 return metadata.isEmpty() ? this : baseType(); 344 } 345 346 /** 347 * Create a new copy of this type but with the specified TypeMetadata. 348 * Only to be used internally! 349 */ 350 protected Type cloneWithMetadata(List<TypeMetadata> metadata) { 351 throw new AssertionError("Cannot add metadata to this type: " + getTag()); 352 } 353 354 /** 355 * Get all the type metadata associated with this type. 356 */ 357 public List<TypeMetadata> getMetadata() { 358 return metadata; 359 } 360 361 /** 362 * Get the type metadata of the given kind associated with this type (if any). 363 */ 364 @SuppressWarnings("unchecked") 365 public <M extends TypeMetadata> M getMetadata(Class<M> metadataClass) { 366 return getMetadata(metadataClass, Function.identity(), null); 367 } 368 369 /** 370 * Get the type metadata of the given kind associated with this type (if any), 371 * and apply the provided mapping function. 372 */ 373 @SuppressWarnings("unchecked") 374 public <M extends TypeMetadata, Z> Z getMetadata(Class<M> metadataClass, Function<M, Z> metadataFunc, Z defaultValue) { 375 for (TypeMetadata m : metadata) { 376 if (m.getClass() == metadataClass) { 377 return metadataFunc.apply((M)m); 378 } 379 } 380 return defaultValue; 381 } 382 383 /** 384 * Create a new copy of this type but with the specified type metadata. 385 * If this type is already associated with a type metadata of the same class, 386 * an exception is thrown. 387 */ 388 public Type addMetadata(TypeMetadata md) { 389 Assert.check(getMetadata(md.getClass()) == null); 390 return cloneWithMetadata(metadata.prepend(md)); 391 } 392 393 /** 394 * Create a new copy of this type but without the specified type metadata. 395 */ 396 public Type dropMetadata(Class<? extends TypeMetadata> metadataClass) { 397 List<TypeMetadata> newMetadata = List.nil(); 398 for (TypeMetadata m : metadata) { 399 if (m.getClass() != metadataClass) { 400 newMetadata = newMetadata.prepend(m); 401 } 402 } 403 return cloneWithMetadata(newMetadata); 404 } 405 406 /** 407 * Does this type require annotation stripping for API clients? 408 */ 409 protected boolean needsStripping() { 410 return false; 411 } 412 413 /** 414 * Strip all metadata associated with this type - this could return a new clone of the type. 415 * This routine is only used to present the correct annotated types back to the users when types 416 * are accessed through compiler APIs; it should not be used anywhere in the compiler internals 417 * as doing so might result in performance penalties. 418 */ 419 public Type stripMetadataIfNeeded() { 420 return needsStripping() ? 421 accept(stripMetadata, null) : 422 this; 423 } 424 425 public Type stripMetadata() { 426 return accept(stripMetadata, null); 427 } 428 //where 429 private static final TypeMapping<Void> stripMetadata = new StructuralTypeMapping<Void>() { 430 @Override 431 public Type visitClassType(ClassType t, Void aVoid) { 432 return super.visitClassType((ClassType)t.typeNoMetadata(), aVoid); 433 } 434 435 @Override 436 public Type visitArrayType(ArrayType t, Void aVoid) { 437 return super.visitArrayType((ArrayType)t.typeNoMetadata(), aVoid); 438 } 439 440 @Override 441 public Type visitTypeVar(TypeVar t, Void aVoid) { 442 return super.visitTypeVar((TypeVar)t.typeNoMetadata(), aVoid); 443 } 444 445 @Override 446 public Type visitWildcardType(WildcardType wt, Void aVoid) { 447 return super.visitWildcardType((WildcardType)wt.typeNoMetadata(), aVoid); 448 } 449 }; 450 451 public Type preannotatedType() { 452 return addMetadata(new Annotations()); 453 } 454 455 public Type annotatedType(final List<Attribute.TypeCompound> annos) { 456 return addMetadata(new Annotations(annos)); 457 } 458 459 public boolean isAnnotated() { 460 return getMetadata(TypeMetadata.Annotations.class) != null; 461 } 462 463 @Override @DefinedBy(Api.LANGUAGE_MODEL) 464 public List<Attribute.TypeCompound> getAnnotationMirrors() { 465 return getMetadata(TypeMetadata.Annotations.class, Annotations::annotations, List.nil()); 466 } 467 468 469 @Override @DefinedBy(Api.LANGUAGE_MODEL) 470 public <A extends Annotation> A getAnnotation(Class<A> annotationType) { 471 return null; 472 } 473 474 475 @Override @DefinedBy(Api.LANGUAGE_MODEL) 476 public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) { 477 @SuppressWarnings("unchecked") 478 A[] tmp = (A[]) java.lang.reflect.Array.newInstance(annotationType, 0); 479 return tmp; 480 } 481 482 /** Return the base types of a list of types. 483 */ 484 public static List<Type> baseTypes(List<Type> ts) { 485 if (ts.nonEmpty()) { 486 Type t = ts.head.baseType(); 487 List<Type> baseTypes = baseTypes(ts.tail); 488 if (t != ts.head || baseTypes != ts.tail) 489 return baseTypes.prepend(t); 490 } 491 return ts; 492 } 493 494 protected void appendAnnotationsString(StringBuilder sb, 495 boolean prefix) { 496 if (isAnnotated()) { 497 if (prefix) { 498 sb.append(" "); 499 } 500 sb.append(getAnnotationMirrors()); 501 sb.append(" "); 502 } 503 } 504 505 protected void appendAnnotationsString(StringBuilder sb) { 506 appendAnnotationsString(sb, false); 507 } 508 509 /** The Java source which this type represents. 510 */ 511 @DefinedBy(Api.LANGUAGE_MODEL) 512 public String toString() { 513 StringBuilder sb = new StringBuilder(); 514 appendAnnotationsString(sb); 515 if (tsym == null || tsym.name == null) { 516 sb.append("<none>"); 517 } else { 518 sb.append(tsym.name.toString()); 519 } 520 if (moreInfo && hasTag(TYPEVAR)) { 521 sb.append(hashCode()); 522 } 523 return sb.toString(); 524 } 525 526 /** 527 * The Java source which this type list represents. A List is 528 * represented as a comma-separated listing of the elements in 529 * that list. 530 */ 531 public static String toString(List<Type> ts) { 532 if (ts.isEmpty()) { 533 return ""; 534 } else { 535 StringBuilder buf = new StringBuilder(); 536 buf.append(ts.head.toString()); 537 for (List<Type> l = ts.tail; l.nonEmpty(); l = l.tail) 538 buf.append(",").append(l.head.toString()); 539 return buf.toString(); 540 } 541 } 542 543 /** 544 * The constant value of this type, converted to String 545 */ 546 public String stringValue() { 547 Object cv = Assert.checkNonNull(constValue()); 548 return cv.toString(); 549 } 550 551 /** 552 * Override this method with care. For most Type instances this should behave as ==. 553 */ 554 @Override @DefinedBy(Api.LANGUAGE_MODEL) 555 public boolean equals(Object t) { 556 return this == t; 557 } 558 559 public boolean equalsIgnoreMetadata(Type t) { 560 return typeNoMetadata().equals(t.typeNoMetadata()); 561 } 562 563 @Override @DefinedBy(Api.LANGUAGE_MODEL) 564 public int hashCode() { 565 return super.hashCode(); 566 } 567 568 public String argtypes(boolean varargs) { 569 List<Type> args = getParameterTypes(); 570 if (!varargs) return args.toString(); 571 StringBuilder buf = new StringBuilder(); 572 while (args.tail.nonEmpty()) { 573 buf.append(args.head); 574 args = args.tail; 575 buf.append(','); 576 } 577 if (args.head.hasTag(ARRAY)) { 578 buf.append(((ArrayType)args.head).elemtype); 579 if (args.head.getAnnotationMirrors().nonEmpty()) { 580 buf.append(args.head.getAnnotationMirrors()); 581 } 582 buf.append("..."); 583 } else { 584 buf.append(args.head); 585 } 586 return buf.toString(); 587 } 588 589 /** Access methods. 590 */ 591 public List<Type> getTypeArguments() { return List.nil(); } 592 public Type getEnclosingType() { return null; } 593 public List<Type> getParameterTypes() { return List.nil(); } 594 public Type getReturnType() { return null; } 595 public Type getReceiverType() { return null; } 596 public List<Type> getThrownTypes() { return List.nil(); } 597 public Type getUpperBound() { return null; } 598 public Type getLowerBound() { return null; } 599 600 /** Navigation methods, these will work for classes, type variables, 601 * foralls, but will return null for arrays and methods. 602 */ 603 604 /** Return all parameters of this type and all its outer types in order 605 * outer (first) to inner (last). 606 */ 607 public List<Type> allparams() { return List.nil(); } 608 609 /** Does this type contain "error" elements? 610 */ 611 public boolean isErroneous() { 612 return false; 613 } 614 615 public static boolean isErroneous(List<Type> ts) { 616 for (List<Type> l = ts; l.nonEmpty(); l = l.tail) 617 if (l.head.isErroneous()) return true; 618 return false; 619 } 620 621 /** Is this type parameterized? 622 * A class type is parameterized if it has some parameters. 623 * An array type is parameterized if its element type is parameterized. 624 * All other types are not parameterized. 625 */ 626 public boolean isParameterized() { 627 return false; 628 } 629 630 /** Is this type a raw type? 631 * A class type is a raw type if it misses some of its parameters. 632 * An array type is a raw type if its element type is raw. 633 * All other types are not raw. 634 * Type validation will ensure that the only raw types 635 * in a program are types that miss all their type variables. 636 */ 637 public boolean isRaw() { 638 return false; 639 } 640 641 /** 642 * A compound type is a special class type whose supertypes are used to store a list 643 * of component types. There are two kinds of compound types: (i) intersection types 644 * {@link IntersectionClassType} and (ii) union types {@link UnionClassType}. 645 */ 646 public boolean isCompound() { 647 return false; 648 } 649 650 public boolean isIntersection() { 651 return false; 652 } 653 654 public boolean isUnion() { 655 return false; 656 } 657 658 public boolean isInterface() { 659 return (tsym.flags() & INTERFACE) != 0; 660 } 661 662 public boolean isFinal() { 663 return (tsym.flags() & FINAL) != 0; 664 } 665 666 /** 667 * Does this type contain occurrences of type t? 668 */ 669 public boolean contains(Type t) { 670 return t.equalsIgnoreMetadata(this); 671 } 672 673 public static boolean contains(List<Type> ts, Type t) { 674 for (List<Type> l = ts; 675 l.tail != null /*inlined: l.nonEmpty()*/; 676 l = l.tail) 677 if (l.head.contains(t)) return true; 678 return false; 679 } 680 681 /** Does this type contain an occurrence of some type in 'ts'? 682 */ 683 public boolean containsAny(List<Type> ts) { 684 for (Type t : ts) 685 if (this.contains(t)) return true; 686 return false; 687 } 688 689 public static boolean containsAny(List<Type> ts1, List<Type> ts2) { 690 for (Type t : ts1) 691 if (t.containsAny(ts2)) return true; 692 return false; 693 } 694 695 public static List<Type> filter(List<Type> ts, Predicate<Type> tf) { 696 ListBuffer<Type> buf = new ListBuffer<>(); 697 for (Type t : ts) { 698 if (tf.test(t)) { 699 buf.append(t); 700 } 701 } 702 return buf.toList(); 703 } 704 705 public boolean isSuperBound() { return false; } 706 public boolean isExtendsBound() { return false; } 707 public boolean isUnbound() { return false; } 708 public Type withTypeVar(Type t) { return this; } 709 710 /** The underlying method type of this type. 711 */ 712 public MethodType asMethodType() { throw new AssertionError(); } 713 714 /** Complete loading all classes in this type. 715 */ 716 public void complete() {} 717 718 public TypeSymbol asElement() { 719 return tsym; 720 } 721 722 @Override @DefinedBy(Api.LANGUAGE_MODEL) 723 public TypeKind getKind() { 724 return TypeKind.OTHER; 725 } 726 727 @Override @DefinedBy(Api.LANGUAGE_MODEL) 728 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 729 throw new AssertionError(); 730 } 731 732 public static class JCPrimitiveType extends Type 733 implements javax.lang.model.type.PrimitiveType { 734 735 TypeTag tag; 736 737 public JCPrimitiveType(TypeTag tag, TypeSymbol tsym) { 738 this(tag, tsym, List.nil()); 739 } 740 741 private JCPrimitiveType(TypeTag tag, TypeSymbol tsym, List<TypeMetadata> metadata) { 742 super(tsym, metadata); 743 this.tag = tag; 744 Assert.check(tag.isPrimitive); 745 } 746 747 @Override 748 protected JCPrimitiveType cloneWithMetadata(List<TypeMetadata> md) { 749 return new JCPrimitiveType(tag, tsym, md) { 750 @Override 751 public Type baseType() { return JCPrimitiveType.this.baseType(); } 752 }; 753 } 754 755 @Override 756 public boolean isNumeric() { 757 return tag != BOOLEAN; 758 } 759 760 @Override 761 public boolean isIntegral() { 762 switch (tag) { 763 case CHAR: 764 case BYTE: 765 case SHORT: 766 case INT: 767 case LONG: 768 return true; 769 default: 770 return false; 771 } 772 } 773 774 @Override 775 public boolean isPrimitive() { 776 return true; 777 } 778 779 @Override 780 public TypeTag getTag() { 781 return tag; 782 } 783 784 @Override 785 public boolean isPrimitiveOrVoid() { 786 return true; 787 } 788 789 /** Define a constant type, of the same kind as this type 790 * and with given constant value 791 */ 792 @Override 793 public Type constType(Object constValue) { 794 return addMetadata(new ConstantValue(constValue)); 795 } 796 797 /** 798 * The constant value of this type, converted to String 799 */ 800 @Override 801 public String stringValue() { 802 Object cv = Assert.checkNonNull(constValue()); 803 if (tag == BOOLEAN) { 804 return ((Integer) cv).intValue() == 0 ? "false" : "true"; 805 } 806 else if (tag == CHAR) { 807 return String.valueOf((char) ((Integer) cv).intValue()); 808 } 809 else { 810 return cv.toString(); 811 } 812 } 813 814 /** Is this a constant type whose value is false? 815 */ 816 @Override 817 public boolean isFalse() { 818 return 819 tag == BOOLEAN && 820 constValue() != null && 821 ((Integer)constValue()).intValue() == 0; 822 } 823 824 /** Is this a constant type whose value is true? 825 */ 826 @Override 827 public boolean isTrue() { 828 return 829 tag == BOOLEAN && 830 constValue() != null && 831 ((Integer)constValue()).intValue() != 0; 832 } 833 834 @Override @DefinedBy(Api.LANGUAGE_MODEL) 835 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 836 return v.visitPrimitive(this, p); 837 } 838 839 @Override @DefinedBy(Api.LANGUAGE_MODEL) 840 public TypeKind getKind() { 841 switch (tag) { 842 case BYTE: return TypeKind.BYTE; 843 case CHAR: return TypeKind.CHAR; 844 case SHORT: return TypeKind.SHORT; 845 case INT: return TypeKind.INT; 846 case LONG: return TypeKind.LONG; 847 case FLOAT: return TypeKind.FLOAT; 848 case DOUBLE: return TypeKind.DOUBLE; 849 case BOOLEAN: return TypeKind.BOOLEAN; 850 } 851 throw new AssertionError(); 852 } 853 854 } 855 856 public static class WildcardType extends Type 857 implements javax.lang.model.type.WildcardType { 858 859 public Type type; 860 public BoundKind kind; 861 public TypeVar bound; 862 863 @Override 864 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 865 return v.visitWildcardType(this, s); 866 } 867 868 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym) { 869 this(type, kind, tsym, null, List.nil()); 870 } 871 872 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, 873 List<TypeMetadata> metadata) { 874 this(type, kind, tsym, null, metadata); 875 } 876 877 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, 878 TypeVar bound) { 879 this(type, kind, tsym, bound, List.nil()); 880 } 881 882 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, 883 TypeVar bound, List<TypeMetadata> metadata) { 884 super(tsym, metadata); 885 this.type = Assert.checkNonNull(type); 886 this.kind = kind; 887 this.bound = bound; 888 } 889 890 @Override 891 protected WildcardType cloneWithMetadata(List<TypeMetadata> md) { 892 return new WildcardType(type, kind, tsym, bound, md) { 893 @Override 894 public Type baseType() { return WildcardType.this.baseType(); } 895 }; 896 } 897 898 @Override 899 public TypeTag getTag() { 900 return WILDCARD; 901 } 902 903 @Override 904 public boolean contains(Type t) { 905 return kind != UNBOUND && type.contains(t); 906 } 907 908 public boolean isSuperBound() { 909 return kind == SUPER || 910 kind == UNBOUND; 911 } 912 public boolean isExtendsBound() { 913 return kind == EXTENDS || 914 kind == UNBOUND; 915 } 916 public boolean isUnbound() { 917 // is it `?` or `? extends Object`? 918 return kind == UNBOUND || 919 (kind == EXTENDS && type.tsym.flatName() == type.tsym.name.table.names.java_lang_Object); 920 } 921 922 @Override 923 public boolean isReference() { 924 return true; 925 } 926 927 @Override 928 public boolean isNullOrReference() { 929 return true; 930 } 931 932 @Override 933 public Type withTypeVar(Type t) { 934 //-System.err.println(this+".withTypeVar("+t+");");//DEBUG 935 if (bound == t) 936 return this; 937 bound = (TypeVar)t; 938 return this; 939 } 940 941 boolean isPrintingBound = false; 942 @DefinedBy(Api.LANGUAGE_MODEL) 943 public String toString() { 944 StringBuilder s = new StringBuilder(); 945 appendAnnotationsString(s); 946 s.append(kind.toString()); 947 if (kind != UNBOUND) 948 s.append(type); 949 if (moreInfo && bound != null && !isPrintingBound) 950 try { 951 isPrintingBound = true; 952 s.append("{:").append(bound.getUpperBound()).append(":}"); 953 } finally { 954 isPrintingBound = false; 955 } 956 return s.toString(); 957 } 958 959 @DefinedBy(Api.LANGUAGE_MODEL) 960 public Type getExtendsBound() { 961 if (kind == EXTENDS) 962 return type; 963 else 964 return null; 965 } 966 967 @DefinedBy(Api.LANGUAGE_MODEL) 968 public Type getSuperBound() { 969 if (kind == SUPER) 970 return type; 971 else 972 return null; 973 } 974 975 @DefinedBy(Api.LANGUAGE_MODEL) 976 public TypeKind getKind() { 977 return TypeKind.WILDCARD; 978 } 979 980 @DefinedBy(Api.LANGUAGE_MODEL) 981 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 982 return v.visitWildcard(this, p); 983 } 984 } 985 986 public static class ClassType extends Type implements DeclaredType, LoadableConstant, 987 javax.lang.model.type.ErrorType { 988 989 /** The enclosing type of this type. If this is the type of an inner 990 * class, outer_field refers to the type of its enclosing 991 * instance class, in all other cases it refers to noType. 992 */ 993 private Type outer_field; 994 995 /** The type parameters of this type (to be set once class is loaded). 996 */ 997 public List<Type> typarams_field; 998 999 /** A cache variable for the type parameters of this type, 1000 * appended to all parameters of its enclosing class. 1001 * @see #allparams 1002 */ 1003 public List<Type> allparams_field; 1004 1005 /** The supertype of this class (to be set once class is loaded). 1006 */ 1007 public Type supertype_field; 1008 1009 /** The interfaces of this class (to be set once class is loaded). 1010 */ 1011 public List<Type> interfaces_field; 1012 1013 /** All the interfaces of this class, including missing ones. 1014 */ 1015 public List<Type> all_interfaces_field; 1016 1017 public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym) { 1018 this(outer, typarams, tsym, List.nil()); 1019 } 1020 1021 public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym, 1022 List<TypeMetadata> metadata) { 1023 super(tsym, metadata); 1024 this.outer_field = outer; 1025 this.typarams_field = typarams; 1026 this.allparams_field = null; 1027 this.supertype_field = null; 1028 this.interfaces_field = null; 1029 } 1030 1031 public int poolTag() { 1032 return ClassFile.CONSTANT_Class; 1033 } 1034 1035 @Override 1036 protected ClassType cloneWithMetadata(List<TypeMetadata> md) { 1037 return new ClassType(outer_field, typarams_field, tsym, md) { 1038 @Override 1039 public Type baseType() { return ClassType.this.baseType(); } 1040 }; 1041 } 1042 1043 @Override 1044 public TypeTag getTag() { 1045 return CLASS; 1046 } 1047 1048 @Override 1049 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1050 return v.visitClassType(this, s); 1051 } 1052 1053 public Type constType(Object constValue) { 1054 return addMetadata(new ConstantValue(constValue)); 1055 } 1056 1057 /** The Java source which this type represents. 1058 */ 1059 @DefinedBy(Api.LANGUAGE_MODEL) 1060 public String toString() { 1061 StringBuilder buf = new StringBuilder(); 1062 if (getEnclosingType().hasTag(CLASS) && tsym.owner.kind == TYP) { 1063 buf.append(getEnclosingType().toString()); 1064 buf.append("."); 1065 appendAnnotationsString(buf); 1066 buf.append(className(tsym, false)); 1067 } else { 1068 if (isAnnotated()) { 1069 if (!tsym.packge().isUnnamed()) { 1070 buf.append(tsym.packge()); 1071 buf.append("."); 1072 } 1073 ListBuffer<Name> names = new ListBuffer<>(); 1074 for (Symbol sym = tsym.owner; sym != null && sym.kind == TYP; sym = sym.owner) { 1075 names.prepend(sym.name); 1076 } 1077 for (Name name : names) { 1078 buf.append(name); 1079 buf.append("."); 1080 } 1081 appendAnnotationsString(buf); 1082 buf.append(tsym.name); 1083 } else { 1084 buf.append(className(tsym, true)); 1085 } 1086 } 1087 1088 if (getTypeArguments().nonEmpty()) { 1089 buf.append('<'); 1090 buf.append(getTypeArguments().toString()); 1091 buf.append(">"); 1092 } 1093 return buf.toString(); 1094 } 1095 //where 1096 private String className(Symbol sym, boolean longform) { 1097 if (sym.name.isEmpty() && (sym.flags() & COMPOUND) != 0) { 1098 StringBuilder s = new StringBuilder(supertype_field.toString()); 1099 for (List<Type> is=interfaces_field; is.nonEmpty(); is = is.tail) { 1100 s.append("&"); 1101 s.append(is.head.toString()); 1102 } 1103 return s.toString(); 1104 } else if (sym.name.isEmpty()) { 1105 String s; 1106 ClassType norm = (ClassType) tsym.type; 1107 if (norm == null) { 1108 s = Log.getLocalizedString("anonymous.class", (Object)null); 1109 } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) { 1110 s = Log.getLocalizedString("anonymous.class", 1111 norm.interfaces_field.head); 1112 } else { 1113 s = Log.getLocalizedString("anonymous.class", 1114 norm.supertype_field); 1115 } 1116 if (moreInfo) 1117 s += String.valueOf(sym.hashCode()); 1118 return s; 1119 } else if (longform) { 1120 return sym.getQualifiedName().toString(); 1121 } else { 1122 return sym.name.toString(); 1123 } 1124 } 1125 1126 @DefinedBy(Api.LANGUAGE_MODEL) 1127 public List<Type> getTypeArguments() { 1128 if (typarams_field == null) { 1129 complete(); 1130 if (typarams_field == null) 1131 typarams_field = List.nil(); 1132 } 1133 return typarams_field; 1134 } 1135 1136 public boolean hasErasedSupertypes() { 1137 return isRaw(); 1138 } 1139 1140 @DefinedBy(Api.LANGUAGE_MODEL) 1141 public Type getEnclosingType() { 1142 return outer_field; 1143 } 1144 1145 public void setEnclosingType(Type outer) { 1146 outer_field = outer; 1147 } 1148 1149 public List<Type> allparams() { 1150 if (allparams_field == null) { 1151 allparams_field = getTypeArguments().prependList(getEnclosingType().allparams()); 1152 } 1153 return allparams_field; 1154 } 1155 1156 public boolean isErroneous() { 1157 return 1158 getEnclosingType().isErroneous() || 1159 isErroneous(getTypeArguments()) || 1160 this != tsym.type && tsym.type.isErroneous(); 1161 } 1162 1163 public boolean isParameterized() { 1164 return allparams().tail != null; 1165 // optimization, was: allparams().nonEmpty(); 1166 } 1167 1168 @Override 1169 public boolean isReference() { 1170 return true; 1171 } 1172 1173 @Override 1174 public boolean isNullOrReference() { 1175 return true; 1176 } 1177 1178 /** A cache for the rank. */ 1179 int rank_field = -1; 1180 1181 /** A class type is raw if it misses some 1182 * of its type parameter sections. 1183 * After validation, this is equivalent to: 1184 * {@code allparams.isEmpty() && tsym.type.allparams.nonEmpty(); } 1185 */ 1186 public boolean isRaw() { 1187 return 1188 this != tsym.type && // necessary, but not sufficient condition 1189 tsym.type.allparams().nonEmpty() && 1190 allparams().isEmpty(); 1191 } 1192 1193 public boolean contains(Type elem) { 1194 return 1195 elem.equalsIgnoreMetadata(this) 1196 || (isParameterized() 1197 && (getEnclosingType().contains(elem) || contains(getTypeArguments(), elem))) 1198 || (isCompound() 1199 && (supertype_field.contains(elem) || contains(interfaces_field, elem))); 1200 } 1201 1202 public void complete() { 1203 tsym.complete(); 1204 } 1205 1206 @DefinedBy(Api.LANGUAGE_MODEL) 1207 public TypeKind getKind() { 1208 tsym.apiComplete(); 1209 return tsym.kind == TYP ? TypeKind.DECLARED : TypeKind.ERROR; 1210 } 1211 1212 @DefinedBy(Api.LANGUAGE_MODEL) 1213 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1214 return v.visitDeclared(this, p); 1215 } 1216 } 1217 1218 public static class ErasedClassType extends ClassType { 1219 public ErasedClassType(Type outer, TypeSymbol tsym, 1220 List<TypeMetadata> metadata) { 1221 super(outer, List.nil(), tsym, metadata); 1222 } 1223 1224 @Override 1225 public boolean hasErasedSupertypes() { 1226 return true; 1227 } 1228 } 1229 1230 // a clone of a ClassType that knows about the alternatives of a union type. 1231 public static class UnionClassType extends ClassType implements UnionType { 1232 final List<? extends Type> alternatives_field; 1233 1234 public UnionClassType(ClassType ct, List<? extends Type> alternatives) { 1235 // Presently no way to refer to this type directly, so we 1236 // cannot put annotations directly on it. 1237 super(ct.outer_field, ct.typarams_field, ct.tsym); 1238 allparams_field = ct.allparams_field; 1239 supertype_field = ct.supertype_field; 1240 interfaces_field = ct.interfaces_field; 1241 all_interfaces_field = ct.interfaces_field; 1242 alternatives_field = alternatives; 1243 } 1244 1245 public Type getLub() { 1246 return tsym.type; 1247 } 1248 1249 @DefinedBy(Api.LANGUAGE_MODEL) 1250 public java.util.List<? extends TypeMirror> getAlternatives() { 1251 return Collections.unmodifiableList(alternatives_field); 1252 } 1253 1254 @Override 1255 public boolean isUnion() { 1256 return true; 1257 } 1258 1259 @Override 1260 public boolean isCompound() { 1261 return getLub().isCompound(); 1262 } 1263 1264 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1265 public TypeKind getKind() { 1266 return TypeKind.UNION; 1267 } 1268 1269 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1270 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1271 return v.visitUnion(this, p); 1272 } 1273 1274 public Iterable<? extends Type> getAlternativeTypes() { 1275 return alternatives_field; 1276 } 1277 } 1278 1279 // a clone of a ClassType that knows about the bounds of an intersection type. 1280 public static class IntersectionClassType extends ClassType implements IntersectionType { 1281 1282 public boolean allInterfaces; 1283 1284 public IntersectionClassType(List<Type> bounds, ClassSymbol csym, boolean allInterfaces) { 1285 // Presently no way to refer to this type directly, so we 1286 // cannot put annotations directly on it. 1287 super(Type.noType, List.nil(), csym); 1288 this.allInterfaces = allInterfaces; 1289 Assert.check((csym.flags() & COMPOUND) != 0); 1290 supertype_field = bounds.head; 1291 interfaces_field = bounds.tail; 1292 Assert.check(!supertype_field.tsym.isCompleted() || 1293 !supertype_field.isInterface(), supertype_field); 1294 } 1295 1296 @DefinedBy(Api.LANGUAGE_MODEL) 1297 public java.util.List<? extends TypeMirror> getBounds() { 1298 return Collections.unmodifiableList(getExplicitComponents()); 1299 } 1300 1301 @Override 1302 public boolean isCompound() { 1303 return true; 1304 } 1305 1306 public List<Type> getComponents() { 1307 return interfaces_field.prepend(supertype_field); 1308 } 1309 1310 @Override 1311 public boolean isIntersection() { 1312 return true; 1313 } 1314 1315 public List<Type> getExplicitComponents() { 1316 return allInterfaces ? 1317 interfaces_field : 1318 getComponents(); 1319 } 1320 1321 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1322 public TypeKind getKind() { 1323 return TypeKind.INTERSECTION; 1324 } 1325 1326 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1327 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1328 return v.visitIntersection(this, p); 1329 } 1330 } 1331 1332 public static class ArrayType extends Type 1333 implements LoadableConstant, javax.lang.model.type.ArrayType { 1334 1335 public Type elemtype; 1336 1337 public ArrayType(Type elemtype, TypeSymbol arrayClass) { 1338 this(elemtype, arrayClass, List.nil()); 1339 } 1340 1341 public ArrayType(Type elemtype, TypeSymbol arrayClass, 1342 List<TypeMetadata> metadata) { 1343 super(arrayClass, metadata); 1344 this.elemtype = elemtype; 1345 } 1346 1347 public ArrayType(ArrayType that) { 1348 //note: type metadata is deliberately shared here, as we want side-effects from annotation 1349 //processing to flow from original array to the cloned array. 1350 this(that.elemtype, that.tsym, that.getMetadata()); 1351 } 1352 1353 public int poolTag() { 1354 return ClassFile.CONSTANT_Class; 1355 } 1356 1357 @Override 1358 protected ArrayType cloneWithMetadata(List<TypeMetadata> md) { 1359 return new ArrayType(elemtype, tsym, md) { 1360 @Override 1361 public Type baseType() { return ArrayType.this.baseType(); } 1362 }; 1363 } 1364 1365 @Override 1366 public TypeTag getTag() { 1367 return ARRAY; 1368 } 1369 1370 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1371 return v.visitArrayType(this, s); 1372 } 1373 1374 @DefinedBy(Api.LANGUAGE_MODEL) 1375 public String toString() { 1376 StringBuilder sb = new StringBuilder(); 1377 1378 // First append root component type 1379 Type t = elemtype; 1380 while (t.getKind() == TypeKind.ARRAY) 1381 t = ((ArrayType) t).getComponentType(); 1382 sb.append(t); 1383 1384 // then append @Anno[] @Anno[] ... @Anno[] 1385 t = this; 1386 do { 1387 t.appendAnnotationsString(sb, true); 1388 sb.append("[]"); 1389 t = ((ArrayType) t).getComponentType(); 1390 } while (t.getKind() == TypeKind.ARRAY); 1391 1392 return sb.toString(); 1393 } 1394 1395 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1396 public boolean equals(Object obj) { 1397 return (obj instanceof ArrayType arrayType) 1398 && (this == arrayType || elemtype.equals(arrayType.elemtype)); 1399 } 1400 1401 @DefinedBy(Api.LANGUAGE_MODEL) 1402 public int hashCode() { 1403 return (ARRAY.ordinal() << 5) + elemtype.hashCode(); 1404 } 1405 1406 public boolean isVarargs() { 1407 return false; 1408 } 1409 1410 public List<Type> allparams() { return elemtype.allparams(); } 1411 1412 public boolean isErroneous() { 1413 return elemtype.isErroneous(); 1414 } 1415 1416 public boolean isParameterized() { 1417 return elemtype.isParameterized(); 1418 } 1419 1420 @Override 1421 public boolean isReference() { 1422 return true; 1423 } 1424 1425 @Override 1426 public boolean isNullOrReference() { 1427 return true; 1428 } 1429 1430 public boolean isRaw() { 1431 return elemtype.isRaw(); 1432 } 1433 1434 public ArrayType makeVarargs() { 1435 return new ArrayType(elemtype, tsym, metadata) { 1436 @Override 1437 public boolean isVarargs() { 1438 return true; 1439 } 1440 }; 1441 } 1442 1443 public boolean contains(Type elem) { 1444 return elem.equalsIgnoreMetadata(this) || elemtype.contains(elem); 1445 } 1446 1447 public void complete() { 1448 elemtype.complete(); 1449 } 1450 1451 @DefinedBy(Api.LANGUAGE_MODEL) 1452 public Type getComponentType() { 1453 return elemtype; 1454 } 1455 1456 @DefinedBy(Api.LANGUAGE_MODEL) 1457 public TypeKind getKind() { 1458 return TypeKind.ARRAY; 1459 } 1460 1461 @DefinedBy(Api.LANGUAGE_MODEL) 1462 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1463 return v.visitArray(this, p); 1464 } 1465 } 1466 1467 public static class MethodType extends Type implements ExecutableType, LoadableConstant { 1468 1469 public List<Type> argtypes; 1470 public Type restype; 1471 public List<Type> thrown; 1472 1473 /** The type annotations on the method receiver. 1474 */ 1475 public Type recvtype; 1476 1477 public MethodType(List<Type> argtypes, 1478 Type restype, 1479 List<Type> thrown, 1480 TypeSymbol methodClass) { 1481 // Presently no way to refer to a method type directly, so 1482 // we cannot put type annotations on it. 1483 super(methodClass, List.nil()); 1484 this.argtypes = argtypes; 1485 this.restype = restype; 1486 this.thrown = thrown; 1487 } 1488 1489 @Override 1490 public TypeTag getTag() { 1491 return METHOD; 1492 } 1493 1494 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1495 return v.visitMethodType(this, s); 1496 } 1497 1498 /** The Java source which this type represents. 1499 * 1500 * XXX 06/09/99 iris This isn't correct Java syntax, but it probably 1501 * should be. 1502 */ 1503 @DefinedBy(Api.LANGUAGE_MODEL) 1504 public String toString() { 1505 StringBuilder sb = new StringBuilder(); 1506 appendAnnotationsString(sb); 1507 sb.append('('); 1508 sb.append(argtypes); 1509 sb.append(')'); 1510 sb.append(restype); 1511 return sb.toString(); 1512 } 1513 1514 @DefinedBy(Api.LANGUAGE_MODEL) 1515 public List<Type> getParameterTypes() { return argtypes; } 1516 @DefinedBy(Api.LANGUAGE_MODEL) 1517 public Type getReturnType() { return restype; } 1518 @DefinedBy(Api.LANGUAGE_MODEL) 1519 public Type getReceiverType() { 1520 return (recvtype == null) ? Type.noType : recvtype; 1521 } 1522 @DefinedBy(Api.LANGUAGE_MODEL) 1523 public List<Type> getThrownTypes() { return thrown; } 1524 1525 public boolean isErroneous() { 1526 return 1527 isErroneous(argtypes) || 1528 restype != null && restype.isErroneous(); 1529 } 1530 1531 @Override 1532 public int poolTag() { 1533 return ClassFile.CONSTANT_MethodType; 1534 } 1535 1536 public boolean contains(Type elem) { 1537 return elem.equalsIgnoreMetadata(this) || contains(argtypes, elem) || restype.contains(elem) || contains(thrown, elem); 1538 } 1539 1540 public MethodType asMethodType() { return this; } 1541 1542 public void complete() { 1543 for (List<Type> l = argtypes; l.nonEmpty(); l = l.tail) 1544 l.head.complete(); 1545 restype.complete(); 1546 recvtype.complete(); 1547 for (List<Type> l = thrown; l.nonEmpty(); l = l.tail) 1548 l.head.complete(); 1549 } 1550 1551 @DefinedBy(Api.LANGUAGE_MODEL) 1552 public List<TypeVar> getTypeVariables() { 1553 return List.nil(); 1554 } 1555 1556 public TypeSymbol asElement() { 1557 return null; 1558 } 1559 1560 @DefinedBy(Api.LANGUAGE_MODEL) 1561 public TypeKind getKind() { 1562 return TypeKind.EXECUTABLE; 1563 } 1564 1565 @DefinedBy(Api.LANGUAGE_MODEL) 1566 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1567 return v.visitExecutable(this, p); 1568 } 1569 } 1570 1571 public static class PackageType extends Type implements NoType { 1572 1573 PackageType(PackageSymbol tsym) { 1574 // Package types cannot be annotated 1575 super(tsym, List.nil()); 1576 } 1577 1578 @Override 1579 public TypeTag getTag() { 1580 return PACKAGE; 1581 } 1582 1583 @Override 1584 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1585 return v.visitPackageType(this, s); 1586 } 1587 1588 @DefinedBy(Api.LANGUAGE_MODEL) 1589 public String toString() { 1590 return tsym.getQualifiedName().toString(); 1591 } 1592 1593 @DefinedBy(Api.LANGUAGE_MODEL) 1594 public TypeKind getKind() { 1595 return TypeKind.PACKAGE; 1596 } 1597 1598 @DefinedBy(Api.LANGUAGE_MODEL) 1599 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1600 return v.visitNoType(this, p); 1601 } 1602 } 1603 1604 public static class ModuleType extends Type implements NoType { 1605 1606 ModuleType(ModuleSymbol tsym) { 1607 // Module types cannot be annotated 1608 super(tsym, List.nil()); 1609 } 1610 1611 @Override 1612 public ModuleType annotatedType(List<Attribute.TypeCompound> annos) { 1613 throw new AssertionError("Cannot annotate a module type"); 1614 } 1615 1616 @Override 1617 public TypeTag getTag() { 1618 return TypeTag.MODULE; 1619 } 1620 1621 @Override 1622 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1623 return v.visitModuleType(this, s); 1624 } 1625 1626 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1627 public String toString() { 1628 return tsym.getQualifiedName().toString(); 1629 } 1630 1631 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1632 public TypeKind getKind() { 1633 return TypeKind.MODULE; 1634 } 1635 1636 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1637 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1638 return v.visitNoType(this, p); 1639 } 1640 } 1641 1642 public static class TypeVar extends Type implements TypeVariable { 1643 1644 /** The upper bound of this type variable; set from outside. 1645 * Must be nonempty once it is set. 1646 * For a bound, `bound' is the bound type itself. 1647 * Multiple bounds are expressed as a single class type which has the 1648 * individual bounds as superclass, respectively interfaces. 1649 * The class type then has as `tsym' a compiler generated class `c', 1650 * which has a flag COMPOUND and whose owner is the type variable 1651 * itself. Furthermore, the erasure_field of the class 1652 * points to the first class or interface bound. 1653 */ 1654 private Type _bound = null; 1655 1656 /** The lower bound of this type variable. 1657 * TypeVars don't normally have a lower bound, so it is normally set 1658 * to syms.botType. 1659 * Subtypes, such as CapturedType, may provide a different value. 1660 */ 1661 public Type lower; 1662 1663 @SuppressWarnings("this-escape") 1664 public TypeVar(Name name, Symbol owner, Type lower) { 1665 super(null, List.nil()); 1666 Assert.checkNonNull(lower); 1667 tsym = new TypeVariableSymbol(0, name, this, owner); 1668 this.setUpperBound(null); 1669 this.lower = lower; 1670 } 1671 1672 public TypeVar(TypeSymbol tsym, Type bound, Type lower) { 1673 this(tsym, bound, lower, List.nil()); 1674 } 1675 1676 @SuppressWarnings("this-escape") 1677 public TypeVar(TypeSymbol tsym, Type bound, Type lower, 1678 List<TypeMetadata> metadata) { 1679 super(tsym, metadata); 1680 Assert.checkNonNull(lower); 1681 this.setUpperBound(bound); 1682 this.lower = lower; 1683 } 1684 1685 @Override 1686 protected TypeVar cloneWithMetadata(List<TypeMetadata> md) { 1687 return new TypeVar(tsym, getUpperBound(), lower, md) { 1688 @Override 1689 public Type baseType() { return TypeVar.this.baseType(); } 1690 1691 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1692 public Type getUpperBound() { return TypeVar.this.getUpperBound(); } 1693 1694 public void setUpperBound(Type bound) { TypeVar.this.setUpperBound(bound); } 1695 }; 1696 } 1697 1698 @Override 1699 public TypeTag getTag() { 1700 return TYPEVAR; 1701 } 1702 1703 @Override 1704 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1705 return v.visitTypeVar(this, s); 1706 } 1707 1708 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1709 public Type getUpperBound() { return _bound; } 1710 1711 public void setUpperBound(Type bound) { this._bound = bound; } 1712 1713 int rank_field = -1; 1714 1715 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1716 public Type getLowerBound() { 1717 return lower; 1718 } 1719 1720 @DefinedBy(Api.LANGUAGE_MODEL) 1721 public TypeKind getKind() { 1722 return TypeKind.TYPEVAR; 1723 } 1724 1725 public boolean isCaptured() { 1726 return false; 1727 } 1728 1729 @Override 1730 public boolean isReference() { 1731 return true; 1732 } 1733 1734 @Override 1735 public boolean isNullOrReference() { 1736 return true; 1737 } 1738 1739 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1740 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1741 return v.visitTypeVariable(this, p); 1742 } 1743 } 1744 1745 /** A captured type variable comes from wildcards which can have 1746 * both upper and lower bound. CapturedType extends TypeVar with 1747 * a lower bound. 1748 */ 1749 public static class CapturedType extends TypeVar { 1750 1751 public WildcardType wildcard; 1752 1753 @SuppressWarnings("this-escape") 1754 public CapturedType(Name name, 1755 Symbol owner, 1756 Type upper, 1757 Type lower, 1758 WildcardType wildcard) { 1759 super(name, owner, lower); 1760 this.lower = Assert.checkNonNull(lower); 1761 this.setUpperBound(upper); 1762 this.wildcard = wildcard; 1763 } 1764 1765 public CapturedType(TypeSymbol tsym, 1766 Type bound, 1767 Type upper, 1768 Type lower, 1769 WildcardType wildcard, 1770 List<TypeMetadata> metadata) { 1771 super(tsym, bound, lower, metadata); 1772 this.wildcard = wildcard; 1773 } 1774 1775 @Override 1776 protected CapturedType cloneWithMetadata(List<TypeMetadata> md) { 1777 return new CapturedType(tsym, getUpperBound(), getUpperBound(), lower, wildcard, md) { 1778 @Override 1779 public Type baseType() { return CapturedType.this.baseType(); } 1780 1781 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1782 public Type getUpperBound() { return CapturedType.this.getUpperBound(); } 1783 1784 public void setUpperBound(Type bound) { CapturedType.this.setUpperBound(bound); } 1785 }; 1786 } 1787 1788 @Override 1789 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1790 return v.visitCapturedType(this, s); 1791 } 1792 1793 @Override 1794 public boolean isCaptured() { 1795 return true; 1796 } 1797 1798 @Override @DefinedBy(Api.LANGUAGE_MODEL) 1799 public String toString() { 1800 StringBuilder sb = new StringBuilder(); 1801 appendAnnotationsString(sb); 1802 sb.append("capture#"); 1803 sb.append((hashCode() & 0xFFFFFFFFL) % Printer.PRIME); 1804 sb.append(" of "); 1805 sb.append(wildcard); 1806 return sb.toString(); 1807 } 1808 } 1809 1810 public abstract static class DelegatedType extends Type { 1811 public Type qtype; 1812 public TypeTag tag; 1813 1814 public DelegatedType(TypeTag tag, Type qtype) { 1815 this(tag, qtype, List.nil()); 1816 } 1817 1818 public DelegatedType(TypeTag tag, Type qtype, 1819 List<TypeMetadata> metadata) { 1820 super(qtype.tsym, metadata); 1821 this.tag = tag; 1822 this.qtype = qtype; 1823 } 1824 1825 public TypeTag getTag() { return tag; } 1826 @DefinedBy(Api.LANGUAGE_MODEL) 1827 public String toString() { return qtype.toString(); } 1828 public List<Type> getTypeArguments() { return qtype.getTypeArguments(); } 1829 public Type getEnclosingType() { return qtype.getEnclosingType(); } 1830 public List<Type> getParameterTypes() { return qtype.getParameterTypes(); } 1831 public Type getReturnType() { return qtype.getReturnType(); } 1832 public Type getReceiverType() { return qtype.getReceiverType(); } 1833 public List<Type> getThrownTypes() { return qtype.getThrownTypes(); } 1834 public List<Type> allparams() { return qtype.allparams(); } 1835 public Type getUpperBound() { return qtype.getUpperBound(); } 1836 public boolean isErroneous() { return qtype.isErroneous(); } 1837 } 1838 1839 /** 1840 * The type of a generic method type. It consists of a method type and 1841 * a list of method type-parameters that are used within the method 1842 * type. 1843 */ 1844 public static class ForAll extends DelegatedType implements ExecutableType { 1845 public List<Type> tvars; 1846 1847 public ForAll(List<Type> tvars, Type qtype) { 1848 super(FORALL, (MethodType)qtype); 1849 this.tvars = tvars; 1850 } 1851 1852 @Override 1853 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1854 return v.visitForAll(this, s); 1855 } 1856 1857 @DefinedBy(Api.LANGUAGE_MODEL) 1858 public String toString() { 1859 StringBuilder sb = new StringBuilder(); 1860 appendAnnotationsString(sb); 1861 sb.append('<'); 1862 sb.append(tvars); 1863 sb.append('>'); 1864 sb.append(qtype); 1865 return sb.toString(); 1866 } 1867 1868 public List<Type> getTypeArguments() { return tvars; } 1869 1870 public boolean isErroneous() { 1871 return qtype.isErroneous(); 1872 } 1873 1874 public boolean contains(Type elem) { 1875 return qtype.contains(elem); 1876 } 1877 1878 public MethodType asMethodType() { 1879 return (MethodType)qtype; 1880 } 1881 1882 public void complete() { 1883 for (List<Type> l = tvars; l.nonEmpty(); l = l.tail) { 1884 ((TypeVar)l.head).getUpperBound().complete(); 1885 } 1886 qtype.complete(); 1887 } 1888 1889 @DefinedBy(Api.LANGUAGE_MODEL) 1890 public List<TypeVar> getTypeVariables() { 1891 return List.convert(TypeVar.class, getTypeArguments()); 1892 } 1893 1894 @DefinedBy(Api.LANGUAGE_MODEL) 1895 public TypeKind getKind() { 1896 return TypeKind.EXECUTABLE; 1897 } 1898 1899 @DefinedBy(Api.LANGUAGE_MODEL) 1900 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 1901 return v.visitExecutable(this, p); 1902 } 1903 } 1904 1905 /** A class for inference variables, for use during method/diamond type 1906 * inference. An inference variable has upper/lower bounds and a set 1907 * of equality constraints. Such bounds are set during subtyping, type-containment, 1908 * type-equality checks, when the types being tested contain inference variables. 1909 * A change listener can be attached to an inference variable, to receive notifications 1910 * whenever the bounds of an inference variable change. 1911 */ 1912 public static class UndetVar extends DelegatedType { 1913 1914 enum Kind { 1915 NORMAL, 1916 CAPTURED, 1917 THROWS; 1918 } 1919 1920 /** Inference variable change listener. The listener method is called 1921 * whenever a change to the inference variable's bounds occurs 1922 */ 1923 public interface UndetVarListener { 1924 /** called when some inference variable bounds (of given kinds ibs) change */ 1925 void varBoundChanged(UndetVar uv, InferenceBound ib, Type bound, boolean update); 1926 /** called when the inferred type is set on some inference variable */ 1927 default void varInstantiated(UndetVar uv) { Assert.error(); } 1928 } 1929 1930 /** 1931 * Inference variable bound kinds 1932 */ 1933 public enum InferenceBound { 1934 /** lower bounds */ 1935 LOWER { 1936 public InferenceBound complement() { return UPPER; } 1937 }, 1938 /** equality constraints */ 1939 EQ { 1940 public InferenceBound complement() { return EQ; } 1941 }, 1942 /** upper bounds */ 1943 UPPER { 1944 public InferenceBound complement() { return LOWER; } 1945 }; 1946 1947 public abstract InferenceBound complement(); 1948 1949 public boolean lessThan(InferenceBound that) { 1950 if (that == this) { 1951 return false; 1952 } else { 1953 switch (that) { 1954 case UPPER: return true; 1955 case LOWER: return false; 1956 case EQ: return (this != UPPER); 1957 default: 1958 Assert.error("Cannot get here!"); 1959 return false; 1960 } 1961 } 1962 } 1963 } 1964 1965 /** list of incorporation actions (used by the incorporation engine). */ 1966 public ArrayDeque<IncorporationAction> incorporationActions = new ArrayDeque<>(); 1967 1968 /** inference variable bounds */ 1969 protected Map<InferenceBound, List<Type>> bounds; 1970 1971 /** inference variable's inferred type (set from Infer.java) */ 1972 private Type inst = null; 1973 1974 /** number of declared (upper) bounds */ 1975 public int declaredCount; 1976 1977 /** inference variable's change listener */ 1978 public UndetVarListener listener = null; 1979 1980 Kind kind; 1981 1982 @Override 1983 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 1984 return v.visitUndetVar(this, s); 1985 } 1986 1987 @SuppressWarnings("this-escape") 1988 public UndetVar(TypeVar origin, UndetVarListener listener, Types types) { 1989 // This is a synthesized internal type, so we cannot annotate it. 1990 super(UNDETVAR, origin); 1991 this.kind = origin.isCaptured() ? 1992 Kind.CAPTURED : 1993 Kind.NORMAL; 1994 this.listener = listener; 1995 bounds = new EnumMap<>(InferenceBound.class); 1996 List<Type> declaredBounds = types.getBounds(origin); 1997 declaredCount = declaredBounds.length(); 1998 bounds.put(InferenceBound.UPPER, List.nil()); 1999 bounds.put(InferenceBound.LOWER, List.nil()); 2000 bounds.put(InferenceBound.EQ, List.nil()); 2001 for (Type t : declaredBounds.reverse()) { 2002 //add bound works in reverse order 2003 addBound(InferenceBound.UPPER, t, types, true); 2004 } 2005 if (origin.isCaptured() && !origin.lower.hasTag(BOT)) { 2006 //add lower bound if needed 2007 addBound(InferenceBound.LOWER, origin.lower, types, true); 2008 } 2009 } 2010 2011 @DefinedBy(Api.LANGUAGE_MODEL) 2012 public String toString() { 2013 StringBuilder sb = new StringBuilder(); 2014 appendAnnotationsString(sb); 2015 if (inst == null) { 2016 sb.append(qtype); 2017 sb.append('?'); 2018 } else { 2019 sb.append(inst); 2020 } 2021 return sb.toString(); 2022 } 2023 2024 public String debugString() { 2025 String result = "inference var = " + qtype + "\n"; 2026 if (inst != null) { 2027 result += "inst = " + inst + '\n'; 2028 } 2029 for (InferenceBound bound: InferenceBound.values()) { 2030 List<Type> aboundList = bounds.get(bound); 2031 if (aboundList != null && aboundList.size() > 0) { 2032 result += bound + " = " + aboundList + '\n'; 2033 } 2034 } 2035 return result; 2036 } 2037 2038 public void setThrow() { 2039 if (this.kind == Kind.CAPTURED) { 2040 //invalid state transition 2041 throw new IllegalStateException(); 2042 } 2043 this.kind = Kind.THROWS; 2044 } 2045 2046 public void setNormal() { 2047 Assert.check(this.kind == Kind.CAPTURED); 2048 this.kind = Kind.NORMAL; 2049 } 2050 2051 /** 2052 * Returns a new copy of this undet var. 2053 */ 2054 public UndetVar dup(Types types) { 2055 UndetVar uv2 = new UndetVar((TypeVar)qtype, listener, types); 2056 dupTo(uv2, types); 2057 return uv2; 2058 } 2059 2060 /** 2061 * Dumps the contents of this undet var on another undet var. 2062 */ 2063 public void dupTo(UndetVar uv2, Types types) { 2064 uv2.listener = null; 2065 uv2.bounds.clear(); 2066 for (InferenceBound ib : InferenceBound.values()) { 2067 uv2.bounds.put(ib, List.nil()); 2068 for (Type t : getBounds(ib)) { 2069 uv2.addBound(ib, t, types, true); 2070 } 2071 } 2072 uv2.inst = inst; 2073 uv2.listener = listener; 2074 uv2.incorporationActions = new ArrayDeque<>(); 2075 for (IncorporationAction action : incorporationActions) { 2076 uv2.incorporationActions.add(action.dup(uv2)); 2077 } 2078 uv2.kind = kind; 2079 } 2080 2081 @Override 2082 public boolean isPartial() { 2083 return true; 2084 } 2085 2086 @Override 2087 public Type baseType() { 2088 return (inst == null) ? this : inst.baseType(); 2089 } 2090 2091 public Type getInst() { 2092 return inst; 2093 } 2094 2095 public void setInst(Type inst) { 2096 this.inst = inst; 2097 if (listener != null) { 2098 listener.varInstantiated(this); 2099 } 2100 } 2101 2102 /** get all bounds of a given kind */ 2103 public List<Type> getBounds(InferenceBound... ibs) { 2104 ListBuffer<Type> buf = new ListBuffer<>(); 2105 for (InferenceBound ib : ibs) { 2106 buf.appendList(bounds.get(ib)); 2107 } 2108 return buf.toList(); 2109 } 2110 2111 /** get the list of declared (upper) bounds */ 2112 public List<Type> getDeclaredBounds() { 2113 ListBuffer<Type> buf = new ListBuffer<>(); 2114 int count = 0; 2115 for (Type b : getBounds(InferenceBound.UPPER)) { 2116 if (count++ == declaredCount) break; 2117 buf.append(b); 2118 } 2119 return buf.toList(); 2120 } 2121 2122 /** internal method used to override an undetvar bounds */ 2123 public void setBounds(InferenceBound ib, List<Type> newBounds) { 2124 bounds.put(ib, newBounds); 2125 } 2126 2127 /** add a bound of a given kind - this might trigger listener notification */ 2128 public final void addBound(InferenceBound ib, Type bound, Types types) { 2129 addBound(ib, bound, types, false); 2130 } 2131 2132 @SuppressWarnings("fallthrough") 2133 private void addBound(InferenceBound ib, Type bound, Types types, boolean update) { 2134 if (kind == Kind.CAPTURED && !update) { 2135 //Captured inference variables bounds must not be updated during incorporation, 2136 //except when some inference variable (beta) has been instantiated in the 2137 //right-hand-side of a 'C<alpha> = capture(C<? extends/super beta>) constraint. 2138 if (bound.hasTag(UNDETVAR) && !((UndetVar)bound).isCaptured()) { 2139 //If the new incoming bound is itself a (regular) inference variable, 2140 //then we are allowed to propagate this inference variable bounds to it. 2141 ((UndetVar)bound).addBound(ib.complement(), this, types, false); 2142 } 2143 } else { 2144 Type bound2 = bound.map(toTypeVarMap).baseType(); 2145 List<Type> prevBounds = bounds.get(ib); 2146 if (bound == qtype) return; 2147 for (Type b : prevBounds) { 2148 //check for redundancy - do not add same bound twice 2149 if (types.isSameType(b, bound2)) return; 2150 } 2151 bounds.put(ib, prevBounds.prepend(bound2)); 2152 notifyBoundChange(ib, bound2, false); 2153 } 2154 } 2155 //where 2156 TypeMapping<Void> toTypeVarMap = new StructuralTypeMapping<Void>() { 2157 @Override 2158 public Type visitUndetVar(UndetVar uv, Void _unused) { 2159 return uv.inst != null ? uv.inst : uv.qtype; 2160 } 2161 }; 2162 2163 /** replace types in all bounds - this might trigger listener notification */ 2164 public void substBounds(List<Type> from, List<Type> to, Types types) { 2165 final ListBuffer<Pair<InferenceBound, Type>> boundsChanged = new ListBuffer<>(); 2166 UndetVarListener prevListener = listener; 2167 try { 2168 //setup new listener for keeping track of changed bounds 2169 listener = (uv, ib, t, _ignored) -> { 2170 Assert.check(uv == UndetVar.this); 2171 boundsChanged.add(new Pair<>(ib, t)); 2172 }; 2173 for (Map.Entry<InferenceBound, List<Type>> _entry : bounds.entrySet()) { 2174 InferenceBound ib = _entry.getKey(); 2175 List<Type> prevBounds = _entry.getValue(); 2176 ListBuffer<Type> newBounds = new ListBuffer<>(); 2177 ListBuffer<Type> deps = new ListBuffer<>(); 2178 //step 1 - re-add bounds that are not dependent on ivars 2179 for (Type t : prevBounds) { 2180 if (!t.containsAny(from)) { 2181 newBounds.append(t); 2182 } else { 2183 deps.append(t); 2184 } 2185 } 2186 //step 2 - replace bounds 2187 bounds.put(ib, newBounds.toList()); 2188 //step 3 - for each dependency, add new replaced bound 2189 for (Type dep : deps) { 2190 addBound(ib, types.subst(dep, from, to), types, true); 2191 } 2192 } 2193 } finally { 2194 listener = prevListener; 2195 for (Pair<InferenceBound, Type> boundUpdate : boundsChanged) { 2196 notifyBoundChange(boundUpdate.fst, boundUpdate.snd, true); 2197 } 2198 } 2199 } 2200 2201 private void notifyBoundChange(InferenceBound ib, Type bound, boolean update) { 2202 if (listener != null) { 2203 listener.varBoundChanged(this, ib, bound, update); 2204 } 2205 } 2206 2207 public final boolean isCaptured() { 2208 return kind == Kind.CAPTURED; 2209 } 2210 2211 public final boolean isThrows() { 2212 return kind == Kind.THROWS; 2213 } 2214 } 2215 2216 /** Represents NONE. 2217 */ 2218 public static class JCNoType extends Type implements NoType { 2219 public JCNoType() { 2220 // Need to use List.nil(), because JCNoType constructor 2221 // gets called in static initializers in Type, where 2222 // noAnnotations is also defined. 2223 super(null, List.nil()); 2224 } 2225 2226 @Override 2227 public TypeTag getTag() { 2228 return NONE; 2229 } 2230 2231 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2232 public TypeKind getKind() { 2233 return TypeKind.NONE; 2234 } 2235 2236 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2237 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 2238 return v.visitNoType(this, p); 2239 } 2240 2241 @Override 2242 public boolean isCompound() { return false; } 2243 } 2244 2245 /** Represents VOID. 2246 */ 2247 public static class JCVoidType extends Type implements NoType { 2248 2249 public JCVoidType() { 2250 // Void cannot be annotated 2251 super(null, List.nil()); 2252 } 2253 2254 @Override 2255 public TypeTag getTag() { 2256 return VOID; 2257 } 2258 2259 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2260 public TypeKind getKind() { 2261 return TypeKind.VOID; 2262 } 2263 2264 @Override 2265 public boolean isCompound() { return false; } 2266 2267 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2268 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 2269 return v.visitNoType(this, p); 2270 } 2271 2272 @Override 2273 public boolean isPrimitiveOrVoid() { 2274 return true; 2275 } 2276 } 2277 2278 static class BottomType extends Type implements NullType { 2279 public BottomType() { 2280 // Bottom is a synthesized internal type, so it cannot be annotated 2281 super(null, List.nil()); 2282 } 2283 2284 @Override 2285 public TypeTag getTag() { 2286 return BOT; 2287 } 2288 2289 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2290 public TypeKind getKind() { 2291 return TypeKind.NULL; 2292 } 2293 2294 @Override 2295 public boolean isCompound() { return false; } 2296 2297 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2298 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 2299 return v.visitNull(this, p); 2300 } 2301 2302 @Override 2303 public Type constType(Object value) { 2304 return this; 2305 } 2306 2307 @Override 2308 public String stringValue() { 2309 return "null"; 2310 } 2311 2312 @Override 2313 public boolean isNullOrReference() { 2314 return true; 2315 } 2316 2317 } 2318 2319 public static class ErrorType extends ClassType 2320 implements javax.lang.model.type.ErrorType { 2321 2322 private Type originalType = null; 2323 2324 public ErrorType(ClassSymbol c, Type originalType) { 2325 this(originalType, c); 2326 c.type = this; 2327 c.kind = ERR; 2328 c.members_field = new Scope.ErrorScope(c); 2329 } 2330 2331 public ErrorType(Type originalType, TypeSymbol tsym) { 2332 super(noType, List.nil(), null); 2333 this.tsym = tsym; 2334 this.originalType = (originalType == null ? noType : originalType); 2335 } 2336 2337 private ErrorType(Type originalType, TypeSymbol tsym, 2338 List<TypeMetadata> metadata) { 2339 super(noType, List.nil(), null, metadata); 2340 this.tsym = tsym; 2341 this.originalType = (originalType == null ? noType : originalType); 2342 } 2343 2344 @Override 2345 protected ErrorType cloneWithMetadata(List<TypeMetadata> md) { 2346 return new ErrorType(originalType, tsym, md) { 2347 @Override 2348 public Type baseType() { return ErrorType.this.baseType(); } 2349 }; 2350 } 2351 2352 @Override 2353 public TypeTag getTag() { 2354 return ERROR; 2355 } 2356 2357 @Override 2358 public boolean isPartial() { 2359 return true; 2360 } 2361 2362 @Override 2363 public boolean isReference() { 2364 return true; 2365 } 2366 2367 @Override 2368 public boolean isNullOrReference() { 2369 return true; 2370 } 2371 2372 public ErrorType(Name name, TypeSymbol container, Type originalType) { 2373 this(new ClassSymbol(PUBLIC|STATIC|ACYCLIC, name, null, container), originalType); 2374 } 2375 2376 @Override 2377 public <R,S> R accept(Type.Visitor<R,S> v, S s) { 2378 return v.visitErrorType(this, s); 2379 } 2380 2381 public Type constType(Object constValue) { return this; } 2382 @DefinedBy(Api.LANGUAGE_MODEL) 2383 public Type getEnclosingType() { return Type.noType; } 2384 public Type getReturnType() { return this; } 2385 public Type asSub(Symbol sym) { return this; } 2386 2387 public boolean isGenType(Type t) { return true; } 2388 public boolean isErroneous() { return true; } 2389 public boolean isCompound() { return false; } 2390 public boolean isInterface() { return false; } 2391 2392 public List<Type> allparams() { return List.nil(); } 2393 @DefinedBy(Api.LANGUAGE_MODEL) 2394 public List<Type> getTypeArguments() { return List.nil(); } 2395 2396 @DefinedBy(Api.LANGUAGE_MODEL) 2397 public TypeKind getKind() { 2398 return TypeKind.ERROR; 2399 } 2400 2401 public Type getOriginalType() { 2402 return originalType; 2403 } 2404 2405 @DefinedBy(Api.LANGUAGE_MODEL) 2406 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 2407 return v.visitError(this, p); 2408 } 2409 } 2410 2411 public static class UnknownType extends Type { 2412 2413 public UnknownType() { 2414 // Unknown is a synthesized internal type, so it cannot be 2415 // annotated. 2416 super(null, List.nil()); 2417 } 2418 2419 @Override 2420 public TypeTag getTag() { 2421 return UNKNOWN; 2422 } 2423 2424 @Override @DefinedBy(Api.LANGUAGE_MODEL) 2425 public <R, P> R accept(TypeVisitor<R, P> v, P p) { 2426 return v.visitUnknown(this, p); 2427 } 2428 2429 @Override 2430 public boolean isPartial() { 2431 return true; 2432 } 2433 } 2434 2435 /** 2436 * A visitor for types. A visitor is used to implement operations 2437 * (or relations) on types. Most common operations on types are 2438 * binary relations and this interface is designed for binary 2439 * relations, that is, operations of the form 2440 * Type × S → R. 2441 * <!-- In plain text: Type x S -> R --> 2442 * 2443 * @param <R> the return type of the operation implemented by this 2444 * visitor; use Void if no return type is needed. 2445 * @param <S> the type of the second argument (the first being the 2446 * type itself) of the operation implemented by this visitor; use 2447 * Void if a second argument is not needed. 2448 */ 2449 public interface Visitor<R,S> { 2450 R visitClassType(ClassType t, S s); 2451 R visitWildcardType(WildcardType t, S s); 2452 R visitArrayType(ArrayType t, S s); 2453 R visitMethodType(MethodType t, S s); 2454 R visitPackageType(PackageType t, S s); 2455 R visitModuleType(ModuleType t, S s); 2456 R visitTypeVar(TypeVar t, S s); 2457 R visitCapturedType(CapturedType t, S s); 2458 R visitForAll(ForAll t, S s); 2459 R visitUndetVar(UndetVar t, S s); 2460 R visitErrorType(ErrorType t, S s); 2461 R visitType(Type t, S s); 2462 } 2463 }