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