jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/code/Symbol.java

-:ddd110646d21
+:609fb59657b4
 */
 public Symbol clone(Symbol newOwner) {
 throw new AssertionError();
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitSymbol(this, p);
+}
 /** The Java source which this symbol represents.
 *  A description of this symbol; overrides Object.
 */
 public String toString() {
 return name.toString();
 public void complete() throws CompletionFailure { other.complete(); }
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return other.accept(v, p);
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitSymbol(other, p);
+}
 }
 /** A class for type symbols. Type variables are represented by instances
 *  of this class, classes and packages by instances of subclasses.
 */
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 assert type.tag == TYPEVAR; // else override will be invoked
 return v.visitTypeParameter(this, p);
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitTypeSymbol(this, p);
+}
 public List<Type> getBounds() {
 TypeVar t = (TypeVar)type;
 Type bound = t.getUpperBound();
 if (!bound.isCompound())
 return List.of(bound);
 }
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return v.visitPackage(this, p);
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitPackageSymbol(this, p);
+}
 }
 /** A class for class symbols
 */
 public static class ClassSymbol extends TypeSymbol implements TypeElement {
 return JavacElements.getAnnotation(this, annoType);
 }
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return v.visitType(this, p);
+}
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitClassSymbol(this, p);
 }
 }
 /** A class for variable symbols
 public void setData(Object data) {
 assert !(data instanceof Env<?>) : this;
 this.data = data;
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitVarSymbol(this, p);
+}
 }
 /** A class for method symbols.
 */
 public static class MethodSymbol extends Symbol implements ExecutableElement {
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return v.visitExecutable(this, p);
 }
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitMethodSymbol(this, p);
+}
 public Type getReturnType() {
 return asType().getReturnType();
 }
 public List<Type> getThrownTypes() {
 public int opcode;
 public OperatorSymbol(Name name, Type type, int opcode, Symbol owner) {
 super(PUBLIC | STATIC, name, type, owner);
 this.opcode = opcode;
+}
+public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
+return v.visitOperatorSymbol(this, p);
 }
 }
 /** Symbol completer interface.
 */
 super.initCause(cause);
 return this;
 }
 }
+/**
+* A visitor for symbols.  A visitor is used to implement operations
+* (or relations) on symbols.  Most common operations on types are
+* binary relations and this interface is designed for binary
+* relations, that is, operations on the form
+* Symbol&nbsp;&times;&nbsp;P&nbsp;&rarr;&nbsp;R.
+* <!-- In plain text: Type x P -> R -->
+*
+* @param <R> the return type of the operation implemented by this
+* visitor; use Void if no return type is needed.
+* @param <P> the type of the second argument (the first being the
+* symbol itself) of the operation implemented by this visitor; use
+* Void if a second argument is not needed.
+*/
+public interface Visitor<R,P> {
+R visitClassSymbol(ClassSymbol s, P arg);
+R visitMethodSymbol(MethodSymbol s, P arg);
+R visitPackageSymbol(PackageSymbol s, P arg);
+R visitOperatorSymbol(OperatorSymbol s, P arg);
+R visitVarSymbol(VarSymbol s, P arg);
+R visitTypeSymbol(TypeSymbol s, P arg);
+R visitSymbol(Symbol s, P arg);
+}
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/code/Symbol.java

src/share/classes/com/sun/tools/javac/code/Symbol.java