1 /*
   2  * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.code;
  27 
  28 import java.lang.annotation.Annotation;
  29 import java.lang.annotation.Inherited;
  30 import java.util.ArrayList;
  31 import java.util.Collections;
  32 import java.util.EnumSet;
  33 import java.util.Map;
  34 import java.util.Set;
  35 import java.util.concurrent.Callable;
  36 import java.util.function.Supplier;
  37 import java.util.function.Predicate;
  38 
  39 import javax.lang.model.element.Element;
  40 import javax.lang.model.element.ElementKind;
  41 import javax.lang.model.element.ElementVisitor;
  42 import javax.lang.model.element.ExecutableElement;
  43 import javax.lang.model.element.Modifier;
  44 import javax.lang.model.element.ModuleElement;
  45 import javax.lang.model.element.NestingKind;
  46 import javax.lang.model.element.PackageElement;
  47 import javax.lang.model.element.RecordComponentElement;
  48 import javax.lang.model.element.TypeElement;
  49 import javax.lang.model.element.TypeParameterElement;
  50 import javax.lang.model.element.VariableElement;
  51 import javax.tools.JavaFileManager;
  52 import javax.tools.JavaFileObject;
  53 
  54 import com.sun.tools.javac.code.Kinds.Kind;
  55 import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;
  56 import com.sun.tools.javac.code.Type.*;
  57 import com.sun.tools.javac.comp.Attr;
  58 import com.sun.tools.javac.comp.AttrContext;
  59 import com.sun.tools.javac.comp.Env;
  60 import com.sun.tools.javac.jvm.*;
  61 import com.sun.tools.javac.jvm.PoolConstant;
  62 import com.sun.tools.javac.tree.JCTree;
  63 import com.sun.tools.javac.tree.JCTree.JCAnnotation;
  64 import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
  65 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
  66 import com.sun.tools.javac.tree.JCTree.Tag;
  67 import com.sun.tools.javac.util.*;
  68 import com.sun.tools.javac.util.DefinedBy.Api;
  69 import com.sun.tools.javac.util.List;
  70 import com.sun.tools.javac.util.Name;
  71 
  72 import static com.sun.tools.javac.code.Flags.*;
  73 import static com.sun.tools.javac.code.Kinds.*;
  74 import static com.sun.tools.javac.code.Kinds.Kind.*;
  75 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
  76 import com.sun.tools.javac.code.Scope.WriteableScope;
  77 import static com.sun.tools.javac.code.TypeTag.CLASS;
  78 import static com.sun.tools.javac.code.TypeTag.FORALL;
  79 import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
  80 import static com.sun.tools.javac.jvm.ByteCodes.iadd;
  81 import static com.sun.tools.javac.jvm.ByteCodes.ishll;
  82 import static com.sun.tools.javac.jvm.ByteCodes.lushrl;
  83 import static com.sun.tools.javac.jvm.ByteCodes.lxor;
  84 import static com.sun.tools.javac.jvm.ByteCodes.string_add;
  85 
  86 /** Root class for Java symbols. It contains subclasses
  87  *  for specific sorts of symbols, such as variables, methods and operators,
  88  *  types, packages. Each subclass is represented as a static inner class
  89  *  inside Symbol.
  90  *
  91  *  <p><b>This is NOT part of any supported API.
  92  *  If you write code that depends on this, you do so at your own risk.
  93  *  This code and its internal interfaces are subject to change or
  94  *  deletion without notice.</b>
  95  */
  96 public abstract class Symbol extends AnnoConstruct implements PoolConstant, Element {
  97 
  98     /** The kind of this symbol.
  99      *  @see Kinds
 100      */
 101     public Kind kind;
 102 
 103     /** The flags of this symbol.
 104      */
 105     public long flags_field;
 106 
 107     /** An accessor method for the flags of this symbol.
 108      *  Flags of class symbols should be accessed through the accessor
 109      *  method to make sure that the class symbol is loaded.
 110      */
 111     public long flags() { return flags_field; }
 112 
 113     /** The name of this symbol in Utf8 representation.
 114      */
 115     public Name name;
 116 
 117     /** The type of this symbol.
 118      */
 119     public Type type;
 120 
 121     /** The owner of this symbol.
 122      */
 123     public Symbol owner;
 124 
 125     /** The completer of this symbol.
 126      * This should never equal null (NULL_COMPLETER should be used instead).
 127      */
 128     public Completer completer;
 129 
 130     /** A cache for the type erasure of this symbol.
 131      */
 132     public Type erasure_field;
 133 
 134     // <editor-fold defaultstate="collapsed" desc="annotations">
 135 
 136     /** The attributes of this symbol are contained in this
 137      * SymbolMetadata. The SymbolMetadata instance is NOT immutable.
 138      */
 139     protected SymbolMetadata metadata;
 140 
 141 
 142     /** An accessor method for the attributes of this symbol.
 143      *  Attributes of class symbols should be accessed through the accessor
 144      *  method to make sure that the class symbol is loaded.
 145      */
 146     public List<Attribute.Compound> getRawAttributes() {
 147         return (metadata == null)
 148                 ? List.nil()
 149                 : metadata.getDeclarationAttributes();
 150     }
 151 
 152     /** An accessor method for the type attributes of this symbol.
 153      *  Attributes of class symbols should be accessed through the accessor
 154      *  method to make sure that the class symbol is loaded.
 155      */
 156     public List<Attribute.TypeCompound> getRawTypeAttributes() {
 157         return (metadata == null)
 158                 ? List.nil()
 159                 : metadata.getTypeAttributes();
 160     }
 161 
 162     /** Fetch a particular annotation from a symbol. */
 163     public Attribute.Compound attribute(Symbol anno) {
 164         for (Attribute.Compound a : getRawAttributes()) {
 165             if (a.type.tsym == anno) return a;
 166         }
 167         return null;
 168     }
 169 
 170     public boolean annotationsPendingCompletion() {
 171         return metadata == null ? false : metadata.pendingCompletion();
 172     }
 173 
 174     public void appendAttributes(List<Attribute.Compound> l) {
 175         if (l.nonEmpty()) {
 176             initedMetadata().append(l);
 177         }
 178     }
 179 
 180     public void appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
 181         if (l.nonEmpty()) {
 182             initedMetadata().appendClassInitTypeAttributes(l);
 183         }
 184     }
 185 
 186     public void appendInitTypeAttributes(List<Attribute.TypeCompound> l) {
 187         if (l.nonEmpty()) {
 188             initedMetadata().appendInitTypeAttributes(l);
 189         }
 190     }
 191 
 192     public void appendUniqueTypeAttributes(List<Attribute.TypeCompound> l) {
 193         if (l.nonEmpty()) {
 194             initedMetadata().appendUniqueTypes(l);
 195         }
 196     }
 197 
 198     public List<Attribute.TypeCompound> getClassInitTypeAttributes() {
 199         return (metadata == null)
 200                 ? List.nil()
 201                 : metadata.getClassInitTypeAttributes();
 202     }
 203 
 204     public List<Attribute.TypeCompound> getInitTypeAttributes() {
 205         return (metadata == null)
 206                 ? List.nil()
 207                 : metadata.getInitTypeAttributes();
 208     }
 209 
 210     public void setInitTypeAttributes(List<Attribute.TypeCompound> l) {
 211         initedMetadata().setInitTypeAttributes(l);
 212     }
 213 
 214     public void setClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
 215         initedMetadata().setClassInitTypeAttributes(l);
 216     }
 217 
 218     public List<Attribute.Compound> getDeclarationAttributes() {
 219         return (metadata == null)
 220                 ? List.nil()
 221                 : metadata.getDeclarationAttributes();
 222     }
 223 
 224     public boolean hasAnnotations() {
 225         return (metadata != null && !metadata.isEmpty());
 226     }
 227 
 228     public boolean hasTypeAnnotations() {
 229         return (metadata != null && !metadata.isTypesEmpty());
 230     }
 231 
 232     public boolean isCompleted() {
 233         return completer.isTerminal();
 234     }
 235 
 236     public void prependAttributes(List<Attribute.Compound> l) {
 237         if (l.nonEmpty()) {
 238             initedMetadata().prepend(l);
 239         }
 240     }
 241 
 242     public void resetAnnotations() {
 243         initedMetadata().reset();
 244     }
 245 
 246     public void setAttributes(Symbol other) {
 247         if (metadata != null || other.metadata != null) {
 248             initedMetadata().setAttributes(other.metadata);
 249         }
 250     }
 251 
 252     public void setDeclarationAttributes(List<Attribute.Compound> a) {
 253         if (metadata != null || a.nonEmpty()) {
 254             initedMetadata().setDeclarationAttributes(a);
 255         }
 256     }
 257 
 258     public void setTypeAttributes(List<Attribute.TypeCompound> a) {
 259         if (metadata != null || a.nonEmpty()) {
 260             if (metadata == null)
 261                 metadata = new SymbolMetadata(this);
 262             metadata.setTypeAttributes(a);
 263         }
 264     }
 265 
 266     private SymbolMetadata initedMetadata() {
 267         if (metadata == null)
 268             metadata = new SymbolMetadata(this);
 269         return metadata;
 270     }
 271 
 272     /** This method is intended for debugging only. */
 273     public SymbolMetadata getMetadata() {
 274         return metadata;
 275     }
 276 
 277     // </editor-fold>
 278 
 279     /** Construct a symbol with given kind, flags, name, type and owner.
 280      */
 281     public Symbol(Kind kind, long flags, Name name, Type type, Symbol owner) {
 282         this.kind = kind;
 283         this.flags_field = flags;
 284         this.type = type;
 285         this.owner = owner;
 286         this.completer = Completer.NULL_COMPLETER;
 287         this.erasure_field = null;
 288         this.name = name;
 289     }
 290 
 291     @Override
 292     public int poolTag() {
 293         throw new AssertionError("Invalid pool entry");
 294     }
 295 
 296     /** Clone this symbol with new owner.
 297      *  Legal only for fields and methods.
 298      */
 299     public Symbol clone(Symbol newOwner) {
 300         throw new AssertionError();
 301     }
 302 
 303     public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
 304         return v.visitSymbol(this, p);
 305     }
 306 
 307     /** The Java source which this symbol represents.
 308      *  A description of this symbol; overrides Object.
 309      */
 310     public String toString() {
 311         return name.toString();
 312     }
 313 
 314     /** A Java source description of the location of this symbol; used for
 315      *  error reporting.
 316      *
 317      * @return null if the symbol is a package or a toplevel class defined in
 318      * the default package; otherwise, the owner symbol is returned
 319      */
 320     public Symbol location() {
 321         if (owner.name == null || (owner.name.isEmpty() &&
 322                                    (owner.flags() & BLOCK) == 0 &&
 323                                    owner.kind != PCK &&
 324                                    owner.kind != TYP)) {
 325             return null;
 326         }
 327         return owner;
 328     }
 329 
 330     public Symbol location(Type site, Types types) {
 331         if (owner.name == null || owner.name.isEmpty()) {
 332             return location();
 333         }
 334         if (owner.type.hasTag(CLASS)) {
 335             Type ownertype = types.asOuterSuper(site, owner);
 336             if (ownertype != null) return ownertype.tsym;
 337         }
 338         return owner;
 339     }
 340 
 341     public Symbol baseSymbol() {
 342         return this;
 343     }
 344 
 345     /** The symbol's erased type.
 346      */
 347     public Type erasure(Types types) {
 348         if (erasure_field == null)
 349             erasure_field = types.erasure(type);
 350         return erasure_field;
 351     }
 352 
 353     /** The external type of a symbol. This is the symbol's erased type
 354      *  except for constructors of inner classes which get the enclosing
 355      *  instance class added as first argument.
 356      */
 357     public Type externalType(Types types) {
 358         Type t = erasure(types);
 359         if (name == name.table.names.init && owner.hasOuterInstance()) {
 360             Type outerThisType = owner.innermostAccessibleEnclosingClass().erasure(types);
 361             return new MethodType(t.getParameterTypes().prepend(outerThisType),
 362                                   t.getReturnType(),
 363                                   t.getThrownTypes(),
 364                                   t.tsym);
 365         } else {
 366             return t;
 367         }
 368     }
 369 
 370     public boolean isDeprecated() {
 371         return (flags_field & DEPRECATED) != 0;
 372     }
 373 
 374     public boolean hasDeprecatedAnnotation() {
 375         return (flags_field & DEPRECATED_ANNOTATION) != 0;
 376     }
 377 
 378     public boolean isDeprecatedForRemoval() {
 379         return (flags_field & DEPRECATED_REMOVAL) != 0;
 380     }
 381 
 382     public boolean isPreviewApi() {
 383         return (flags_field & PREVIEW_API) != 0;
 384     }
 385 
 386     public boolean isDeprecatableViaAnnotation() {
 387         switch (getKind()) {
 388             case LOCAL_VARIABLE:
 389             case PACKAGE:
 390             case PARAMETER:
 391             case RESOURCE_VARIABLE:
 392             case EXCEPTION_PARAMETER:
 393                 return false;
 394             default:
 395                 return true;
 396         }
 397     }
 398 
 399     public boolean isStatic() {
 400         return
 401             (flags() & STATIC) != 0 ||
 402             (owner.flags() & INTERFACE) != 0 && kind != MTH &&
 403              name != name.table.names._this;
 404     }
 405 
 406     public boolean isStrict() {
 407         return (flags() & STRICT) != 0;
 408     }
 409 
 410     public boolean isInterface() {
 411         return (flags_field & INTERFACE) != 0;
 412     }
 413 
 414     public boolean isAbstract() {
 415         return (flags_field & ABSTRACT) != 0;
 416     }
 417 
 418     public boolean isPrivate() {
 419         return (flags_field & Flags.AccessFlags) == PRIVATE;
 420     }
 421 
 422     public boolean isValueClass() {
 423         return (flags_field & VALUE_CLASS) != 0;
 424     }
 425 
 426     public boolean isIdentityClass() {
 427         return !isInterface() && (flags_field & IDENTITY_TYPE) != 0;
 428     }
 429 
 430     public boolean isPublic() {
 431         return (flags_field & Flags.AccessFlags) == PUBLIC;
 432     }
 433 
 434     public boolean isEnum() {
 435         return (flags() & ENUM) != 0;
 436     }
 437 
 438     public boolean isSealed() {
 439         return (flags_field & SEALED) != 0;
 440     }
 441 
 442     public boolean isNonSealed() {
 443         return (flags_field & NON_SEALED) != 0;
 444     }
 445 
 446     public boolean isFinal() {
 447         return (flags_field & FINAL) != 0;
 448     }
 449 
 450     public boolean isImplicit() {
 451         return (flags_field & IMPLICIT_CLASS) != 0;
 452     }
 453 
 454    /** Is this symbol declared (directly or indirectly) local
 455      *  to a method or variable initializer?
 456      *  Also includes fields of inner classes which are in
 457      *  turn local to a method or variable initializer.
 458      */
 459     public boolean isDirectlyOrIndirectlyLocal() {
 460         return
 461             (owner.kind.matches(KindSelector.VAL_MTH) ||
 462              (owner.kind == TYP && owner.isDirectlyOrIndirectlyLocal()));
 463     }
 464 
 465     /** Has this symbol an empty name? This includes anonymous
 466      *  inner classes.
 467      */
 468     public boolean isAnonymous() {
 469         return name.isEmpty();
 470     }
 471 
 472     /** Is this symbol a constructor?
 473      */
 474     public boolean isConstructor() {
 475         return name == name.table.names.init;
 476     }
 477 
 478     public boolean isDynamic() {
 479         return false;
 480     }
 481 
 482     /** The fully qualified name of this symbol.
 483      *  This is the same as the symbol's name except for class symbols,
 484      *  which are handled separately.
 485      */
 486     public Name getQualifiedName() {
 487         return name;
 488     }
 489 
 490     /** The fully qualified name of this symbol after converting to flat
 491      *  representation. This is the same as the symbol's name except for
 492      *  class symbols, which are handled separately.
 493      */
 494     public Name flatName() {
 495         return getQualifiedName();
 496     }
 497 
 498     /** If this is a class or package, its members, otherwise null.
 499      */
 500     public WriteableScope members() {
 501         return null;
 502     }
 503 
 504     /** A class is an inner class if it it has an enclosing instance class.
 505      */
 506     public boolean isInner() {
 507         return kind == TYP && type.getEnclosingType().hasTag(CLASS);
 508     }
 509 
 510     /** An inner class has an outer instance if it is not an interface, enum or record,
 511      *  it has an enclosing instance class which might be referenced from the class.
 512      *  Nested classes can see instance members of their enclosing class.
 513      *  Their constructors carry an additional this$n parameter, inserted
 514      *  implicitly by the compiler.
 515      *
 516      *  @see #isInner
 517      */
 518     public boolean hasOuterInstance() {
 519         return
 520             type.getEnclosingType().hasTag(CLASS) && (flags() & (INTERFACE | ENUM | RECORD)) == 0 &&
 521                     ((flags() & NOOUTERTHIS) == 0 || type.getEnclosingType().tsym.hasOuterInstance());
 522     }
 523 
 524     /** If the class containing this symbol is a local or an anonymous class, then it might be
 525      *  defined inside one or more pre-construction contexts, for which the corresponding enclosing
 526      *  instance is considered inaccessible. This method return the class symbol corresponding to the
 527      *  innermost enclosing type that is accessible from this symbol's class. Note: this method should
 528      *  only be called after checking that {@link #hasOuterInstance()} returns {@code true}.
 529      */
 530     public ClassSymbol innermostAccessibleEnclosingClass() {
 531         Assert.check(enclClass().hasOuterInstance());
 532         Type current = enclClass().type;
 533         while ((current.tsym.flags() & NOOUTERTHIS) != 0) {
 534             current = current.getEnclosingType();
 535         }
 536         return (ClassSymbol) current.getEnclosingType().tsym;
 537     }
 538 
 539     /** The closest enclosing class of this symbol's declaration.
 540      *  Warning: this (misnamed) method returns the receiver itself
 541      *  when the receiver is a class (as opposed to its enclosing
 542      *  class as one may be misled to believe.)
 543      */
 544     public ClassSymbol enclClass() {
 545         Symbol c = this;
 546         while (c != null &&
 547                (!c.kind.matches(KindSelector.TYP) || !c.type.hasTag(CLASS))) {
 548             c = c.owner;
 549         }
 550         return (ClassSymbol)c;
 551     }
 552 
 553     /** The outermost class which indirectly owns this symbol.
 554      */
 555     public ClassSymbol outermostClass() {
 556         Symbol sym = this;
 557         Symbol prev = null;
 558         while (sym.kind != PCK) {
 559             prev = sym;
 560             sym = sym.owner;
 561         }
 562         return (ClassSymbol) prev;
 563     }
 564 
 565     /** The package which indirectly owns this symbol.
 566      */
 567     public PackageSymbol packge() {
 568         Symbol sym = this;
 569         while (sym.kind != PCK) {
 570             sym = sym.owner;
 571         }
 572         return (PackageSymbol) sym;
 573     }
 574 
 575     /** Is this symbol a subclass of `base'? Only defined for ClassSymbols.
 576      */
 577     public boolean isSubClass(Symbol base, Types types) {
 578         throw new AssertionError("isSubClass " + this);
 579     }
 580 
 581     /** Fully check membership: hierarchy, protection, and hiding.
 582      *  Does not exclude methods not inherited due to overriding.
 583      */
 584     public boolean isMemberOf(TypeSymbol clazz, Types types) {
 585         return
 586             owner == clazz ||
 587             clazz.isSubClass(owner, types) &&
 588             isInheritedIn(clazz, types) &&
 589             !hiddenIn((ClassSymbol)clazz, types);
 590     }
 591 
 592     /** Is this symbol the same as or enclosed by the given class? */
 593     public boolean isEnclosedBy(ClassSymbol clazz) {
 594         for (Symbol sym = this; sym.kind != PCK; sym = sym.owner)
 595             if (sym == clazz) return true;
 596         return false;
 597     }
 598 
 599     private boolean hiddenIn(ClassSymbol clazz, Types types) {
 600         Symbol sym = hiddenInInternal(clazz, types);
 601         Assert.check(sym != null, "the result of hiddenInInternal() can't be null");
 602         /* If we find the current symbol then there is no symbol hiding it
 603          */
 604         return sym != this;
 605     }
 606 
 607     /** This method looks in the supertypes graph that has the current class as the
 608      * initial node, till it finds the current symbol or another symbol that hides it.
 609      * If the current class has more than one supertype (extends one class and
 610      * implements one or more interfaces) then null can be returned, meaning that
 611      * a wrong path in the supertypes graph was selected. Null can only be returned
 612      * as a temporary value, as a result of the recursive call.
 613      */
 614     private Symbol hiddenInInternal(ClassSymbol currentClass, Types types) {
 615         if (currentClass == owner) {
 616             return this;
 617         }
 618         for (Symbol sym : currentClass.members().getSymbolsByName(name)) {
 619             if (sym.kind == kind &&
 620                     (kind != MTH ||
 621                     (sym.flags() & STATIC) != 0 &&
 622                     types.isSubSignature(sym.type, type))) {
 623                 return sym;
 624             }
 625         }
 626         Symbol hiddenSym = null;
 627         for (Type st : types.interfaces(currentClass.type)
 628                 .prepend(types.supertype(currentClass.type))) {
 629             if (st != null && (st.hasTag(CLASS))) {
 630                 Symbol sym = hiddenInInternal((ClassSymbol)st.tsym, types);
 631                 if (sym == this) {
 632                     return this;
 633                 } else if (sym != null) {
 634                     hiddenSym = sym;
 635                 }
 636             }
 637         }
 638         return hiddenSym;
 639     }
 640 
 641     /** Is this symbol accessible in a given class?
 642      *  PRE: If symbol's owner is a interface,
 643      *       it is already assumed that the interface is a superinterface
 644      *       the given class.
 645      *  @param clazz  The class for which we want to establish membership.
 646      *                This must be a subclass of the member's owner.
 647      */
 648     public final boolean isAccessibleIn(Symbol clazz, Types types) {
 649         switch ((int)(flags_field & Flags.AccessFlags)) {
 650         default: // error recovery
 651         case PUBLIC:
 652             return true;
 653         case PRIVATE:
 654             return this.owner == clazz;
 655         case PROTECTED:
 656             // we model interfaces as extending Object
 657             return (clazz.flags() & INTERFACE) == 0;
 658         case 0:
 659             PackageSymbol thisPackage = this.packge();
 660             for (Symbol sup = clazz;
 661                  sup != null && sup != this.owner;
 662                  sup = types.supertype(sup.type).tsym) {
 663                 while (sup.type.hasTag(TYPEVAR))
 664                     sup = sup.type.getUpperBound().tsym;
 665                 if (sup.type.isErroneous())
 666                     return true; // error recovery
 667                 if ((sup.flags() & COMPOUND) != 0)
 668                     continue;
 669                 if (sup.packge() != thisPackage)
 670                     return false;
 671             }
 672             return (clazz.flags() & INTERFACE) == 0;
 673         }
 674     }
 675 
 676     /** Is this symbol inherited into a given class?
 677      *  PRE: If symbol's owner is a interface,
 678      *       it is already assumed that the interface is a superinterface
 679      *       of the given class.
 680      *  @param clazz  The class for which we want to establish membership.
 681      *                This must be a subclass of the member's owner.
 682      */
 683     public boolean isInheritedIn(Symbol clazz, Types types) {
 684         return isAccessibleIn(clazz, types);
 685     }
 686 
 687     /** The (variable or method) symbol seen as a member of given
 688      *  class type`site' (this might change the symbol's type).
 689      *  This is used exclusively for producing diagnostics.
 690      */
 691     public Symbol asMemberOf(Type site, Types types) {
 692         throw new AssertionError();
 693     }
 694 
 695     /** Does this method symbol override `other' symbol, when both are seen as
 696      *  members of class `origin'?  It is assumed that _other is a member
 697      *  of origin.
 698      *
 699      *  It is assumed that both symbols have the same name.  The static
 700      *  modifier is ignored for this test.
 701      *
 702      *  See JLS 8.4.8.1 (without transitivity) and 8.4.8.4
 703      */
 704     public boolean overrides(Symbol _other, TypeSymbol origin, Types types, boolean checkResult) {
 705         return false;
 706     }
 707 
 708     /** Complete the elaboration of this symbol's definition.
 709      */
 710     public void complete() throws CompletionFailure {
 711         if (completer != Completer.NULL_COMPLETER) {
 712             Completer c = completer;
 713             completer = Completer.NULL_COMPLETER;
 714             c.complete(this);
 715         }
 716     }
 717 
 718     public void apiComplete() throws CompletionFailure {
 719         try {
 720             complete();
 721         } catch (CompletionFailure cf) {
 722             cf.dcfh.handleAPICompletionFailure(cf);
 723         }
 724     }
 725 
 726     /** True if the symbol represents an entity that exists.
 727      */
 728     public boolean exists() {
 729         return true;
 730     }
 731 
 732     @DefinedBy(Api.LANGUAGE_MODEL)
 733     public Type asType() {
 734         return type;
 735     }
 736 
 737     @DefinedBy(Api.LANGUAGE_MODEL)
 738     public Symbol getEnclosingElement() {
 739         return owner;
 740     }
 741 
 742     @DefinedBy(Api.LANGUAGE_MODEL)
 743     public ElementKind getKind() {
 744         return ElementKind.OTHER;       // most unkind
 745     }
 746 
 747     @DefinedBy(Api.LANGUAGE_MODEL)
 748     public Set<Modifier> getModifiers() {
 749         apiComplete();
 750         return Flags.asModifierSet(flags());
 751     }
 752 
 753     @DefinedBy(Api.LANGUAGE_MODEL)
 754     public Name getSimpleName() {
 755         return name;
 756     }
 757 
 758     /**
 759      * This is the implementation for {@code
 760      * javax.lang.model.element.Element.getAnnotationMirrors()}.
 761      */
 762     @Override @DefinedBy(Api.LANGUAGE_MODEL)
 763     public List<Attribute.Compound> getAnnotationMirrors() {
 764         apiComplete();
 765         return getRawAttributes();
 766     }
 767 
 768 
 769     // TODO: getEnclosedElements should return a javac List, fix in FilteredMemberList
 770     @DefinedBy(Api.LANGUAGE_MODEL)
 771     public java.util.List<Symbol> getEnclosedElements() {
 772         return List.nil();
 773     }
 774 
 775     public List<TypeVariableSymbol> getTypeParameters() {
 776         ListBuffer<TypeVariableSymbol> l = new ListBuffer<>();
 777         for (Type t : type.getTypeArguments()) {
 778             Assert.check(t.tsym.getKind() == ElementKind.TYPE_PARAMETER);
 779             l.append((TypeVariableSymbol)t.tsym);
 780         }
 781         return l.toList();
 782     }
 783 
 784     public static class DelegatedSymbol<T extends Symbol> extends Symbol {
 785         protected T other;
 786         public DelegatedSymbol(T other) {
 787             super(other.kind, other.flags_field, other.name, other.type, other.owner);
 788             this.other = other;
 789         }
 790         public String toString() { return other.toString(); }
 791         public Symbol location() { return other.location(); }
 792         public Symbol location(Type site, Types types) { return other.location(site, types); }
 793         public Symbol baseSymbol() { return other; }
 794         public Type erasure(Types types) { return other.erasure(types); }
 795         public Type externalType(Types types) { return other.externalType(types); }
 796         public boolean isDirectlyOrIndirectlyLocal() { return other.isDirectlyOrIndirectlyLocal(); }
 797         public boolean isConstructor() { return other.isConstructor(); }
 798         public Name getQualifiedName() { return other.getQualifiedName(); }
 799         public Name flatName() { return other.flatName(); }
 800         public WriteableScope members() { return other.members(); }
 801         public boolean isInner() { return other.isInner(); }
 802         public boolean hasOuterInstance() { return other.hasOuterInstance(); }
 803         public ClassSymbol enclClass() { return other.enclClass(); }
 804         public ClassSymbol outermostClass() { return other.outermostClass(); }
 805         public PackageSymbol packge() { return other.packge(); }
 806         public boolean isSubClass(Symbol base, Types types) { return other.isSubClass(base, types); }
 807         public boolean isMemberOf(TypeSymbol clazz, Types types) { return other.isMemberOf(clazz, types); }
 808         public boolean isEnclosedBy(ClassSymbol clazz) { return other.isEnclosedBy(clazz); }
 809         public boolean isInheritedIn(Symbol clazz, Types types) { return other.isInheritedIn(clazz, types); }
 810         public Symbol asMemberOf(Type site, Types types) { return other.asMemberOf(site, types); }
 811         public void complete() throws CompletionFailure { other.complete(); }
 812 
 813         @DefinedBy(Api.LANGUAGE_MODEL)
 814         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 815             return other.accept(v, p);
 816         }
 817 
 818         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
 819             return v.visitSymbol(other, p);
 820         }
 821 
 822         public T getUnderlyingSymbol() {
 823             return other;
 824         }
 825     }
 826 
 827     /** A base class for Symbols representing types.
 828      */
 829     public abstract static class TypeSymbol extends Symbol {
 830         public TypeSymbol(Kind kind, long flags, Name name, Type type, Symbol owner) {
 831             super(kind, flags, name, type, owner);
 832         }
 833         /** form a fully qualified name from a name and an owner
 834          */
 835         public static Name formFullName(Name name, Symbol owner) {
 836             if (owner == null) return name;
 837             if ((owner.kind != ERR) &&
 838                 (owner.kind.matches(KindSelector.VAL_MTH) ||
 839                  (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
 840                  )) return name;
 841             Name prefix = owner.getQualifiedName();
 842             if (prefix == null || prefix == prefix.table.names.empty)
 843                 return name;
 844             else return prefix.append('.', name);
 845         }
 846 
 847         /** form a fully qualified name from a name and an owner, after
 848          *  converting to flat representation
 849          */
 850         public static Name formFlatName(Name name, Symbol owner) {
 851             if (owner == null || owner.kind.matches(KindSelector.VAL_MTH) ||
 852                 (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
 853                 ) return name;
 854             char sep = owner.kind == TYP ? '$' : '.';
 855             Name prefix = owner.flatName();
 856             if (prefix == null || prefix == prefix.table.names.empty)
 857                 return name;
 858             else return prefix.append(sep, name);
 859         }
 860 
 861         /**
 862          * A partial ordering between type symbols that refines the
 863          * class inheritance graph.
 864          *
 865          * Type variables always precede other kinds of symbols.
 866          */
 867         public final boolean precedes(TypeSymbol that, Types types) {
 868             if (this == that)
 869                 return false;
 870             if (type.hasTag(that.type.getTag())) {
 871                 if (type.hasTag(CLASS)) {
 872                     return
 873                         types.rank(that.type) < types.rank(this.type) ||
 874                         (types.rank(that.type) == types.rank(this.type) &&
 875                          this.getQualifiedName().compareTo(that.getQualifiedName()) < 0);
 876                 } else if (type.hasTag(TYPEVAR)) {
 877                     return types.isSubtype(this.type, that.type);
 878                 }
 879             }
 880             return type.hasTag(TYPEVAR);
 881         }
 882 
 883         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 884         public List<Symbol> getEnclosedElements() {
 885             List<Symbol> list = List.nil();
 886             if (kind == TYP && type.hasTag(TYPEVAR)) {
 887                 return list;
 888             }
 889             apiComplete();
 890             for (Symbol sym : members().getSymbols(NON_RECURSIVE)) {
 891                 sym.apiComplete();
 892                 if ((sym.flags() & SYNTHETIC) == 0 && sym.owner == this && sym.kind != ERR) {
 893                     list = list.prepend(sym);
 894                 }
 895             }
 896             return list;
 897         }
 898 
 899         public AnnotationTypeMetadata getAnnotationTypeMetadata() {
 900             Assert.error("Only on ClassSymbol");
 901             return null; //unreachable
 902         }
 903 
 904         public boolean isAnnotationType() { return false; }
 905 
 906         @Override
 907         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
 908             return v.visitTypeSymbol(this, p);
 909         }
 910     }
 911 
 912     /**
 913      * Type variables are represented by instances of this class.
 914      */
 915     public static class TypeVariableSymbol
 916             extends TypeSymbol implements TypeParameterElement {
 917 
 918         public TypeVariableSymbol(long flags, Name name, Type type, Symbol owner) {
 919             super(TYP, flags, name, type, owner);
 920         }
 921 
 922         @DefinedBy(Api.LANGUAGE_MODEL)
 923         public ElementKind getKind() {
 924             return ElementKind.TYPE_PARAMETER;
 925         }
 926 
 927         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 928         public Symbol getGenericElement() {
 929             return owner;
 930         }
 931 
 932         @DefinedBy(Api.LANGUAGE_MODEL)
 933         public List<Type> getBounds() {
 934             TypeVar t = (TypeVar)type;
 935             Type bound = t.getUpperBound();
 936             if (!bound.isCompound())
 937                 return List.of(bound);
 938             ClassType ct = (ClassType)bound;
 939             if (!ct.tsym.erasure_field.isInterface()) {
 940                 return ct.interfaces_field.prepend(ct.supertype_field);
 941             } else {
 942                 // No superclass was given in bounds.
 943                 // In this case, supertype is Object, erasure is first interface.
 944                 return ct.interfaces_field;
 945             }
 946         }
 947 
 948         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 949         public List<Attribute.Compound> getAnnotationMirrors() {
 950             // Declaration annotations on type variables are stored in type attributes
 951             // on the owner of the TypeVariableSymbol
 952             List<Attribute.TypeCompound> candidates = owner.getRawTypeAttributes();
 953             int index = owner.getTypeParameters().indexOf(this);
 954             List<Attribute.Compound> res = List.nil();
 955             for (Attribute.TypeCompound a : candidates) {
 956                 if (isCurrentSymbolsAnnotation(a, index))
 957                     res = res.prepend(a);
 958             }
 959 
 960             return res.reverse();
 961         }
 962 
 963         // Helper to getAnnotation[s]
 964         @Override
 965         public <A extends Annotation> Attribute.Compound getAttribute(Class<A> annoType) {
 966             String name = annoType.getName();
 967 
 968             // Declaration annotations on type variables are stored in type attributes
 969             // on the owner of the TypeVariableSymbol
 970             List<Attribute.TypeCompound> candidates = owner.getRawTypeAttributes();
 971             int index = owner.getTypeParameters().indexOf(this);
 972             for (Attribute.TypeCompound anno : candidates)
 973                 if (isCurrentSymbolsAnnotation(anno, index) &&
 974                     name.contentEquals(anno.type.tsym.flatName()))
 975                     return anno;
 976 
 977             return null;
 978         }
 979             //where:
 980             boolean isCurrentSymbolsAnnotation(Attribute.TypeCompound anno, int index) {
 981                 return (anno.position.type == TargetType.CLASS_TYPE_PARAMETER ||
 982                         anno.position.type == TargetType.METHOD_TYPE_PARAMETER) &&
 983                         anno.position.parameter_index == index;
 984             }
 985 
 986 
 987         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 988         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 989             return v.visitTypeParameter(this, p);
 990         }
 991     }
 992     /** A class for module symbols.
 993      */
 994     public static class ModuleSymbol extends TypeSymbol
 995             implements ModuleElement {
 996 
 997         public Name version;
 998         public JavaFileManager.Location sourceLocation;
 999         public JavaFileManager.Location classLocation;
1000         public JavaFileManager.Location patchLocation;
1001         public JavaFileManager.Location patchOutputLocation;
1002 
1003         /** All directives, in natural order. */
1004         public List<com.sun.tools.javac.code.Directive> directives;
1005         public List<com.sun.tools.javac.code.Directive.RequiresDirective> requires;
1006         public List<com.sun.tools.javac.code.Directive.ExportsDirective> exports;
1007         public List<com.sun.tools.javac.code.Directive.OpensDirective> opens;
1008         public List<com.sun.tools.javac.code.Directive.ProvidesDirective> provides;
1009         public List<com.sun.tools.javac.code.Directive.UsesDirective> uses;
1010 
1011         public ClassSymbol module_info;
1012 
1013         public PackageSymbol unnamedPackage;
1014         public Map<Name, PackageSymbol> visiblePackages;
1015         public Set<ModuleSymbol> readModules;
1016         public List<Symbol> enclosedPackages = List.nil();
1017 
1018         public Completer usesProvidesCompleter = Completer.NULL_COMPLETER;
1019         public final Set<ModuleFlags> flags = EnumSet.noneOf(ModuleFlags.class);
1020         public final Set<ModuleResolutionFlags> resolutionFlags = EnumSet.noneOf(ModuleResolutionFlags.class);
1021 
1022         /**
1023          * Create a ModuleSymbol with an associated module-info ClassSymbol.
1024          */
1025         public static ModuleSymbol create(Name name, Name module_info) {
1026             ModuleSymbol msym = new ModuleSymbol(name, null);
1027             ClassSymbol info = new ClassSymbol(Flags.MODULE, module_info, msym);
1028             info.fullname = formFullName(module_info, msym);
1029             info.flatname = info.fullname;
1030             info.members_field = WriteableScope.create(info);
1031             msym.module_info = info;
1032             return msym;
1033         }
1034 
1035         @SuppressWarnings("this-escape")
1036         public ModuleSymbol(Name name, Symbol owner) {
1037             super(MDL, 0, name, null, owner);
1038             Assert.checkNonNull(name);
1039             this.type = new ModuleType(this);
1040         }
1041 
1042         @Override
1043         public int poolTag() {
1044             return ClassFile.CONSTANT_Module;
1045         }
1046 
1047         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1048         public Name getSimpleName() {
1049             return Convert.shortName(name);
1050         }
1051 
1052         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1053         public boolean isOpen() {
1054             return flags.contains(ModuleFlags.OPEN);
1055         }
1056 
1057         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1058         public boolean isUnnamed() {
1059             return name.isEmpty() && owner == null;
1060         }
1061 
1062         @Override
1063         public boolean isDeprecated() {
1064             return hasDeprecatedAnnotation();
1065         }
1066 
1067         public boolean isNoModule() {
1068             return false;
1069         }
1070 
1071         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1072         public ElementKind getKind() {
1073             return ElementKind.MODULE;
1074         }
1075 
1076         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1077         public java.util.List<Directive> getDirectives() {
1078             apiComplete();
1079             completeUsesProvides();
1080             return Collections.unmodifiableList(directives);
1081         }
1082 
1083         public void completeUsesProvides() {
1084             if (usesProvidesCompleter != Completer.NULL_COMPLETER) {
1085                 Completer c = usesProvidesCompleter;
1086                 usesProvidesCompleter = Completer.NULL_COMPLETER;
1087                 c.complete(this);
1088             }
1089         }
1090 
1091         @Override
1092         public ClassSymbol outermostClass() {
1093             return null;
1094         }
1095 
1096         @Override
1097         public String toString() {
1098             // TODO: the following strings should be localized
1099             // Do this with custom anon subtypes in Symtab
1100             String n = (name == null) ? "<unknown>"
1101                     : (name.isEmpty()) ? "<unnamed>"
1102                     : String.valueOf(name);
1103             return n;
1104         }
1105 
1106         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1107         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
1108             return v.visitModule(this, p);
1109         }
1110 
1111         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1112         public List<Symbol> getEnclosedElements() {
1113             List<Symbol> list = List.nil();
1114             for (Symbol sym : enclosedPackages) {
1115                 if (sym.members().anyMatch(m -> m.kind == TYP))
1116                     list = list.prepend(sym);
1117             }
1118             return list;
1119         }
1120 
1121         public void reset() {
1122             this.directives = null;
1123             this.requires = null;
1124             this.exports = null;
1125             this.provides = null;
1126             this.uses = null;
1127             this.visiblePackages = null;
1128         }
1129 
1130     }
1131 
1132     public enum ModuleFlags {
1133         OPEN(0x0020),
1134         SYNTHETIC(0x1000),
1135         MANDATED(0x8000);
1136 
1137         public static int value(Set<ModuleFlags> s) {
1138             int v = 0;
1139             for (ModuleFlags f: s)
1140                 v |= f.value;
1141             return v;
1142         }
1143 
1144         private ModuleFlags(int value) {
1145             this.value = value;
1146         }
1147 
1148         public final int value;
1149     }
1150 
1151     public enum ModuleResolutionFlags {
1152         DO_NOT_RESOLVE_BY_DEFAULT(0x0001),
1153         WARN_DEPRECATED(0x0002),
1154         WARN_DEPRECATED_REMOVAL(0x0004),
1155         WARN_INCUBATING(0x0008);
1156 
1157         public static int value(Set<ModuleResolutionFlags> s) {
1158             int v = 0;
1159             for (ModuleResolutionFlags f: s)
1160                 v |= f.value;
1161             return v;
1162         }
1163 
1164         private ModuleResolutionFlags(int value) {
1165             this.value = value;
1166         }
1167 
1168         public final int value;
1169     }
1170 
1171     /** A class for package symbols
1172      */
1173     public static class PackageSymbol extends TypeSymbol
1174         implements PackageElement {
1175 
1176         public WriteableScope members_field;
1177         public Name fullname;
1178         public ClassSymbol package_info; // see bug 6443073
1179         public ModuleSymbol modle;
1180         // the file containing the documentation comments for the package
1181         public JavaFileObject sourcefile;
1182 
1183         public PackageSymbol(Name name, Type type, Symbol owner) {
1184             super(PCK, 0, name, type, owner);
1185             this.members_field = null;
1186             this.fullname = formFullName(name, owner);
1187         }
1188 
1189         @SuppressWarnings("this-escape")
1190         public PackageSymbol(Name name, Symbol owner) {
1191             this(name, null, owner);
1192             this.type = new PackageType(this);
1193         }
1194 
1195         public String toString() {
1196             return fullname.toString();
1197         }
1198 
1199         @DefinedBy(Api.LANGUAGE_MODEL)
1200         public Name getQualifiedName() {
1201             return fullname;
1202         }
1203 
1204         @DefinedBy(Api.LANGUAGE_MODEL)
1205         public boolean isUnnamed() {
1206             return name.isEmpty() && owner != null;
1207         }
1208 
1209         public WriteableScope members() {
1210             complete();
1211             return members_field;
1212         }
1213 
1214         @Override
1215         public int poolTag() {
1216             return ClassFile.CONSTANT_Package;
1217         }
1218 
1219         public long flags() {
1220             complete();
1221             return flags_field;
1222         }
1223 
1224         @Override
1225         public List<Attribute.Compound> getRawAttributes() {
1226             complete();
1227             if (package_info != null) {
1228                 package_info.complete();
1229                 mergeAttributes();
1230             }
1231             return super.getRawAttributes();
1232         }
1233 
1234         private void mergeAttributes() {
1235             if (metadata == null &&
1236                 package_info.metadata != null) {
1237                 metadata = new SymbolMetadata(this);
1238                 metadata.setAttributes(package_info.metadata);
1239             }
1240         }
1241 
1242         /** A package "exists" if a type or package that exists has
1243          *  been seen within it.
1244          */
1245         public boolean exists() {
1246             return (flags_field & EXISTS) != 0;
1247         }
1248 
1249         @DefinedBy(Api.LANGUAGE_MODEL)
1250         public ElementKind getKind() {
1251             return ElementKind.PACKAGE;
1252         }
1253 
1254         @DefinedBy(Api.LANGUAGE_MODEL)
1255         public Symbol getEnclosingElement() {
1256             return modle != null && !modle.isNoModule() ? modle : null;
1257         }
1258 
1259         @DefinedBy(Api.LANGUAGE_MODEL)
1260         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
1261             return v.visitPackage(this, p);
1262         }
1263 
1264         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
1265             return v.visitPackageSymbol(this, p);
1266         }
1267 
1268         /**Resets the Symbol into the state good for next round of annotation processing.*/
1269         public void reset() {
1270             metadata = null;
1271         }
1272 
1273     }
1274 
1275     public static class RootPackageSymbol extends PackageSymbol {
1276         public final MissingInfoHandler missingInfoHandler;
1277         public final boolean allowPrivateInvokeVirtual;
1278 
1279         public RootPackageSymbol(Name name, Symbol owner,
1280                                  MissingInfoHandler missingInfoHandler,
1281                                  boolean allowPrivateInvokeVirtual) {
1282             super(name, owner);
1283             this.missingInfoHandler = missingInfoHandler;
1284             this.allowPrivateInvokeVirtual = allowPrivateInvokeVirtual;
1285         }
1286 
1287     }
1288 
1289     /** A class for class symbols
1290      */
1291     public static class ClassSymbol extends TypeSymbol implements TypeElement {
1292 
1293         /** a scope for all class members; variables, methods and inner classes
1294          *  type parameters are not part of this scope
1295          */
1296         public WriteableScope members_field;
1297 
1298         /** the fully qualified name of the class, i.e. pck.outer.inner.
1299          *  null for anonymous classes
1300          */
1301         public Name fullname;
1302 
1303         /** the fully qualified name of the class after converting to flat
1304          *  representation, i.e. pck.outer$inner,
1305          *  set externally for local and anonymous classes
1306          */
1307         public Name flatname;
1308 
1309         /** the sourcefile where the class came from
1310          */
1311         public JavaFileObject sourcefile;
1312 
1313         /** the classfile from where to load this class
1314          *  this will have extension .class or .java
1315          */
1316         public JavaFileObject classfile;
1317 
1318         /** the list of translated local classes (used for generating
1319          * InnerClasses attribute)
1320          */
1321         public List<ClassSymbol> trans_local;
1322 
1323         /** the annotation metadata attached to this class */
1324         private AnnotationTypeMetadata annotationTypeMetadata;
1325 
1326         /* the list of any of record components, only non empty if the class is a record
1327          * and it has at least one record component
1328          */
1329         private List<RecordComponent> recordComponents = List.nil();
1330 
1331         // sealed classes related fields
1332         /** The classes, or interfaces, permitted to extend this class, or interface
1333          */
1334         private java.util.List<PermittedClassWithPos> permitted;
1335 
1336         public boolean isPermittedExplicit = false;
1337 
1338         private record PermittedClassWithPos(Symbol permittedClass, int pos) {}
1339 
1340         public ClassSymbol(long flags, Name name, Type type, Symbol owner) {
1341             super(TYP, flags, name, type, owner);
1342             this.members_field = null;
1343             this.fullname = formFullName(name, owner);
1344             this.flatname = formFlatName(name, owner);
1345             this.sourcefile = null;
1346             this.classfile = null;
1347             this.annotationTypeMetadata = AnnotationTypeMetadata.notAnAnnotationType();
1348             this.permitted = new ArrayList<>();
1349         }
1350 
1351         public ClassSymbol(long flags, Name name, Symbol owner) {
1352             this(
1353                 flags,
1354                 name,
1355                 new ClassType(Type.noType, null, null, List.nil()),
1356                 owner);
1357             this.type.tsym = this;
1358         }
1359 
1360         public void addPermittedSubclass(ClassSymbol csym, int pos) {
1361             Assert.check(!isPermittedExplicit);
1362             // we need to insert at the right pos
1363             PermittedClassWithPos element = new PermittedClassWithPos(csym, pos);
1364             int index = Collections.binarySearch(permitted, element, java.util.Comparator.comparing(PermittedClassWithPos::pos));
1365             if (index < 0) {
1366                 index = -index - 1;
1367             }
1368             permitted.add(index, element);
1369         }
1370 
1371         public boolean isPermittedSubclass(Symbol csym) {
1372             for (PermittedClassWithPos permittedClassWithPos : permitted) {
1373                 if (permittedClassWithPos.permittedClass.equals(csym)) {
1374                     return true;
1375                 }
1376             }
1377             return false;
1378         }
1379 
1380         public void clearPermittedSubclasses() {
1381             permitted.clear();
1382         }
1383 
1384         public void setPermittedSubclasses(List<Symbol> permittedSubs) {
1385             permitted.clear();
1386             for (Symbol csym : permittedSubs) {
1387                 permitted.add(new PermittedClassWithPos(csym, 0));
1388             }
1389         }
1390 
1391         /** The Java source which this symbol represents.
1392          */
1393         public String toString() {
1394             return className();
1395         }
1396 
1397         public long flags() {
1398             complete();
1399             return flags_field;
1400         }
1401 
1402         public WriteableScope members() {
1403             complete();
1404             return members_field;
1405         }
1406 
1407         @Override
1408         public List<Attribute.Compound> getRawAttributes() {
1409             complete();
1410             return super.getRawAttributes();
1411         }
1412 
1413         @Override
1414         public List<Attribute.TypeCompound> getRawTypeAttributes() {
1415             complete();
1416             return super.getRawTypeAttributes();
1417         }
1418 
1419         public Type erasure(Types types) {
1420             if (erasure_field == null)
1421                 erasure_field = new ClassType(types.erasure(type.getEnclosingType()),
1422                                               List.nil(), this,
1423                                               type.getMetadata());
1424             return erasure_field;
1425         }
1426 
1427         public String className() {
1428             if (name.isEmpty())
1429                 return
1430                     Log.getLocalizedString("anonymous.class", flatname);
1431             else
1432                 return fullname.toString();
1433         }
1434 
1435          @Override @DefinedBy(Api.LANGUAGE_MODEL)
1436          public Name getQualifiedName() {
1437              return fullname;
1438          }
1439 
1440          @Override @DefinedBy(Api.LANGUAGE_MODEL)
1441          public Name getSimpleName() {
1442              return name;
1443          }
1444 
1445         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1446         public List<Symbol> getEnclosedElements() {
1447             List<Symbol> result = super.getEnclosedElements();
1448             if (!recordComponents.isEmpty()) {
1449                 List<RecordComponent> reversed = recordComponents.reverse();
1450                 for (RecordComponent rc : reversed) {
1451                     result = result.prepend(rc);
1452                 }
1453             }
1454             return result;
1455         }
1456 
1457         public Name flatName() {
1458             return flatname;
1459         }
1460 
1461         public boolean isSubClass(Symbol base, Types types) {
1462             if (this == base) {
1463                 return true;
1464             } else if ((base.flags() & INTERFACE) != 0) {
1465                 for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
1466                     for (List<Type> is = types.interfaces(t);
1467                          is.nonEmpty();
1468                          is = is.tail)
1469                         if (is.head.tsym.isSubClass(base, types)) return true;
1470             } else {
1471                 for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
1472                     if (t.tsym == base) return true;
1473             }
1474             return false;
1475         }
1476 
1477         /** Complete the elaboration of this symbol's definition.
1478          */
1479         public void complete() throws CompletionFailure {
1480             Completer origCompleter = completer;
1481             try {
1482                 super.complete();
1483             } catch (CompletionFailure ex) {
1484                 ex.dcfh.classSymbolCompleteFailed(this, origCompleter);
1485                 // quiet error recovery
1486                 flags_field |= (PUBLIC|STATIC);
1487                 this.type = new ErrorType(this, Type.noType);
1488                 throw ex;
1489             }
1490         }
1491 
1492         @DefinedBy(Api.LANGUAGE_MODEL)
1493         public List<Type> getInterfaces() {
1494             apiComplete();
1495             if (type instanceof ClassType classType) {
1496                 if (classType.interfaces_field == null) // FIXME: shouldn't be null
1497                     classType.interfaces_field = List.nil();
1498                 if (classType.all_interfaces_field != null)
1499                     return Type.getModelTypes(classType.all_interfaces_field);
1500                 return classType.interfaces_field;
1501             } else {
1502                 return List.nil();
1503             }
1504         }
1505 
1506         @DefinedBy(Api.LANGUAGE_MODEL)
1507         public Type getSuperclass() {
1508             apiComplete();
1509             if (type instanceof ClassType classType) {
1510                 if (classType.supertype_field == null) // FIXME: shouldn't be null
1511                     classType.supertype_field = Type.noType;
1512                 // An interface has no superclass; its supertype is Object.
1513                 return classType.isInterface()
1514                     ? Type.noType
1515                     : classType.supertype_field.getModelType();
1516             } else {
1517                 return Type.noType;
1518             }
1519         }
1520 
1521         /**
1522          * Returns the next class to search for inherited annotations or {@code null}
1523          * if the next class can't be found.
1524          */
1525         private ClassSymbol getSuperClassToSearchForAnnotations() {
1526 
1527             Type sup = getSuperclass();
1528 
1529             if (!sup.hasTag(CLASS) || sup.isErroneous())
1530                 return null;
1531 
1532             return (ClassSymbol) sup.tsym;
1533         }
1534 
1535 
1536         @Override
1537         protected <A extends Annotation> A[] getInheritedAnnotations(Class<A> annoType) {
1538 
1539             ClassSymbol sup = getSuperClassToSearchForAnnotations();
1540 
1541             return sup == null ? super.getInheritedAnnotations(annoType)
1542                                : sup.getAnnotationsByType(annoType);
1543         }
1544 
1545 
1546         @DefinedBy(Api.LANGUAGE_MODEL)
1547         public ElementKind getKind() {
1548             apiComplete();
1549             long flags = flags();
1550             if ((flags & ANNOTATION) != 0)
1551                 return ElementKind.ANNOTATION_TYPE;
1552             else if ((flags & INTERFACE) != 0)
1553                 return ElementKind.INTERFACE;
1554             else if ((flags & ENUM) != 0)
1555                 return ElementKind.ENUM;
1556             else if ((flags & RECORD) != 0)
1557                 return ElementKind.RECORD;
1558             else
1559                 return ElementKind.CLASS;
1560         }
1561 
1562         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1563         public Set<Modifier> getModifiers() {
1564             apiComplete();
1565             long flags = flags();
1566             return Flags.asModifierSet(flags & ~DEFAULT);
1567         }
1568 
1569         public RecordComponent getRecordComponent(VarSymbol field) {
1570             for (RecordComponent rc : recordComponents) {
1571                 if (rc.name == field.name) {
1572                     return rc;
1573                 }
1574             }
1575             return null;
1576         }
1577 
1578         /* creates a record component if non is related to the given variable and recreates a brand new one
1579          * in other case
1580          */
1581         public RecordComponent createRecordComponent(RecordComponent existing, JCVariableDecl rcDecl, VarSymbol varSym) {
1582             RecordComponent rc = null;
1583             if (existing != null && !recordComponents.isEmpty()) {
1584                 ListBuffer<RecordComponent> newRComps = new ListBuffer<>();
1585                 for (RecordComponent rcomp : recordComponents) {
1586                     if (existing == rcomp) {
1587                         newRComps.add(rc = new RecordComponent(varSym, existing.ast, existing.isVarargs));
1588                     } else {
1589                         newRComps.add(rcomp);
1590                     }
1591                 }
1592                 recordComponents = newRComps.toList();
1593             } else {
1594                 // Didn't find the record component: create one.
1595                 recordComponents = recordComponents.append(rc = new RecordComponent(varSym, rcDecl));
1596             }
1597             return rc;
1598         }
1599 
1600         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1601         public List<? extends RecordComponent> getRecordComponents() {
1602             return recordComponents;
1603         }
1604 
1605         public void setRecordComponents(List<RecordComponent> recordComponents) {
1606             this.recordComponents = recordComponents;
1607         }
1608 
1609         @DefinedBy(Api.LANGUAGE_MODEL)
1610         public NestingKind getNestingKind() {
1611             apiComplete();
1612             if (owner.kind == PCK) // Handles implicitly declared classes as well
1613                 return NestingKind.TOP_LEVEL;
1614             else if (name.isEmpty())
1615                 return NestingKind.ANONYMOUS;
1616             else if (owner.kind == MTH)
1617                 return NestingKind.LOCAL;
1618             else
1619                 return NestingKind.MEMBER;
1620         }
1621 
1622         @Override
1623         protected <A extends Annotation> Attribute.Compound getAttribute(final Class<A> annoType) {
1624 
1625             Attribute.Compound attrib = super.getAttribute(annoType);
1626 
1627             boolean inherited = annoType.isAnnotationPresent(Inherited.class);
1628             if (attrib != null || !inherited)
1629                 return attrib;
1630 
1631             // Search supertypes
1632             ClassSymbol superType = getSuperClassToSearchForAnnotations();
1633             return superType == null ? null
1634                                      : superType.getAttribute(annoType);
1635         }
1636 
1637         @DefinedBy(Api.LANGUAGE_MODEL)
1638         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
1639             return v.visitType(this, p);
1640         }
1641 
1642         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
1643             return v.visitClassSymbol(this, p);
1644         }
1645 
1646         public void markAbstractIfNeeded(Types types) {
1647             if (types.enter.getEnv(this) != null &&
1648                 (flags() & ENUM) != 0 && types.supertype(type).tsym == types.syms.enumSym &&
1649                 (flags() & (FINAL | ABSTRACT)) == 0) {
1650                 if (types.firstUnimplementedAbstract(this) != null)
1651                     // add the ABSTRACT flag to an enum
1652                     flags_field |= ABSTRACT;
1653             }
1654         }
1655 
1656         /**Resets the Symbol into the state good for next round of annotation processing.*/
1657         public void reset() {
1658             kind = TYP;
1659             erasure_field = null;
1660             members_field = null;
1661             flags_field = 0;
1662             if (type instanceof ClassType classType) {
1663                 classType.setEnclosingType(Type.noType);
1664                 classType.rank_field = -1;
1665                 classType.typarams_field = null;
1666                 classType.allparams_field = null;
1667                 classType.supertype_field = null;
1668                 classType.interfaces_field = null;
1669                 classType.all_interfaces_field = null;
1670             }
1671             clearAnnotationMetadata();
1672         }
1673 
1674         public void clearAnnotationMetadata() {
1675             metadata = null;
1676             annotationTypeMetadata = AnnotationTypeMetadata.notAnAnnotationType();
1677         }
1678 
1679         @Override
1680         public AnnotationTypeMetadata getAnnotationTypeMetadata() {
1681             return annotationTypeMetadata;
1682         }
1683 
1684         @Override
1685         public boolean isAnnotationType() {
1686             return (flags_field & Flags.ANNOTATION) != 0;
1687         }
1688 
1689         public void setAnnotationTypeMetadata(AnnotationTypeMetadata a) {
1690             Assert.checkNonNull(a);
1691             Assert.check(!annotationTypeMetadata.isMetadataForAnnotationType());
1692             this.annotationTypeMetadata = a;
1693         }
1694 
1695         public boolean isRecord() {
1696             return (flags_field & RECORD) != 0;
1697         }
1698 
1699         @DefinedBy(Api.LANGUAGE_MODEL)
1700         public List<Type> getPermittedSubclasses() {
1701             return permitted.stream().map(s -> s.permittedClass().type).collect(List.collector());
1702         }
1703     }
1704 
1705 
1706     /** A class for variable symbols
1707      */
1708     @SuppressWarnings("preview")
1709     public static class VarSymbol extends Symbol implements VariableElement {
1710 
1711         /** The variable's declaration position.
1712          */
1713         public int pos = Position.NOPOS;
1714 
1715         /** The variable's address. Used for different purposes during
1716          *  flow analysis, translation and code generation.
1717          *  Flow analysis:
1718          *    If this is a blank final or local variable, its sequence number.
1719          *  Translation:
1720          *    If this is a private field, its access number.
1721          *  Code generation:
1722          *    If this is a local variable, its logical slot number.
1723          */
1724         public int adr = -1;
1725 
1726         /** Construct a variable symbol, given its flags, name, type and owner.
1727          */
1728         public VarSymbol(long flags, Name name, Type type, Symbol owner) {
1729             super(VAR, flags, name, type, owner);
1730         }
1731 
1732         @Override
1733         public int poolTag() {
1734             return ClassFile.CONSTANT_Fieldref;
1735         }
1736 
1737         public MethodHandleSymbol asMethodHandle(boolean getter) {
1738             return new MethodHandleSymbol(this, getter);
1739         }
1740 
1741         /** Clone this symbol with new owner.
1742          */
1743         public VarSymbol clone(Symbol newOwner) {
1744             VarSymbol v = new VarSymbol(flags_field, name, type, newOwner) {
1745                 @Override
1746                 public Symbol baseSymbol() {
1747                     return VarSymbol.this;
1748                 }
1749 
1750                 @Override
1751                 public Object poolKey(Types types) {
1752                     return new Pair<>(newOwner, baseSymbol());
1753                 }
1754             };
1755             v.pos = pos;
1756             v.adr = adr;
1757             v.data = data;
1758 //          System.out.println("clone " + v + " in " + newOwner);//DEBUG
1759             return v;
1760         }
1761 
1762         public String toString() {
1763             return name.toString();
1764         }
1765 
1766         public Symbol asMemberOf(Type site, Types types) {
1767             return new VarSymbol(flags_field, name, types.memberType(site, this), owner);
1768         }
1769 
1770         @DefinedBy(Api.LANGUAGE_MODEL)
1771         public ElementKind getKind() {
1772             long flags = flags();
1773             if ((flags & PARAMETER) != 0) {
1774                 if (isExceptionParameter())
1775                     return ElementKind.EXCEPTION_PARAMETER;
1776                 else
1777                     return ElementKind.PARAMETER;
1778             } else if ((flags & ENUM) != 0) {
1779                 return ElementKind.ENUM_CONSTANT;
1780             } else if (owner.kind == TYP || owner.kind == ERR) {
1781                 return ElementKind.FIELD;
1782             } else if (isResourceVariable()) {
1783                 return ElementKind.RESOURCE_VARIABLE;
1784             } else if ((flags & MATCH_BINDING) != 0) {
1785                 ElementKind kind = ElementKind.BINDING_VARIABLE;
1786                 return kind;
1787             } else {
1788                 return ElementKind.LOCAL_VARIABLE;
1789             }
1790         }
1791 
1792         @DefinedBy(Api.LANGUAGE_MODEL)
1793         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
1794             return v.visitVariable(this, p);
1795         }
1796 
1797         @DefinedBy(Api.LANGUAGE_MODEL)
1798         public Object getConstantValue() { // Mirror API
1799             return Constants.decode(getConstValue(), type);
1800         }
1801 
1802         public void setLazyConstValue(final Env<AttrContext> env,
1803                                       final Attr attr,
1804                                       final JCVariableDecl variable)
1805         {
1806             setData((Callable<Object>)() -> attr.attribLazyConstantValue(env, variable, type));
1807         }
1808 
1809         /**
1810          * The variable's constant value, if this is a constant.
1811          * Before the constant value is evaluated, it points to an
1812          * initializer environment.  If this is not a constant, it can
1813          * be used for other stuff.
1814          */
1815         private Object data;
1816 
1817         public boolean isExceptionParameter() {
1818             return data == ElementKind.EXCEPTION_PARAMETER;
1819         }
1820 
1821         public boolean isResourceVariable() {
1822             return data == ElementKind.RESOURCE_VARIABLE;
1823         }
1824 
1825         public Object getConstValue() {
1826             // TODO: Consider if getConstValue and getConstantValue can be collapsed
1827             if (data == ElementKind.EXCEPTION_PARAMETER ||
1828                 data == ElementKind.RESOURCE_VARIABLE) {
1829                 return null;
1830             } else if (data instanceof Callable<?> callableData) {
1831                 // In this case, this is a final variable, with an as
1832                 // yet unevaluated initializer.
1833                 data = null; // to make sure we don't evaluate this twice.
1834                 try {
1835                     data = callableData.call();
1836                 } catch (Exception ex) {
1837                     throw new AssertionError(ex);
1838                 }
1839             }
1840             return data;
1841         }
1842 
1843         public void setData(Object data) {
1844             Assert.check(!(data instanceof Env<?>), this);
1845             this.data = data;
1846         }
1847 
1848         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
1849             return v.visitVarSymbol(this, p);
1850         }
1851 
1852         public boolean isUnnamedVariable() {
1853             return name.isEmpty();
1854         }
1855     }
1856 
1857     public static class RecordComponent extends VarSymbol implements RecordComponentElement {
1858         public MethodSymbol accessor;
1859         public JCTree.JCMethodDecl accessorMeth;
1860 
1861         /* if the user happens to erroneously declare two components with the same name, we need a way to differentiate
1862          * them, the code will fail anyway but we need to keep the information for better error recovery
1863          */
1864         private final int pos;
1865 
1866         private final boolean isVarargs;
1867 
1868         private JCVariableDecl ast;
1869 
1870         /**
1871          * Construct a record component, given its flags, name, type and owner.
1872          */
1873         public RecordComponent(Name name, Type type, Symbol owner) {
1874             super(PUBLIC, name, type, owner);
1875             pos = -1;
1876             ast = null;
1877             isVarargs = false;
1878         }
1879 
1880         public RecordComponent(VarSymbol field, JCVariableDecl ast) {
1881             this(field, ast, field.type.hasTag(TypeTag.ARRAY) && ((ArrayType)field.type).isVarargs());
1882         }
1883 
1884         public RecordComponent(VarSymbol field, JCVariableDecl ast, boolean isVarargs) {
1885             super(PUBLIC, field.name, field.type, field.owner);
1886             this.ast = ast;
1887             this.pos = field.pos;
1888             /* it is better to store the original information for this one, instead of relying
1889              * on the info in the type of the symbol. This is because on the presence of APs
1890              * the symbol will be blown out and we won't be able to know if the original
1891              * record component was declared varargs or not.
1892              */
1893             this.isVarargs = isVarargs;
1894         }
1895 
1896         public List<JCAnnotation> getOriginalAnnos() { return this.ast == null ? List.nil() : this.ast.mods.annotations; }
1897 
1898         public JCVariableDecl declarationFor() { return this.ast; }
1899 
1900         public boolean isVarargs() {
1901             return isVarargs;
1902         }
1903 
1904         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1905         public ElementKind getKind() {
1906             return ElementKind.RECORD_COMPONENT;
1907         }
1908 
1909         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1910         public ExecutableElement getAccessor() {
1911             return accessor;
1912         }
1913 
1914         @Override @DefinedBy(Api.LANGUAGE_MODEL)
1915         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
1916             return v.visitRecordComponent(this, p);
1917         }
1918     }
1919 
1920     public static class ParamSymbol extends VarSymbol {
1921         public ParamSymbol(long flags, Name name, Type type, Symbol owner) {
1922             super(flags, name, type, owner);
1923         }
1924 
1925         @Override
1926         public Name getSimpleName() {
1927             if ((flags_field & NAME_FILLED) == 0) {
1928                 flags_field |= NAME_FILLED;
1929                 Symbol rootPack = this;
1930                 while (rootPack != null && !(rootPack instanceof RootPackageSymbol)) {
1931                     rootPack = rootPack.owner;
1932                 }
1933                 if (rootPack != null) {
1934                     Name inferredName =
1935                             ((RootPackageSymbol) rootPack).missingInfoHandler.getParameterName(this);
1936                     if (inferredName != null) {
1937                         this.name = inferredName;
1938                     }
1939                 }
1940             }
1941             return super.getSimpleName();
1942         }
1943 
1944     }
1945 
1946     public static class BindingSymbol extends VarSymbol {
1947 
1948         public BindingSymbol(long flags, Name name, Type type, Symbol owner) {
1949             super(flags | Flags.HASINIT | Flags.MATCH_BINDING, name, type, owner);
1950         }
1951 
1952         public boolean isAliasFor(BindingSymbol b) {
1953             return aliases().containsAll(b.aliases());
1954         }
1955 
1956         List<BindingSymbol> aliases() {
1957             return List.of(this);
1958         }
1959 
1960         public void preserveBinding() {
1961             flags_field |= Flags.MATCH_BINDING_TO_OUTER;
1962         }
1963 
1964         public boolean isPreserved() {
1965             return (flags_field & Flags.MATCH_BINDING_TO_OUTER) != 0;
1966         }
1967     }
1968 
1969     /** A class for method symbols.
1970      */
1971     public static class MethodSymbol extends Symbol implements ExecutableElement {
1972 
1973         /** The code of the method. */
1974         public Code code = null;
1975 
1976         /** The extra (synthetic/mandated) parameters of the method. */
1977         public List<VarSymbol> extraParams = List.nil();
1978 
1979         /** The captured local variables in an anonymous class */
1980         public List<VarSymbol> capturedLocals = List.nil();
1981 
1982         /** The parameters of the method. */
1983         public List<VarSymbol> params = null;
1984 
1985         /** For an annotation type element, its default value if any.
1986          *  The value is null if none appeared in the method
1987          *  declaration.
1988          */
1989         public Attribute defaultValue = null;
1990 
1991         /** Construct a method symbol, given its flags, name, type and owner.
1992          */
1993         public MethodSymbol(long flags, Name name, Type type, Symbol owner) {
1994             super(MTH, flags, name, type, owner);
1995             if (owner.type.hasTag(TYPEVAR)) Assert.error(owner + "." + name);
1996         }
1997 
1998         /** Clone this symbol with new owner.
1999          */
2000         public MethodSymbol clone(Symbol newOwner) {
2001             MethodSymbol m = new MethodSymbol(flags_field, name, type, newOwner) {
2002                 @Override
2003                 public Symbol baseSymbol() {
2004                     return MethodSymbol.this;
2005                 }
2006 
2007                 @Override
2008                 public Object poolKey(Types types) {
2009                     return new Pair<>(newOwner, baseSymbol());
2010                 }
2011             };
2012             m.code = code;
2013             return m;
2014         }
2015 
2016         @Override @DefinedBy(Api.LANGUAGE_MODEL)
2017         public Set<Modifier> getModifiers() {
2018             // just in case the method is restricted but that is not a modifier
2019             long flags = flags() & ~RESTRICTED;
2020             return Flags.asModifierSet((flags & DEFAULT) != 0 ? flags & ~ABSTRACT : flags);
2021         }
2022 
2023         /** The Java source which this symbol represents.
2024          */
2025         public String toString() {
2026             if ((flags() & BLOCK) != 0) {
2027                 return owner.name.toString();
2028             } else {
2029                 String s = (name == name.table.names.init)
2030                     ? owner.name.toString()
2031                     : name.toString();
2032                 if (type != null) {
2033                     if (type.hasTag(FORALL))
2034                         s = "<" + ((ForAll)type).getTypeArguments() + ">" + s;
2035                     s += "(" + type.argtypes((flags() & VARARGS) != 0) + ")";
2036                 }
2037                 return s;
2038             }
2039         }
2040 
2041         @Override
2042         public int poolTag() {
2043             return owner.isInterface() ?
2044                     ClassFile.CONSTANT_InterfaceMethodref : ClassFile.CONSTANT_Methodref;
2045         }
2046 
2047         public boolean isHandle() {
2048             return false;
2049         }
2050 
2051 
2052         public MethodHandleSymbol asHandle() {
2053             return new MethodHandleSymbol(this);
2054         }
2055 
2056         /** find a symbol that this (proxy method) symbol implements.
2057          *  @param    c       The class whose members are searched for
2058          *                    implementations
2059          */
2060         public Symbol implemented(TypeSymbol c, Types types) {
2061             Symbol impl = null;
2062             for (List<Type> is = types.interfaces(c.type);
2063                  impl == null && is.nonEmpty();
2064                  is = is.tail) {
2065                 TypeSymbol i = is.head.tsym;
2066                 impl = implementedIn(i, types);
2067                 if (impl == null)
2068                     impl = implemented(i, types);
2069             }
2070             return impl;
2071         }
2072 
2073         public Symbol implementedIn(TypeSymbol c, Types types) {
2074             Symbol impl = null;
2075             for (Symbol sym : c.members().getSymbolsByName(name)) {
2076                 if (this.overrides(sym, (TypeSymbol)owner, types, true) &&
2077                     // FIXME: I suspect the following requires a
2078                     // subst() for a parametric return type.
2079                     types.isSameType(type.getReturnType(),
2080                                      types.memberType(owner.type, sym).getReturnType())) {
2081                     impl = sym;
2082                 }
2083             }
2084             return impl;
2085         }
2086 
2087         /** Will the erasure of this method be considered by the VM to
2088          *  override the erasure of the other when seen from class `origin'?
2089          */
2090         public boolean binaryOverrides(Symbol _other, TypeSymbol origin, Types types) {
2091             if (isConstructor() || _other.kind != MTH) return false;
2092 
2093             if (this == _other) return true;
2094             MethodSymbol other = (MethodSymbol)_other;
2095 
2096             // check for a direct implementation
2097             if (other.isOverridableIn((TypeSymbol)owner) &&
2098                 types.asSuper(owner.type, other.owner) != null &&
2099                 types.isSameType(erasure(types), other.erasure(types)))
2100                 return true;
2101 
2102             // check for an inherited implementation
2103             return
2104                 (flags() & ABSTRACT) == 0 &&
2105                 other.isOverridableIn(origin) &&
2106                 this.isMemberOf(origin, types) &&
2107                 types.isSameType(erasure(types), other.erasure(types));
2108         }
2109 
2110         /** The implementation of this (abstract) symbol in class origin,
2111          *  from the VM's point of view, null if method does not have an
2112          *  implementation in class.
2113          *  @param origin   The class of which the implementation is a member.
2114          */
2115         public MethodSymbol binaryImplementation(ClassSymbol origin, Types types) {
2116             for (TypeSymbol c = origin; c != null; c = types.supertype(c.type).tsym) {
2117                 for (Symbol sym : c.members().getSymbolsByName(name)) {
2118                     if (sym.kind == MTH &&
2119                         ((MethodSymbol)sym).binaryOverrides(this, origin, types))
2120                         return (MethodSymbol)sym;
2121                 }
2122             }
2123             return null;
2124         }
2125 
2126         /** Does this symbol override `other' symbol, when both are seen as
2127          *  members of class `origin'?  It is assumed that _other is a member
2128          *  of origin.
2129          *
2130          *  It is assumed that both symbols have the same name.  The static
2131          *  modifier is ignored for this test.
2132          *
2133          *  A quirk in the works is that if the receiver is a method symbol for
2134          *  an inherited abstract method we answer false summarily all else being
2135          *  immaterial. Abstract "own" methods (i.e `this' is a direct member of
2136          *  origin) don't get rejected as summarily and are put to test against the
2137          *  suitable criteria.
2138          *
2139          *  See JLS 8.4.8.1 (without transitivity) and 8.4.8.4
2140          */
2141         public boolean overrides(Symbol _other, TypeSymbol origin, Types types, boolean checkResult) {
2142             return overrides(_other, origin, types, checkResult, true);
2143         }
2144 
2145         /** Does this symbol override `other' symbol, when both are seen as
2146          *  members of class `origin'?  It is assumed that _other is a member
2147          *  of origin.
2148          *
2149          *  Caveat: If `this' is an abstract inherited member of origin, it is
2150          *  deemed to override `other' only when `requireConcreteIfInherited'
2151          *  is false.
2152          *
2153          *  It is assumed that both symbols have the same name.  The static
2154          *  modifier is ignored for this test.
2155          *
2156          *  See JLS 8.4.8.1 (without transitivity) and 8.4.8.4
2157          */
2158         public boolean overrides(Symbol _other, TypeSymbol origin, Types types, boolean checkResult,
2159                                             boolean requireConcreteIfInherited) {
2160             if (isConstructor() || _other.kind != MTH) return false;
2161 
2162             if (this == _other) return true;
2163             MethodSymbol other = (MethodSymbol)_other;
2164 
2165             // check for a direct implementation
2166             if (other.isOverridableIn((TypeSymbol)owner) &&
2167                 types.asSuper(owner.type, other.owner) != null) {
2168                 Type mt = types.memberType(owner.type, this);
2169                 Type ot = types.memberType(owner.type, other);
2170                 if (types.isSubSignature(mt, ot)) {
2171                     if (!checkResult)
2172                         return true;
2173                     if (types.returnTypeSubstitutable(mt, ot))
2174                         return true;
2175                 }
2176             }
2177 
2178             // check for an inherited implementation
2179             if (((flags() & ABSTRACT) != 0 && requireConcreteIfInherited) ||
2180                     ((other.flags() & ABSTRACT) == 0 && (other.flags() & DEFAULT) == 0) ||
2181                     !other.isOverridableIn(origin) ||
2182                     !this.isMemberOf(origin, types))
2183                 return false;
2184 
2185             // assert types.asSuper(origin.type, other.owner) != null;
2186             Type mt = types.memberType(origin.type, this);
2187             Type ot = types.memberType(origin.type, other);
2188             return
2189                 types.isSubSignature(mt, ot) &&
2190                 (!checkResult || types.resultSubtype(mt, ot, types.noWarnings));
2191         }
2192 
2193         private boolean isOverridableIn(TypeSymbol origin) {
2194             // JLS 8.4.8.1
2195             switch ((int)(flags_field & Flags.AccessFlags)) {
2196             case Flags.PRIVATE:
2197                 return false;
2198             case Flags.PUBLIC:
2199                 return !this.owner.isInterface() ||
2200                         (flags_field & STATIC) == 0;
2201             case Flags.PROTECTED:
2202                 return (origin.flags() & INTERFACE) == 0;
2203             case 0:
2204                 // for package private: can only override in the same
2205                 // package
2206                 return
2207                     this.packge() == origin.packge() &&
2208                     (origin.flags() & INTERFACE) == 0;
2209             default:
2210                 return false;
2211             }
2212         }
2213 
2214         @Override
2215         public boolean isInheritedIn(Symbol clazz, Types types) {
2216             switch ((int)(flags_field & Flags.AccessFlags)) {
2217                 case PUBLIC:
2218                     return !this.owner.isInterface() ||
2219                             clazz == owner ||
2220                             (flags_field & STATIC) == 0;
2221                 default:
2222                     return super.isInheritedIn(clazz, types);
2223             }
2224         }
2225 
2226         public boolean isLambdaMethod() {
2227             return (flags() & LAMBDA_METHOD) == LAMBDA_METHOD;
2228         }
2229 
2230         /** override this method to point to the original enclosing method if this method symbol represents a synthetic
2231          *  lambda method
2232          */
2233         public MethodSymbol originalEnclosingMethod() {
2234             return this;
2235         }
2236 
2237         /** The implementation of this (abstract) symbol in class origin;
2238          *  null if none exists. Synthetic methods are not considered
2239          *  as possible implementations.
2240          */
2241         public MethodSymbol implementation(TypeSymbol origin, Types types, boolean checkResult) {
2242             return implementation(origin, types, checkResult, implementation_filter);
2243         }
2244         // where
2245             public static final Predicate<Symbol> implementation_filter = s ->
2246                     s.kind == MTH && (s.flags() & SYNTHETIC) == 0;
2247 
2248         public MethodSymbol implementation(TypeSymbol origin, Types types, boolean checkResult, Predicate<Symbol> implFilter) {
2249             MethodSymbol res = types.implementation(this, origin, checkResult, implFilter);
2250             if (res != null)
2251                 return res;
2252             // if origin is derived from a raw type, we might have missed
2253             // an implementation because we do not know enough about instantiations.
2254             // in this case continue with the supertype as origin.
2255             if (types.isDerivedRaw(origin.type) && !origin.isInterface())
2256                 return implementation(types.supertype(origin.type).tsym, types, checkResult);
2257             else
2258                 return null;
2259         }
2260 
2261         public List<VarSymbol> params() {
2262             owner.complete();
2263             if (params == null) {
2264                 ListBuffer<VarSymbol> newParams = new ListBuffer<>();
2265                 int i = 0;
2266                 for (Type t : type.getParameterTypes()) {
2267                     Name paramName = name.table.fromString("arg" + i);
2268                     VarSymbol param = new VarSymbol(PARAMETER, paramName, t, this);
2269                     newParams.append(param);
2270                     i++;
2271                 }
2272                 params = newParams.toList();
2273             }
2274             Assert.checkNonNull(params);
2275             return params;
2276         }
2277 
2278         public Symbol asMemberOf(Type site, Types types) {
2279             return new MethodSymbol(flags_field, name, types.memberType(site, this), owner);
2280         }
2281 
2282         @DefinedBy(Api.LANGUAGE_MODEL)
2283         public ElementKind getKind() {
2284             if (name == name.table.names.init)
2285                 return ElementKind.CONSTRUCTOR;
2286             else if (name == name.table.names.clinit)
2287                 return ElementKind.STATIC_INIT;
2288             else if ((flags() & BLOCK) != 0)
2289                 return isStatic() ? ElementKind.STATIC_INIT : ElementKind.INSTANCE_INIT;
2290             else
2291                 return ElementKind.METHOD;
2292         }
2293 
2294         public boolean isStaticOrInstanceInit() {
2295             return getKind() == ElementKind.STATIC_INIT ||
2296                     getKind() == ElementKind.INSTANCE_INIT;
2297         }
2298 
2299         @DefinedBy(Api.LANGUAGE_MODEL)
2300         public Attribute getDefaultValue() {
2301             return defaultValue;
2302         }
2303 
2304         @DefinedBy(Api.LANGUAGE_MODEL)
2305         public List<VarSymbol> getParameters() {
2306             return params();
2307         }
2308 
2309         @DefinedBy(Api.LANGUAGE_MODEL)
2310         public boolean isVarArgs() {
2311             return (flags() & VARARGS) != 0;
2312         }
2313 
2314         @DefinedBy(Api.LANGUAGE_MODEL)
2315         public boolean isDefault() {
2316             return (flags() & DEFAULT) != 0;
2317         }
2318 
2319         @DefinedBy(Api.LANGUAGE_MODEL)
2320         public <R, P> R accept(ElementVisitor<R, P> v, P p) {
2321             return v.visitExecutable(this, p);
2322         }
2323 
2324         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
2325             return v.visitMethodSymbol(this, p);
2326         }
2327 
2328         @DefinedBy(Api.LANGUAGE_MODEL)
2329         public Type getReceiverType() {
2330             return asType().getReceiverType();
2331         }
2332 
2333         public Type implicitReceiverType() {
2334             ClassSymbol enclosingClass = enclClass();
2335             if (enclosingClass == null) {
2336                 return null;
2337             }
2338             Type enclosingType = enclosingClass.type;
2339             if (isConstructor()) {
2340                 return enclosingType.getEnclosingType();
2341             }
2342             if (!isStatic()) {
2343                 return enclosingType;
2344             }
2345             return null;
2346         }
2347 
2348         @DefinedBy(Api.LANGUAGE_MODEL)
2349         public Type getReturnType() {
2350             return asType().getReturnType();
2351         }
2352 
2353         @DefinedBy(Api.LANGUAGE_MODEL)
2354         public List<Type> getThrownTypes() {
2355             return asType().getThrownTypes();
2356         }
2357     }
2358 
2359     /** A class for invokedynamic method calls.
2360      */
2361     public static class DynamicMethodSymbol extends MethodSymbol implements Dynamic {
2362 
2363         public LoadableConstant[] staticArgs;
2364         public MethodHandleSymbol bsm;
2365 
2366         public DynamicMethodSymbol(Name name, Symbol owner, MethodHandleSymbol bsm, Type type, LoadableConstant[] staticArgs) {
2367             super(0, name, type, owner);
2368             this.bsm = bsm;
2369             this.staticArgs = staticArgs;
2370         }
2371 
2372         @Override
2373         public Name name() {
2374             return name;
2375         }
2376 
2377         @Override
2378         public boolean isDynamic() {
2379             return true;
2380         }
2381 
2382         @Override
2383         public LoadableConstant[] staticArgs() {
2384             return staticArgs;
2385         }
2386 
2387         @Override
2388         public MethodHandleSymbol bootstrapMethod() {
2389             return bsm;
2390         }
2391 
2392         @Override
2393         public int poolTag() {
2394             return ClassFile.CONSTANT_InvokeDynamic;
2395         }
2396 
2397         @Override
2398         public Type dynamicType() {
2399             return type;
2400         }
2401     }
2402 
2403     /** A class for condy.
2404      */
2405     public static class DynamicVarSymbol extends VarSymbol implements Dynamic, LoadableConstant {
2406         public LoadableConstant[] staticArgs;
2407         public MethodHandleSymbol bsm;
2408 
2409         public DynamicVarSymbol(Name name, Symbol owner, MethodHandleSymbol bsm, Type type, LoadableConstant[] staticArgs) {
2410             super(0, name, type, owner);
2411             this.bsm = bsm;
2412             this.staticArgs = staticArgs;
2413         }
2414 
2415         @Override
2416         public Name name() {
2417             return name;
2418         }
2419 
2420         @Override
2421         public boolean isDynamic() {
2422             return true;
2423         }
2424 
2425         @Override
2426         public PoolConstant dynamicType() {
2427             return type;
2428         }
2429 
2430         @Override
2431         public LoadableConstant[] staticArgs() {
2432             return staticArgs;
2433         }
2434 
2435         @Override
2436         public LoadableConstant bootstrapMethod() {
2437             return bsm;
2438         }
2439 
2440         @Override
2441         public int poolTag() {
2442             return ClassFile.CONSTANT_Dynamic;
2443         }
2444     }
2445 
2446     /** A class for method handles.
2447      */
2448     public static class MethodHandleSymbol extends MethodSymbol implements LoadableConstant {
2449 
2450         private Symbol refSym;
2451         private boolean getter;
2452 
2453         public MethodHandleSymbol(Symbol msym) {
2454             this(msym, false);
2455         }
2456 
2457         public MethodHandleSymbol(Symbol msym, boolean getter) {
2458             super(msym.flags_field, msym.name, msym.type, msym.owner);
2459             this.refSym = msym;
2460             this.getter = getter;
2461         }
2462 
2463         /**
2464          * Returns the kind associated with this method handle.
2465          */
2466         public int referenceKind() {
2467             if (refSym.kind == VAR) {
2468                 return getter ?
2469                         refSym.isStatic() ? ClassFile.REF_getStatic : ClassFile.REF_getField :
2470                         refSym.isStatic() ? ClassFile.REF_putStatic : ClassFile.REF_putField;
2471             } else {
2472                 if (refSym.isConstructor()) {
2473                     return ClassFile.REF_newInvokeSpecial;
2474                 } else {
2475                     if (refSym.isStatic()) {
2476                         return ClassFile.REF_invokeStatic;
2477                     } else if ((refSym.flags() & PRIVATE) != 0 && !allowPrivateInvokeVirtual()) {
2478                         return ClassFile.REF_invokeSpecial;
2479                     } else if (refSym.enclClass().isInterface()) {
2480                         return ClassFile.REF_invokeInterface;
2481                     } else {
2482                         return ClassFile.REF_invokeVirtual;
2483                     }
2484                 }
2485             }
2486         }
2487 
2488         private boolean allowPrivateInvokeVirtual() {
2489             Symbol rootPack = this;
2490             while (rootPack != null && !(rootPack instanceof RootPackageSymbol)) {
2491                 rootPack = rootPack.owner;
2492             }
2493             return rootPack != null && ((RootPackageSymbol) rootPack).allowPrivateInvokeVirtual;
2494         }
2495         @Override
2496         public int poolTag() {
2497             return ClassFile.CONSTANT_MethodHandle;
2498         }
2499 
2500         @Override
2501         public Object poolKey(Types types) {
2502             return new Pair<>(baseSymbol(), referenceKind());
2503         }
2504 
2505         @Override
2506         public MethodHandleSymbol asHandle() {
2507             return this;
2508         }
2509 
2510         @Override
2511         public Symbol baseSymbol() {
2512             return refSym;
2513         }
2514 
2515 
2516         @Override
2517         public boolean isHandle() {
2518             return true;
2519         }
2520     }
2521 
2522     /** A class for predefined operators.
2523      */
2524     public static class OperatorSymbol extends MethodSymbol {
2525 
2526         public int opcode;
2527         private int accessCode = Integer.MIN_VALUE;
2528 
2529         public OperatorSymbol(Name name, Type type, int opcode, Symbol owner) {
2530             super(PUBLIC | STATIC, name, type, owner);
2531             this.opcode = opcode;
2532         }
2533 
2534         @Override
2535         public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
2536             return v.visitOperatorSymbol(this, p);
2537         }
2538 
2539         public int getAccessCode(Tag tag) {
2540             if (accessCode != Integer.MIN_VALUE && !tag.isIncOrDecUnaryOp()) {
2541                 return accessCode;
2542             }
2543             accessCode = AccessCode.from(tag, opcode);
2544             return accessCode;
2545         }
2546 
2547         /** Access codes for dereferencing, assignment,
2548          *  and pre/post increment/decrement.
2549 
2550          *  All access codes for accesses to the current class are even.
2551          *  If a member of the superclass should be accessed instead (because
2552          *  access was via a qualified super), add one to the corresponding code
2553          *  for the current class, making the number odd.
2554          *  This numbering scheme is used by the backend to decide whether
2555          *  to issue an invokevirtual or invokespecial call.
2556          *
2557          *  @see Gen#visitSelect(JCFieldAccess tree)
2558          */
2559         public enum AccessCode {
2560             UNKNOWN(-1, Tag.NO_TAG),
2561             DEREF(0, Tag.NO_TAG),
2562             ASSIGN(2, Tag.ASSIGN),
2563             PREINC(4, Tag.PREINC),
2564             PREDEC(6, Tag.PREDEC),
2565             POSTINC(8, Tag.POSTINC),
2566             POSTDEC(10, Tag.POSTDEC),
2567             FIRSTASGOP(12, Tag.NO_TAG);
2568 
2569             public final int code;
2570             public final Tag tag;
2571             public static final int numberOfAccessCodes = (lushrl - ishll + lxor + 2 - iadd) * 2 + FIRSTASGOP.code + 2;
2572 
2573             AccessCode(int code, Tag tag) {
2574                 this.code = code;
2575                 this.tag = tag;
2576             }
2577 
2578             public static AccessCode getFromCode(int code) {
2579                 for (AccessCode aCodes : AccessCode.values()) {
2580                     if (aCodes.code == code) {
2581                         return aCodes;
2582                     }
2583                 }
2584                 return UNKNOWN;
2585             }
2586 
2587             static int from(Tag tag, int opcode) {
2588                 /** Map bytecode of binary operation to access code of corresponding
2589                 *  assignment operation. This is always an even number.
2590                 */
2591                 switch (tag) {
2592                     case PREINC:
2593                         return AccessCode.PREINC.code;
2594                     case PREDEC:
2595                         return AccessCode.PREDEC.code;
2596                     case POSTINC:
2597                         return AccessCode.POSTINC.code;
2598                     case POSTDEC:
2599                         return AccessCode.POSTDEC.code;
2600                 }
2601                 if (iadd <= opcode && opcode <= lxor) {
2602                     return (opcode - iadd) * 2 + FIRSTASGOP.code;
2603                 } else if (opcode == string_add) {
2604                     return (lxor + 1 - iadd) * 2 + FIRSTASGOP.code;
2605                 } else if (ishll <= opcode && opcode <= lushrl) {
2606                     return (opcode - ishll + lxor + 2 - iadd) * 2 + FIRSTASGOP.code;
2607                 }
2608                 return -1;
2609             }
2610         }
2611     }
2612 
2613     /** Symbol completer interface.
2614      */
2615     public static interface Completer {
2616 
2617         /** Dummy completer to be used when the symbol has been completed or
2618          * does not need completion.
2619          */
2620         public static final Completer NULL_COMPLETER = new Completer() {
2621             public void complete(Symbol sym) { }
2622             public boolean isTerminal() { return true; }
2623         };
2624 
2625         void complete(Symbol sym) throws CompletionFailure;
2626 
2627         /** Returns true if this completer is <em>terminal</em>. A terminal
2628          * completer is used as a place holder when the symbol is completed.
2629          * Calling complete on a terminal completer will not affect the symbol.
2630          *
2631          * The dummy NULL_COMPLETER and the GraphDependencies completer are
2632          * examples of terminal completers.
2633          *
2634          * @return true iff this completer is terminal
2635          */
2636         default boolean isTerminal() {
2637             return false;
2638         }
2639     }
2640 
2641     public static class CompletionFailure extends RuntimeException {
2642         private static final long serialVersionUID = 0;
2643         public final transient DeferredCompletionFailureHandler dcfh;
2644         public transient Symbol sym;
2645 
2646         /** A diagnostic object describing the failure
2647          */
2648         private transient JCDiagnostic diag;
2649 
2650         private transient Supplier<JCDiagnostic> diagSupplier;
2651 
2652         public CompletionFailure(Symbol sym, Supplier<JCDiagnostic> diagSupplier, DeferredCompletionFailureHandler dcfh) {
2653             this.dcfh = dcfh;
2654             this.sym = sym;
2655             this.diagSupplier = diagSupplier;
2656 //          this.printStackTrace();//DEBUG
2657         }
2658 
2659         public JCDiagnostic getDiagnostic() {
2660             if (diag == null && diagSupplier != null) {
2661                 diag = diagSupplier.get();
2662             }
2663             return diag;
2664         }
2665 
2666         @Override
2667         public String getMessage() {
2668             return getDiagnostic().getMessage(null);
2669         }
2670 
2671         public JCDiagnostic getDetailValue() {
2672             return getDiagnostic();
2673         }
2674 
2675         @Override
2676         public CompletionFailure initCause(Throwable cause) {
2677             super.initCause(cause);
2678             return this;
2679         }
2680 
2681         public void resetDiagnostic(Supplier<JCDiagnostic> diagSupplier) {
2682             this.diagSupplier = diagSupplier;
2683             this.diag = null;
2684         }
2685 
2686     }
2687 
2688     /**
2689      * A visitor for symbols.  A visitor is used to implement operations
2690      * (or relations) on symbols.  Most common operations on types are
2691      * binary relations and this interface is designed for binary
2692      * relations, that is, operations on the form
2693      * Symbol&nbsp;&times;&nbsp;P&nbsp;&rarr;&nbsp;R.
2694      * <!-- In plain text: Type x P -> R -->
2695      *
2696      * @param <R> the return type of the operation implemented by this
2697      * visitor; use Void if no return type is needed.
2698      * @param <P> the type of the second argument (the first being the
2699      * symbol itself) of the operation implemented by this visitor; use
2700      * Void if a second argument is not needed.
2701      */
2702     public interface Visitor<R,P> {
2703         R visitClassSymbol(ClassSymbol s, P arg);
2704         R visitMethodSymbol(MethodSymbol s, P arg);
2705         R visitPackageSymbol(PackageSymbol s, P arg);
2706         R visitOperatorSymbol(OperatorSymbol s, P arg);
2707         R visitVarSymbol(VarSymbol s, P arg);
2708         R visitTypeSymbol(TypeSymbol s, P arg);
2709         R visitSymbol(Symbol s, P arg);
2710     }
2711 }