1 /*
   2  * Copyright (c) 2003, 2021, 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.ref.SoftReference;
  29 import java.util.HashSet;
  30 import java.util.HashMap;
  31 import java.util.Locale;
  32 import java.util.Map;
  33 import java.util.Optional;
  34 import java.util.Set;
  35 import java.util.WeakHashMap;
  36 import java.util.function.BiPredicate;
  37 import java.util.function.Function;
  38 import java.util.function.Predicate;
  39 import java.util.stream.Collector;
  40 
  41 import javax.tools.JavaFileObject;
  42 
  43 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
  44 import com.sun.tools.javac.code.Lint.LintCategory;
  45 import com.sun.tools.javac.code.Source.Feature;
  46 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
  47 import com.sun.tools.javac.code.TypeMetadata.Entry.Kind;
  48 import com.sun.tools.javac.comp.AttrContext;
  49 import com.sun.tools.javac.comp.Check;
  50 import com.sun.tools.javac.comp.Enter;
  51 import com.sun.tools.javac.comp.Env;
  52 import com.sun.tools.javac.jvm.ClassFile;
  53 import com.sun.tools.javac.util.*;
  54 
  55 import static com.sun.tools.javac.code.BoundKind.*;
  56 import static com.sun.tools.javac.code.Flags.*;
  57 import static com.sun.tools.javac.code.Kinds.Kind.*;
  58 import static com.sun.tools.javac.code.Scope.*;
  59 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
  60 import static com.sun.tools.javac.code.Symbol.*;
  61 import static com.sun.tools.javac.code.Type.*;
  62 import static com.sun.tools.javac.code.TypeTag.*;
  63 import static com.sun.tools.javac.jvm.ClassFile.externalize;
  64 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
  65 
  66 /**
  67  * Utility class containing various operations on types.
  68  *
  69  * <p>Unless other names are more illustrative, the following naming
  70  * conventions should be observed in this file:
  71  *
  72  * <dl>
  73  * <dt>t</dt>
  74  * <dd>If the first argument to an operation is a type, it should be named t.</dd>
  75  * <dt>s</dt>
  76  * <dd>Similarly, if the second argument to an operation is a type, it should be named s.</dd>
  77  * <dt>ts</dt>
  78  * <dd>If an operations takes a list of types, the first should be named ts.</dd>
  79  * <dt>ss</dt>
  80  * <dd>A second list of types should be named ss.</dd>
  81  * </dl>
  82  *
  83  * <p><b>This is NOT part of any supported API.
  84  * If you write code that depends on this, you do so at your own risk.
  85  * This code and its internal interfaces are subject to change or
  86  * deletion without notice.</b>
  87  */
  88 public class Types {
  89     protected static final Context.Key<Types> typesKey = new Context.Key<>();
  90 
  91     final Symtab syms;
  92     final JavacMessages messages;
  93     final Names names;
  94     final boolean allowDefaultMethods;
  95     final boolean mapCapturesToBounds;
  96     final boolean allowValueBasedClasses;
  97     final Check chk;
  98     final Enter enter;
  99     JCDiagnostic.Factory diags;
 100     List<Warner> warnStack = List.nil();
 101     final Name capturedName;
 102 
 103     public final Warner noWarnings;
 104 
 105     // <editor-fold defaultstate="collapsed" desc="Instantiating">
 106     public static Types instance(Context context) {
 107         Types instance = context.get(typesKey);
 108         if (instance == null)
 109             instance = new Types(context);
 110         return instance;
 111     }
 112 
 113     protected Types(Context context) {
 114         context.put(typesKey, this);
 115         syms = Symtab.instance(context);
 116         names = Names.instance(context);
 117         Source source = Source.instance(context);
 118         allowDefaultMethods = Feature.DEFAULT_METHODS.allowedInSource(source);
 119         mapCapturesToBounds = Feature.MAP_CAPTURES_TO_BOUNDS.allowedInSource(source);
 120         chk = Check.instance(context);
 121         enter = Enter.instance(context);
 122         capturedName = names.fromString("<captured wildcard>");
 123         messages = JavacMessages.instance(context);
 124         diags = JCDiagnostic.Factory.instance(context);
 125         noWarnings = new Warner(null);
 126         Options options = Options.instance(context);
 127         allowValueBasedClasses = options.isSet("allowValueBasedClasses");
 128     }
 129     // </editor-fold>
 130 
 131     // <editor-fold defaultstate="collapsed" desc="bounds">
 132     /**
 133      * Get a wildcard's upper bound, returning non-wildcards unchanged.
 134      * @param t a type argument, either a wildcard or a type
 135      */
 136     public Type wildUpperBound(Type t) {
 137         if (t.hasTag(WILDCARD)) {
 138             WildcardType w = (WildcardType) t;
 139             if (w.isSuperBound())
 140                 return w.bound == null ? syms.objectType : w.bound.getUpperBound();
 141             else
 142                 return wildUpperBound(w.type);
 143         }
 144         else return t;
 145     }
 146 
 147     /**
 148      * Get a capture variable's upper bound, returning other types unchanged.
 149      * @param t a type
 150      */
 151     public Type cvarUpperBound(Type t) {
 152         if (t.hasTag(TYPEVAR)) {
 153             TypeVar v = (TypeVar) t;
 154             return v.isCaptured() ? cvarUpperBound(v.getUpperBound()) : v;
 155         }
 156         else return t;
 157     }
 158 
 159     /**
 160      * Get a wildcard's lower bound, returning non-wildcards unchanged.
 161      * @param t a type argument, either a wildcard or a type
 162      */
 163     public Type wildLowerBound(Type t) {
 164         if (t.hasTag(WILDCARD)) {
 165             WildcardType w = (WildcardType) t;
 166             return w.isExtendsBound() ? syms.botType : wildLowerBound(w.type);
 167         }
 168         else return t;
 169     }
 170 
 171     /**
 172      * Get a capture variable's lower bound, returning other types unchanged.
 173      * @param t a type
 174      */
 175     public Type cvarLowerBound(Type t) {
 176         if (t.hasTag(TYPEVAR) && ((TypeVar) t).isCaptured()) {
 177             return cvarLowerBound(t.getLowerBound());
 178         }
 179         else return t;
 180     }
 181 
 182     /**
 183      * Recursively skip type-variables until a class/array type is found; capture conversion is then
 184      * (optionally) applied to the resulting type. This is useful for i.e. computing a site that is
 185      * suitable for a method lookup.
 186      */
 187     public Type skipTypeVars(Type site, boolean capture) {
 188         while (site.hasTag(TYPEVAR)) {
 189             site = site.getUpperBound();
 190         }
 191         return capture ? capture(site) : site;
 192     }
 193     // </editor-fold>
 194 
 195     // <editor-fold defaultstate="collapsed" desc="projections">
 196 
 197     /**
 198      * A projection kind. See {@link TypeProjection}
 199      */
 200     enum ProjectionKind {
 201         UPWARDS() {
 202             @Override
 203             ProjectionKind complement() {
 204                 return DOWNWARDS;
 205             }
 206         },
 207         DOWNWARDS() {
 208             @Override
 209             ProjectionKind complement() {
 210                 return UPWARDS;
 211             }
 212         };
 213 
 214         abstract ProjectionKind complement();
 215     }
 216 
 217     /**
 218      * This visitor performs upwards and downwards projections on types.
 219      *
 220      * A projection is defined as a function that takes a type T, a set of type variables V and that
 221      * produces another type S.
 222      *
 223      * An upwards projection maps a type T into a type S such that (i) T has no variables in V,
 224      * and (ii) S is an upper bound of T.
 225      *
 226      * A downwards projection maps a type T into a type S such that (i) T has no variables in V,
 227      * and (ii) S is a lower bound of T.
 228      *
 229      * Note that projections are only allowed to touch variables in V. Therefore, it is possible for
 230      * a projection to leave its input type unchanged if it does not contain any variables in V.
 231      *
 232      * Moreover, note that while an upwards projection is always defined (every type as an upper bound),
 233      * a downwards projection is not always defined.
 234      *
 235      * Examples:
 236      *
 237      * {@code upwards(List<#CAP1>, [#CAP1]) = List<? extends String>, where #CAP1 <: String }
 238      * {@code downwards(List<#CAP2>, [#CAP2]) = List<? super String>, where #CAP2 :> String }
 239      * {@code upwards(List<#CAP1>, [#CAP2]) = List<#CAP1> }
 240      * {@code downwards(List<#CAP1>, [#CAP1]) = not defined }
 241      */
 242     class TypeProjection extends TypeMapping<ProjectionKind> {
 243 
 244         List<Type> vars;
 245         Set<Type> seen = new HashSet<>();
 246 
 247         public TypeProjection(List<Type> vars) {
 248             this.vars = vars;
 249         }
 250 
 251         @Override
 252         public Type visitClassType(ClassType t, ProjectionKind pkind) {
 253             if (t.isCompound()) {
 254                 List<Type> components = directSupertypes(t);
 255                 List<Type> components1 = components.map(c -> c.map(this, pkind));
 256                 if (components == components1) return t;
 257                 else return makeIntersectionType(components1);
 258             } else {
 259                 Type outer = t.getEnclosingType();
 260                 Type outer1 = visit(outer, pkind);
 261                 List<Type> typarams = t.getTypeArguments();
 262                 List<Type> formals = t.tsym.type.getTypeArguments();
 263                 ListBuffer<Type> typarams1 = new ListBuffer<>();
 264                 boolean changed = false;
 265                 for (Type actual : typarams) {
 266                     Type t2 = mapTypeArgument(t, formals.head.getUpperBound(), actual, pkind);
 267                     if (t2.hasTag(BOT)) {
 268                         //not defined
 269                         return syms.botType;
 270                     }
 271                     typarams1.add(t2);
 272                     changed |= actual != t2;
 273                     formals = formals.tail;
 274                 }
 275                 if (outer1 == outer && !changed) return t;
 276                 else return new ClassType(outer1, typarams1.toList(), t.tsym, t.getMetadata(), t.getFlavor()) {
 277                     @Override
 278                     protected boolean needsStripping() {
 279                         return true;
 280                     }
 281                 };
 282             }
 283         }
 284 
 285         @Override
 286         public Type visitArrayType(ArrayType t, ProjectionKind s) {
 287             Type elemtype = t.elemtype;
 288             Type elemtype1 = visit(elemtype, s);
 289             if (elemtype1 == elemtype) {
 290                 return t;
 291             } else if (elemtype1.hasTag(BOT)) {
 292                 //undefined
 293                 return syms.botType;
 294             } else {
 295                 return new ArrayType(elemtype1, t.tsym, t.metadata) {
 296                     @Override
 297                     protected boolean needsStripping() {
 298                         return true;
 299                     }
 300                 };
 301             }
 302         }
 303 
 304         @Override
 305         public Type visitTypeVar(TypeVar t, ProjectionKind pkind) {
 306             if (vars.contains(t)) {
 307                 if (seen.add(t)) {
 308                     try {
 309                         final Type bound;
 310                         switch (pkind) {
 311                             case UPWARDS:
 312                                 bound = t.getUpperBound();
 313                                 break;
 314                             case DOWNWARDS:
 315                                 bound = (t.getLowerBound() == null) ?
 316                                         syms.botType :
 317                                         t.getLowerBound();
 318                                 break;
 319                             default:
 320                                 Assert.error();
 321                                 return null;
 322                         }
 323                         return bound.map(this, pkind);
 324                     } finally {
 325                         seen.remove(t);
 326                     }
 327                 } else {
 328                     //cycle
 329                     return pkind == ProjectionKind.UPWARDS ?
 330                             syms.objectType : syms.botType;
 331                 }
 332             } else {
 333                 return t;
 334             }
 335         }
 336 
 337         private Type mapTypeArgument(Type site, Type declaredBound, Type t, ProjectionKind pkind) {
 338             return t.containsAny(vars) ?
 339                     t.map(new TypeArgumentProjection(site, declaredBound), pkind) :
 340                     t;
 341         }
 342 
 343         class TypeArgumentProjection extends TypeMapping<ProjectionKind> {
 344 
 345             Type site;
 346             Type declaredBound;
 347 
 348             TypeArgumentProjection(Type site, Type declaredBound) {
 349                 this.site = site;
 350                 this.declaredBound = declaredBound;
 351             }
 352 
 353             @Override
 354             public Type visitType(Type t, ProjectionKind pkind) {
 355                 //type argument is some type containing restricted vars
 356                 if (pkind == ProjectionKind.DOWNWARDS) {
 357                     //not defined
 358                     return syms.botType;
 359                 }
 360                 Type upper = t.map(TypeProjection.this, ProjectionKind.UPWARDS);
 361                 Type lower = t.map(TypeProjection.this, ProjectionKind.DOWNWARDS);
 362                 List<Type> formals = site.tsym.type.getTypeArguments();
 363                 BoundKind bk;
 364                 Type bound;
 365                 if (!isSameType(upper, syms.objectType) &&
 366                         (declaredBound.containsAny(formals) ||
 367                          !isSubtype(declaredBound, upper))) {
 368                     bound = upper;
 369                     bk = EXTENDS;
 370                 } else if (!lower.hasTag(BOT)) {
 371                     bound = lower;
 372                     bk = SUPER;
 373                 } else {
 374                     bound = syms.objectType;
 375                     bk = UNBOUND;
 376                 }
 377                 return makeWildcard(bound, bk);
 378             }
 379 
 380             @Override
 381             public Type visitWildcardType(WildcardType wt, ProjectionKind pkind) {
 382                 //type argument is some wildcard whose bound contains restricted vars
 383                 Type bound = syms.botType;
 384                 BoundKind bk = wt.kind;
 385                 switch (wt.kind) {
 386                     case EXTENDS:
 387                         bound = wt.type.map(TypeProjection.this, pkind);
 388                         if (bound.hasTag(BOT)) {
 389                             return syms.botType;
 390                         }
 391                         break;
 392                     case SUPER:
 393                         bound = wt.type.map(TypeProjection.this, pkind.complement());
 394                         if (bound.hasTag(BOT)) {
 395                             bound = syms.objectType;
 396                             bk = UNBOUND;
 397                         }
 398                         break;
 399                 }
 400                 return makeWildcard(bound, bk);
 401             }
 402 
 403             private Type makeWildcard(Type bound, BoundKind bk) {
 404                 return new WildcardType(bound, bk, syms.boundClass) {
 405                     @Override
 406                     protected boolean needsStripping() {
 407                         return true;
 408                     }
 409                 };
 410             }
 411         }
 412     }
 413 
 414     /**
 415      * Computes an upward projection of given type, and vars. See {@link TypeProjection}.
 416      *
 417      * @param t the type to be projected
 418      * @param vars the set of type variables to be mapped
 419      * @return the type obtained as result of the projection
 420      */
 421     public Type upward(Type t, List<Type> vars) {
 422         return t.map(new TypeProjection(vars), ProjectionKind.UPWARDS);
 423     }
 424 
 425     /**
 426      * Computes the set of captured variables mentioned in a given type. See {@link CaptureScanner}.
 427      * This routine is typically used to computed the input set of variables to be used during
 428      * an upwards projection (see {@link Types#upward(Type, List)}).
 429      *
 430      * @param t the type where occurrences of captured variables have to be found
 431      * @return the set of captured variables found in t
 432      */
 433     public List<Type> captures(Type t) {
 434         CaptureScanner cs = new CaptureScanner();
 435         Set<Type> captures = new HashSet<>();
 436         cs.visit(t, captures);
 437         return List.from(captures);
 438     }
 439 
 440     /**
 441      * This visitor scans a type recursively looking for occurrences of captured type variables.
 442      */
 443     class CaptureScanner extends SimpleVisitor<Void, Set<Type>> {
 444 
 445         @Override
 446         public Void visitType(Type t, Set<Type> types) {
 447             return null;
 448         }
 449 
 450         @Override
 451         public Void visitClassType(ClassType t, Set<Type> seen) {
 452             if (t.isCompound()) {
 453                 directSupertypes(t).forEach(s -> visit(s, seen));
 454             } else {
 455                 t.allparams().forEach(ta -> visit(ta, seen));
 456             }
 457             return null;
 458         }
 459 
 460         @Override
 461         public Void visitArrayType(ArrayType t, Set<Type> seen) {
 462             return visit(t.elemtype, seen);
 463         }
 464 
 465         @Override
 466         public Void visitWildcardType(WildcardType t, Set<Type> seen) {
 467             visit(t.type, seen);
 468             return null;
 469         }
 470 
 471         @Override
 472         public Void visitTypeVar(TypeVar t, Set<Type> seen) {
 473             if ((t.tsym.flags() & Flags.SYNTHETIC) != 0 && seen.add(t)) {
 474                 visit(t.getUpperBound(), seen);
 475             }
 476             return null;
 477         }
 478 
 479         @Override
 480         public Void visitCapturedType(CapturedType t, Set<Type> seen) {
 481             if (seen.add(t)) {
 482                 visit(t.getUpperBound(), seen);
 483                 visit(t.getLowerBound(), seen);
 484             }
 485             return null;
 486         }
 487     }
 488 
 489     // </editor-fold>
 490 
 491     // <editor-fold defaultstate="collapsed" desc="isUnbounded">
 492     /**
 493      * Checks that all the arguments to a class are unbounded
 494      * wildcards or something else that doesn't make any restrictions
 495      * on the arguments. If a class isUnbounded, a raw super- or
 496      * subclass can be cast to it without a warning.
 497      * @param t a type
 498      * @return true iff the given type is unbounded or raw
 499      */
 500     public boolean isUnbounded(Type t) {
 501         return isUnbounded.visit(t);
 502     }
 503     // where
 504         private final UnaryVisitor<Boolean> isUnbounded = new UnaryVisitor<Boolean>() {
 505 
 506             public Boolean visitType(Type t, Void ignored) {
 507                 return true;
 508             }
 509 
 510             @Override
 511             public Boolean visitClassType(ClassType t, Void ignored) {
 512                 List<Type> parms = t.tsym.type.allparams();
 513                 List<Type> args = t.allparams();
 514                 while (parms.nonEmpty()) {
 515                     WildcardType unb = new WildcardType(syms.objectType,
 516                                                         BoundKind.UNBOUND,
 517                                                         syms.boundClass,
 518                                                         (TypeVar)parms.head);
 519                     if (!containsType(args.head, unb))
 520                         return false;
 521                     parms = parms.tail;
 522                     args = args.tail;
 523                 }
 524                 return true;
 525             }
 526         };
 527     // </editor-fold>
 528 
 529     // <editor-fold defaultstate="collapsed" desc="asSub">
 530     /**
 531      * Return the least specific subtype of t that starts with symbol
 532      * sym.  If none exists, return null.  The least specific subtype
 533      * is determined as follows:
 534      *
 535      * <p>If there is exactly one parameterized instance of sym that is a
 536      * subtype of t, that parameterized instance is returned.<br>
 537      * Otherwise, if the plain type or raw type `sym' is a subtype of
 538      * type t, the type `sym' itself is returned.  Otherwise, null is
 539      * returned.
 540      */
 541     public Type asSub(Type t, Symbol sym) {
 542         return asSub.visit(t, sym);
 543     }
 544     // where
 545         private final SimpleVisitor<Type,Symbol> asSub = new SimpleVisitor<Type,Symbol>() {
 546 
 547             public Type visitType(Type t, Symbol sym) {
 548                 return null;
 549             }
 550 
 551             @Override
 552             public Type visitClassType(ClassType t, Symbol sym) {
 553                 if (t.tsym == sym)
 554                     return t;
 555                 Type base = asSuper(sym.type, t.tsym);
 556                 if (base == null)
 557                     return null;
 558                 ListBuffer<Type> from = new ListBuffer<>();
 559                 ListBuffer<Type> to = new ListBuffer<>();
 560                 try {
 561                     adapt(base, t, from, to);
 562                 } catch (AdaptFailure ex) {
 563                     return null;
 564                 }
 565                 Type res = subst(sym.type, from.toList(), to.toList());
 566                 if (!isSubtype(res, t))
 567                     return null;
 568                 ListBuffer<Type> openVars = new ListBuffer<>();
 569                 for (List<Type> l = sym.type.allparams();
 570                      l.nonEmpty(); l = l.tail)
 571                     if (res.contains(l.head) && !t.contains(l.head))
 572                         openVars.append(l.head);
 573                 if (openVars.nonEmpty()) {
 574                     if (t.isRaw()) {
 575                         // The subtype of a raw type is raw
 576                         res = erasure(res);
 577                     } else {
 578                         // Unbound type arguments default to ?
 579                         List<Type> opens = openVars.toList();
 580                         ListBuffer<Type> qs = new ListBuffer<>();
 581                         for (List<Type> iter = opens; iter.nonEmpty(); iter = iter.tail) {
 582                             qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND,
 583                                                        syms.boundClass, (TypeVar) iter.head));
 584                         }
 585                         res = subst(res, opens, qs.toList());
 586                     }
 587                 }
 588                 return res;
 589             }
 590 
 591             @Override
 592             public Type visitErrorType(ErrorType t, Symbol sym) {
 593                 return t;
 594             }
 595         };
 596     // </editor-fold>
 597 
 598     // <editor-fold defaultstate="collapsed" desc="isConvertible">
 599     /**
 600      * Is t a subtype of or convertible via boxing/unboxing
 601      * conversion to s?
 602      */
 603     public boolean isConvertible(Type t, Type s, Warner warn) {
 604         if (t.hasTag(ERROR)) {
 605             return true;
 606         }
 607 
 608         boolean tValue = t.isPrimitiveClass();
 609         boolean sValue = s.isPrimitiveClass();
 610         if (tValue != sValue) {
 611             return tValue ?
 612                     isSubtype(t.referenceProjection(), s) :
 613                     !t.hasTag(BOT) && isSubtype(t, s.referenceProjection());
 614         }
 615 
 616         boolean tPrimitive = t.isPrimitive();
 617         boolean sPrimitive = s.isPrimitive();
 618         if (tPrimitive == sPrimitive) {
 619             return isSubtypeUnchecked(t, s, warn);
 620         }
 621         boolean tUndet = t.hasTag(UNDETVAR);
 622         boolean sUndet = s.hasTag(UNDETVAR);
 623 
 624         if (tUndet || sUndet) {
 625             return tUndet ?
 626                     isSubtype(t, boxedTypeOrType(s)) :
 627                     isSubtype(boxedTypeOrType(t), s);
 628         }
 629 
 630         return tPrimitive
 631             ? isSubtype(boxedClass(t).type, s)
 632             : isSubtype(unboxedType(t), s);
 633     }
 634 
 635     /**
 636      * Is t a subtype of or convertible via boxing/unboxing
 637      * conversions to s?
 638      */
 639     public boolean isConvertible(Type t, Type s) {
 640         return isConvertible(t, s, noWarnings);
 641     }
 642     // </editor-fold>
 643 
 644     // <editor-fold defaultstate="collapsed" desc="findSam">
 645 
 646     /**
 647      * Exception used to report a function descriptor lookup failure. The exception
 648      * wraps a diagnostic that can be used to generate more details error
 649      * messages.
 650      */
 651     public static class FunctionDescriptorLookupError extends RuntimeException {
 652         private static final long serialVersionUID = 0;
 653 
 654         transient JCDiagnostic diagnostic;
 655 
 656         FunctionDescriptorLookupError() {
 657             this.diagnostic = null;
 658         }
 659 
 660         FunctionDescriptorLookupError setMessage(JCDiagnostic diag) {
 661             this.diagnostic = diag;
 662             return this;
 663         }
 664 
 665         public JCDiagnostic getDiagnostic() {
 666             return diagnostic;
 667         }
 668     }
 669 
 670     /**
 671      * A cache that keeps track of function descriptors associated with given
 672      * functional interfaces.
 673      */
 674     class DescriptorCache {
 675 
 676         private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<>();
 677 
 678         class FunctionDescriptor {
 679             Symbol descSym;
 680 
 681             FunctionDescriptor(Symbol descSym) {
 682                 this.descSym = descSym;
 683             }
 684 
 685             public Symbol getSymbol() {
 686                 return descSym;
 687             }
 688 
 689             public Type getType(Type site) {
 690                 site = removeWildcards(site);
 691                 if (site.isIntersection()) {
 692                     IntersectionClassType ict = (IntersectionClassType)site;
 693                     for (Type component : ict.getExplicitComponents()) {
 694                         if (!chk.checkValidGenericType(component)) {
 695                             //if the inferred functional interface type is not well-formed,
 696                             //or if it's not a subtype of the original target, issue an error
 697                             throw failure(diags.fragment(Fragments.NoSuitableFunctionalIntfInst(site)));
 698                         }
 699                     }
 700                 } else {
 701                     if (!chk.checkValidGenericType(site)) {
 702                         //if the inferred functional interface type is not well-formed,
 703                         //or if it's not a subtype of the original target, issue an error
 704                         throw failure(diags.fragment(Fragments.NoSuitableFunctionalIntfInst(site)));
 705                     }
 706                 }
 707                 return memberType(site, descSym);
 708             }
 709         }
 710 
 711         class Entry {
 712             final FunctionDescriptor cachedDescRes;
 713             final int prevMark;
 714 
 715             public Entry(FunctionDescriptor cachedDescRes,
 716                     int prevMark) {
 717                 this.cachedDescRes = cachedDescRes;
 718                 this.prevMark = prevMark;
 719             }
 720 
 721             boolean matches(int mark) {
 722                 return  this.prevMark == mark;
 723             }
 724         }
 725 
 726         FunctionDescriptor get(TypeSymbol origin) throws FunctionDescriptorLookupError {
 727             Entry e = _map.get(origin);
 728             CompoundScope members = membersClosure(origin.type, false);
 729             if (e == null ||
 730                     !e.matches(members.getMark())) {
 731                 FunctionDescriptor descRes = findDescriptorInternal(origin, members);
 732                 _map.put(origin, new Entry(descRes, members.getMark()));
 733                 return descRes;
 734             }
 735             else {
 736                 return e.cachedDescRes;
 737             }
 738         }
 739 
 740         /**
 741          * Compute the function descriptor associated with a given functional interface
 742          */
 743         public FunctionDescriptor findDescriptorInternal(TypeSymbol origin,
 744                 CompoundScope membersCache) throws FunctionDescriptorLookupError {
 745             if (!origin.isInterface() || (origin.flags() & ANNOTATION) != 0 || origin.isSealed()) {
 746                 //t must be an interface
 747                 throw failure("not.a.functional.intf", origin);
 748             }
 749 
 750             final ListBuffer<Symbol> abstracts = new ListBuffer<>();
 751             for (Symbol sym : membersCache.getSymbols(new DescriptorFilter(origin))) {
 752                 Type mtype = memberType(origin.type, sym);
 753                 if (abstracts.isEmpty()) {
 754                     abstracts.append(sym);
 755                 } else if ((sym.name == abstracts.first().name &&
 756                         overrideEquivalent(mtype, memberType(origin.type, abstracts.first())))) {
 757                     if (!abstracts.stream().filter(msym -> msym.owner.isSubClass(sym.enclClass(), Types.this))
 758                             .map(msym -> memberType(origin.type, msym))
 759                             .anyMatch(abstractMType -> isSubSignature(abstractMType, mtype))) {
 760                         abstracts.append(sym);
 761                     }
 762                 } else {
 763                     //the target method(s) should be the only abstract members of t
 764                     throw failure("not.a.functional.intf.1",  origin,
 765                             diags.fragment(Fragments.IncompatibleAbstracts(Kinds.kindName(origin), origin)));
 766                 }
 767             }
 768             if (abstracts.isEmpty()) {
 769                 //t must define a suitable non-generic method
 770                 throw failure("not.a.functional.intf.1", origin,
 771                             diags.fragment(Fragments.NoAbstracts(Kinds.kindName(origin), origin)));
 772             }
 773             FunctionDescriptor descRes;
 774             if (abstracts.size() == 1) {
 775                 descRes = new FunctionDescriptor(abstracts.first());
 776             } else { // size > 1
 777                 descRes = mergeDescriptors(origin, abstracts.toList());
 778                 if (descRes == null) {
 779                     //we can get here if the functional interface is ill-formed
 780                     ListBuffer<JCDiagnostic> descriptors = new ListBuffer<>();
 781                     for (Symbol desc : abstracts) {
 782                         String key = desc.type.getThrownTypes().nonEmpty() ?
 783                                 "descriptor.throws" : "descriptor";
 784                         descriptors.append(diags.fragment(key, desc.name,
 785                                 desc.type.getParameterTypes(),
 786                                 desc.type.getReturnType(),
 787                                 desc.type.getThrownTypes()));
 788                     }
 789                     JCDiagnostic msg =
 790                             diags.fragment(Fragments.IncompatibleDescsInFunctionalIntf(Kinds.kindName(origin),
 791                                                                                        origin));
 792                     JCDiagnostic.MultilineDiagnostic incompatibleDescriptors =
 793                             new JCDiagnostic.MultilineDiagnostic(msg, descriptors.toList());
 794                     throw failure(incompatibleDescriptors);
 795                 }
 796             }
 797             // an interface must be neither an identity interface nor a value interface to be functional.
 798             List<Type> allInterfaces = closure(origin.type);
 799             for (Type iface : allInterfaces) {
 800                 if (iface.isValueInterface()) {
 801                     throw failure("not.a.functional.intf.1", origin, diags.fragment(Fragments.ValueInterfaceNonfunctional));
 802                 }
 803                 if (iface.isIdentityInterface()) {
 804                     throw failure("not.a.functional.intf.1", origin, diags.fragment(Fragments.IdentityInterfaceNonfunctional));
 805                 }
 806             }
 807             return descRes;
 808         }
 809 
 810         /**
 811          * Compute a synthetic type for the target descriptor given a list
 812          * of override-equivalent methods in the functional interface type.
 813          * The resulting method type is a method type that is override-equivalent
 814          * and return-type substitutable with each method in the original list.
 815          */
 816         private FunctionDescriptor mergeDescriptors(TypeSymbol origin, List<Symbol> methodSyms) {
 817             return mergeAbstracts(methodSyms, origin.type, false)
 818                     .map(bestSoFar -> new FunctionDescriptor(bestSoFar.baseSymbol()) {
 819                         @Override
 820                         public Type getType(Type origin) {
 821                             Type mt = memberType(origin, getSymbol());
 822                             return createMethodTypeWithThrown(mt, bestSoFar.type.getThrownTypes());
 823                         }
 824                     }).orElse(null);
 825         }
 826 
 827         FunctionDescriptorLookupError failure(String msg, Object... args) {
 828             return failure(diags.fragment(msg, args));
 829         }
 830 
 831         FunctionDescriptorLookupError failure(JCDiagnostic diag) {
 832             return new FunctionDescriptorLookupError().setMessage(diag);
 833         }
 834     }
 835 
 836     private DescriptorCache descCache = new DescriptorCache();
 837 
 838     /**
 839      * Find the method descriptor associated to this class symbol - if the
 840      * symbol 'origin' is not a functional interface, an exception is thrown.
 841      */
 842     public Symbol findDescriptorSymbol(TypeSymbol origin) throws FunctionDescriptorLookupError {
 843         return descCache.get(origin).getSymbol();
 844     }
 845 
 846     /**
 847      * Find the type of the method descriptor associated to this class symbol -
 848      * if the symbol 'origin' is not a functional interface, an exception is thrown.
 849      */
 850     public Type findDescriptorType(Type origin) throws FunctionDescriptorLookupError {
 851         return descCache.get(origin.tsym).getType(origin);
 852     }
 853 
 854     /**
 855      * Is given type a functional interface?
 856      */
 857     public boolean isFunctionalInterface(TypeSymbol tsym) {
 858         try {
 859             findDescriptorSymbol(tsym);
 860             return true;
 861         } catch (FunctionDescriptorLookupError ex) {
 862             return false;
 863         }
 864     }
 865 
 866     public boolean isFunctionalInterface(Type site) {
 867         try {
 868             findDescriptorType(site);
 869             return true;
 870         } catch (FunctionDescriptorLookupError ex) {
 871             return false;
 872         }
 873     }
 874 
 875     public Type removeWildcards(Type site) {
 876         if (site.getTypeArguments().stream().anyMatch(t -> t.hasTag(WILDCARD))) {
 877             //compute non-wildcard parameterization - JLS 9.9
 878             List<Type> actuals = site.getTypeArguments();
 879             List<Type> formals = site.tsym.type.getTypeArguments();
 880             ListBuffer<Type> targs = new ListBuffer<>();
 881             for (Type formal : formals) {
 882                 Type actual = actuals.head;
 883                 Type bound = formal.getUpperBound();
 884                 if (actuals.head.hasTag(WILDCARD)) {
 885                     WildcardType wt = (WildcardType)actual;
 886                     //check that bound does not contain other formals
 887                     if (bound.containsAny(formals)) {
 888                         targs.add(wt.type);
 889                     } else {
 890                         //compute new type-argument based on declared bound and wildcard bound
 891                         switch (wt.kind) {
 892                             case UNBOUND:
 893                                 targs.add(bound);
 894                                 break;
 895                             case EXTENDS:
 896                                 targs.add(glb(bound, wt.type));
 897                                 break;
 898                             case SUPER:
 899                                 targs.add(wt.type);
 900                                 break;
 901                             default:
 902                                 Assert.error("Cannot get here!");
 903                         }
 904                     }
 905                 } else {
 906                     //not a wildcard - the new type argument remains unchanged
 907                     targs.add(actual);
 908                 }
 909                 actuals = actuals.tail;
 910             }
 911             return subst(site.tsym.type, formals, targs.toList());
 912         } else {
 913             return site;
 914         }
 915     }
 916 
 917     /**
 918      * Create a symbol for a class that implements a given functional interface
 919      * and overrides its functional descriptor. This routine is used for two
 920      * main purposes: (i) checking well-formedness of a functional interface;
 921      * (ii) perform functional interface bridge calculation.
 922      */
 923     public ClassSymbol makeFunctionalInterfaceClass(Env<AttrContext> env, Name name, Type target, long cflags) {
 924         if (target == null || target == syms.unknownType) {
 925             return null;
 926         }
 927         Symbol descSym = findDescriptorSymbol(target.tsym);
 928         Type descType = findDescriptorType(target);
 929         ClassSymbol csym = new ClassSymbol(cflags, name, env.enclClass.sym.outermostClass());
 930         csym.completer = Completer.NULL_COMPLETER;
 931         csym.members_field = WriteableScope.create(csym);
 932         MethodSymbol instDescSym = new MethodSymbol(descSym.flags(), descSym.name, descType, csym);
 933         csym.members_field.enter(instDescSym);
 934         Type.ClassType ctype = new Type.ClassType(Type.noType, List.nil(), csym);
 935         ctype.supertype_field = syms.objectType;
 936         ctype.interfaces_field = target.isIntersection() ?
 937                 directSupertypes(target) :
 938                 List.of(target);
 939         csym.type = ctype;
 940         csym.sourcefile = ((ClassSymbol)csym.owner).sourcefile;
 941         return csym;
 942     }
 943 
 944     /**
 945      * Find the minimal set of methods that are overridden by the functional
 946      * descriptor in 'origin'. All returned methods are assumed to have different
 947      * erased signatures.
 948      */
 949     public List<Symbol> functionalInterfaceBridges(TypeSymbol origin) {
 950         Assert.check(isFunctionalInterface(origin));
 951         Symbol descSym = findDescriptorSymbol(origin);
 952         CompoundScope members = membersClosure(origin.type, false);
 953         ListBuffer<Symbol> overridden = new ListBuffer<>();
 954         outer: for (Symbol m2 : members.getSymbolsByName(descSym.name, bridgeFilter)) {
 955             if (m2 == descSym) continue;
 956             else if (descSym.overrides(m2, origin, Types.this, false)) {
 957                 for (Symbol m3 : overridden) {
 958                     if (isSameType(m3.erasure(Types.this), m2.erasure(Types.this)) ||
 959                             (m3.overrides(m2, origin, Types.this, false) &&
 960                             (pendingBridges((ClassSymbol)origin, m3.enclClass()) ||
 961                             (((MethodSymbol)m2).binaryImplementation((ClassSymbol)m3.owner, Types.this) != null)))) {
 962                         continue outer;
 963                     }
 964                 }
 965                 overridden.add(m2);
 966             }
 967         }
 968         return overridden.toList();
 969     }
 970     //where
 971         // Use anonymous class instead of lambda expression intentionally,
 972         // because the variable `names` has modifier: final.
 973         private Predicate<Symbol> bridgeFilter = new Predicate<Symbol>() {
 974             public boolean test(Symbol t) {
 975                 return t.kind == MTH &&
 976                         t.name != names.init &&
 977                         t.name != names.clinit &&
 978                         (t.flags() & SYNTHETIC) == 0;
 979             }
 980         };
 981 
 982         private boolean pendingBridges(ClassSymbol origin, TypeSymbol s) {
 983             //a symbol will be completed from a classfile if (a) symbol has
 984             //an associated file object with CLASS kind and (b) the symbol has
 985             //not been entered
 986             if (origin.classfile != null &&
 987                     origin.classfile.getKind() == JavaFileObject.Kind.CLASS &&
 988                     enter.getEnv(origin) == null) {
 989                 return false;
 990             }
 991             if (origin == s) {
 992                 return true;
 993             }
 994             for (Type t : interfaces(origin.type)) {
 995                 if (pendingBridges((ClassSymbol)t.tsym, s)) {
 996                     return true;
 997                 }
 998             }
 999             return false;
1000         }
1001     // </editor-fold>
1002 
1003    /**
1004     * Scope filter used to skip methods that should be ignored (such as methods
1005     * overridden by j.l.Object) during function interface conversion interface check
1006     */
1007     class DescriptorFilter implements Predicate<Symbol> {
1008 
1009        TypeSymbol origin;
1010 
1011        DescriptorFilter(TypeSymbol origin) {
1012            this.origin = origin;
1013        }
1014 
1015        @Override
1016        public boolean test(Symbol sym) {
1017            return sym.kind == MTH &&
1018                    (sym.flags() & (ABSTRACT | DEFAULT)) == ABSTRACT &&
1019                    !overridesObjectMethod(origin, sym) &&
1020                    (interfaceCandidates(origin.type, (MethodSymbol)sym).head.flags() & DEFAULT) == 0;
1021        }
1022     }
1023 
1024     // <editor-fold defaultstate="collapsed" desc="isSubtype">
1025     /**
1026      * Is t an unchecked subtype of s?
1027      */
1028     public boolean isSubtypeUnchecked(Type t, Type s) {
1029         return isSubtypeUnchecked(t, s, noWarnings);
1030     }
1031     /**
1032      * Is t an unchecked subtype of s?
1033      */
1034     public boolean isSubtypeUnchecked(Type t, Type s, Warner warn) {
1035         boolean result = isSubtypeUncheckedInternal(t, s, true, warn);
1036         if (result) {
1037             checkUnsafeVarargsConversion(t, s, warn);
1038         }
1039         return result;
1040     }
1041     //where
1042         private boolean isSubtypeUncheckedInternal(Type t, Type s, boolean capture, Warner warn) {
1043             if (t.hasTag(ARRAY) && s.hasTag(ARRAY)) {
1044                 if (((ArrayType)t).elemtype.isPrimitive()) {
1045                     return isSameType(elemtype(t), elemtype(s));
1046                 } else {
1047                     // if T.ref <: S, then T[] <: S[]
1048                     Type es = elemtype(s);
1049                     Type et = elemtype(t);
1050                     if (et.isPrimitiveClass()) {
1051                         et = et.referenceProjection();
1052                         if (es.isPrimitiveClass())
1053                             es = es.referenceProjection();  // V <: V, surely
1054                     }
1055                     if (!isSubtypeUncheckedInternal(et, es, false, warn))
1056                         return false;
1057                     return true;
1058                 }
1059             } else if (isSubtype(t, s, capture)) {
1060                 return true;
1061             } else if (t.hasTag(TYPEVAR)) {
1062                 return isSubtypeUncheckedInternal(t.getUpperBound(), s, false, warn);
1063             } else if (!s.isRaw()) {
1064                 Type t2 = asSuper(t, s.tsym);
1065                 if (t2 != null && t2.isRaw()) {
1066                     if (isReifiable(s)) {
1067                         warn.silentWarn(LintCategory.UNCHECKED);
1068                     } else {
1069                         warn.warn(LintCategory.UNCHECKED);
1070                     }
1071                     return true;
1072                 }
1073             }
1074             return false;
1075         }
1076 
1077         private void checkUnsafeVarargsConversion(Type t, Type s, Warner warn) {
1078             if (!t.hasTag(ARRAY) || isReifiable(t)) {
1079                 return;
1080             }
1081             ArrayType from = (ArrayType)t;
1082             boolean shouldWarn = false;
1083             switch (s.getTag()) {
1084                 case ARRAY:
1085                     ArrayType to = (ArrayType)s;
1086                     shouldWarn = from.isVarargs() &&
1087                             !to.isVarargs() &&
1088                             !isReifiable(from);
1089                     break;
1090                 case CLASS:
1091                     shouldWarn = from.isVarargs();
1092                     break;
1093             }
1094             if (shouldWarn) {
1095                 warn.warn(LintCategory.VARARGS);
1096             }
1097         }
1098 
1099     /**
1100      * Is t a subtype of s?<br>
1101      * (not defined for Method and ForAll types)
1102      */
1103     public final boolean isSubtype(Type t, Type s) {
1104         return isSubtype(t, s, true);
1105     }
1106     public final boolean isSubtypeNoCapture(Type t, Type s) {
1107         return isSubtype(t, s, false);
1108     }
1109     public boolean isSubtype(Type t, Type s, boolean capture) {
1110         if (t.equalsIgnoreMetadata(s))
1111             return true;
1112         if (s.isPartial())
1113             return isSuperType(s, t);
1114 
1115         if (s.isCompound()) {
1116             for (Type s2 : interfaces(s).prepend(supertype(s))) {
1117                 if (!isSubtype(t, s2, capture))
1118                     return false;
1119             }
1120             return true;
1121         }
1122 
1123         // Generally, if 's' is a lower-bounded type variable, recur on lower bound; but
1124         // for inference variables and intersections, we need to keep 's'
1125         // (see JLS 4.10.2 for intersections and 18.2.3 for inference vars)
1126         if (!t.hasTag(UNDETVAR) && !t.isCompound()) {
1127             // TODO: JDK-8039198, bounds checking sometimes passes in a wildcard as s
1128             Type lower = cvarLowerBound(wildLowerBound(s));
1129             if (s != lower && !lower.hasTag(BOT))
1130                 return isSubtype(capture ? capture(t) : t, lower, false);
1131         }
1132 
1133         return isSubtype.visit(capture ? capture(t) : t, s);
1134     }
1135     // where
1136         private TypeRelation isSubtype = new TypeRelation()
1137         {
1138             @Override
1139             public Boolean visitType(Type t, Type s) {
1140                 switch (t.getTag()) {
1141                  case BYTE:
1142                      return (!s.hasTag(CHAR) && t.getTag().isSubRangeOf(s.getTag()));
1143                  case CHAR:
1144                      return (!s.hasTag(SHORT) && t.getTag().isSubRangeOf(s.getTag()));
1145                  case SHORT: case INT: case LONG:
1146                  case FLOAT: case DOUBLE:
1147                      return t.getTag().isSubRangeOf(s.getTag());
1148                  case BOOLEAN: case VOID:
1149                      return t.hasTag(s.getTag());
1150                  case TYPEVAR:
1151                      return isSubtypeNoCapture(t.getUpperBound(), s);
1152                  case BOT:
1153                      return
1154                          s.hasTag(BOT) || (s.hasTag(CLASS) && !s.isPrimitiveClass()) ||
1155                          s.hasTag(ARRAY) || s.hasTag(TYPEVAR);
1156                  case WILDCARD: //we shouldn't be here - avoids crash (see 7034495)
1157                  case NONE:
1158                      return false;
1159                  default:
1160                      throw new AssertionError("isSubtype " + t.getTag());
1161                  }
1162             }
1163 
1164             private Set<TypePair> cache = new HashSet<>();
1165 
1166             private boolean containsTypeRecursive(Type t, Type s) {
1167                 TypePair pair = new TypePair(t, s);
1168                 if (cache.add(pair)) {
1169                     try {
1170                         return containsType(t.getTypeArguments(),
1171                                             s.getTypeArguments());
1172                     } finally {
1173                         cache.remove(pair);
1174                     }
1175                 } else {
1176                     return containsType(t.getTypeArguments(),
1177                                         rewriteSupers(s).getTypeArguments());
1178                 }
1179             }
1180 
1181             private Type rewriteSupers(Type t) {
1182                 if (!t.isParameterized())
1183                     return t;
1184                 ListBuffer<Type> from = new ListBuffer<>();
1185                 ListBuffer<Type> to = new ListBuffer<>();
1186                 adaptSelf(t, from, to);
1187                 if (from.isEmpty())
1188                     return t;
1189                 ListBuffer<Type> rewrite = new ListBuffer<>();
1190                 boolean changed = false;
1191                 for (Type orig : to.toList()) {
1192                     Type s = rewriteSupers(orig);
1193                     if (s.isSuperBound() && !s.isExtendsBound()) {
1194                         s = new WildcardType(syms.objectType,
1195                                              BoundKind.UNBOUND,
1196                                              syms.boundClass,
1197                                              s.getMetadata());
1198                         changed = true;
1199                     } else if (s != orig) {
1200                         s = new WildcardType(wildUpperBound(s),
1201                                              BoundKind.EXTENDS,
1202                                              syms.boundClass,
1203                                              s.getMetadata());
1204                         changed = true;
1205                     }
1206                     rewrite.append(s);
1207                 }
1208                 if (changed)
1209                     return subst(t.tsym.type, from.toList(), rewrite.toList());
1210                 else
1211                     return t;
1212             }
1213 
1214             @Override
1215             public Boolean visitClassType(ClassType t, Type s) {
1216                 Type sup = asSuper(t, s.tsym);
1217                 if (sup == null) return false;
1218                 // If t is an intersection, sup might not be a class type
1219                 if (!sup.hasTag(CLASS)) return isSubtypeNoCapture(sup, s);
1220                 return sup.tsym == s.tsym
1221                     && (t.tsym != s.tsym || t.isReferenceProjection() == s.isReferenceProjection())
1222                      // Check type variable containment
1223                     && (!s.isParameterized() || containsTypeRecursive(s, sup))
1224                     && isSubtypeNoCapture(sup.getEnclosingType(),
1225                                           s.getEnclosingType());
1226             }
1227 
1228             @Override
1229             public Boolean visitArrayType(ArrayType t, Type s) {
1230                 if (s.hasTag(ARRAY)) {
1231                     if (t.elemtype.isPrimitive())
1232                         return isSameType(t.elemtype, elemtype(s));
1233                     else {
1234                         // if T.ref <: S, then T[] <: S[]
1235                         Type es = elemtype(s);
1236                         Type et = elemtype(t);
1237                         if (et.isPrimitiveClass()) {
1238                             et = et.referenceProjection();
1239                             if (es.isPrimitiveClass())
1240                                 es = es.referenceProjection();  // V <: V, surely
1241                         }
1242                         return isSubtypeNoCapture(et, es);
1243                     }
1244                 }
1245 
1246                 if (s.hasTag(CLASS)) {
1247                     Name sname = s.tsym.getQualifiedName();
1248                     return sname == names.java_lang_Object
1249                         || sname == names.java_lang_Cloneable
1250                         || sname == names.java_io_Serializable;
1251                 }
1252 
1253                 return false;
1254             }
1255 
1256             @Override
1257             public Boolean visitUndetVar(UndetVar t, Type s) {
1258                 //todo: test against origin needed? or replace with substitution?
1259                 if (t == s || t.qtype == s || s.hasTag(ERROR) || s.hasTag(UNKNOWN)) {
1260                     return true;
1261                 } else if (s.hasTag(BOT)) {
1262                     //if 's' is 'null' there's no instantiated type U for which
1263                     //U <: s (but 'null' itself, which is not a valid type)
1264                     return false;
1265                 }
1266 
1267                 t.addBound(InferenceBound.UPPER, s, Types.this);
1268                 return true;
1269             }
1270 
1271             @Override
1272             public Boolean visitErrorType(ErrorType t, Type s) {
1273                 return true;
1274             }
1275         };
1276 
1277     /**
1278      * Is t a subtype of every type in given list `ts'?<br>
1279      * (not defined for Method and ForAll types)<br>
1280      * Allows unchecked conversions.
1281      */
1282     public boolean isSubtypeUnchecked(Type t, List<Type> ts, Warner warn) {
1283         for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
1284             if (!isSubtypeUnchecked(t, l.head, warn))
1285                 return false;
1286         return true;
1287     }
1288 
1289     /**
1290      * Are corresponding elements of ts subtypes of ss?  If lists are
1291      * of different length, return false.
1292      */
1293     public boolean isSubtypes(List<Type> ts, List<Type> ss) {
1294         while (ts.tail != null && ss.tail != null
1295                /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ &&
1296                isSubtype(ts.head, ss.head)) {
1297             ts = ts.tail;
1298             ss = ss.tail;
1299         }
1300         return ts.tail == null && ss.tail == null;
1301         /*inlined: ts.isEmpty() && ss.isEmpty();*/
1302     }
1303 
1304     /**
1305      * Are corresponding elements of ts subtypes of ss, allowing
1306      * unchecked conversions?  If lists are of different length,
1307      * return false.
1308      **/
1309     public boolean isSubtypesUnchecked(List<Type> ts, List<Type> ss, Warner warn) {
1310         while (ts.tail != null && ss.tail != null
1311                /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ &&
1312                isSubtypeUnchecked(ts.head, ss.head, warn)) {
1313             ts = ts.tail;
1314             ss = ss.tail;
1315         }
1316         return ts.tail == null && ss.tail == null;
1317         /*inlined: ts.isEmpty() && ss.isEmpty();*/
1318     }
1319     // </editor-fold>
1320 
1321     // <editor-fold defaultstate="collapsed" desc="isSuperType">
1322     /**
1323      * Is t a supertype of s?
1324      */
1325     public boolean isSuperType(Type t, Type s) {
1326         switch (t.getTag()) {
1327         case ERROR:
1328             return true;
1329         case UNDETVAR: {
1330             UndetVar undet = (UndetVar)t;
1331             if (t == s ||
1332                 undet.qtype == s ||
1333                 s.hasTag(ERROR) ||
1334                 s.hasTag(BOT)) {
1335                 return true;
1336             }
1337             undet.addBound(InferenceBound.LOWER, s, this);
1338             return true;
1339         }
1340         default:
1341             return isSubtype(s, t);
1342         }
1343     }
1344     // </editor-fold>
1345 
1346     // <editor-fold defaultstate="collapsed" desc="isSameType">
1347     /**
1348      * Are corresponding elements of the lists the same type?  If
1349      * lists are of different length, return false.
1350      */
1351     public boolean isSameTypes(List<Type> ts, List<Type> ss) {
1352         while (ts.tail != null && ss.tail != null
1353                /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ &&
1354                isSameType(ts.head, ss.head)) {
1355             ts = ts.tail;
1356             ss = ss.tail;
1357         }
1358         return ts.tail == null && ss.tail == null;
1359         /*inlined: ts.isEmpty() && ss.isEmpty();*/
1360     }
1361 
1362     /**
1363      * A polymorphic signature method (JLS 15.12.3) is a method that
1364      *   (i) is declared in the java.lang.invoke.MethodHandle/VarHandle classes;
1365      *  (ii) takes a single variable arity parameter;
1366      * (iii) whose declared type is Object[];
1367      *  (iv) has any return type, Object signifying a polymorphic return type; and
1368      *   (v) is native.
1369     */
1370    public boolean isSignaturePolymorphic(MethodSymbol msym) {
1371        List<Type> argtypes = msym.type.getParameterTypes();
1372        return (msym.flags_field & NATIVE) != 0 &&
1373               (msym.owner == syms.methodHandleType.tsym || msym.owner == syms.varHandleType.tsym) &&
1374                argtypes.length() == 1 &&
1375                argtypes.head.hasTag(TypeTag.ARRAY) &&
1376                ((ArrayType)argtypes.head).elemtype.tsym == syms.objectType.tsym;
1377    }
1378 
1379     /**
1380      * Is t the same type as s?
1381      */
1382     public boolean isSameType(Type t, Type s) {
1383         return isSameTypeVisitor.visit(t, s);
1384     }
1385     // where
1386 
1387         /**
1388          * Type-equality relation - type variables are considered
1389          * equals if they share the same object identity.
1390          */
1391         TypeRelation isSameTypeVisitor = new TypeRelation() {
1392 
1393             public Boolean visitType(Type t, Type s) {
1394                 if (t.equalsIgnoreMetadata(s))
1395                     return true;
1396 
1397                 if (s.isPartial())
1398                     return visit(s, t);
1399 
1400                 switch (t.getTag()) {
1401                 case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
1402                 case DOUBLE: case BOOLEAN: case VOID: case BOT: case NONE:
1403                     return t.hasTag(s.getTag());
1404                 case TYPEVAR: {
1405                     if (s.hasTag(TYPEVAR)) {
1406                         //type-substitution does not preserve type-var types
1407                         //check that type var symbols and bounds are indeed the same
1408                         return t == s;
1409                     }
1410                     else {
1411                         //special case for s == ? super X, where upper(s) = u
1412                         //check that u == t, where u has been set by Type.withTypeVar
1413                         return s.isSuperBound() &&
1414                                 !s.isExtendsBound() &&
1415                                 visit(t, wildUpperBound(s));
1416                     }
1417                 }
1418                 default:
1419                     throw new AssertionError("isSameType " + t.getTag());
1420                 }
1421             }
1422 
1423             @Override
1424             public Boolean visitWildcardType(WildcardType t, Type s) {
1425                 if (!s.hasTag(WILDCARD)) {
1426                     return false;
1427                 } else {
1428                     WildcardType t2 = (WildcardType)s;
1429                     return (t.kind == t2.kind || (t.isExtendsBound() && s.isExtendsBound())) &&
1430                             isSameType(t.type, t2.type);
1431                 }
1432             }
1433 
1434             @Override
1435             public Boolean visitClassType(ClassType t, Type s) {
1436                 if (t == s)
1437                     return true;
1438 
1439                 if (s.isPartial())
1440                     return visit(s, t);
1441 
1442                 if (s.isSuperBound() && !s.isExtendsBound())
1443                     return visit(t, wildUpperBound(s)) && visit(t, wildLowerBound(s));
1444 
1445                 if (t.isCompound() && s.isCompound()) {
1446                     if (!visit(supertype(t), supertype(s)))
1447                         return false;
1448 
1449                     Map<Symbol,Type> tMap = new HashMap<>();
1450                     for (Type ti : interfaces(t)) {
1451                         if (tMap.containsKey(ti)) {
1452                             throw new AssertionError("Malformed intersection");
1453                         }
1454                         tMap.put(ti.tsym, ti);
1455                     }
1456                     for (Type si : interfaces(s)) {
1457                         if (!tMap.containsKey(si.tsym))
1458                             return false;
1459                         Type ti = tMap.remove(si.tsym);
1460                         if (!visit(ti, si))
1461                             return false;
1462                     }
1463                     return tMap.isEmpty();
1464                 }
1465                 return t.tsym == s.tsym
1466                     && t.isReferenceProjection() == s.isReferenceProjection()
1467                     && visit(getEnclosingType(t), getEnclosingType(s))
1468                     && containsTypeEquivalent(t.getTypeArguments(), s.getTypeArguments());
1469             }
1470                 // where
1471                 private Type getEnclosingType(Type t) {
1472                     Type et = t.getEnclosingType();
1473                     if (et.isReferenceProjection()) {
1474                         et = et.valueProjection();
1475                     }
1476                     return et;
1477                 }
1478 
1479             @Override
1480             public Boolean visitArrayType(ArrayType t, Type s) {
1481                 if (t == s)
1482                     return true;
1483 
1484                 if (s.isPartial())
1485                     return visit(s, t);
1486 
1487                 return s.hasTag(ARRAY)
1488                     && containsTypeEquivalent(t.elemtype, elemtype(s));
1489             }
1490 
1491             @Override
1492             public Boolean visitMethodType(MethodType t, Type s) {
1493                 // isSameType for methods does not take thrown
1494                 // exceptions into account!
1495                 return hasSameArgs(t, s) && visit(t.getReturnType(), s.getReturnType());
1496             }
1497 
1498             @Override
1499             public Boolean visitPackageType(PackageType t, Type s) {
1500                 return t == s;
1501             }
1502 
1503             @Override
1504             public Boolean visitForAll(ForAll t, Type s) {
1505                 if (!s.hasTag(FORALL)) {
1506                     return false;
1507                 }
1508 
1509                 ForAll forAll = (ForAll)s;
1510                 return hasSameBounds(t, forAll)
1511                     && visit(t.qtype, subst(forAll.qtype, forAll.tvars, t.tvars));
1512             }
1513 
1514             @Override
1515             public Boolean visitUndetVar(UndetVar t, Type s) {
1516                 if (s.hasTag(WILDCARD)) {
1517                     // FIXME, this might be leftovers from before capture conversion
1518                     return false;
1519                 }
1520 
1521                 if (t == s || t.qtype == s || s.hasTag(ERROR) || s.hasTag(UNKNOWN)) {
1522                     return true;
1523                 }
1524 
1525                 t.addBound(InferenceBound.EQ, s, Types.this);
1526 
1527                 return true;
1528             }
1529 
1530             @Override
1531             public Boolean visitErrorType(ErrorType t, Type s) {
1532                 return true;
1533             }
1534         };
1535 
1536     // </editor-fold>
1537 
1538     // <editor-fold defaultstate="collapsed" desc="Contains Type">
1539     public boolean containedBy(Type t, Type s) {
1540         switch (t.getTag()) {
1541         case UNDETVAR:
1542             if (s.hasTag(WILDCARD)) {
1543                 UndetVar undetvar = (UndetVar)t;
1544                 WildcardType wt = (WildcardType)s;
1545                 switch(wt.kind) {
1546                     case UNBOUND:
1547                         break;
1548                     case EXTENDS: {
1549                         Type bound = wildUpperBound(s);
1550                         undetvar.addBound(InferenceBound.UPPER, bound, this);
1551                         break;
1552                     }
1553                     case SUPER: {
1554                         Type bound = wildLowerBound(s);
1555                         undetvar.addBound(InferenceBound.LOWER, bound, this);
1556                         break;
1557                     }
1558                 }
1559                 return true;
1560             } else {
1561                 return isSameType(t, s);
1562             }
1563         case ERROR:
1564             return true;
1565         default:
1566             return containsType(s, t);
1567         }
1568     }
1569 
1570     boolean containsType(List<Type> ts, List<Type> ss) {
1571         while (ts.nonEmpty() && ss.nonEmpty()
1572                && containsType(ts.head, ss.head)) {
1573             ts = ts.tail;
1574             ss = ss.tail;
1575         }
1576         return ts.isEmpty() && ss.isEmpty();
1577     }
1578 
1579     /**
1580      * Check if t contains s.
1581      *
1582      * <p>T contains S if:
1583      *
1584      * <p>{@code L(T) <: L(S) && U(S) <: U(T)}
1585      *
1586      * <p>This relation is only used by ClassType.isSubtype(), that
1587      * is,
1588      *
1589      * <p>{@code C<S> <: C<T> if T contains S.}
1590      *
1591      * <p>Because of F-bounds, this relation can lead to infinite
1592      * recursion.  Thus we must somehow break that recursion.  Notice
1593      * that containsType() is only called from ClassType.isSubtype().
1594      * Since the arguments have already been checked against their
1595      * bounds, we know:
1596      *
1597      * <p>{@code U(S) <: U(T) if T is "super" bound (U(T) *is* the bound)}
1598      *
1599      * <p>{@code L(T) <: L(S) if T is "extends" bound (L(T) is bottom)}
1600      *
1601      * @param t a type
1602      * @param s a type
1603      */
1604     public boolean containsType(Type t, Type s) {
1605         return containsType.visit(t, s);
1606     }
1607     // where
1608         private TypeRelation containsType = new TypeRelation() {
1609 
1610             public Boolean visitType(Type t, Type s) {
1611                 if (s.isPartial())
1612                     return containedBy(s, t);
1613                 else
1614                     return isSameType(t, s);
1615             }
1616 
1617 //            void debugContainsType(WildcardType t, Type s) {
1618 //                System.err.println();
1619 //                System.err.format(" does %s contain %s?%n", t, s);
1620 //                System.err.format(" %s U(%s) <: U(%s) %s = %s%n",
1621 //                                  wildUpperBound(s), s, t, wildUpperBound(t),
1622 //                                  t.isSuperBound()
1623 //                                  || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t)));
1624 //                System.err.format(" %s L(%s) <: L(%s) %s = %s%n",
1625 //                                  wildLowerBound(t), t, s, wildLowerBound(s),
1626 //                                  t.isExtendsBound()
1627 //                                  || isSubtypeNoCapture(wildLowerBound(t), wildLowerBound(s)));
1628 //                System.err.println();
1629 //            }
1630 
1631             @Override
1632             public Boolean visitWildcardType(WildcardType t, Type s) {
1633                 if (s.isPartial())
1634                     return containedBy(s, t);
1635                 else {
1636 //                    debugContainsType(t, s);
1637 
1638                     // -----------------------------------  Unspecified behavior ----------------
1639 
1640                     /* If a primitive class V implements an interface I, then does "? extends I" contain V?
1641                        It seems widening must be applied here to answer yes to compile some common code
1642                        patterns.
1643                     */
1644 
1645                     // ---------------------------------------------------------------------------
1646                     return isSameWildcard(t, s)
1647                         || isCaptureOf(s, t)
1648                         || ((t.isExtendsBound() || isSubtypeNoCapture(wildLowerBound(t), wildLowerBound(s))) &&
1649                             (t.isSuperBound() || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t))));
1650                 }
1651             }
1652 
1653             @Override
1654             public Boolean visitUndetVar(UndetVar t, Type s) {
1655                 if (!s.hasTag(WILDCARD)) {
1656                     return isSameType(t, s);
1657                 } else {
1658                     return false;
1659                 }
1660             }
1661 
1662             @Override
1663             public Boolean visitErrorType(ErrorType t, Type s) {
1664                 return true;
1665             }
1666         };
1667 
1668     public boolean isCaptureOf(Type s, WildcardType t) {
1669         if (!s.hasTag(TYPEVAR) || !((TypeVar)s).isCaptured())
1670             return false;
1671         return isSameWildcard(t, ((CapturedType)s).wildcard);
1672     }
1673 
1674     public boolean isSameWildcard(WildcardType t, Type s) {
1675         if (!s.hasTag(WILDCARD))
1676             return false;
1677         WildcardType w = (WildcardType)s;
1678         return w.kind == t.kind && w.type == t.type;
1679     }
1680 
1681     public boolean containsTypeEquivalent(List<Type> ts, List<Type> ss) {
1682         while (ts.nonEmpty() && ss.nonEmpty()
1683                && containsTypeEquivalent(ts.head, ss.head)) {
1684             ts = ts.tail;
1685             ss = ss.tail;
1686         }
1687         return ts.isEmpty() && ss.isEmpty();
1688     }
1689     // </editor-fold>
1690 
1691     // <editor-fold defaultstate="collapsed" desc="isCastable">
1692     public boolean isCastable(Type t, Type s) {
1693         return isCastable(t, s, noWarnings);
1694     }
1695 
1696     /**
1697      * Is t castable to s?<br>
1698      * s is assumed to be an erased type.<br>
1699      * (not defined for Method and ForAll types).
1700      */
1701     public boolean isCastable(Type t, Type s, Warner warn) {
1702         // if same type
1703         if (t == s)
1704             return true;
1705         // if one of the types is primitive
1706         if (t.isPrimitive() != s.isPrimitive()) {
1707             t = skipTypeVars(t, false);
1708             return (isConvertible(t, s, warn)
1709                     || (s.isPrimitive() &&
1710                         isSubtype(boxedClass(s).type, t)));
1711         }
1712         boolean result;
1713         if (warn != warnStack.head) {
1714             try {
1715                 warnStack = warnStack.prepend(warn);
1716                 checkUnsafeVarargsConversion(t, s, warn);
1717                 result = isCastable.visit(t,s);
1718             } finally {
1719                 warnStack = warnStack.tail;
1720             }
1721         } else {
1722             result = isCastable.visit(t,s);
1723         }
1724         if (result && t.hasTag(CLASS) && t.tsym.kind.matches(Kinds.KindSelector.TYP)
1725                 && s.hasTag(CLASS) && s.tsym.kind.matches(Kinds.KindSelector.TYP)
1726                 && (t.tsym.isSealed() || s.tsym.isSealed())) {
1727             return (t.isCompound() || s.isCompound()) ?
1728                     true :
1729                     !areDisjoint((ClassSymbol)t.tsym, (ClassSymbol)s.tsym);
1730         }
1731         return result;
1732     }
1733     // where
1734         private boolean areDisjoint(ClassSymbol ts, ClassSymbol ss) {
1735             if (isSubtype(erasure(ts.type.referenceProjectionOrSelf()), erasure(ss.type))) {
1736                 return false;
1737             }
1738             // if both are classes or both are interfaces, shortcut
1739             if (ts.isInterface() == ss.isInterface() && isSubtype(erasure(ss.type), erasure(ts.type))) {
1740                 return false;
1741             }
1742             if (ts.isInterface() && !ss.isInterface()) {
1743                 /* so ts is interface but ss is a class
1744                  * an interface is disjoint from a class if the class is disjoint form the interface
1745                  */
1746                 return areDisjoint(ss, ts);
1747             }
1748             // a final class that is not subtype of ss is disjoint
1749             if (!ts.isInterface() && ts.isFinal()) {
1750                 return true;
1751             }
1752             // if at least one is sealed
1753             if (ts.isSealed() || ss.isSealed()) {
1754                 // permitted subtypes have to be disjoint with the other symbol
1755                 ClassSymbol sealedOne = ts.isSealed() ? ts : ss;
1756                 ClassSymbol other = sealedOne == ts ? ss : ts;
1757                 return sealedOne.permitted.stream().allMatch(sym -> areDisjoint((ClassSymbol)sym, other));
1758             }
1759             return false;
1760         }
1761 
1762         private TypeRelation isCastable = new TypeRelation() {
1763 
1764             public Boolean visitType(Type t, Type s) {
1765                 if (s.hasTag(ERROR) || t.hasTag(NONE))
1766                     return true;
1767 
1768                 switch (t.getTag()) {
1769                 case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
1770                 case DOUBLE:
1771                     return s.isNumeric();
1772                 case BOOLEAN:
1773                     return s.hasTag(BOOLEAN);
1774                 case VOID:
1775                     return false;
1776                 case BOT:
1777                     return isSubtype(t, s);
1778                 default:
1779                     throw new AssertionError();
1780                 }
1781             }
1782 
1783             @Override
1784             public Boolean visitWildcardType(WildcardType t, Type s) {
1785                 return isCastable(wildUpperBound(t), s, warnStack.head);
1786             }
1787 
1788             @Override
1789             public Boolean visitClassType(ClassType t, Type s) {
1790                 if (s.hasTag(ERROR) || (s.hasTag(BOT) && !t.isPrimitiveClass()))
1791                     return true;
1792 
1793                 if (s.hasTag(TYPEVAR)) {
1794                     if (isCastable(t, s.getUpperBound(), noWarnings)) {
1795                         warnStack.head.warn(LintCategory.UNCHECKED);
1796                         return true;
1797                     } else {
1798                         return false;
1799                     }
1800                 }
1801 
1802                 if (t.isCompound() || s.isCompound()) {
1803                     return !t.isCompound() ?
1804                             visitCompoundType((ClassType)s, t, true) :
1805                             visitCompoundType(t, s, false);
1806                 }
1807 
1808                 if (s.hasTag(CLASS) || s.hasTag(ARRAY)) {
1809                     if (t.isPrimitiveClass()) {
1810                         // (s) Value ? == (s) Value.ref
1811                         t = t.referenceProjection();
1812                     }
1813                     if (s.isPrimitiveClass()) {
1814                         // (Value) t ? == (Value.ref) t
1815                         s = s.referenceProjection();
1816                     }
1817                     boolean upcast;
1818                     if ((upcast = isSubtype(erasure(t), erasure(s)))
1819                         || isSubtype(erasure(s), erasure(t))) {
1820                         if (!upcast && s.hasTag(ARRAY)) {
1821                             if (!isReifiable(s))
1822                                 warnStack.head.warn(LintCategory.UNCHECKED);
1823                             return true;
1824                         } else if (s.isRaw()) {
1825                             return true;
1826                         } else if (t.isRaw()) {
1827                             if (!isUnbounded(s))
1828                                 warnStack.head.warn(LintCategory.UNCHECKED);
1829                             return true;
1830                         }
1831                         // Assume |a| <: |b|
1832                         final Type a = upcast ? t : s;
1833                         final Type b = upcast ? s : t;
1834                         final boolean HIGH = true;
1835                         final boolean LOW = false;
1836                         final boolean DONT_REWRITE_TYPEVARS = false;
1837                         Type aHigh = rewriteQuantifiers(a, HIGH, DONT_REWRITE_TYPEVARS);
1838                         Type aLow  = rewriteQuantifiers(a, LOW,  DONT_REWRITE_TYPEVARS);
1839                         Type bHigh = rewriteQuantifiers(b, HIGH, DONT_REWRITE_TYPEVARS);
1840                         Type bLow  = rewriteQuantifiers(b, LOW,  DONT_REWRITE_TYPEVARS);
1841                         Type lowSub = asSub(bLow, aLow.tsym);
1842                         Type highSub = (lowSub == null) ? null : asSub(bHigh, aHigh.tsym);
1843                         if (highSub == null) {
1844                             final boolean REWRITE_TYPEVARS = true;
1845                             aHigh = rewriteQuantifiers(a, HIGH, REWRITE_TYPEVARS);
1846                             aLow  = rewriteQuantifiers(a, LOW,  REWRITE_TYPEVARS);
1847                             bHigh = rewriteQuantifiers(b, HIGH, REWRITE_TYPEVARS);
1848                             bLow  = rewriteQuantifiers(b, LOW,  REWRITE_TYPEVARS);
1849                             lowSub = asSub(bLow, aLow.tsym);
1850                             highSub = (lowSub == null) ? null : asSub(bHigh, aHigh.tsym);
1851                         }
1852                         if (highSub != null) {
1853                             if (!(a.tsym == highSub.tsym && a.tsym == lowSub.tsym)) {
1854                                 Assert.error(a.tsym + " != " + highSub.tsym + " != " + lowSub.tsym);
1855                             }
1856                             if (!disjointTypes(aHigh.allparams(), highSub.allparams())
1857                                 && !disjointTypes(aHigh.allparams(), lowSub.allparams())
1858                                 && !disjointTypes(aLow.allparams(), highSub.allparams())
1859                                 && !disjointTypes(aLow.allparams(), lowSub.allparams())) {
1860                                 if (upcast ? giveWarning(a, b) :
1861                                     giveWarning(b, a))
1862                                     warnStack.head.warn(LintCategory.UNCHECKED);
1863                                 return true;
1864                             }
1865                         }
1866                         if (isReifiable(s))
1867                             return isSubtypeUnchecked(a, b);
1868                         else
1869                             return isSubtypeUnchecked(a, b, warnStack.head);
1870                     }
1871 
1872                     // Sidecast
1873                     if (s.hasTag(CLASS)) {
1874                         if ((s.tsym.flags() & INTERFACE) != 0) {
1875                             return ((t.tsym.flags() & FINAL) == 0)
1876                                 ? sideCast(t, s, warnStack.head)
1877                                 : sideCastFinal(t, s, warnStack.head);
1878                         } else if ((t.tsym.flags() & INTERFACE) != 0) {
1879                             return ((s.tsym.flags() & FINAL) == 0)
1880                                 ? sideCast(t, s, warnStack.head)
1881                                 : sideCastFinal(t, s, warnStack.head);
1882                         } else {
1883                             // unrelated class types
1884                             return false;
1885                         }
1886                     }
1887                 }
1888                 return false;
1889             }
1890 
1891             boolean visitCompoundType(ClassType ct, Type s, boolean reverse) {
1892                 Warner warn = noWarnings;
1893                 for (Type c : directSupertypes(ct)) {
1894                     warn.clear();
1895                     if (reverse ? !isCastable(s, c, warn) : !isCastable(c, s, warn))
1896                         return false;
1897                 }
1898                 if (warn.hasLint(LintCategory.UNCHECKED))
1899                     warnStack.head.warn(LintCategory.UNCHECKED);
1900                 return true;
1901             }
1902 
1903             @Override
1904             public Boolean visitArrayType(ArrayType t, Type s) {
1905                 switch (s.getTag()) {
1906                 case ERROR:
1907                 case BOT:
1908                     return true;
1909                 case TYPEVAR:
1910                     if (isCastable(s, t, noWarnings)) {
1911                         warnStack.head.warn(LintCategory.UNCHECKED);
1912                         return true;
1913                     } else {
1914                         return false;
1915                     }
1916                 case CLASS:
1917                     return isSubtype(t, s);
1918                 case ARRAY:
1919                     if (elemtype(t).isPrimitive() || elemtype(s).isPrimitive()) {
1920                         return elemtype(t).hasTag(elemtype(s).getTag());
1921                     } else {
1922                         Type et = elemtype(t);
1923                         Type es = elemtype(s);
1924                         if (!visit(et, es))
1925                             return false;
1926                         return true;
1927                     }
1928                 default:
1929                     return false;
1930                 }
1931             }
1932 
1933             @Override
1934             public Boolean visitTypeVar(TypeVar t, Type s) {
1935                 switch (s.getTag()) {
1936                 case ERROR:
1937                 case BOT:
1938                     return true;
1939                 case TYPEVAR:
1940                     if (isSubtype(t, s)) {
1941                         return true;
1942                     } else if (isCastable(t.getUpperBound(), s, noWarnings)) {
1943                         warnStack.head.warn(LintCategory.UNCHECKED);
1944                         return true;
1945                     } else {
1946                         return false;
1947                     }
1948                 default:
1949                     return isCastable(t.getUpperBound(), s, warnStack.head);
1950                 }
1951             }
1952 
1953             @Override
1954             public Boolean visitErrorType(ErrorType t, Type s) {
1955                 return true;
1956             }
1957         };
1958     // </editor-fold>
1959 
1960     // <editor-fold defaultstate="collapsed" desc="disjointTypes">
1961     public boolean disjointTypes(List<Type> ts, List<Type> ss) {
1962         while (ts.tail != null && ss.tail != null) {
1963             if (disjointType(ts.head, ss.head)) return true;
1964             ts = ts.tail;
1965             ss = ss.tail;
1966         }
1967         return false;
1968     }
1969 
1970     /**
1971      * Two types or wildcards are considered disjoint if it can be
1972      * proven that no type can be contained in both. It is
1973      * conservative in that it is allowed to say that two types are
1974      * not disjoint, even though they actually are.
1975      *
1976      * The type {@code C<X>} is castable to {@code C<Y>} exactly if
1977      * {@code X} and {@code Y} are not disjoint.
1978      */
1979     public boolean disjointType(Type t, Type s) {
1980         return disjointType.visit(t, s);
1981     }
1982     // where
1983         private TypeRelation disjointType = new TypeRelation() {
1984 
1985             private Set<TypePair> cache = new HashSet<>();
1986 
1987             @Override
1988             public Boolean visitType(Type t, Type s) {
1989                 if (s.hasTag(WILDCARD))
1990                     return visit(s, t);
1991                 else
1992                     return notSoftSubtypeRecursive(t, s) || notSoftSubtypeRecursive(s, t);
1993             }
1994 
1995             private boolean isCastableRecursive(Type t, Type s) {
1996                 TypePair pair = new TypePair(t, s);
1997                 if (cache.add(pair)) {
1998                     try {
1999                         return Types.this.isCastable(t, s);
2000                     } finally {
2001                         cache.remove(pair);
2002                     }
2003                 } else {
2004                     return true;
2005                 }
2006             }
2007 
2008             private boolean notSoftSubtypeRecursive(Type t, Type s) {
2009                 TypePair pair = new TypePair(t, s);
2010                 if (cache.add(pair)) {
2011                     try {
2012                         return Types.this.notSoftSubtype(t, s);
2013                     } finally {
2014                         cache.remove(pair);
2015                     }
2016                 } else {
2017                     return false;
2018                 }
2019             }
2020 
2021             @Override
2022             public Boolean visitWildcardType(WildcardType t, Type s) {
2023                 if (t.isUnbound())
2024                     return false;
2025 
2026                 if (!s.hasTag(WILDCARD)) {
2027                     if (t.isExtendsBound())
2028                         return notSoftSubtypeRecursive(s, t.type);
2029                     else
2030                         return notSoftSubtypeRecursive(t.type, s);
2031                 }
2032 
2033                 if (s.isUnbound())
2034                     return false;
2035 
2036                 if (t.isExtendsBound()) {
2037                     if (s.isExtendsBound())
2038                         return !isCastableRecursive(t.type, wildUpperBound(s));
2039                     else if (s.isSuperBound())
2040                         return notSoftSubtypeRecursive(wildLowerBound(s), t.type);
2041                 } else if (t.isSuperBound()) {
2042                     if (s.isExtendsBound())
2043                         return notSoftSubtypeRecursive(t.type, wildUpperBound(s));
2044                 }
2045                 return false;
2046             }
2047         };
2048     // </editor-fold>
2049 
2050     // <editor-fold defaultstate="collapsed" desc="cvarLowerBounds">
2051     public List<Type> cvarLowerBounds(List<Type> ts) {
2052         return ts.map(cvarLowerBoundMapping);
2053     }
2054         private final TypeMapping<Void> cvarLowerBoundMapping = new TypeMapping<Void>() {
2055             @Override
2056             public Type visitCapturedType(CapturedType t, Void _unused) {
2057                 return cvarLowerBound(t);
2058             }
2059         };
2060     // </editor-fold>
2061 
2062     // <editor-fold defaultstate="collapsed" desc="notSoftSubtype">
2063     /**
2064      * This relation answers the question: is impossible that
2065      * something of type `t' can be a subtype of `s'? This is
2066      * different from the question "is `t' not a subtype of `s'?"
2067      * when type variables are involved: Integer is not a subtype of T
2068      * where {@code <T extends Number>} but it is not true that Integer cannot
2069      * possibly be a subtype of T.
2070      */
2071     public boolean notSoftSubtype(Type t, Type s) {
2072         if (t == s) return false;
2073         if (t.hasTag(TYPEVAR)) {
2074             TypeVar tv = (TypeVar) t;
2075             return !isCastable(tv.getUpperBound(),
2076                                relaxBound(s),
2077                                noWarnings);
2078         }
2079         if (!s.hasTag(WILDCARD))
2080             s = cvarUpperBound(s);
2081 
2082         return !isSubtype(t, relaxBound(s));
2083     }
2084 
2085     private Type relaxBound(Type t) {
2086         return (t.hasTag(TYPEVAR)) ?
2087                 rewriteQuantifiers(skipTypeVars(t, false), true, true) :
2088                 t;
2089     }
2090     // </editor-fold>
2091 
2092     // <editor-fold defaultstate="collapsed" desc="isReifiable">
2093     public boolean isReifiable(Type t) {
2094         return isReifiable.visit(t);
2095     }
2096     // where
2097         private UnaryVisitor<Boolean> isReifiable = new UnaryVisitor<Boolean>() {
2098 
2099             public Boolean visitType(Type t, Void ignored) {
2100                 return true;
2101             }
2102 
2103             @Override
2104             public Boolean visitClassType(ClassType t, Void ignored) {
2105                 if (t.isCompound())
2106                     return false;
2107                 else {
2108                     if (!t.isParameterized())
2109                         return true;
2110 
2111                     for (Type param : t.allparams()) {
2112                         if (!param.isUnbound())
2113                             return false;
2114                     }
2115                     return true;
2116                 }
2117             }
2118 
2119             @Override
2120             public Boolean visitArrayType(ArrayType t, Void ignored) {
2121                 return visit(t.elemtype);
2122             }
2123 
2124             @Override
2125             public Boolean visitTypeVar(TypeVar t, Void ignored) {
2126                 return false;
2127             }
2128         };
2129     // </editor-fold>
2130 
2131     // <editor-fold defaultstate="collapsed" desc="Array Utils">
2132     public boolean isArray(Type t) {
2133         while (t.hasTag(WILDCARD))
2134             t = wildUpperBound(t);
2135         return t.hasTag(ARRAY);
2136     }
2137 
2138     /**
2139      * The element type of an array.
2140      */
2141     public Type elemtype(Type t) {
2142         switch (t.getTag()) {
2143         case WILDCARD:
2144             return elemtype(wildUpperBound(t));
2145         case ARRAY:
2146             return ((ArrayType)t).elemtype;
2147         case FORALL:
2148             return elemtype(((ForAll)t).qtype);
2149         case ERROR:
2150             return t;
2151         default:
2152             return null;
2153         }
2154     }
2155 
2156     public Type elemtypeOrType(Type t) {
2157         Type elemtype = elemtype(t);
2158         return elemtype != null ?
2159             elemtype :
2160             t;
2161     }
2162 
2163     /**
2164      * Mapping to take element type of an arraytype
2165      */
2166     private TypeMapping<Void> elemTypeFun = new TypeMapping<Void>() {
2167         @Override
2168         public Type visitArrayType(ArrayType t, Void _unused) {
2169             return t.elemtype;
2170         }
2171 
2172         @Override
2173         public Type visitTypeVar(TypeVar t, Void _unused) {
2174             return visit(skipTypeVars(t, false));
2175         }
2176     };
2177 
2178     /**
2179      * The number of dimensions of an array type.
2180      */
2181     public int dimensions(Type t) {
2182         int result = 0;
2183         while (t.hasTag(ARRAY)) {
2184             result++;
2185             t = elemtype(t);
2186         }
2187         return result;
2188     }
2189 
2190     /**
2191      * Returns an ArrayType with the component type t
2192      *
2193      * @param t The component type of the ArrayType
2194      * @return the ArrayType for the given component
2195      */
2196     public ArrayType makeArrayType(Type t) {
2197         if (t.hasTag(VOID) || t.hasTag(PACKAGE)) {
2198             Assert.error("Type t must not be a VOID or PACKAGE type, " + t.toString());
2199         }
2200         return new ArrayType(t, syms.arrayClass);
2201     }
2202     // </editor-fold>
2203 
2204     // <editor-fold defaultstate="collapsed" desc="asSuper">
2205     /**
2206      * Return the (most specific) base type of t that starts with the
2207      * given symbol.  If none exists, return null.
2208      *
2209      * Caveat Emptor: Since javac represents the class of all arrays with a singleton
2210      * symbol Symtab.arrayClass, which by being a singleton cannot hold any discriminant,
2211      * this method could yield surprising answers when invoked on arrays. For example when
2212      * invoked with t being byte [] and sym being t.sym itself, asSuper would answer null.
2213      *
2214      * Further caveats in Valhalla: There are two "hazards" we need to watch out for when using
2215      * this method.
2216      *
2217      * 1. Since Foo.ref and Foo.val share the same symbol, that of Foo.class, a call to
2218      *    asSuper(Foo.ref.type, Foo.val.type.tsym) would return non-null. This MAY NOT BE correct
2219      *    depending on the call site. Foo.val is NOT a super type of Foo.ref either in the language
2220      *    model or in the VM's world view. An example of such an hazardous call used to exist in
2221      *    Gen.visitTypeCast. When we emit code for  (Foo) Foo.ref.instance a check for whether we
2222      *    really need the cast cannot/shouldn't be gated on
2223      *
2224      *        asSuper(tree.expr.type, tree.clazz.type.tsym) == null)
2225      *
2226      *    but use !types.isSubtype(tree.expr.type, tree.clazz.type) which operates in terms of
2227      *    types. When we operate in terms of symbols, there is a loss of type information leading
2228      *    to a hazard. Whether a call to asSuper should be transformed into a isSubtype call is
2229      *    tricky. isSubtype returns just a boolean while asSuper returns richer information which
2230      *    may be required at the call site. Also where the concerned symbol corresponds to a
2231      *    generic class, an asSuper call cannot be conveniently rewritten as an isSubtype call
2232      *    (see that asSuper(ArrayList<String>.type, List<T>.tsym) != null while
2233      *    isSubType(ArrayList<String>.type, List<T>.type) is false;) So care needs to be exercised.
2234      *
2235      * 2. Given a primitive class Foo, a call to asSuper(Foo.type, SuperclassOfFoo.tsym) and/or
2236      *    a call to asSuper(Foo.type, SuperinterfaceOfFoo.tsym) would answer null. In many places
2237      *    that is NOT what we want. An example of such a hazardous call used to occur in
2238      *    Attr.visitForeachLoop when checking to make sure the for loop's control variable of a type
2239      *    that implements Iterable: viz: types.asSuper(exprType, syms.iterableType.tsym);
2240      *    These hazardous calls should be rewritten as
2241      *    types.asSuper(exprType.referenceProjectionOrSelf(), syms.iterableType.tsym); instead.
2242      *
2243      * @param t a type
2244      * @param sym a symbol
2245      */
2246     public Type asSuper(Type t, Symbol sym) {
2247         /* Some examples:
2248          *
2249          * (Enum<E>, Comparable) => Comparable<E>
2250          * (c.s.s.d.AttributeTree.ValueKind, Enum) => Enum<c.s.s.d.AttributeTree.ValueKind>
2251          * (c.s.s.t.ExpressionTree, c.s.s.t.Tree) => c.s.s.t.Tree
2252          * (j.u.List<capture#160 of ? extends c.s.s.d.DocTree>, Iterable) =>
2253          *     Iterable<capture#160 of ? extends c.s.s.d.DocTree>
2254          */
2255 
2256         if (t.isPrimitiveClass()) {
2257             // No man may be an island, but the bell tolls for a value.
2258             return t.tsym == sym ? t : null;
2259         }
2260 
2261         if (sym.type == syms.objectType) { //optimization
2262             return syms.objectType;
2263         }
2264         return asSuper.visit(t, sym);
2265     }
2266     // where
2267         private SimpleVisitor<Type,Symbol> asSuper = new SimpleVisitor<Type,Symbol>() {
2268 
2269             private Set<Symbol> seenTypes = new HashSet<>();
2270 
2271             public Type visitType(Type t, Symbol sym) {
2272                 return null;
2273             }
2274 
2275             @Override
2276             public Type visitClassType(ClassType t, Symbol sym) {
2277                 if (t.tsym == sym)
2278                     return t;
2279 
2280                 Symbol c = t.tsym;
2281                 if (!seenTypes.add(c)) {
2282                     return null;
2283                 }
2284                 try {
2285                     Type st = supertype(t);
2286                     if (st.hasTag(CLASS) || st.hasTag(TYPEVAR)) {
2287                         Type x = asSuper(st, sym);
2288                         if (x != null)
2289                             return x;
2290                     }
2291                     if ((sym.flags() & INTERFACE) != 0) {
2292                         for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail) {
2293                             if (!l.head.hasTag(ERROR)) {
2294                                 Type x = asSuper(l.head, sym);
2295                                 if (x != null)
2296                                     return x;
2297                             }
2298                         }
2299                     }
2300                     return null;
2301                 } finally {
2302                     seenTypes.remove(c);
2303                 }
2304             }
2305 
2306             @Override
2307             public Type visitArrayType(ArrayType t, Symbol sym) {
2308                 return isSubtype(t, sym.type) ? sym.type : null;
2309             }
2310 
2311             @Override
2312             public Type visitTypeVar(TypeVar t, Symbol sym) {
2313                 if (t.tsym == sym)
2314                     return t;
2315                 else
2316                     return asSuper(t.getUpperBound(), sym);
2317             }
2318 
2319             @Override
2320             public Type visitErrorType(ErrorType t, Symbol sym) {
2321                 return t;
2322             }
2323         };
2324 
2325     public boolean isIdentityType(Type t) {
2326         if (t.isPrimitiveClass() || t.isReferenceProjection() || t.isValueClass() || t.isValueInterface()) {
2327             return false;
2328         }
2329         if (t.tsym == syms.objectType.tsym) {
2330             return false;
2331         }
2332         if (t.hasTag(ARRAY))
2333             return true;
2334         if (t.hasTag(CLASS) && !t.isValueClass() && !t.isReferenceProjection() && !t.tsym.isInterface() && !t.tsym.isAbstract()) {
2335             return true;
2336         }
2337         if (implicitIdentityType(t)) {
2338             return true;
2339         }
2340         return false;
2341     }
2342         // where
2343         private boolean implicitIdentityType(Type t) {
2344             /* An abstract class can be declared with the identity/value modifier;
2345              * or, if it declares a field, an instance initializer, a non-empty constructor, or
2346              * a synchronized instance method, it implicitly is an Identity type.
2347              */
2348             if (!t.tsym.isAbstract())
2349                 return false;
2350 
2351             for (; t != Type.noType; t = supertype(t)) {
2352 
2353                 if (t == null || t.tsym == null || t.tsym.kind == ERR)
2354                     return false;
2355 
2356                 if  (t.tsym == syms.objectType.tsym)
2357                     return false;
2358 
2359                 if (!t.tsym.isAbstract()) {
2360                     return !t.tsym.isPrimitiveClass();
2361                 }
2362 
2363                 if ((t.tsym.flags() & HASINITBLOCK) != 0) {
2364                     return true;
2365                 }
2366 
2367                 // No instance fields and no arged constructors both mean inner classes cannot be primitive class supers.
2368                 Type encl = t.getEnclosingType();
2369                 if (encl != null && encl.hasTag(CLASS)) {
2370                     return true;
2371                 }
2372                 for (Symbol s : t.tsym.members().getSymbols(NON_RECURSIVE)) {
2373                     switch (s.kind) {
2374                         case VAR:
2375                             if ((s.flags() & STATIC) == 0) {
2376                                 return true;
2377                             }
2378                             break;
2379                         case MTH:
2380                             if ((s.flags() & (SYNCHRONIZED | STATIC)) == SYNCHRONIZED) {
2381                                 return true;
2382                             } else if (s.isConstructor()) {
2383                                 MethodSymbol m = (MethodSymbol)s;
2384                                 if (m.getParameters().size() > 0 || (m.flags() & EMPTYNOARGCONSTR) == 0) {
2385                                     return true;
2386                                 }
2387                             }
2388                             break;
2389                     }
2390                 }
2391             }
2392             return false;
2393         }
2394 
2395     /**
2396      * Return the base type of t or any of its outer types that starts
2397      * with the given symbol.  If none exists, return null.
2398      *
2399      * @param t a type
2400      * @param sym a symbol
2401      */
2402     public Type asOuterSuper(Type t, Symbol sym) {
2403         switch (t.getTag()) {
2404         case CLASS:
2405             do {
2406                 Type s = asSuper(t, sym);
2407                 if (s != null) return s;
2408                 t = t.getEnclosingType();
2409             } while (t.hasTag(CLASS));
2410             return null;
2411         case ARRAY:
2412             return isSubtype(t, sym.type) ? sym.type : null;
2413         case TYPEVAR:
2414             return asSuper(t, sym);
2415         case ERROR:
2416             return t;
2417         default:
2418             return null;
2419         }
2420     }
2421 
2422     /**
2423      * Return the base type of t or any of its enclosing types that
2424      * starts with the given symbol.  If none exists, return null.
2425      *
2426      * @param t a type
2427      * @param sym a symbol
2428      */
2429     public Type asEnclosingSuper(Type t, Symbol sym) {
2430         switch (t.getTag()) {
2431         case CLASS:
2432             do {
2433                 Type s = asSuper(t, sym);
2434                 if (s != null) return s;
2435                 Type outer = t.getEnclosingType();
2436                 t = (outer.hasTag(CLASS)) ? outer :
2437                     (t.tsym.owner.enclClass() != null) ? t.tsym.owner.enclClass().type :
2438                     Type.noType;
2439             } while (t.hasTag(CLASS));
2440             return null;
2441         case ARRAY:
2442             return isSubtype(t, sym.type) ? sym.type : null;
2443         case TYPEVAR:
2444             return asSuper(t, sym);
2445         case ERROR:
2446             return t;
2447         default:
2448             return null;
2449         }
2450     }
2451     // </editor-fold>
2452 
2453     // <editor-fold defaultstate="collapsed" desc="memberType">
2454     /**
2455      * The type of given symbol, seen as a member of t.
2456      *
2457      * @param t a type
2458      * @param sym a symbol
2459      */
2460     public Type memberType(Type t, Symbol sym) {
2461 
2462         if ((sym.flags() & STATIC) != 0)
2463             return sym.type;
2464 
2465         /* If any primitive class types are involved, switch over to the reference universe,
2466            where the hierarchy is navigable. V and V.ref have identical membership
2467            with no bridging needs.
2468         */
2469         if (t.isPrimitiveClass())
2470             t = t.referenceProjection();
2471 
2472         return memberType.visit(t, sym);
2473         }
2474     // where
2475         private SimpleVisitor<Type,Symbol> memberType = new SimpleVisitor<Type,Symbol>() {
2476 
2477             public Type visitType(Type t, Symbol sym) {
2478                 return sym.type;
2479             }
2480 
2481             @Override
2482             public Type visitWildcardType(WildcardType t, Symbol sym) {
2483                 return memberType(wildUpperBound(t), sym);
2484             }
2485 
2486             @Override
2487             public Type visitClassType(ClassType t, Symbol sym) {
2488                 Symbol owner = sym.owner;
2489                 long flags = sym.flags();
2490                 if (((flags & STATIC) == 0) && owner.type.isParameterized()) {
2491                     Type base = asOuterSuper(t, owner);
2492                     //if t is an intersection type T = CT & I1 & I2 ... & In
2493                     //its supertypes CT, I1, ... In might contain wildcards
2494                     //so we need to go through capture conversion
2495                     base = t.isCompound() ? capture(base) : base;
2496                     if (base != null) {
2497                         List<Type> ownerParams = owner.type.allparams();
2498                         List<Type> baseParams = base.allparams();
2499                         if (ownerParams.nonEmpty()) {
2500                             if (baseParams.isEmpty()) {
2501                                 // then base is a raw type
2502                                 return erasure(sym.type);
2503                             } else {
2504                                 return subst(sym.type, ownerParams, baseParams);
2505                             }
2506                         }
2507                     }
2508                 }
2509                 return sym.type;
2510             }
2511 
2512             @Override
2513             public Type visitTypeVar(TypeVar t, Symbol sym) {
2514                 return memberType(t.getUpperBound(), sym);
2515             }
2516 
2517             @Override
2518             public Type visitErrorType(ErrorType t, Symbol sym) {
2519                 return t;
2520             }
2521         };
2522     // </editor-fold>
2523 
2524     // <editor-fold defaultstate="collapsed" desc="isAssignable">
2525     public boolean isAssignable(Type t, Type s) {
2526         return isAssignable(t, s, noWarnings);
2527     }
2528 
2529     /**
2530      * Is t assignable to s?<br>
2531      * Equivalent to subtype except for constant values and raw
2532      * types.<br>
2533      * (not defined for Method and ForAll types)
2534      */
2535     public boolean isAssignable(Type t, Type s, Warner warn) {
2536         if (t.hasTag(ERROR))
2537             return true;
2538         if (t.getTag().isSubRangeOf(INT) && t.constValue() != null) {
2539             int value = ((Number)t.constValue()).intValue();
2540             switch (s.getTag()) {
2541             case BYTE:
2542             case CHAR:
2543             case SHORT:
2544             case INT:
2545                 if (s.getTag().checkRange(value))
2546                     return true;
2547                 break;
2548             case CLASS:
2549                 switch (unboxedType(s).getTag()) {
2550                 case BYTE:
2551                 case CHAR:
2552                 case SHORT:
2553                     return isAssignable(t, unboxedType(s), warn);
2554                 }
2555                 break;
2556             }
2557         }
2558         return isConvertible(t, s, warn);
2559     }
2560     // </editor-fold>
2561 
2562     // <editor-fold defaultstate="collapsed" desc="erasure">
2563     /**
2564      * The erasure of t {@code |t|} -- the type that results when all
2565      * type parameters in t are deleted.
2566      */
2567     public Type erasure(Type t) {
2568         return eraseNotNeeded(t) ? t : erasure(t, false);
2569     }
2570     //where
2571     private boolean eraseNotNeeded(Type t) {
2572         // We don't want to erase primitive types and String type as that
2573         // operation is idempotent. Also, erasing these could result in loss
2574         // of information such as constant values attached to such types.
2575         return (t.isPrimitive()) || (syms.stringType.tsym == t.tsym);
2576     }
2577 
2578     private Type erasure(Type t, boolean recurse) {
2579         if (t.isPrimitive()) {
2580             return t; /* fast special case */
2581         } else {
2582             Type out = erasure.visit(t, recurse);
2583             return out;
2584         }
2585     }
2586     // where
2587         private TypeMapping<Boolean> erasure = new StructuralTypeMapping<Boolean>() {
2588             private Type combineMetadata(final Type s,
2589                                          final Type t) {
2590                 if (t.getMetadata() != TypeMetadata.EMPTY) {
2591                     switch (s.getKind()) {
2592                         case OTHER:
2593                         case UNION:
2594                         case INTERSECTION:
2595                         case PACKAGE:
2596                         case EXECUTABLE:
2597                         case NONE:
2598                         case VOID:
2599                         case ERROR:
2600                             return s;
2601                         default: return s.cloneWithMetadata(s.getMetadata().without(Kind.ANNOTATIONS));
2602                     }
2603                 } else {
2604                     return s;
2605                 }
2606             }
2607 
2608             public Type visitType(Type t, Boolean recurse) {
2609                 if (t.isPrimitive())
2610                     return t; /*fast special case*/
2611                 else {
2612                     //other cases already handled
2613                     return combineMetadata(t, t);
2614                 }
2615             }
2616 
2617             @Override
2618             public Type visitWildcardType(WildcardType t, Boolean recurse) {
2619                 Type erased = erasure(wildUpperBound(t), recurse);
2620                 return combineMetadata(erased, t);
2621             }
2622 
2623             @Override
2624             public Type visitClassType(ClassType t, Boolean recurse) {
2625                 // erasure(projection(primitive)) = projection(erasure(primitive))
2626                 Type erased = eraseClassType(t, recurse);
2627                 if (erased.hasTag(CLASS) && t.flavor != erased.getFlavor()) {
2628                     erased = new ClassType(erased.getEnclosingType(),
2629                             List.nil(), erased.tsym,
2630                             erased.getMetadata(), t.flavor);
2631                 }
2632                 return erased;
2633             }
2634                 // where
2635                 private Type eraseClassType(ClassType t, Boolean recurse) {
2636                     Type erased = t.tsym.erasure(Types.this);
2637                     if (recurse) {
2638                         erased = new ErasedClassType(erased.getEnclosingType(), erased.tsym,
2639                                 t.getMetadata().without(Kind.ANNOTATIONS));
2640                         return erased;
2641                     } else {
2642                         return combineMetadata(erased, t);
2643                     }
2644                 }
2645 
2646             @Override
2647             public Type visitTypeVar(TypeVar t, Boolean recurse) {
2648                 Type erased = erasure(t.getUpperBound(), recurse);
2649                 return combineMetadata(erased, t);
2650             }
2651         };
2652 
2653     public List<Type> erasure(List<Type> ts) {
2654         return erasure.visit(ts, false);
2655     }
2656 
2657     public Type erasureRecursive(Type t) {
2658         return erasure(t, true);
2659     }
2660 
2661     public List<Type> erasureRecursive(List<Type> ts) {
2662         return erasure.visit(ts, true);
2663     }
2664     // </editor-fold>
2665 
2666     // <editor-fold defaultstate="collapsed" desc="makeIntersectionType">
2667     /**
2668      * Make an intersection type from non-empty list of types.  The list should be ordered according to
2669      * {@link TypeSymbol#precedes(TypeSymbol, Types)}. Note that this might cause a symbol completion.
2670      * Hence, this version of makeIntersectionType may not be called during a classfile read.
2671      *
2672      * @param bounds    the types from which the intersection type is formed
2673      */
2674     public IntersectionClassType makeIntersectionType(List<Type> bounds) {
2675         return makeIntersectionType(bounds, bounds.head.tsym.isInterface());
2676     }
2677 
2678     /**
2679      * Make an intersection type from non-empty list of types.  The list should be ordered according to
2680      * {@link TypeSymbol#precedes(TypeSymbol, Types)}. This does not cause symbol completion as
2681      * an extra parameter indicates as to whether all bounds are interfaces - in which case the
2682      * supertype is implicitly assumed to be 'Object'.
2683      *
2684      * @param bounds        the types from which the intersection type is formed
2685      * @param allInterfaces are all bounds interface types?
2686      */
2687     public IntersectionClassType makeIntersectionType(List<Type> bounds, boolean allInterfaces) {
2688         Assert.check(bounds.nonEmpty());
2689         Type firstExplicitBound = bounds.head;
2690         if (allInterfaces) {
2691             bounds = bounds.prepend(syms.objectType);
2692         }
2693         long flags = ABSTRACT | PUBLIC | SYNTHETIC | COMPOUND | ACYCLIC;
2694         ClassSymbol bc =
2695             new ClassSymbol(flags,
2696                             Type.moreInfo
2697                                 ? names.fromString(bounds.toString())
2698                                 : names.empty,
2699                             null,
2700                             syms.noSymbol);
2701         IntersectionClassType intersectionType = new IntersectionClassType(bounds, bc, allInterfaces);
2702         bc.type = intersectionType;
2703         bc.erasure_field = (bounds.head.hasTag(TYPEVAR)) ?
2704                 syms.objectType : // error condition, recover
2705                 erasure(firstExplicitBound);
2706         bc.members_field = WriteableScope.create(bc);
2707         return intersectionType;
2708     }
2709     // </editor-fold>
2710 
2711     // <editor-fold defaultstate="collapsed" desc="supertype">
2712     public Type supertype(Type t) {
2713         return supertype.visit(t);
2714     }
2715     // where
2716         private UnaryVisitor<Type> supertype = new UnaryVisitor<Type>() {
2717 
2718             public Type visitType(Type t, Void ignored) {
2719                 // A note on wildcards: there is no good way to
2720                 // determine a supertype for a super bounded wildcard.
2721                 return Type.noType;
2722             }
2723 
2724             @Override
2725             public Type visitClassType(ClassType t, Void ignored) {
2726                 if (t.supertype_field == null) {
2727                     Type supertype = ((ClassSymbol)t.tsym).getSuperclass();
2728                     // An interface has no superclass; its supertype is Object.
2729                     if (t.isInterface())
2730                         supertype = ((ClassType)t.tsym.type).supertype_field;
2731                     if (t.supertype_field == null) {
2732                         List<Type> actuals = classBound(t).allparams();
2733                         List<Type> formals = t.tsym.type.allparams();
2734                         if (t.hasErasedSupertypes()) {
2735                             t.supertype_field = erasureRecursive(supertype);
2736                         } else if (formals.nonEmpty()) {
2737                             t.supertype_field = subst(supertype, formals, actuals);
2738                         }
2739                         else {
2740                             t.supertype_field = supertype;
2741                         }
2742                     }
2743                 }
2744                 return t.supertype_field;
2745             }
2746 
2747             /**
2748              * The supertype is always a class type. If the type
2749              * variable's bounds start with a class type, this is also
2750              * the supertype.  Otherwise, the supertype is
2751              * java.lang.Object.
2752              */
2753             @Override
2754             public Type visitTypeVar(TypeVar t, Void ignored) {
2755                 if (t.getUpperBound().hasTag(TYPEVAR) ||
2756                     (!t.getUpperBound().isCompound() && !t.getUpperBound().isInterface())) {
2757                     return t.getUpperBound();
2758                 } else {
2759                     return supertype(t.getUpperBound());
2760                 }
2761             }
2762 
2763             @Override
2764             public Type visitArrayType(ArrayType t, Void ignored) {
2765                 if (t.elemtype.isPrimitive() || isSameType(t.elemtype, syms.objectType))
2766                     return arraySuperType();
2767                 else
2768                     return new ArrayType(supertype(t.elemtype), t.tsym);
2769             }
2770 
2771             @Override
2772             public Type visitErrorType(ErrorType t, Void ignored) {
2773                 return Type.noType;
2774             }
2775         };
2776     // </editor-fold>
2777 
2778     // <editor-fold defaultstate="collapsed" desc="interfaces">
2779     /**
2780      * Return the interfaces implemented by this class.
2781      */
2782     public List<Type> interfaces(Type t) {
2783         return interfaces.visit(t);
2784     }
2785     // where
2786         private UnaryVisitor<List<Type>> interfaces = new UnaryVisitor<List<Type>>() {
2787 
2788             public List<Type> visitType(Type t, Void ignored) {
2789                 return List.nil();
2790             }
2791 
2792             @Override
2793             public List<Type> visitClassType(ClassType t, Void ignored) {
2794                 if (t.interfaces_field == null) {
2795                     List<Type> interfaces = ((ClassSymbol)t.tsym).getInterfaces();
2796                     if (t.interfaces_field == null) {
2797                         // If t.interfaces_field is null, then t must
2798                         // be a parameterized type (not to be confused
2799                         // with a generic type declaration).
2800                         // Terminology:
2801                         //    Parameterized type: List<String>
2802                         //    Generic type declaration: class List<E> { ... }
2803                         // So t corresponds to List<String> and
2804                         // t.tsym.type corresponds to List<E>.
2805                         // The reason t must be parameterized type is
2806                         // that completion will happen as a side
2807                         // effect of calling
2808                         // ClassSymbol.getInterfaces.  Since
2809                         // t.interfaces_field is null after
2810                         // completion, we can assume that t is not the
2811                         // type of a class/interface declaration.
2812                         Assert.check(t != t.tsym.type, t);
2813                         List<Type> actuals = t.allparams();
2814                         List<Type> formals = t.tsym.type.allparams();
2815                         if (t.hasErasedSupertypes()) {
2816                             t.interfaces_field = erasureRecursive(interfaces);
2817                         } else if (formals.nonEmpty()) {
2818                             t.interfaces_field = subst(interfaces, formals, actuals);
2819                         }
2820                         else {
2821                             t.interfaces_field = interfaces;
2822                         }
2823                     }
2824                 }
2825                 return t.interfaces_field;
2826             }
2827 
2828             @Override
2829             public List<Type> visitTypeVar(TypeVar t, Void ignored) {
2830                 if (t.getUpperBound().isCompound())
2831                     return interfaces(t.getUpperBound());
2832 
2833                 if (t.getUpperBound().isInterface())
2834                     return List.of(t.getUpperBound());
2835 
2836                 return List.nil();
2837             }
2838         };
2839 
2840     public List<Type> directSupertypes(Type t) {
2841         return directSupertypes.visit(t);
2842     }
2843     // where
2844         private final UnaryVisitor<List<Type>> directSupertypes = new UnaryVisitor<List<Type>>() {
2845 
2846             public List<Type> visitType(final Type type, final Void ignored) {
2847                 if (!type.isIntersection()) {
2848                     final Type sup = supertype(type);
2849                     return (sup == Type.noType || sup == type || sup == null)
2850                         ? interfaces(type)
2851                         : interfaces(type).prepend(sup);
2852                 } else {
2853                     return ((IntersectionClassType)type).getExplicitComponents();
2854                 }
2855             }
2856         };
2857 
2858     public boolean isDirectSuperInterface(TypeSymbol isym, TypeSymbol origin) {
2859         for (Type i2 : interfaces(origin.type)) {
2860             if (isym == i2.tsym) return true;
2861         }
2862         return false;
2863     }
2864     // </editor-fold>
2865 
2866     // <editor-fold defaultstate="collapsed" desc="isDerivedRaw">
2867     Map<Type,Boolean> isDerivedRawCache = new HashMap<>();
2868 
2869     public boolean isDerivedRaw(Type t) {
2870         Boolean result = isDerivedRawCache.get(t);
2871         if (result == null) {
2872             result = isDerivedRawInternal(t);
2873             isDerivedRawCache.put(t, result);
2874         }
2875         return result;
2876     }
2877 
2878     public boolean isDerivedRawInternal(Type t) {
2879         if (t.isErroneous())
2880             return false;
2881         return
2882             t.isRaw() ||
2883             supertype(t) != Type.noType && isDerivedRaw(supertype(t)) ||
2884             isDerivedRaw(interfaces(t));
2885     }
2886 
2887     public boolean isDerivedRaw(List<Type> ts) {
2888         List<Type> l = ts;
2889         while (l.nonEmpty() && !isDerivedRaw(l.head)) l = l.tail;
2890         return l.nonEmpty();
2891     }
2892     // </editor-fold>
2893 
2894     // <editor-fold defaultstate="collapsed" desc="setBounds">
2895     /**
2896      * Same as {@link Types#setBounds(TypeVar, List, boolean)}, except that third parameter is computed directly,
2897      * as follows: if all all bounds are interface types, the computed supertype is Object,otherwise
2898      * the supertype is simply left null (in this case, the supertype is assumed to be the head of
2899      * the bound list passed as second argument). Note that this check might cause a symbol completion.
2900      * Hence, this version of setBounds may not be called during a classfile read.
2901      *
2902      * @param t         a type variable
2903      * @param bounds    the bounds, must be nonempty
2904      */
2905     public void setBounds(TypeVar t, List<Type> bounds) {
2906         setBounds(t, bounds, bounds.head.tsym.isInterface());
2907     }
2908 
2909     /**
2910      * Set the bounds field of the given type variable to reflect a (possibly multiple) list of bounds.
2911      * This does not cause symbol completion as an extra parameter indicates as to whether all bounds
2912      * are interfaces - in which case the supertype is implicitly assumed to be 'Object'.
2913      *
2914      * @param t             a type variable
2915      * @param bounds        the bounds, must be nonempty
2916      * @param allInterfaces are all bounds interface types?
2917      */
2918     public void setBounds(TypeVar t, List<Type> bounds, boolean allInterfaces) {
2919         t.setUpperBound( bounds.tail.isEmpty() ?
2920                 bounds.head :
2921                 makeIntersectionType(bounds, allInterfaces) );
2922         t.rank_field = -1;
2923     }
2924     // </editor-fold>
2925 
2926     // <editor-fold defaultstate="collapsed" desc="getBounds">
2927     /**
2928      * Return list of bounds of the given type variable.
2929      */
2930     public List<Type> getBounds(TypeVar t) {
2931         if (t.getUpperBound().hasTag(NONE))
2932             return List.nil();
2933         else if (t.getUpperBound().isErroneous() || !t.getUpperBound().isCompound())
2934             return List.of(t.getUpperBound());
2935         else if ((erasure(t).tsym.flags() & INTERFACE) == 0)
2936             return interfaces(t).prepend(supertype(t));
2937         else
2938             // No superclass was given in bounds.
2939             // In this case, supertype is Object, erasure is first interface.
2940             return interfaces(t);
2941     }
2942     // </editor-fold>
2943 
2944     // <editor-fold defaultstate="collapsed" desc="classBound">
2945     /**
2946      * If the given type is a (possibly selected) type variable,
2947      * return the bounding class of this type, otherwise return the
2948      * type itself.
2949      */
2950     public Type classBound(Type t) {
2951         return classBound.visit(t);
2952     }
2953     // where
2954         private UnaryVisitor<Type> classBound = new UnaryVisitor<Type>() {
2955 
2956             public Type visitType(Type t, Void ignored) {
2957                 return t;
2958             }
2959 
2960             @Override
2961             public Type visitClassType(ClassType t, Void ignored) {
2962                 Type outer1 = classBound(t.getEnclosingType());
2963                 if (outer1 != t.getEnclosingType())
2964                     return new ClassType(outer1, t.getTypeArguments(), t.tsym,
2965                                          t.getMetadata(), t.getFlavor());
2966                 else
2967                     return t;
2968             }
2969 
2970             @Override
2971             public Type visitTypeVar(TypeVar t, Void ignored) {
2972                 return classBound(supertype(t));
2973             }
2974 
2975             @Override
2976             public Type visitErrorType(ErrorType t, Void ignored) {
2977                 return t;
2978             }
2979         };
2980     // </editor-fold>
2981 
2982     // <editor-fold defaultstate="collapsed" desc="sub signature / override equivalence">
2983     /**
2984      * Returns true iff the first signature is a <em>sub
2985      * signature</em> of the other.  This is <b>not</b> an equivalence
2986      * relation.
2987      *
2988      * @jls 8.4.2 Method Signature
2989      * @see #overrideEquivalent(Type t, Type s)
2990      * @param t first signature (possibly raw).
2991      * @param s second signature (could be subjected to erasure).
2992      * @return true if t is a sub signature of s.
2993      */
2994     public boolean isSubSignature(Type t, Type s) {
2995         return isSubSignature(t, s, true);
2996     }
2997 
2998     public boolean isSubSignature(Type t, Type s, boolean strict) {
2999         return hasSameArgs(t, s, strict) || hasSameArgs(t, erasure(s), strict);
3000     }
3001 
3002     /**
3003      * Returns true iff these signatures are related by <em>override
3004      * equivalence</em>.  This is the natural extension of
3005      * isSubSignature to an equivalence relation.
3006      *
3007      * @jls 8.4.2 Method Signature
3008      * @see #isSubSignature(Type t, Type s)
3009      * @param t a signature (possible raw, could be subjected to
3010      * erasure).
3011      * @param s a signature (possible raw, could be subjected to
3012      * erasure).
3013      * @return true if either argument is a sub signature of the other.
3014      */
3015     public boolean overrideEquivalent(Type t, Type s) {
3016         return hasSameArgs(t, s) ||
3017             hasSameArgs(t, erasure(s)) || hasSameArgs(erasure(t), s);
3018     }
3019 
3020     public boolean overridesObjectMethod(TypeSymbol origin, Symbol msym) {
3021         for (Symbol sym : syms.objectType.tsym.members().getSymbolsByName(msym.name)) {
3022             if (msym.overrides(sym, origin, Types.this, true)) {
3023                 return true;
3024             }
3025         }
3026         return false;
3027     }
3028 
3029     /**
3030      * This enum defines the strategy for implementing most specific return type check
3031      * during the most specific and functional interface checks.
3032      */
3033     public enum MostSpecificReturnCheck {
3034         /**
3035          * Return r1 is more specific than r2 if {@code r1 <: r2}. Extra care required for (i) handling
3036          * method type variables (if either method is generic) and (ii) subtyping should be replaced
3037          * by type-equivalence for primitives. This is essentially an inlined version of
3038          * {@link Types#resultSubtype(Type, Type, Warner)}, where the assignability check has been
3039          * replaced with a strict subtyping check.
3040          */
3041         BASIC() {
3042             @Override
3043             public boolean test(Type mt1, Type mt2, Types types) {
3044                 List<Type> tvars = mt1.getTypeArguments();
3045                 List<Type> svars = mt2.getTypeArguments();
3046                 Type t = mt1.getReturnType();
3047                 Type s = types.subst(mt2.getReturnType(), svars, tvars);
3048                 return types.isSameType(t, s) ||
3049                     !t.isPrimitive() &&
3050                     !s.isPrimitive() &&
3051                     types.isSubtype(t, s);
3052             }
3053         },
3054         /**
3055          * Return r1 is more specific than r2 if r1 is return-type-substitutable for r2.
3056          */
3057         RTS() {
3058             @Override
3059             public boolean test(Type mt1, Type mt2, Types types) {
3060                 return types.returnTypeSubstitutable(mt1, mt2);
3061             }
3062         };
3063 
3064         public abstract boolean test(Type mt1, Type mt2, Types types);
3065     }
3066 
3067     /**
3068      * Merge multiple abstract methods. The preferred method is a method that is a subsignature
3069      * of all the other signatures and whose return type is more specific {@see MostSpecificReturnCheck}.
3070      * The resulting preferred method has a thrown clause that is the intersection of the merged
3071      * methods' clauses.
3072      */
3073     public Optional<Symbol> mergeAbstracts(List<Symbol> ambiguousInOrder, Type site, boolean sigCheck) {
3074         //first check for preconditions
3075         boolean shouldErase = false;
3076         List<Type> erasedParams = ambiguousInOrder.head.erasure(this).getParameterTypes();
3077         for (Symbol s : ambiguousInOrder) {
3078             if ((s.flags() & ABSTRACT) == 0 ||
3079                     (sigCheck && !isSameTypes(erasedParams, s.erasure(this).getParameterTypes()))) {
3080                 return Optional.empty();
3081             } else if (s.type.hasTag(FORALL)) {
3082                 shouldErase = true;
3083             }
3084         }
3085         //then merge abstracts
3086         for (MostSpecificReturnCheck mostSpecificReturnCheck : MostSpecificReturnCheck.values()) {
3087             outer: for (Symbol s : ambiguousInOrder) {
3088                 Type mt = memberType(site, s);
3089                 List<Type> allThrown = mt.getThrownTypes();
3090                 for (Symbol s2 : ambiguousInOrder) {
3091                     if (s != s2) {
3092                         Type mt2 = memberType(site, s2);
3093                         if (!isSubSignature(mt, mt2) ||
3094                                 !mostSpecificReturnCheck.test(mt, mt2, this)) {
3095                             //ambiguity cannot be resolved
3096                             continue outer;
3097                         } else {
3098                             List<Type> thrownTypes2 = mt2.getThrownTypes();
3099                             if (!mt.hasTag(FORALL) && shouldErase) {
3100                                 thrownTypes2 = erasure(thrownTypes2);
3101                             } else if (mt.hasTag(FORALL)) {
3102                                 //subsignature implies that if most specific is generic, then all other
3103                                 //methods are too
3104                                 Assert.check(mt2.hasTag(FORALL));
3105                                 // if both are generic methods, adjust thrown types ahead of intersection computation
3106                                 thrownTypes2 = subst(thrownTypes2, mt2.getTypeArguments(), mt.getTypeArguments());
3107                             }
3108                             allThrown = chk.intersect(allThrown, thrownTypes2);
3109                         }
3110                     }
3111                 }
3112                 return (allThrown == mt.getThrownTypes()) ?
3113                         Optional.of(s) :
3114                         Optional.of(new MethodSymbol(
3115                                 s.flags(),
3116                                 s.name,
3117                                 createMethodTypeWithThrown(s.type, allThrown),
3118                                 s.owner) {
3119                             @Override
3120                             public Symbol baseSymbol() {
3121                                 return s;
3122                             }
3123                         });
3124             }
3125         }
3126         return Optional.empty();
3127     }
3128 
3129     // <editor-fold defaultstate="collapsed" desc="Determining method implementation in given site">
3130     class ImplementationCache {
3131 
3132         private WeakHashMap<MethodSymbol, SoftReference<Map<TypeSymbol, Entry>>> _map = new WeakHashMap<>();
3133 
3134         class Entry {
3135             final MethodSymbol cachedImpl;
3136             final Predicate<Symbol> implFilter;
3137             final boolean checkResult;
3138             final int prevMark;
3139 
3140             public Entry(MethodSymbol cachedImpl,
3141                     Predicate<Symbol> scopeFilter,
3142                     boolean checkResult,
3143                     int prevMark) {
3144                 this.cachedImpl = cachedImpl;
3145                 this.implFilter = scopeFilter;
3146                 this.checkResult = checkResult;
3147                 this.prevMark = prevMark;
3148             }
3149 
3150             boolean matches(Predicate<Symbol> scopeFilter, boolean checkResult, int mark) {
3151                 return this.implFilter == scopeFilter &&
3152                         this.checkResult == checkResult &&
3153                         this.prevMark == mark;
3154             }
3155         }
3156 
3157         MethodSymbol get(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Predicate<Symbol> implFilter) {
3158             SoftReference<Map<TypeSymbol, Entry>> ref_cache = _map.get(ms);
3159             Map<TypeSymbol, Entry> cache = ref_cache != null ? ref_cache.get() : null;
3160             if (cache == null) {
3161                 cache = new HashMap<>();
3162                 _map.put(ms, new SoftReference<>(cache));
3163             }
3164             Entry e = cache.get(origin);
3165             CompoundScope members = membersClosure(origin.type, true);
3166             if (e == null ||
3167                     !e.matches(implFilter, checkResult, members.getMark())) {
3168                 MethodSymbol impl = implementationInternal(ms, origin, checkResult, implFilter);
3169                 cache.put(origin, new Entry(impl, implFilter, checkResult, members.getMark()));
3170                 return impl;
3171             }
3172             else {
3173                 return e.cachedImpl;
3174             }
3175         }
3176 
3177         private MethodSymbol implementationInternal(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Predicate<Symbol> implFilter) {
3178             for (Type t = origin.type; t.hasTag(CLASS) || t.hasTag(TYPEVAR); t = supertype(t)) {
3179                 t = skipTypeVars(t, false);
3180                 TypeSymbol c = t.tsym;
3181                 Symbol bestSoFar = null;
3182                 for (Symbol sym : c.members().getSymbolsByName(ms.name, implFilter)) {
3183                     if (sym != null && sym.overrides(ms, origin, Types.this, checkResult)) {
3184                         bestSoFar = sym;
3185                         if ((sym.flags() & ABSTRACT) == 0) {
3186                             //if concrete impl is found, exit immediately
3187                             break;
3188                         }
3189                     }
3190                 }
3191                 if (bestSoFar != null) {
3192                     //return either the (only) concrete implementation or the first abstract one
3193                     return (MethodSymbol)bestSoFar;
3194                 }
3195             }
3196             return null;
3197         }
3198     }
3199 
3200     private ImplementationCache implCache = new ImplementationCache();
3201 
3202     public MethodSymbol implementation(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Predicate<Symbol> implFilter) {
3203         return implCache.get(ms, origin, checkResult, implFilter);
3204     }
3205     // </editor-fold>
3206 
3207     // <editor-fold defaultstate="collapsed" desc="compute transitive closure of all members in given site">
3208     class MembersClosureCache extends SimpleVisitor<Scope.CompoundScope, Void> {
3209 
3210         private Map<TypeSymbol, CompoundScope> _map = new HashMap<>();
3211 
3212         Set<TypeSymbol> seenTypes = new HashSet<>();
3213 
3214         class MembersScope extends CompoundScope {
3215 
3216             CompoundScope scope;
3217 
3218             public MembersScope(CompoundScope scope) {
3219                 super(scope.owner);
3220                 this.scope = scope;
3221             }
3222 
3223             Predicate<Symbol> combine(Predicate<Symbol> sf) {
3224                 return s -> !s.owner.isInterface() && (sf == null || sf.test(s));
3225             }
3226 
3227             @Override
3228             public Iterable<Symbol> getSymbols(Predicate<Symbol> sf, LookupKind lookupKind) {
3229                 return scope.getSymbols(combine(sf), lookupKind);
3230             }
3231 
3232             @Override
3233             public Iterable<Symbol> getSymbolsByName(Name name, Predicate<Symbol> sf, LookupKind lookupKind) {
3234                 return scope.getSymbolsByName(name, combine(sf), lookupKind);
3235             }
3236 
3237             @Override
3238             public int getMark() {
3239                 return scope.getMark();
3240             }
3241         }
3242 
3243         CompoundScope nilScope;
3244 
3245         /** members closure visitor methods **/
3246 
3247         public CompoundScope visitType(Type t, Void _unused) {
3248             if (nilScope == null) {
3249                 nilScope = new CompoundScope(syms.noSymbol);
3250             }
3251             return nilScope;
3252         }
3253 
3254         @Override
3255         public CompoundScope visitClassType(ClassType t, Void _unused) {
3256             if (!seenTypes.add(t.tsym)) {
3257                 //this is possible when an interface is implemented in multiple
3258                 //superclasses, or when a class hierarchy is circular - in such
3259                 //cases we don't need to recurse (empty scope is returned)
3260                 return new CompoundScope(t.tsym);
3261             }
3262             try {
3263                 seenTypes.add(t.tsym);
3264                 ClassSymbol csym = (ClassSymbol)t.tsym;
3265                 CompoundScope membersClosure = _map.get(csym);
3266                 if (membersClosure == null) {
3267                     membersClosure = new CompoundScope(csym);
3268                     for (Type i : interfaces(t)) {
3269                         membersClosure.prependSubScope(visit(i, null));
3270                     }
3271                     membersClosure.prependSubScope(visit(supertype(t), null));
3272                     membersClosure.prependSubScope(csym.members());
3273                     _map.put(csym, membersClosure);
3274                 }
3275                 return membersClosure;
3276             }
3277             finally {
3278                 seenTypes.remove(t.tsym);
3279             }
3280         }
3281 
3282         @Override
3283         public CompoundScope visitTypeVar(TypeVar t, Void _unused) {
3284             return visit(t.getUpperBound(), null);
3285         }
3286     }
3287 
3288     private MembersClosureCache membersCache = new MembersClosureCache();
3289 
3290     public CompoundScope membersClosure(Type site, boolean skipInterface) {
3291         CompoundScope cs = membersCache.visit(site, null);
3292         Assert.checkNonNull(cs, () -> "type " + site);
3293         return skipInterface ? membersCache.new MembersScope(cs) : cs;
3294     }
3295     // </editor-fold>
3296 
3297 
3298     /** Return first abstract member of class `sym'.
3299      */
3300     public MethodSymbol firstUnimplementedAbstract(ClassSymbol sym) {
3301         try {
3302             return firstUnimplementedAbstractImpl(sym, sym);
3303         } catch (CompletionFailure ex) {
3304             chk.completionError(enter.getEnv(sym).tree.pos(), ex);
3305             return null;
3306         }
3307     }
3308         //where:
3309         private MethodSymbol firstUnimplementedAbstractImpl(ClassSymbol impl, ClassSymbol c) {
3310             MethodSymbol undef = null;
3311             // Do not bother to search in classes that are not abstract,
3312             // since they cannot have abstract members.
3313             if (c == impl || (c.flags() & (ABSTRACT | INTERFACE)) != 0) {
3314                 Scope s = c.members();
3315                 for (Symbol sym : s.getSymbols(NON_RECURSIVE)) {
3316                     if (sym.kind == MTH &&
3317                         (sym.flags() & (ABSTRACT|DEFAULT|PRIVATE)) == ABSTRACT) {
3318                         MethodSymbol absmeth = (MethodSymbol)sym;
3319                         MethodSymbol implmeth = absmeth.implementation(impl, this, true);
3320                         if (implmeth == null || implmeth == absmeth) {
3321                             //look for default implementations
3322                             if (allowDefaultMethods) {
3323                                 MethodSymbol prov = interfaceCandidates(impl.type, absmeth).head;
3324                                 if (prov != null && prov.overrides(absmeth, impl, this, true)) {
3325                                     implmeth = prov;
3326                                 }
3327                             }
3328                         }
3329                         if (implmeth == null || implmeth == absmeth) {
3330                             undef = absmeth;
3331                             break;
3332                         }
3333                     }
3334                 }
3335                 if (undef == null) {
3336                     Type st = supertype(c.type);
3337                     if (st.hasTag(CLASS))
3338                         undef = firstUnimplementedAbstractImpl(impl, (ClassSymbol)st.tsym);
3339                 }
3340                 for (List<Type> l = interfaces(c.type);
3341                      undef == null && l.nonEmpty();
3342                      l = l.tail) {
3343                     undef = firstUnimplementedAbstractImpl(impl, (ClassSymbol)l.head.tsym);
3344                 }
3345             }
3346             return undef;
3347         }
3348 
3349     public class CandidatesCache {
3350         public Map<Entry, List<MethodSymbol>> cache = new WeakHashMap<>();
3351 
3352         class Entry {
3353             Type site;
3354             MethodSymbol msym;
3355 
3356             Entry(Type site, MethodSymbol msym) {
3357                 this.site = site;
3358                 this.msym = msym;
3359             }
3360 
3361             @Override
3362             public boolean equals(Object obj) {
3363                 return (obj instanceof Entry entry)
3364                         && entry.msym == msym
3365                         && isSameType(site, entry.site);
3366             }
3367 
3368             @Override
3369             public int hashCode() {
3370                 return Types.this.hashCode(site) & ~msym.hashCode();
3371             }
3372         }
3373 
3374         public List<MethodSymbol> get(Entry e) {
3375             return cache.get(e);
3376         }
3377 
3378         public void put(Entry e, List<MethodSymbol> msymbols) {
3379             cache.put(e, msymbols);
3380         }
3381     }
3382 
3383     public CandidatesCache candidatesCache = new CandidatesCache();
3384 
3385     //where
3386     public List<MethodSymbol> interfaceCandidates(Type site, MethodSymbol ms) {
3387         CandidatesCache.Entry e = candidatesCache.new Entry(site, ms);
3388         List<MethodSymbol> candidates = candidatesCache.get(e);
3389         if (candidates == null) {
3390             Predicate<Symbol> filter = new MethodFilter(ms, site);
3391             List<MethodSymbol> candidates2 = List.nil();
3392             for (Symbol s : membersClosure(site, false).getSymbols(filter)) {
3393                 if (!site.tsym.isInterface() && !s.owner.isInterface()) {
3394                     return List.of((MethodSymbol)s);
3395                 } else if (!candidates2.contains(s)) {
3396                     candidates2 = candidates2.prepend((MethodSymbol)s);
3397                 }
3398             }
3399             candidates = prune(candidates2);
3400             candidatesCache.put(e, candidates);
3401         }
3402         return candidates;
3403     }
3404 
3405     public List<MethodSymbol> prune(List<MethodSymbol> methods) {
3406         ListBuffer<MethodSymbol> methodsMin = new ListBuffer<>();
3407         for (MethodSymbol m1 : methods) {
3408             boolean isMin_m1 = true;
3409             for (MethodSymbol m2 : methods) {
3410                 if (m1 == m2) continue;
3411                 if (m2.owner != m1.owner &&
3412                         asSuper(m2.owner.type, m1.owner) != null) {
3413                     isMin_m1 = false;
3414                     break;
3415                 }
3416             }
3417             if (isMin_m1)
3418                 methodsMin.append(m1);
3419         }
3420         return methodsMin.toList();
3421     }
3422     // where
3423             private class MethodFilter implements Predicate<Symbol> {
3424 
3425                 Symbol msym;
3426                 Type site;
3427 
3428                 MethodFilter(Symbol msym, Type site) {
3429                     this.msym = msym;
3430                     this.site = site;
3431                 }
3432 
3433                 @Override
3434                 public boolean test(Symbol s) {
3435                     return s.kind == MTH &&
3436                             s.name == msym.name &&
3437                             (s.flags() & SYNTHETIC) == 0 &&
3438                             s.isInheritedIn(site.tsym, Types.this) &&
3439                             overrideEquivalent(memberType(site, s), memberType(site, msym));
3440                 }
3441             }
3442     // </editor-fold>
3443 
3444     /**
3445      * Does t have the same arguments as s?  It is assumed that both
3446      * types are (possibly polymorphic) method types.  Monomorphic
3447      * method types "have the same arguments", if their argument lists
3448      * are equal.  Polymorphic method types "have the same arguments",
3449      * if they have the same arguments after renaming all type
3450      * variables of one to corresponding type variables in the other,
3451      * where correspondence is by position in the type parameter list.
3452      */
3453     public boolean hasSameArgs(Type t, Type s) {
3454         return hasSameArgs(t, s, true);
3455     }
3456 
3457     public boolean hasSameArgs(Type t, Type s, boolean strict) {
3458         return hasSameArgs(t, s, strict ? hasSameArgs_strict : hasSameArgs_nonstrict);
3459     }
3460 
3461     private boolean hasSameArgs(Type t, Type s, TypeRelation hasSameArgs) {
3462         return hasSameArgs.visit(t, s);
3463     }
3464     // where
3465         private class HasSameArgs extends TypeRelation {
3466 
3467             boolean strict;
3468 
3469             public HasSameArgs(boolean strict) {
3470                 this.strict = strict;
3471             }
3472 
3473             public Boolean visitType(Type t, Type s) {
3474                 throw new AssertionError();
3475             }
3476 
3477             @Override
3478             public Boolean visitMethodType(MethodType t, Type s) {
3479                 return s.hasTag(METHOD)
3480                     && containsTypeEquivalent(t.argtypes, s.getParameterTypes());
3481             }
3482 
3483             @Override
3484             public Boolean visitForAll(ForAll t, Type s) {
3485                 if (!s.hasTag(FORALL))
3486                     return strict ? false : visitMethodType(t.asMethodType(), s);
3487 
3488                 ForAll forAll = (ForAll)s;
3489                 return hasSameBounds(t, forAll)
3490                     && visit(t.qtype, subst(forAll.qtype, forAll.tvars, t.tvars));
3491             }
3492 
3493             @Override
3494             public Boolean visitErrorType(ErrorType t, Type s) {
3495                 return false;
3496             }
3497         }
3498 
3499     TypeRelation hasSameArgs_strict = new HasSameArgs(true);
3500         TypeRelation hasSameArgs_nonstrict = new HasSameArgs(false);
3501 
3502     // </editor-fold>
3503 
3504     // <editor-fold defaultstate="collapsed" desc="subst">
3505     public List<Type> subst(List<Type> ts,
3506                             List<Type> from,
3507                             List<Type> to) {
3508         return ts.map(new Subst(from, to));
3509     }
3510 
3511     /**
3512      * Substitute all occurrences of a type in `from' with the
3513      * corresponding type in `to' in 't'. Match lists `from' and `to'
3514      * from the right: If lists have different length, discard leading
3515      * elements of the longer list.
3516      */
3517     public Type subst(Type t, List<Type> from, List<Type> to) {
3518         return t.map(new Subst(from, to));
3519     }
3520 
3521     private class Subst extends StructuralTypeMapping<Void> {
3522         List<Type> from;
3523         List<Type> to;
3524 
3525         public Subst(List<Type> from, List<Type> to) {
3526             int fromLength = from.length();
3527             int toLength = to.length();
3528             while (fromLength > toLength) {
3529                 fromLength--;
3530                 from = from.tail;
3531             }
3532             while (fromLength < toLength) {
3533                 toLength--;
3534                 to = to.tail;
3535             }
3536             this.from = from;
3537             this.to = to;
3538         }
3539 
3540         @Override
3541         public Type visitTypeVar(TypeVar t, Void ignored) {
3542             for (List<Type> from = this.from, to = this.to;
3543                  from.nonEmpty();
3544                  from = from.tail, to = to.tail) {
3545                 if (t.equalsIgnoreMetadata(from.head)) {
3546                     return to.head.withTypeVar(t);
3547                 }
3548             }
3549             return t;
3550         }
3551 
3552         @Override
3553         public Type visitClassType(ClassType t, Void ignored) {
3554             if (!t.isCompound()) {
3555                 return super.visitClassType(t, ignored);
3556             } else {
3557                 Type st = visit(supertype(t));
3558                 List<Type> is = visit(interfaces(t), ignored);
3559                 if (st == supertype(t) && is == interfaces(t))
3560                     return t;
3561                 else
3562                     return makeIntersectionType(is.prepend(st));
3563             }
3564         }
3565 
3566         @Override
3567         public Type visitWildcardType(WildcardType t, Void ignored) {
3568             WildcardType t2 = (WildcardType)super.visitWildcardType(t, ignored);
3569             if (t2 != t && t.isExtendsBound() && t2.type.isExtendsBound()) {
3570                 t2.type = wildUpperBound(t2.type);
3571             }
3572             return t2;
3573         }
3574 
3575         @Override
3576         public Type visitForAll(ForAll t, Void ignored) {
3577             if (Type.containsAny(to, t.tvars)) {
3578                 //perform alpha-renaming of free-variables in 't'
3579                 //if 'to' types contain variables that are free in 't'
3580                 List<Type> freevars = newInstances(t.tvars);
3581                 t = new ForAll(freevars,
3582                                Types.this.subst(t.qtype, t.tvars, freevars));
3583             }
3584             List<Type> tvars1 = substBounds(t.tvars, from, to);
3585             Type qtype1 = visit(t.qtype);
3586             if (tvars1 == t.tvars && qtype1 == t.qtype) {
3587                 return t;
3588             } else if (tvars1 == t.tvars) {
3589                 return new ForAll(tvars1, qtype1) {
3590                     @Override
3591                     public boolean needsStripping() {
3592                         return true;
3593                     }
3594                 };
3595             } else {
3596                 return new ForAll(tvars1, Types.this.subst(qtype1, t.tvars, tvars1)) {
3597                     @Override
3598                     public boolean needsStripping() {
3599                         return true;
3600                     }
3601                 };
3602             }
3603         }
3604     }
3605 
3606     public List<Type> substBounds(List<Type> tvars,
3607                                   List<Type> from,
3608                                   List<Type> to) {
3609         if (tvars.isEmpty())
3610             return tvars;
3611         ListBuffer<Type> newBoundsBuf = new ListBuffer<>();
3612         boolean changed = false;
3613         // calculate new bounds
3614         for (Type t : tvars) {
3615             TypeVar tv = (TypeVar) t;
3616             Type bound = subst(tv.getUpperBound(), from, to);
3617             if (bound != tv.getUpperBound())
3618                 changed = true;
3619             newBoundsBuf.append(bound);
3620         }
3621         if (!changed)
3622             return tvars;
3623         ListBuffer<Type> newTvars = new ListBuffer<>();
3624         // create new type variables without bounds
3625         for (Type t : tvars) {
3626             newTvars.append(new TypeVar(t.tsym, null, syms.botType,
3627                                         t.getMetadata()));
3628         }
3629         // the new bounds should use the new type variables in place
3630         // of the old
3631         List<Type> newBounds = newBoundsBuf.toList();
3632         from = tvars;
3633         to = newTvars.toList();
3634         for (; !newBounds.isEmpty(); newBounds = newBounds.tail) {
3635             newBounds.head = subst(newBounds.head, from, to);
3636         }
3637         newBounds = newBoundsBuf.toList();
3638         // set the bounds of new type variables to the new bounds
3639         for (Type t : newTvars.toList()) {
3640             TypeVar tv = (TypeVar) t;
3641             tv.setUpperBound( newBounds.head );
3642             newBounds = newBounds.tail;
3643         }
3644         return newTvars.toList();
3645     }
3646 
3647     public TypeVar substBound(TypeVar t, List<Type> from, List<Type> to) {
3648         Type bound1 = subst(t.getUpperBound(), from, to);
3649         if (bound1 == t.getUpperBound())
3650             return t;
3651         else {
3652             // create new type variable without bounds
3653             TypeVar tv = new TypeVar(t.tsym, null, syms.botType,
3654                                      t.getMetadata());
3655             // the new bound should use the new type variable in place
3656             // of the old
3657             tv.setUpperBound( subst(bound1, List.of(t), List.of(tv)) );
3658             return tv;
3659         }
3660     }
3661     // </editor-fold>
3662 
3663     // <editor-fold defaultstate="collapsed" desc="hasSameBounds">
3664     /**
3665      * Does t have the same bounds for quantified variables as s?
3666      */
3667     public boolean hasSameBounds(ForAll t, ForAll s) {
3668         List<Type> l1 = t.tvars;
3669         List<Type> l2 = s.tvars;
3670         while (l1.nonEmpty() && l2.nonEmpty() &&
3671                isSameType(l1.head.getUpperBound(),
3672                           subst(l2.head.getUpperBound(),
3673                                 s.tvars,
3674                                 t.tvars))) {
3675             l1 = l1.tail;
3676             l2 = l2.tail;
3677         }
3678         return l1.isEmpty() && l2.isEmpty();
3679     }
3680     // </editor-fold>
3681 
3682     // <editor-fold defaultstate="collapsed" desc="newInstances">
3683     /** Create new vector of type variables from list of variables
3684      *  changing all recursive bounds from old to new list.
3685      */
3686     public List<Type> newInstances(List<Type> tvars) {
3687         List<Type> tvars1 = tvars.map(newInstanceFun);
3688         for (List<Type> l = tvars1; l.nonEmpty(); l = l.tail) {
3689             TypeVar tv = (TypeVar) l.head;
3690             tv.setUpperBound( subst(tv.getUpperBound(), tvars, tvars1) );
3691         }
3692         return tvars1;
3693     }
3694         private static final TypeMapping<Void> newInstanceFun = new TypeMapping<Void>() {
3695             @Override
3696             public TypeVar visitTypeVar(TypeVar t, Void _unused) {
3697                 return new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound(), t.getMetadata());
3698             }
3699         };
3700     // </editor-fold>
3701 
3702     public Type createMethodTypeWithParameters(Type original, List<Type> newParams) {
3703         return original.accept(methodWithParameters, newParams);
3704     }
3705     // where
3706         private final MapVisitor<List<Type>> methodWithParameters = new MapVisitor<List<Type>>() {
3707             public Type visitType(Type t, List<Type> newParams) {
3708                 throw new IllegalArgumentException("Not a method type: " + t);
3709             }
3710             public Type visitMethodType(MethodType t, List<Type> newParams) {
3711                 return new MethodType(newParams, t.restype, t.thrown, t.tsym);
3712             }
3713             public Type visitForAll(ForAll t, List<Type> newParams) {
3714                 return new ForAll(t.tvars, t.qtype.accept(this, newParams));
3715             }
3716         };
3717 
3718     public Type createMethodTypeWithThrown(Type original, List<Type> newThrown) {
3719         return original.accept(methodWithThrown, newThrown);
3720     }
3721     // where
3722         private final MapVisitor<List<Type>> methodWithThrown = new MapVisitor<List<Type>>() {
3723             public Type visitType(Type t, List<Type> newThrown) {
3724                 throw new IllegalArgumentException("Not a method type: " + t);
3725             }
3726             public Type visitMethodType(MethodType t, List<Type> newThrown) {
3727                 return new MethodType(t.argtypes, t.restype, newThrown, t.tsym);
3728             }
3729             public Type visitForAll(ForAll t, List<Type> newThrown) {
3730                 return new ForAll(t.tvars, t.qtype.accept(this, newThrown));
3731             }
3732         };
3733 
3734     public Type createMethodTypeWithReturn(Type original, Type newReturn) {
3735         return original.accept(methodWithReturn, newReturn);
3736     }
3737     // where
3738         private final MapVisitor<Type> methodWithReturn = new MapVisitor<Type>() {
3739             public Type visitType(Type t, Type newReturn) {
3740                 throw new IllegalArgumentException("Not a method type: " + t);
3741             }
3742             public Type visitMethodType(MethodType t, Type newReturn) {
3743                 return new MethodType(t.argtypes, newReturn, t.thrown, t.tsym) {
3744                     @Override
3745                     public Type baseType() {
3746                         return t;
3747                     }
3748                 };
3749             }
3750             public Type visitForAll(ForAll t, Type newReturn) {
3751                 return new ForAll(t.tvars, t.qtype.accept(this, newReturn)) {
3752                     @Override
3753                     public Type baseType() {
3754                         return t;
3755                     }
3756                 };
3757             }
3758         };
3759 
3760     // <editor-fold defaultstate="collapsed" desc="createErrorType">
3761     public Type createErrorType(Type originalType) {
3762         return new ErrorType(originalType, syms.errSymbol);
3763     }
3764 
3765     public Type createErrorType(ClassSymbol c, Type originalType) {
3766         return new ErrorType(c, originalType);
3767     }
3768 
3769     public Type createErrorType(Name name, TypeSymbol container, Type originalType) {
3770         return new ErrorType(name, container, originalType);
3771     }
3772     // </editor-fold>
3773 
3774     // <editor-fold defaultstate="collapsed" desc="rank">
3775     /**
3776      * The rank of a class is the length of the longest path between
3777      * the class and java.lang.Object in the class inheritance
3778      * graph. Undefined for all but reference types.
3779      */
3780     public int rank(Type t) {
3781         switch(t.getTag()) {
3782         case CLASS: {
3783             ClassType cls = (ClassType)t;
3784             if (cls.rank_field < 0) {
3785                 Name fullname = cls.tsym.getQualifiedName();
3786                 if (fullname == names.java_lang_Object)
3787                     cls.rank_field = 0;
3788                 else {
3789                     int r = rank(supertype(cls));
3790                     for (List<Type> l = interfaces(cls);
3791                          l.nonEmpty();
3792                          l = l.tail) {
3793                         if (rank(l.head) > r)
3794                             r = rank(l.head);
3795                     }
3796                     cls.rank_field = r + 1;
3797                 }
3798             }
3799             return cls.rank_field;
3800         }
3801         case TYPEVAR: {
3802             TypeVar tvar = (TypeVar)t;
3803             if (tvar.rank_field < 0) {
3804                 int r = rank(supertype(tvar));
3805                 for (List<Type> l = interfaces(tvar);
3806                      l.nonEmpty();
3807                      l = l.tail) {
3808                     if (rank(l.head) > r) r = rank(l.head);
3809                 }
3810                 tvar.rank_field = r + 1;
3811             }
3812             return tvar.rank_field;
3813         }
3814         case ERROR:
3815         case NONE:
3816             return 0;
3817         default:
3818             throw new AssertionError();
3819         }
3820     }
3821     // </editor-fold>
3822 
3823     /**
3824      * Helper method for generating a string representation of a given type
3825      * accordingly to a given locale
3826      */
3827     public String toString(Type t, Locale locale) {
3828         return Printer.createStandardPrinter(messages).visit(t, locale);
3829     }
3830 
3831     /**
3832      * Helper method for generating a string representation of a given type
3833      * accordingly to a given locale
3834      */
3835     public String toString(Symbol t, Locale locale) {
3836         return Printer.createStandardPrinter(messages).visit(t, locale);
3837     }
3838 
3839     // <editor-fold defaultstate="collapsed" desc="toString">
3840     /**
3841      * This toString is slightly more descriptive than the one on Type.
3842      *
3843      * @deprecated Types.toString(Type t, Locale l) provides better support
3844      * for localization
3845      */
3846     @Deprecated
3847     public String toString(Type t) {
3848         if (t.hasTag(FORALL)) {
3849             ForAll forAll = (ForAll)t;
3850             return typaramsString(forAll.tvars) + forAll.qtype;
3851         }
3852         return "" + t;
3853     }
3854     // where
3855         private String typaramsString(List<Type> tvars) {
3856             StringBuilder s = new StringBuilder();
3857             s.append('<');
3858             boolean first = true;
3859             for (Type t : tvars) {
3860                 if (!first) s.append(", ");
3861                 first = false;
3862                 appendTyparamString(((TypeVar)t), s);
3863             }
3864             s.append('>');
3865             return s.toString();
3866         }
3867         private void appendTyparamString(TypeVar t, StringBuilder buf) {
3868             buf.append(t);
3869             if (t.getUpperBound() == null ||
3870                 t.getUpperBound().tsym.getQualifiedName() == names.java_lang_Object)
3871                 return;
3872             buf.append(" extends "); // Java syntax; no need for i18n
3873             Type bound = t.getUpperBound();
3874             if (!bound.isCompound()) {
3875                 buf.append(bound);
3876             } else if ((erasure(t).tsym.flags() & INTERFACE) == 0) {
3877                 buf.append(supertype(t));
3878                 for (Type intf : interfaces(t)) {
3879                     buf.append('&');
3880                     buf.append(intf);
3881                 }
3882             } else {
3883                 // No superclass was given in bounds.
3884                 // In this case, supertype is Object, erasure is first interface.
3885                 boolean first = true;
3886                 for (Type intf : interfaces(t)) {
3887                     if (!first) buf.append('&');
3888                     first = false;
3889                     buf.append(intf);
3890                 }
3891             }
3892         }
3893     // </editor-fold>
3894 
3895     // <editor-fold defaultstate="collapsed" desc="Determining least upper bounds of types">
3896     /**
3897      * A cache for closures.
3898      *
3899      * <p>A closure is a list of all the supertypes and interfaces of
3900      * a class or interface type, ordered by ClassSymbol.precedes
3901      * (that is, subclasses come first, arbitrary but fixed
3902      * otherwise).
3903      */
3904     private Map<Type,List<Type>> closureCache = new HashMap<>();
3905 
3906     /**
3907      * Returns the closure of a class or interface type.
3908      */
3909     public List<Type> closure(Type t) {
3910         List<Type> cl = closureCache.get(t);
3911         if (cl == null) {
3912             Type st = supertype(t);
3913             if (!t.isCompound()) {
3914                 if (st.hasTag(CLASS)) {
3915                     cl = insert(closure(st), t);
3916                 } else if (st.hasTag(TYPEVAR)) {
3917                     cl = closure(st).prepend(t);
3918                 } else {
3919                     cl = List.of(t);
3920                 }
3921             } else {
3922                 cl = closure(supertype(t));
3923             }
3924             for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail)
3925                 cl = union(cl, closure(l.head));
3926             closureCache.put(t, cl);
3927         }
3928         return cl;
3929     }
3930 
3931     /**
3932      * Collect types into a new closure (using a @code{ClosureHolder})
3933      */
3934     public Collector<Type, ClosureHolder, List<Type>> closureCollector(boolean minClosure, BiPredicate<Type, Type> shouldSkip) {
3935         return Collector.of(() -> new ClosureHolder(minClosure, shouldSkip),
3936                 ClosureHolder::add,
3937                 ClosureHolder::merge,
3938                 ClosureHolder::closure);
3939     }
3940     //where
3941         class ClosureHolder {
3942             List<Type> closure;
3943             final boolean minClosure;
3944             final BiPredicate<Type, Type> shouldSkip;
3945 
3946             ClosureHolder(boolean minClosure, BiPredicate<Type, Type> shouldSkip) {
3947                 this.closure = List.nil();
3948                 this.minClosure = minClosure;
3949                 this.shouldSkip = shouldSkip;
3950             }
3951 
3952             void add(Type type) {
3953                 closure = insert(closure, type, shouldSkip);
3954             }
3955 
3956             ClosureHolder merge(ClosureHolder other) {
3957                 closure = union(closure, other.closure, shouldSkip);
3958                 return this;
3959             }
3960 
3961             List<Type> closure() {
3962                 return minClosure ? closureMin(closure) : closure;
3963             }
3964         }
3965 
3966     BiPredicate<Type, Type> basicClosureSkip = (t1, t2) -> t1.tsym == t2.tsym;
3967 
3968     /**
3969      * Insert a type in a closure
3970      */
3971     public List<Type> insert(List<Type> cl, Type t, BiPredicate<Type, Type> shouldSkip) {
3972         if (cl.isEmpty()) {
3973             return cl.prepend(t);
3974         } else if (shouldSkip.test(t, cl.head)) {
3975             return cl;
3976         } else if (t.tsym.precedes(cl.head.tsym, this)) {
3977             return cl.prepend(t);
3978         } else {
3979             // t comes after head, or the two are unrelated
3980             return insert(cl.tail, t, shouldSkip).prepend(cl.head);
3981         }
3982     }
3983 
3984     public List<Type> insert(List<Type> cl, Type t) {
3985         return insert(cl, t, basicClosureSkip);
3986     }
3987 
3988     /**
3989      * Form the union of two closures
3990      */
3991     public List<Type> union(List<Type> cl1, List<Type> cl2, BiPredicate<Type, Type> shouldSkip) {
3992         if (cl1.isEmpty()) {
3993             return cl2;
3994         } else if (cl2.isEmpty()) {
3995             return cl1;
3996         } else if (shouldSkip.test(cl1.head, cl2.head)) {
3997             return union(cl1.tail, cl2.tail, shouldSkip).prepend(cl1.head);
3998         } else if (cl2.head.tsym.precedes(cl1.head.tsym, this)) {
3999             return union(cl1, cl2.tail, shouldSkip).prepend(cl2.head);
4000         } else {
4001             return union(cl1.tail, cl2, shouldSkip).prepend(cl1.head);
4002         }
4003     }
4004 
4005     public List<Type> union(List<Type> cl1, List<Type> cl2) {
4006         return union(cl1, cl2, basicClosureSkip);
4007     }
4008 
4009     /**
4010      * Intersect two closures
4011      */
4012     public List<Type> intersect(List<Type> cl1, List<Type> cl2) {
4013         if (cl1 == cl2)
4014             return cl1;
4015         if (cl1.isEmpty() || cl2.isEmpty())
4016             return List.nil();
4017         if (cl1.head.tsym.precedes(cl2.head.tsym, this))
4018             return intersect(cl1.tail, cl2);
4019         if (cl2.head.tsym.precedes(cl1.head.tsym, this))
4020             return intersect(cl1, cl2.tail);
4021         if (isSameType(cl1.head, cl2.head))
4022             return intersect(cl1.tail, cl2.tail).prepend(cl1.head);
4023         if (cl1.head.tsym == cl2.head.tsym &&
4024             cl1.head.hasTag(CLASS) && cl2.head.hasTag(CLASS)) {
4025             if (cl1.head.isParameterized() && cl2.head.isParameterized()) {
4026                 Type merge = merge(cl1.head,cl2.head);
4027                 return intersect(cl1.tail, cl2.tail).prepend(merge);
4028             }
4029             if (cl1.head.isRaw() || cl2.head.isRaw())
4030                 return intersect(cl1.tail, cl2.tail).prepend(erasure(cl1.head));
4031         }
4032         return intersect(cl1.tail, cl2.tail);
4033     }
4034     // where
4035         class TypePair {
4036             final Type t1;
4037             final Type t2;;
4038 
4039             TypePair(Type t1, Type t2) {
4040                 this.t1 = t1;
4041                 this.t2 = t2;
4042             }
4043             @Override
4044             public int hashCode() {
4045                 return 127 * Types.this.hashCode(t1) + Types.this.hashCode(t2);
4046             }
4047             @Override
4048             public boolean equals(Object obj) {
4049                 return (obj instanceof TypePair typePair)
4050                         && isSameType(t1, typePair.t1)
4051                         && isSameType(t2, typePair.t2);
4052             }
4053         }
4054         Set<TypePair> mergeCache = new HashSet<>();
4055         private Type merge(Type c1, Type c2) {
4056             ClassType class1 = (ClassType) c1;
4057             List<Type> act1 = class1.getTypeArguments();
4058             ClassType class2 = (ClassType) c2;
4059             List<Type> act2 = class2.getTypeArguments();
4060             ListBuffer<Type> merged = new ListBuffer<>();
4061             List<Type> typarams = class1.tsym.type.getTypeArguments();
4062 
4063             while (act1.nonEmpty() && act2.nonEmpty() && typarams.nonEmpty()) {
4064                 if (containsType(act1.head, act2.head)) {
4065                     merged.append(act1.head);
4066                 } else if (containsType(act2.head, act1.head)) {
4067                     merged.append(act2.head);
4068                 } else {
4069                     TypePair pair = new TypePair(c1, c2);
4070                     Type m;
4071                     if (mergeCache.add(pair)) {
4072                         m = new WildcardType(lub(wildUpperBound(act1.head),
4073                                                  wildUpperBound(act2.head)),
4074                                              BoundKind.EXTENDS,
4075                                              syms.boundClass);
4076                         mergeCache.remove(pair);
4077                     } else {
4078                         m = new WildcardType(syms.objectType,
4079                                              BoundKind.UNBOUND,
4080                                              syms.boundClass);
4081                     }
4082                     merged.append(m.withTypeVar(typarams.head));
4083                 }
4084                 act1 = act1.tail;
4085                 act2 = act2.tail;
4086                 typarams = typarams.tail;
4087             }
4088             Assert.check(act1.isEmpty() && act2.isEmpty() && typarams.isEmpty());
4089             // There is no spec detailing how type annotations are to
4090             // be inherited.  So set it to noAnnotations for now
4091             return new ClassType(class1.getEnclosingType(), merged.toList(),
4092                                  class1.tsym, TypeMetadata.EMPTY, class1.getFlavor());
4093         }
4094 
4095     /**
4096      * Return the minimum type of a closure, a compound type if no
4097      * unique minimum exists.
4098      */
4099     private Type compoundMin(List<Type> cl) {
4100         if (cl.isEmpty()) return syms.objectType;
4101         List<Type> compound = closureMin(cl);
4102         if (compound.isEmpty())
4103             return null;
4104         else if (compound.tail.isEmpty())
4105             return compound.head;
4106         else
4107             return makeIntersectionType(compound);
4108     }
4109 
4110     /**
4111      * Return the minimum types of a closure, suitable for computing
4112      * compoundMin or glb.
4113      */
4114     private List<Type> closureMin(List<Type> cl) {
4115         ListBuffer<Type> classes = new ListBuffer<>();
4116         ListBuffer<Type> interfaces = new ListBuffer<>();
4117         Set<Type> toSkip = new HashSet<>();
4118         while (!cl.isEmpty()) {
4119             Type current = cl.head;
4120             boolean keep = !toSkip.contains(current);
4121             if (keep && current.hasTag(TYPEVAR)) {
4122                 // skip lower-bounded variables with a subtype in cl.tail
4123                 for (Type t : cl.tail) {
4124                     if (isSubtypeNoCapture(t, current)) {
4125                         keep = false;
4126                         break;
4127                     }
4128                 }
4129             }
4130             if (keep) {
4131                 if (current.isInterface())
4132                     interfaces.append(current);
4133                 else
4134                     classes.append(current);
4135                 for (Type t : cl.tail) {
4136                     // skip supertypes of 'current' in cl.tail
4137                     if (isSubtypeNoCapture(current, t))
4138                         toSkip.add(t);
4139                 }
4140             }
4141             cl = cl.tail;
4142         }
4143         return classes.appendList(interfaces).toList();
4144     }
4145 
4146     /**
4147      * Return the least upper bound of list of types.  if the lub does
4148      * not exist return null.
4149      */
4150     public Type lub(List<Type> ts) {
4151         return lub(ts.toArray(new Type[ts.length()]));
4152     }
4153 
4154     /**
4155      * Return the least upper bound (lub) of set of types.  If the lub
4156      * does not exist return the type of null (bottom).
4157      */
4158     public Type lub(Type... ts) {
4159         final int UNKNOWN_BOUND = 0;
4160         final int ARRAY_BOUND = 1;
4161         final int CLASS_BOUND = 2;
4162 
4163         int[] kinds = new int[ts.length];
4164         int boundkind = UNKNOWN_BOUND;
4165         for (int i = 0 ; i < ts.length ; i++) {
4166             Type t = ts[i];
4167             switch (t.getTag()) {
4168             case CLASS:
4169                 boundkind |= kinds[i] = CLASS_BOUND;
4170                 break;
4171             case ARRAY:
4172                 boundkind |= kinds[i] = ARRAY_BOUND;
4173                 break;
4174             case  TYPEVAR:
4175                 do {
4176                     t = t.getUpperBound();
4177                 } while (t.hasTag(TYPEVAR));
4178                 if (t.hasTag(ARRAY)) {
4179                     boundkind |= kinds[i] = ARRAY_BOUND;
4180                 } else {
4181                     boundkind |= kinds[i] = CLASS_BOUND;
4182                 }
4183                 break;
4184             default:
4185                 kinds[i] = UNKNOWN_BOUND;
4186                 if (t.isPrimitive())
4187                     return syms.errType;
4188             }
4189         }
4190         switch (boundkind) {
4191         case 0:
4192             return syms.botType;
4193 
4194         case ARRAY_BOUND:
4195             // calculate lub(A[], B[])
4196             Type[] elements = new Type[ts.length];
4197             for (int i = 0 ; i < ts.length ; i++) {
4198                 Type elem = elements[i] = elemTypeFun.apply(ts[i]);
4199                 if (elem.isPrimitive()) {
4200                     // if a primitive type is found, then return
4201                     // arraySuperType unless all the types are the
4202                     // same
4203                     Type first = ts[0];
4204                     for (int j = 1 ; j < ts.length ; j++) {
4205                         if (!isSameType(first, ts[j])) {
4206                              // lub(int[], B[]) is Cloneable & Serializable
4207                             return arraySuperType();
4208                         }
4209                     }
4210                     // all the array types are the same, return one
4211                     // lub(int[], int[]) is int[]
4212                     return first;
4213                 }
4214             }
4215             // lub(A[], B[]) is lub(A, B)[]
4216             return new ArrayType(lub(elements), syms.arrayClass);
4217 
4218         case CLASS_BOUND:
4219             // calculate lub(A, B)
4220             int startIdx = 0;
4221             for (int i = 0; i < ts.length ; i++) {
4222                 Type t = ts[i];
4223                 if (t.hasTag(CLASS) || t.hasTag(TYPEVAR)) {
4224                     break;
4225                 } else {
4226                     startIdx++;
4227                 }
4228             }
4229             Assert.check(startIdx < ts.length);
4230             //step 1 - compute erased candidate set (EC)
4231             List<Type> cl = erasedSupertypes(ts[startIdx]);
4232             for (int i = startIdx + 1 ; i < ts.length ; i++) {
4233                 Type t = ts[i];
4234                 if (t.hasTag(CLASS) || t.hasTag(TYPEVAR))
4235                     cl = intersect(cl, erasedSupertypes(t));
4236             }
4237             //step 2 - compute minimal erased candidate set (MEC)
4238             List<Type> mec = closureMin(cl);
4239             //step 3 - for each element G in MEC, compute lci(Inv(G))
4240             List<Type> candidates = List.nil();
4241             for (Type erasedSupertype : mec) {
4242                 List<Type> lci = List.of(asSuper(ts[startIdx], erasedSupertype.tsym));
4243                 for (int i = startIdx + 1 ; i < ts.length ; i++) {
4244                     Type superType = asSuper(ts[i], erasedSupertype.tsym);
4245                     lci = intersect(lci, superType != null ? List.of(superType) : List.nil());
4246                 }
4247                 candidates = candidates.appendList(lci);
4248             }
4249             //step 4 - let MEC be { G1, G2 ... Gn }, then we have that
4250             //lub = lci(Inv(G1)) & lci(Inv(G2)) & ... & lci(Inv(Gn))
4251             return compoundMin(candidates);
4252 
4253         default:
4254             // calculate lub(A, B[])
4255             List<Type> classes = List.of(arraySuperType());
4256             for (int i = 0 ; i < ts.length ; i++) {
4257                 if (kinds[i] != ARRAY_BOUND) // Filter out any arrays
4258                     classes = classes.prepend(ts[i]);
4259             }
4260             // lub(A, B[]) is lub(A, arraySuperType)
4261             return lub(classes);
4262         }
4263     }
4264     // where
4265         List<Type> erasedSupertypes(Type t) {
4266             ListBuffer<Type> buf = new ListBuffer<>();
4267             for (Type sup : closure(t)) {
4268                 if (sup.hasTag(TYPEVAR)) {
4269                     buf.append(sup);
4270                 } else {
4271                     buf.append(erasure(sup));
4272                 }
4273             }
4274             return buf.toList();
4275         }
4276 
4277         private Type arraySuperType;
4278         private Type arraySuperType() {
4279             // initialized lazily to avoid problems during compiler startup
4280             if (arraySuperType == null) {
4281                 // JLS 10.8: all arrays implement Cloneable and Serializable.
4282                 arraySuperType = makeIntersectionType(List.of(syms.serializableType,
4283                         syms.cloneableType), true);
4284             }
4285             return arraySuperType;
4286         }
4287     // </editor-fold>
4288 
4289     // <editor-fold defaultstate="collapsed" desc="Greatest lower bound">
4290     public Type glb(List<Type> ts) {
4291         Type t1 = ts.head;
4292         for (Type t2 : ts.tail) {
4293             if (t1.isErroneous())
4294                 return t1;
4295             t1 = glb(t1, t2);
4296         }
4297         return t1;
4298     }
4299     //where
4300     public Type glb(Type t, Type s) {
4301         if (s == null)
4302             return t;
4303         else if (t.isPrimitive() || s.isPrimitive())
4304             return syms.errType;
4305         else if (isSubtypeNoCapture(t, s))
4306             return t;
4307         else if (isSubtypeNoCapture(s, t))
4308             return s;
4309 
4310         List<Type> closure = union(closure(t), closure(s));
4311         return glbFlattened(closure, t);
4312     }
4313     //where
4314     /**
4315      * Perform glb for a list of non-primitive, non-error, non-compound types;
4316      * redundant elements are removed.  Bounds should be ordered according to
4317      * {@link Symbol#precedes(TypeSymbol,Types)}.
4318      *
4319      * @param flatBounds List of type to glb
4320      * @param errT Original type to use if the result is an error type
4321      */
4322     private Type glbFlattened(List<Type> flatBounds, Type errT) {
4323         List<Type> bounds = closureMin(flatBounds);
4324 
4325         if (bounds.isEmpty()) {             // length == 0
4326             return syms.objectType;
4327         } else if (bounds.tail.isEmpty()) { // length == 1
4328             return bounds.head;
4329         } else {                            // length > 1
4330             int classCount = 0;
4331             List<Type> cvars = List.nil();
4332             List<Type> lowers = List.nil();
4333             for (Type bound : bounds) {
4334                 if (!bound.isInterface()) {
4335                     classCount++;
4336                     Type lower = cvarLowerBound(bound);
4337                     if (bound != lower && !lower.hasTag(BOT)) {
4338                         cvars = cvars.append(bound);
4339                         lowers = lowers.append(lower);
4340                     }
4341                 }
4342             }
4343             if (classCount > 1) {
4344                 if (lowers.isEmpty()) {
4345                     return createErrorType(errT);
4346                 } else {
4347                     // try again with lower bounds included instead of capture variables
4348                     List<Type> newBounds = bounds.diff(cvars).appendList(lowers);
4349                     return glb(newBounds);
4350                 }
4351             }
4352         }
4353         return makeIntersectionType(bounds);
4354     }
4355     // </editor-fold>
4356 
4357     // <editor-fold defaultstate="collapsed" desc="hashCode">
4358     /**
4359      * Compute a hash code on a type.
4360      */
4361     public int hashCode(Type t) {
4362         return hashCode(t, false);
4363     }
4364 
4365     public int hashCode(Type t, boolean strict) {
4366         return strict ?
4367                 hashCodeStrictVisitor.visit(t) :
4368                 hashCodeVisitor.visit(t);
4369     }
4370     // where
4371         private static final HashCodeVisitor hashCodeVisitor = new HashCodeVisitor();
4372         private static final HashCodeVisitor hashCodeStrictVisitor = new HashCodeVisitor() {
4373             @Override
4374             public Integer visitTypeVar(TypeVar t, Void ignored) {
4375                 return System.identityHashCode(t);
4376             }
4377         };
4378 
4379         private static class HashCodeVisitor extends UnaryVisitor<Integer> {
4380             public Integer visitType(Type t, Void ignored) {
4381                 return t.getTag().ordinal();
4382             }
4383 
4384             @Override
4385             public Integer visitClassType(ClassType t, Void ignored) {
4386                 int result = visit(t.getEnclosingType());
4387                 result *= 127;
4388                 result += t.tsym.flatName().hashCode();
4389                 for (Type s : t.getTypeArguments()) {
4390                     result *= 127;
4391                     result += visit(s);
4392                 }
4393                 return result;
4394             }
4395 
4396             @Override
4397             public Integer visitMethodType(MethodType t, Void ignored) {
4398                 int h = METHOD.ordinal();
4399                 for (List<Type> thisargs = t.argtypes;
4400                      thisargs.tail != null;
4401                      thisargs = thisargs.tail)
4402                     h = (h << 5) + visit(thisargs.head);
4403                 return (h << 5) + visit(t.restype);
4404             }
4405 
4406             @Override
4407             public Integer visitWildcardType(WildcardType t, Void ignored) {
4408                 int result = t.kind.hashCode();
4409                 if (t.type != null) {
4410                     result *= 127;
4411                     result += visit(t.type);
4412                 }
4413                 return result;
4414             }
4415 
4416             @Override
4417             public Integer visitArrayType(ArrayType t, Void ignored) {
4418                 return visit(t.elemtype) + 12;
4419             }
4420 
4421             @Override
4422             public Integer visitTypeVar(TypeVar t, Void ignored) {
4423                 return System.identityHashCode(t);
4424             }
4425 
4426             @Override
4427             public Integer visitUndetVar(UndetVar t, Void ignored) {
4428                 return System.identityHashCode(t);
4429             }
4430 
4431             @Override
4432             public Integer visitErrorType(ErrorType t, Void ignored) {
4433                 return 0;
4434             }
4435         }
4436     // </editor-fold>
4437 
4438     // <editor-fold defaultstate="collapsed" desc="Return-Type-Substitutable">
4439     /**
4440      * Does t have a result that is a subtype of the result type of s,
4441      * suitable for covariant returns?  It is assumed that both types
4442      * are (possibly polymorphic) method types.  Monomorphic method
4443      * types are handled in the obvious way.  Polymorphic method types
4444      * require renaming all type variables of one to corresponding
4445      * type variables in the other, where correspondence is by
4446      * position in the type parameter list. */
4447     public boolean resultSubtype(Type t, Type s, Warner warner) {
4448         List<Type> tvars = t.getTypeArguments();
4449         List<Type> svars = s.getTypeArguments();
4450         Type tres = t.getReturnType();
4451         Type sres = subst(s.getReturnType(), svars, tvars);
4452         return covariantReturnType(tres, sres, warner);
4453     }
4454 
4455     /**
4456      * Return-Type-Substitutable.
4457      * @jls 8.4.5 Method Result
4458      */
4459     public boolean returnTypeSubstitutable(Type r1, Type r2) {
4460         if (hasSameArgs(r1, r2))
4461             return resultSubtype(r1, r2, noWarnings);
4462         else
4463             return covariantReturnType(r1.getReturnType(),
4464                                        erasure(r2.getReturnType()),
4465                                        noWarnings);
4466     }
4467 
4468     public boolean returnTypeSubstitutable(Type r1,
4469                                            Type r2, Type r2res,
4470                                            Warner warner) {
4471         if (isSameType(r1.getReturnType(), r2res))
4472             return true;
4473         if (r1.getReturnType().isPrimitive() || r2res.isPrimitive())
4474             return false;
4475 
4476         if (hasSameArgs(r1, r2))
4477             return covariantReturnType(r1.getReturnType(), r2res, warner);
4478         if (isSubtypeUnchecked(r1.getReturnType(), r2res, warner))
4479             return true;
4480         if (!isSubtype(r1.getReturnType(), erasure(r2res)))
4481             return false;
4482         warner.warn(LintCategory.UNCHECKED);
4483         return true;
4484     }
4485 
4486     /**
4487      * Is t an appropriate return type in an overrider for a
4488      * method that returns s?
4489      */
4490     public boolean covariantReturnType(Type t, Type s, Warner warner) {
4491         return
4492             isSameType(t, s) ||
4493             !t.isPrimitive() &&
4494             !s.isPrimitive() &&
4495             isAssignable(t, s, warner);
4496     }
4497     // </editor-fold>
4498 
4499     // <editor-fold defaultstate="collapsed" desc="Box/unbox support">
4500     /**
4501      * Return the class that boxes the given primitive.
4502      */
4503     public ClassSymbol boxedClass(Type t) {
4504         return syms.enterClass(syms.java_base, syms.boxedName[t.getTag().ordinal()]);
4505     }
4506 
4507     /**
4508      * Return the boxed type if 't' is primitive, otherwise return 't' itself.
4509      */
4510     public Type boxedTypeOrType(Type t) {
4511         return t.isPrimitive() ?
4512             boxedClass(t).type :
4513             t;
4514     }
4515 
4516     /**
4517      * Return the primitive type corresponding to a boxed type.
4518      */
4519     public Type unboxedType(Type t) {
4520         if (t.hasTag(ERROR))
4521             return Type.noType;
4522         for (int i=0; i<syms.boxedName.length; i++) {
4523             Name box = syms.boxedName[i];
4524             if (box != null &&
4525                 asSuper(t, syms.enterClass(syms.java_base, box)) != null)
4526                 return syms.typeOfTag[i];
4527         }
4528         return Type.noType;
4529     }
4530 
4531     /**
4532      * Return the unboxed type if 't' is a boxed class, otherwise return 't' itself.
4533      */
4534     public Type unboxedTypeOrType(Type t) {
4535         Type unboxedType = unboxedType(t);
4536         return unboxedType.hasTag(NONE) ? t : unboxedType;
4537     }
4538     // </editor-fold>
4539 
4540     // <editor-fold defaultstate="collapsed" desc="Capture conversion">
4541     /*
4542      * JLS 5.1.10 Capture Conversion:
4543      *
4544      * Let G name a generic type declaration with n formal type
4545      * parameters A1 ... An with corresponding bounds U1 ... Un. There
4546      * exists a capture conversion from G<T1 ... Tn> to G<S1 ... Sn>,
4547      * where, for 1 <= i <= n:
4548      *
4549      * + If Ti is a wildcard type argument (4.5.1) of the form ? then
4550      *   Si is a fresh type variable whose upper bound is
4551      *   Ui[A1 := S1, ..., An := Sn] and whose lower bound is the null
4552      *   type.
4553      *
4554      * + If Ti is a wildcard type argument of the form ? extends Bi,
4555      *   then Si is a fresh type variable whose upper bound is
4556      *   glb(Bi, Ui[A1 := S1, ..., An := Sn]) and whose lower bound is
4557      *   the null type, where glb(V1,... ,Vm) is V1 & ... & Vm. It is
4558      *   a compile-time error if for any two classes (not interfaces)
4559      *   Vi and Vj,Vi is not a subclass of Vj or vice versa.
4560      *
4561      * + If Ti is a wildcard type argument of the form ? super Bi,
4562      *   then Si is a fresh type variable whose upper bound is
4563      *   Ui[A1 := S1, ..., An := Sn] and whose lower bound is Bi.
4564      *
4565      * + Otherwise, Si = Ti.
4566      *
4567      * Capture conversion on any type other than a parameterized type
4568      * (4.5) acts as an identity conversion (5.1.1). Capture
4569      * conversions never require a special action at run time and
4570      * therefore never throw an exception at run time.
4571      *
4572      * Capture conversion is not applied recursively.
4573      */
4574     /**
4575      * Capture conversion as specified by the JLS.
4576      */
4577 
4578     public List<Type> capture(List<Type> ts) {
4579         List<Type> buf = List.nil();
4580         for (Type t : ts) {
4581             buf = buf.prepend(capture(t));
4582         }
4583         return buf.reverse();
4584     }
4585 
4586     public Type capture(Type t) {
4587         if (!t.hasTag(CLASS)) {
4588             return t;
4589         }
4590         if (t.getEnclosingType() != Type.noType) {
4591             Type capturedEncl = capture(t.getEnclosingType());
4592             if (capturedEncl != t.getEnclosingType()) {
4593                 Type type1 = memberType(capturedEncl, t.tsym);
4594                 t = subst(type1, t.tsym.type.getTypeArguments(), t.getTypeArguments());
4595             }
4596         }
4597         ClassType cls = (ClassType)t;
4598         if (cls.isRaw() || !cls.isParameterized())
4599             return cls;
4600 
4601         ClassType G = (ClassType)cls.asElement().asType();
4602         List<Type> A = G.getTypeArguments();
4603         List<Type> T = cls.getTypeArguments();
4604         List<Type> S = freshTypeVariables(T);
4605 
4606         List<Type> currentA = A;
4607         List<Type> currentT = T;
4608         List<Type> currentS = S;
4609         boolean captured = false;
4610         while (!currentA.isEmpty() &&
4611                !currentT.isEmpty() &&
4612                !currentS.isEmpty()) {
4613             if (currentS.head != currentT.head) {
4614                 captured = true;
4615                 WildcardType Ti = (WildcardType)currentT.head;
4616                 Type Ui = currentA.head.getUpperBound();
4617                 CapturedType Si = (CapturedType)currentS.head;
4618                 if (Ui == null)
4619                     Ui = syms.objectType;
4620                 switch (Ti.kind) {
4621                 case UNBOUND:
4622                     Si.setUpperBound( subst(Ui, A, S) );
4623                     Si.lower = syms.botType;
4624                     break;
4625                 case EXTENDS:
4626                     Si.setUpperBound( glb(Ti.getExtendsBound(), subst(Ui, A, S)) );
4627                     Si.lower = syms.botType;
4628                     break;
4629                 case SUPER:
4630                     Si.setUpperBound( subst(Ui, A, S) );
4631                     Si.lower = Ti.getSuperBound();
4632                     break;
4633                 }
4634                 Type tmpBound = Si.getUpperBound().hasTag(UNDETVAR) ? ((UndetVar)Si.getUpperBound()).qtype : Si.getUpperBound();
4635                 Type tmpLower = Si.lower.hasTag(UNDETVAR) ? ((UndetVar)Si.lower).qtype : Si.lower;
4636                 if (!Si.getUpperBound().hasTag(ERROR) &&
4637                     !Si.lower.hasTag(ERROR) &&
4638                     isSameType(tmpBound, tmpLower)) {
4639                     currentS.head = Si.getUpperBound();
4640                 }
4641             }
4642             currentA = currentA.tail;
4643             currentT = currentT.tail;
4644             currentS = currentS.tail;
4645         }
4646         if (!currentA.isEmpty() || !currentT.isEmpty() || !currentS.isEmpty())
4647             return erasure(t); // some "rare" type involved
4648 
4649         if (captured)
4650             return new ClassType(cls.getEnclosingType(), S, cls.tsym,
4651                                  cls.getMetadata(), cls.getFlavor());
4652         else
4653             return t;
4654     }
4655     // where
4656         public List<Type> freshTypeVariables(List<Type> types) {
4657             ListBuffer<Type> result = new ListBuffer<>();
4658             for (Type t : types) {
4659                 if (t.hasTag(WILDCARD)) {
4660                     Type bound = ((WildcardType)t).getExtendsBound();
4661                     if (bound == null)
4662                         bound = syms.objectType;
4663                     result.append(new CapturedType(capturedName,
4664                                                    syms.noSymbol,
4665                                                    bound,
4666                                                    syms.botType,
4667                                                    (WildcardType)t));
4668                 } else {
4669                     result.append(t);
4670                 }
4671             }
4672             return result.toList();
4673         }
4674     // </editor-fold>
4675 
4676     // <editor-fold defaultstate="collapsed" desc="Internal utility methods">
4677     private boolean sideCast(Type from, Type to, Warner warn) {
4678         // We are casting from type $from$ to type $to$, which are
4679         // non-final unrelated types.  This method
4680         // tries to reject a cast by transferring type parameters
4681         // from $to$ to $from$ by common superinterfaces.
4682         boolean reverse = false;
4683         Type target = to;
4684         if ((to.tsym.flags() & INTERFACE) == 0) {
4685             Assert.check((from.tsym.flags() & INTERFACE) != 0);
4686             reverse = true;
4687             to = from;
4688             from = target;
4689         }
4690         List<Type> commonSupers = superClosure(to, erasure(from));
4691         boolean giveWarning = commonSupers.isEmpty();
4692         // The arguments to the supers could be unified here to
4693         // get a more accurate analysis
4694         while (commonSupers.nonEmpty()) {
4695             Type t1 = asSuper(from, commonSupers.head.tsym);
4696             Type t2 = commonSupers.head; // same as asSuper(to, commonSupers.head.tsym);
4697             if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
4698                 return false;
4699             giveWarning = giveWarning || (reverse ? giveWarning(t2, t1) : giveWarning(t1, t2));
4700             commonSupers = commonSupers.tail;
4701         }
4702         if (giveWarning && !isReifiable(reverse ? from : to))
4703             warn.warn(LintCategory.UNCHECKED);
4704         return true;
4705     }
4706 
4707     private boolean sideCastFinal(Type from, Type to, Warner warn) {
4708         // We are casting from type $from$ to type $to$, which are
4709         // unrelated types one of which is final and the other of
4710         // which is an interface.  This method
4711         // tries to reject a cast by transferring type parameters
4712         // from the final class to the interface.
4713         boolean reverse = false;
4714         Type target = to;
4715         if ((to.tsym.flags() & INTERFACE) == 0) {
4716             Assert.check((from.tsym.flags() & INTERFACE) != 0);
4717             reverse = true;
4718             to = from;
4719             from = target;
4720         }
4721         Assert.check((from.tsym.flags() & FINAL) != 0);
4722         Type t1 = asSuper(from, to.tsym);
4723         if (t1 == null) return false;
4724         Type t2 = to;
4725         if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
4726             return false;
4727         if (!isReifiable(target) &&
4728             (reverse ? giveWarning(t2, t1) : giveWarning(t1, t2)))
4729             warn.warn(LintCategory.UNCHECKED);
4730         return true;
4731     }
4732 
4733     private boolean giveWarning(Type from, Type to) {
4734         List<Type> bounds = to.isCompound() ?
4735                 directSupertypes(to) : List.of(to);
4736         for (Type b : bounds) {
4737             Type subFrom = asSub(from, b.tsym);
4738             if (b.isParameterized() &&
4739                     (!(isUnbounded(b) ||
4740                     isSubtype(from, b) ||
4741                     ((subFrom != null) && containsType(b.allparams(), subFrom.allparams()))))) {
4742                 return true;
4743             }
4744         }
4745         return false;
4746     }
4747 
4748     private List<Type> superClosure(Type t, Type s) {
4749         List<Type> cl = List.nil();
4750         for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail) {
4751             if (isSubtype(s, erasure(l.head))) {
4752                 cl = insert(cl, l.head);
4753             } else {
4754                 cl = union(cl, superClosure(l.head, s));
4755             }
4756         }
4757         return cl;
4758     }
4759 
4760     private boolean containsTypeEquivalent(Type t, Type s) {
4761         return isSameType(t, s) || // shortcut
4762             containsType(t, s) && containsType(s, t);
4763     }
4764 
4765     // <editor-fold defaultstate="collapsed" desc="adapt">
4766     /**
4767      * Adapt a type by computing a substitution which maps a source
4768      * type to a target type.
4769      *
4770      * @param source    the source type
4771      * @param target    the target type
4772      * @param from      the type variables of the computed substitution
4773      * @param to        the types of the computed substitution.
4774      */
4775     public void adapt(Type source,
4776                        Type target,
4777                        ListBuffer<Type> from,
4778                        ListBuffer<Type> to) throws AdaptFailure {
4779         new Adapter(from, to).adapt(source, target);
4780     }
4781 
4782     class Adapter extends SimpleVisitor<Void, Type> {
4783 
4784         ListBuffer<Type> from;
4785         ListBuffer<Type> to;
4786         Map<Symbol,Type> mapping;
4787 
4788         Adapter(ListBuffer<Type> from, ListBuffer<Type> to) {
4789             this.from = from;
4790             this.to = to;
4791             mapping = new HashMap<>();
4792         }
4793 
4794         public void adapt(Type source, Type target) throws AdaptFailure {
4795             visit(source, target);
4796             List<Type> fromList = from.toList();
4797             List<Type> toList = to.toList();
4798             while (!fromList.isEmpty()) {
4799                 Type val = mapping.get(fromList.head.tsym);
4800                 if (toList.head != val)
4801                     toList.head = val;
4802                 fromList = fromList.tail;
4803                 toList = toList.tail;
4804             }
4805         }
4806 
4807         @Override
4808         public Void visitClassType(ClassType source, Type target) throws AdaptFailure {
4809             if (target.hasTag(CLASS))
4810                 adaptRecursive(source.allparams(), target.allparams());
4811             return null;
4812         }
4813 
4814         @Override
4815         public Void visitArrayType(ArrayType source, Type target) throws AdaptFailure {
4816             if (target.hasTag(ARRAY))
4817                 adaptRecursive(elemtype(source), elemtype(target));
4818             return null;
4819         }
4820 
4821         @Override
4822         public Void visitWildcardType(WildcardType source, Type target) throws AdaptFailure {
4823             if (source.isExtendsBound())
4824                 adaptRecursive(wildUpperBound(source), wildUpperBound(target));
4825             else if (source.isSuperBound())
4826                 adaptRecursive(wildLowerBound(source), wildLowerBound(target));
4827             return null;
4828         }
4829 
4830         @Override
4831         public Void visitTypeVar(TypeVar source, Type target) throws AdaptFailure {
4832             // Check to see if there is
4833             // already a mapping for $source$, in which case
4834             // the old mapping will be merged with the new
4835             Type val = mapping.get(source.tsym);
4836             if (val != null) {
4837                 if (val.isSuperBound() && target.isSuperBound()) {
4838                     val = isSubtype(wildLowerBound(val), wildLowerBound(target))
4839                         ? target : val;
4840                 } else if (val.isExtendsBound() && target.isExtendsBound()) {
4841                     val = isSubtype(wildUpperBound(val), wildUpperBound(target))
4842                         ? val : target;
4843                 } else if (!isSameType(val, target)) {
4844                     throw new AdaptFailure();
4845                 }
4846             } else {
4847                 val = target;
4848                 from.append(source);
4849                 to.append(target);
4850             }
4851             mapping.put(source.tsym, val);
4852             return null;
4853         }
4854 
4855         @Override
4856         public Void visitType(Type source, Type target) {
4857             return null;
4858         }
4859 
4860         private Set<TypePair> cache = new HashSet<>();
4861 
4862         private void adaptRecursive(Type source, Type target) {
4863             TypePair pair = new TypePair(source, target);
4864             if (cache.add(pair)) {
4865                 try {
4866                     visit(source, target);
4867                 } finally {
4868                     cache.remove(pair);
4869                 }
4870             }
4871         }
4872 
4873         private void adaptRecursive(List<Type> source, List<Type> target) {
4874             if (source.length() == target.length()) {
4875                 while (source.nonEmpty()) {
4876                     adaptRecursive(source.head, target.head);
4877                     source = source.tail;
4878                     target = target.tail;
4879                 }
4880             }
4881         }
4882     }
4883 
4884     public static class AdaptFailure extends RuntimeException {
4885         static final long serialVersionUID = -7490231548272701566L;
4886     }
4887 
4888     private void adaptSelf(Type t,
4889                            ListBuffer<Type> from,
4890                            ListBuffer<Type> to) {
4891         try {
4892             //if (t.tsym.type != t)
4893                 adapt(t.tsym.type, t, from, to);
4894         } catch (AdaptFailure ex) {
4895             // Adapt should never fail calculating a mapping from
4896             // t.tsym.type to t as there can be no merge problem.
4897             throw new AssertionError(ex);
4898         }
4899     }
4900     // </editor-fold>
4901 
4902     /**
4903      * Rewrite all type variables (universal quantifiers) in the given
4904      * type to wildcards (existential quantifiers).  This is used to
4905      * determine if a cast is allowed.  For example, if high is true
4906      * and {@code T <: Number}, then {@code List<T>} is rewritten to
4907      * {@code List<?  extends Number>}.  Since {@code List<Integer> <:
4908      * List<? extends Number>} a {@code List<T>} can be cast to {@code
4909      * List<Integer>} with a warning.
4910      * @param t a type
4911      * @param high if true return an upper bound; otherwise a lower
4912      * bound
4913      * @param rewriteTypeVars only rewrite captured wildcards if false;
4914      * otherwise rewrite all type variables
4915      * @return the type rewritten with wildcards (existential
4916      * quantifiers) only
4917      */
4918     private Type rewriteQuantifiers(Type t, boolean high, boolean rewriteTypeVars) {
4919         return new Rewriter(high, rewriteTypeVars).visit(t);
4920     }
4921 
4922     class Rewriter extends UnaryVisitor<Type> {
4923 
4924         boolean high;
4925         boolean rewriteTypeVars;
4926 
4927         Rewriter(boolean high, boolean rewriteTypeVars) {
4928             this.high = high;
4929             this.rewriteTypeVars = rewriteTypeVars;
4930         }
4931 
4932         @Override
4933         public Type visitClassType(ClassType t, Void s) {
4934             ListBuffer<Type> rewritten = new ListBuffer<>();
4935             boolean changed = false;
4936             for (Type arg : t.allparams()) {
4937                 Type bound = visit(arg);
4938                 if (arg != bound) {
4939                     changed = true;
4940                 }
4941                 rewritten.append(bound);
4942             }
4943             if (changed)
4944                 return subst(t.tsym.type,
4945                         t.tsym.type.allparams(),
4946                         rewritten.toList());
4947             else
4948                 return t;
4949         }
4950 
4951         public Type visitType(Type t, Void s) {
4952             return t;
4953         }
4954 
4955         @Override
4956         public Type visitCapturedType(CapturedType t, Void s) {
4957             Type w_bound = t.wildcard.type;
4958             Type bound = w_bound.contains(t) ?
4959                         erasure(w_bound) :
4960                         visit(w_bound);
4961             return rewriteAsWildcardType(visit(bound), t.wildcard.bound, t.wildcard.kind);
4962         }
4963 
4964         @Override
4965         public Type visitTypeVar(TypeVar t, Void s) {
4966             if (rewriteTypeVars) {
4967                 Type bound = t.getUpperBound().contains(t) ?
4968                         erasure(t.getUpperBound()) :
4969                         visit(t.getUpperBound());
4970                 return rewriteAsWildcardType(bound, t, EXTENDS);
4971             } else {
4972                 return t;
4973             }
4974         }
4975 
4976         @Override
4977         public Type visitWildcardType(WildcardType t, Void s) {
4978             Type bound2 = visit(t.type);
4979             return t.type == bound2 ? t : rewriteAsWildcardType(bound2, t.bound, t.kind);
4980         }
4981 
4982         private Type rewriteAsWildcardType(Type bound, TypeVar formal, BoundKind bk) {
4983             switch (bk) {
4984                case EXTENDS: return high ?
4985                        makeExtendsWildcard(B(bound), formal) :
4986                        makeExtendsWildcard(syms.objectType, formal);
4987                case SUPER: return high ?
4988                        makeSuperWildcard(syms.botType, formal) :
4989                        makeSuperWildcard(B(bound), formal);
4990                case UNBOUND: return makeExtendsWildcard(syms.objectType, formal);
4991                default:
4992                    Assert.error("Invalid bound kind " + bk);
4993                    return null;
4994             }
4995         }
4996 
4997         Type B(Type t) {
4998             while (t.hasTag(WILDCARD)) {
4999                 WildcardType w = (WildcardType)t;
5000                 t = high ?
5001                     w.getExtendsBound() :
5002                     w.getSuperBound();
5003                 if (t == null) {
5004                     t = high ? syms.objectType : syms.botType;
5005                 }
5006             }
5007             return t;
5008         }
5009     }
5010 
5011 
5012     /**
5013      * Create a wildcard with the given upper (extends) bound; create
5014      * an unbounded wildcard if bound is Object.
5015      *
5016      * @param bound the upper bound
5017      * @param formal the formal type parameter that will be
5018      * substituted by the wildcard
5019      */
5020     private WildcardType makeExtendsWildcard(Type bound, TypeVar formal) {
5021         if (bound == syms.objectType) {
5022             return new WildcardType(syms.objectType,
5023                                     BoundKind.UNBOUND,
5024                                     syms.boundClass,
5025                                     formal);
5026         } else {
5027             return new WildcardType(bound,
5028                                     BoundKind.EXTENDS,
5029                                     syms.boundClass,
5030                                     formal);
5031         }
5032     }
5033 
5034     /**
5035      * Create a wildcard with the given lower (super) bound; create an
5036      * unbounded wildcard if bound is bottom (type of {@code null}).
5037      *
5038      * @param bound the lower bound
5039      * @param formal the formal type parameter that will be
5040      * substituted by the wildcard
5041      */
5042     private WildcardType makeSuperWildcard(Type bound, TypeVar formal) {
5043         if (bound.hasTag(BOT)) {
5044             return new WildcardType(syms.objectType,
5045                                     BoundKind.UNBOUND,
5046                                     syms.boundClass,
5047                                     formal);
5048         } else {
5049             return new WildcardType(bound,
5050                                     BoundKind.SUPER,
5051                                     syms.boundClass,
5052                                     formal);
5053         }
5054     }
5055 
5056     /**
5057      * A wrapper for a type that allows use in sets.
5058      */
5059     public static class UniqueType {
5060         public final Type type;
5061         final Types types;
5062         private boolean encodeTypeSig;
5063 
5064         public UniqueType(Type type, Types types, boolean encodeTypeSig) {
5065             this.type = type;
5066             this.types = types;
5067             this.encodeTypeSig = encodeTypeSig;
5068         }
5069 
5070         public UniqueType(Type type, Types types) {
5071             this(type, types, true);
5072         }
5073 
5074         public int hashCode() {
5075             return types.hashCode(type);
5076         }
5077 
5078         public boolean equals(Object obj) {
5079             return (obj instanceof UniqueType uniqueType) &&
5080                     types.isSameType(type, uniqueType.type);
5081         }
5082 
5083         public boolean encodeTypeSig() {
5084             return encodeTypeSig;
5085         }
5086 
5087         public String toString() {
5088             return type.toString();
5089         }
5090 
5091     }
5092     // </editor-fold>
5093 
5094     // <editor-fold defaultstate="collapsed" desc="Visitors">
5095     /**
5096      * A default visitor for types.  All visitor methods except
5097      * visitType are implemented by delegating to visitType.  Concrete
5098      * subclasses must provide an implementation of visitType and can
5099      * override other methods as needed.
5100      *
5101      * @param <R> the return type of the operation implemented by this
5102      * visitor; use Void if no return type is needed.
5103      * @param <S> the type of the second argument (the first being the
5104      * type itself) of the operation implemented by this visitor; use
5105      * Void if a second argument is not needed.
5106      */
5107     public abstract static class DefaultTypeVisitor<R,S> implements Type.Visitor<R,S> {
5108         public final R visit(Type t, S s)               { return t.accept(this, s); }
5109         public R visitClassType(ClassType t, S s)       { return visitType(t, s); }
5110         public R visitWildcardType(WildcardType t, S s) { return visitType(t, s); }
5111         public R visitArrayType(ArrayType t, S s)       { return visitType(t, s); }
5112         public R visitMethodType(MethodType t, S s)     { return visitType(t, s); }
5113         public R visitPackageType(PackageType t, S s)   { return visitType(t, s); }
5114         public R visitModuleType(ModuleType t, S s)     { return visitType(t, s); }
5115         public R visitTypeVar(TypeVar t, S s)           { return visitType(t, s); }
5116         public R visitCapturedType(CapturedType t, S s) { return visitType(t, s); }
5117         public R visitForAll(ForAll t, S s)             { return visitType(t, s); }
5118         public R visitUndetVar(UndetVar t, S s)         { return visitType(t, s); }
5119         public R visitErrorType(ErrorType t, S s)       { return visitType(t, s); }
5120     }
5121 
5122     /**
5123      * A default visitor for symbols.  All visitor methods except
5124      * visitSymbol are implemented by delegating to visitSymbol.  Concrete
5125      * subclasses must provide an implementation of visitSymbol and can
5126      * override other methods as needed.
5127      *
5128      * @param <R> the return type of the operation implemented by this
5129      * visitor; use Void if no return type is needed.
5130      * @param <S> the type of the second argument (the first being the
5131      * symbol itself) of the operation implemented by this visitor; use
5132      * Void if a second argument is not needed.
5133      */
5134     public abstract static class DefaultSymbolVisitor<R,S> implements Symbol.Visitor<R,S> {
5135         public final R visit(Symbol s, S arg)                   { return s.accept(this, arg); }
5136         public R visitClassSymbol(ClassSymbol s, S arg)         { return visitSymbol(s, arg); }
5137         public R visitMethodSymbol(MethodSymbol s, S arg)       { return visitSymbol(s, arg); }
5138         public R visitOperatorSymbol(OperatorSymbol s, S arg)   { return visitSymbol(s, arg); }
5139         public R visitPackageSymbol(PackageSymbol s, S arg)     { return visitSymbol(s, arg); }
5140         public R visitTypeSymbol(TypeSymbol s, S arg)           { return visitSymbol(s, arg); }
5141         public R visitVarSymbol(VarSymbol s, S arg)             { return visitSymbol(s, arg); }
5142     }
5143 
5144     /**
5145      * A <em>simple</em> visitor for types.  This visitor is simple as
5146      * captured wildcards, for-all types (generic methods), and
5147      * undetermined type variables (part of inference) are hidden.
5148      * Captured wildcards are hidden by treating them as type
5149      * variables and the rest are hidden by visiting their qtypes.
5150      *
5151      * @param <R> the return type of the operation implemented by this
5152      * visitor; use Void if no return type is needed.
5153      * @param <S> the type of the second argument (the first being the
5154      * type itself) of the operation implemented by this visitor; use
5155      * Void if a second argument is not needed.
5156      */
5157     public abstract static class SimpleVisitor<R,S> extends DefaultTypeVisitor<R,S> {
5158         @Override
5159         public R visitCapturedType(CapturedType t, S s) {
5160             return visitTypeVar(t, s);
5161         }
5162         @Override
5163         public R visitForAll(ForAll t, S s) {
5164             return visit(t.qtype, s);
5165         }
5166         @Override
5167         public R visitUndetVar(UndetVar t, S s) {
5168             return visit(t.qtype, s);
5169         }
5170     }
5171 
5172     /**
5173      * A plain relation on types.  That is a 2-ary function on the
5174      * form Type&nbsp;&times;&nbsp;Type&nbsp;&rarr;&nbsp;Boolean.
5175      * <!-- In plain text: Type x Type -> Boolean -->
5176      */
5177     public abstract static class TypeRelation extends SimpleVisitor<Boolean,Type> {}
5178 
5179     /**
5180      * A convenience visitor for implementing operations that only
5181      * require one argument (the type itself), that is, unary
5182      * operations.
5183      *
5184      * @param <R> the return type of the operation implemented by this
5185      * visitor; use Void if no return type is needed.
5186      */
5187     public abstract static class UnaryVisitor<R> extends SimpleVisitor<R,Void> {
5188         public final R visit(Type t) { return t.accept(this, null); }
5189     }
5190 
5191     /**
5192      * A visitor for implementing a mapping from types to types.  The
5193      * default behavior of this class is to implement the identity
5194      * mapping (mapping a type to itself).  This can be overridden in
5195      * subclasses.
5196      *
5197      * @param <S> the type of the second argument (the first being the
5198      * type itself) of this mapping; use Void if a second argument is
5199      * not needed.
5200      */
5201     public static class MapVisitor<S> extends DefaultTypeVisitor<Type,S> {
5202         public final Type visit(Type t) { return t.accept(this, null); }
5203         public Type visitType(Type t, S s) { return t; }
5204     }
5205 
5206     /**
5207      * An abstract class for mappings from types to types (see {@link Type#map(TypeMapping)}.
5208      * This class implements the functional interface {@code Function}, that allows it to be used
5209      * fluently in stream-like processing.
5210      */
5211     public static class TypeMapping<S> extends MapVisitor<S> implements Function<Type, Type> {
5212         @Override
5213         public Type apply(Type type) { return visit(type); }
5214 
5215         List<Type> visit(List<Type> ts, S s) {
5216             return ts.map(t -> visit(t, s));
5217         }
5218 
5219         @Override
5220         public Type visitCapturedType(CapturedType t, S s) {
5221             return visitTypeVar(t, s);
5222         }
5223     }
5224     // </editor-fold>
5225 
5226 
5227     // <editor-fold defaultstate="collapsed" desc="Annotation support">
5228 
5229     public RetentionPolicy getRetention(Attribute.Compound a) {
5230         return getRetention(a.type.tsym);
5231     }
5232 
5233     public RetentionPolicy getRetention(TypeSymbol sym) {
5234         RetentionPolicy vis = RetentionPolicy.CLASS; // the default
5235         Attribute.Compound c = sym.attribute(syms.retentionType.tsym);
5236         if (c != null) {
5237             Attribute value = c.member(names.value);
5238             if (value != null && value instanceof Attribute.Enum attributeEnum) {
5239                 Name levelName = attributeEnum.value.name;
5240                 if (levelName == names.SOURCE) vis = RetentionPolicy.SOURCE;
5241                 else if (levelName == names.CLASS) vis = RetentionPolicy.CLASS;
5242                 else if (levelName == names.RUNTIME) vis = RetentionPolicy.RUNTIME;
5243                 else ;// /* fail soft */ throw new AssertionError(levelName);
5244             }
5245         }
5246         return vis;
5247     }
5248     // </editor-fold>
5249 
5250     // <editor-fold defaultstate="collapsed" desc="Signature Generation">
5251 
5252     public abstract static class SignatureGenerator {
5253 
5254         public static class InvalidSignatureException extends RuntimeException {
5255             private static final long serialVersionUID = 0;
5256 
5257             private final transient Type type;
5258 
5259             InvalidSignatureException(Type type) {
5260                 this.type = type;
5261             }
5262 
5263             public Type type() {
5264                 return type;
5265             }
5266         }
5267 
5268         private final Types types;
5269 
5270         protected abstract void append(char ch);
5271         protected abstract void append(byte[] ba);
5272         protected abstract void append(Name name);
5273         protected void classReference(ClassSymbol c) { /* by default: no-op */ }
5274 
5275         protected SignatureGenerator(Types types) {
5276             this.types = types;
5277         }
5278 
5279         protected void reportIllegalSignature(Type t) {
5280             throw new InvalidSignatureException(t);
5281         }
5282 
5283         /**
5284          * Assemble signature of given type in string buffer.
5285          */
5286         public void assembleSig(Type type) {
5287             switch (type.getTag()) {
5288                 case BYTE:
5289                     append('B');
5290                     break;
5291                 case SHORT:
5292                     append('S');
5293                     break;
5294                 case CHAR:
5295                     append('C');
5296                     break;
5297                 case INT:
5298                     append('I');
5299                     break;
5300                 case LONG:
5301                     append('J');
5302                     break;
5303                 case FLOAT:
5304                     append('F');
5305                     break;
5306                 case DOUBLE:
5307                     append('D');
5308                     break;
5309                 case BOOLEAN:
5310                     append('Z');
5311                     break;
5312                 case VOID:
5313                     append('V');
5314                     break;
5315                 case CLASS:
5316                     if (type.isCompound()) {
5317                         reportIllegalSignature(type);
5318                     }
5319                     if (type.isPrimitiveClass())
5320                         append('Q');
5321                     else
5322                         append('L');
5323                     assembleClassSig(type);
5324                     append(';');
5325                     break;
5326                 case ARRAY:
5327                     ArrayType at = (ArrayType) type;
5328                     append('[');
5329                     assembleSig(at.elemtype);
5330                     break;
5331                 case METHOD:
5332                     MethodType mt = (MethodType) type;
5333                     append('(');
5334                     assembleSig(mt.argtypes);
5335                     append(')');
5336                     assembleSig(mt.restype);
5337                     if (hasTypeVar(mt.thrown)) {
5338                         for (List<Type> l = mt.thrown; l.nonEmpty(); l = l.tail) {
5339                             append('^');
5340                             assembleSig(l.head);
5341                         }
5342                     }
5343                     break;
5344                 case WILDCARD: {
5345                     Type.WildcardType ta = (Type.WildcardType) type;
5346                     switch (ta.kind) {
5347                         case SUPER:
5348                             append('-');
5349                             assembleSig(ta.type);
5350                             break;
5351                         case EXTENDS:
5352                             append('+');
5353                             assembleSig(ta.type);
5354                             break;
5355                         case UNBOUND:
5356                             append('*');
5357                             break;
5358                         default:
5359                             throw new AssertionError(ta.kind);
5360                     }
5361                     break;
5362                 }
5363                 case TYPEVAR:
5364                     if (((TypeVar)type).isCaptured()) {
5365                         reportIllegalSignature(type);
5366                     }
5367                     append('T');
5368                     append(type.tsym.name);
5369                     append(';');
5370                     break;
5371                 case FORALL:
5372                     Type.ForAll ft = (Type.ForAll) type;
5373                     assembleParamsSig(ft.tvars);
5374                     assembleSig(ft.qtype);
5375                     break;
5376                 default:
5377                     throw new AssertionError("typeSig " + type.getTag());
5378             }
5379         }
5380 
5381         public boolean hasTypeVar(List<Type> l) {
5382             while (l.nonEmpty()) {
5383                 if (l.head.hasTag(TypeTag.TYPEVAR)) {
5384                     return true;
5385                 }
5386                 l = l.tail;
5387             }
5388             return false;
5389         }
5390 
5391         public void assembleClassSig(Type type) {
5392             ClassType ct = (ClassType) type;
5393             ClassSymbol c = (ClassSymbol) ct.tsym;
5394             classReference(c);
5395             Type outer = ct.getEnclosingType();
5396             if (outer.allparams().nonEmpty()) {
5397                 boolean rawOuter =
5398                         c.owner.kind == MTH || // either a local class
5399                         c.name == types.names.empty; // or anonymous
5400                 assembleClassSig(rawOuter
5401                         ? types.erasure(outer)
5402                         : outer);
5403                 append(rawOuter ? '$' : '.');
5404                 Assert.check(c.flatname.startsWith(c.owner.enclClass().flatname));
5405                 append(rawOuter
5406                         ? c.flatname.subName(c.owner.enclClass().flatname.getByteLength() + 1, c.flatname.getByteLength())
5407                         : c.name);
5408             } else {
5409                 append(externalize(c.flatname));
5410             }
5411             if (ct.getTypeArguments().nonEmpty()) {
5412                 append('<');
5413                 assembleSig(ct.getTypeArguments());
5414                 append('>');
5415             }
5416         }
5417 
5418         public void assembleParamsSig(List<Type> typarams) {
5419             append('<');
5420             for (List<Type> ts = typarams; ts.nonEmpty(); ts = ts.tail) {
5421                 Type.TypeVar tvar = (Type.TypeVar) ts.head;
5422                 append(tvar.tsym.name);
5423                 List<Type> bounds = types.getBounds(tvar);
5424                 if ((bounds.head.tsym.flags() & INTERFACE) != 0) {
5425                     append(':');
5426                 }
5427                 for (List<Type> l = bounds; l.nonEmpty(); l = l.tail) {
5428                     append(':');
5429                     assembleSig(l.head);
5430                 }
5431             }
5432             append('>');
5433         }
5434 
5435         public void assembleSig(List<Type> types) {
5436             for (List<Type> ts = types; ts.nonEmpty(); ts = ts.tail) {
5437                 assembleSig(ts.head);
5438             }
5439         }
5440     }
5441 
5442     public Type constantType(LoadableConstant c) {
5443         switch (c.poolTag()) {
5444             case ClassFile.CONSTANT_Class:
5445                 return syms.classType;
5446             case ClassFile.CONSTANT_String:
5447                 return syms.stringType;
5448             case ClassFile.CONSTANT_Integer:
5449                 return syms.intType;
5450             case ClassFile.CONSTANT_Float:
5451                 return syms.floatType;
5452             case ClassFile.CONSTANT_Long:
5453                 return syms.longType;
5454             case ClassFile.CONSTANT_Double:
5455                 return syms.doubleType;
5456             case ClassFile.CONSTANT_MethodHandle:
5457                 return syms.methodHandleType;
5458             case ClassFile.CONSTANT_MethodType:
5459                 return syms.methodTypeType;
5460             case ClassFile.CONSTANT_Dynamic:
5461                 return ((DynamicVarSymbol)c).type;
5462             default:
5463                 throw new AssertionError("Not a loadable constant: " + c.poolTag());
5464         }
5465     }
5466     // </editor-fold>
5467 
5468     public void newRound() {
5469         descCache._map.clear();
5470         isDerivedRawCache.clear();
5471         implCache._map.clear();
5472         membersCache._map.clear();
5473         closureCache.clear();
5474     }
5475 }