2225 lines
77 KiB
Java
2225 lines
77 KiB
Java
package lombok.delombok;
|
|
|
|
import com.adjust.sdk.Constants;
|
|
import com.discord.api.permission.Permission;
|
|
import com.discord.models.domain.ModelAuditLogEntry;
|
|
import com.discord.widgets.chat.input.autocomplete.AutocompleteViewModel;
|
|
import com.google.android.material.badge.BadgeDrawable;
|
|
import com.sun.source.tree.Tree;
|
|
import com.sun.tools.javac.tree.DocCommentTable;
|
|
import com.sun.tools.javac.tree.JCTree;
|
|
import com.sun.tools.javac.util.JCDiagnostic;
|
|
import com.sun.tools.javac.util.List;
|
|
import com.sun.tools.javac.util.Name;
|
|
import java.io.IOException;
|
|
import java.io.Writer;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import lombok.javac.CommentInfo;
|
|
import lombok.javac.Javac;
|
|
import lombok.javac.JavacTreeMaker;
|
|
import lombok.javac.PackageName;
|
|
import lombok.permit.Permit;
|
|
/* loaded from: com.discord-118107.apk:lombok/delombok/PrettyPrinter.SCL.lombok */
|
|
public class PrettyPrinter extends JCTree.Visitor {
|
|
private static final Map<JavacTreeMaker.TreeTag, String> OPERATORS;
|
|
private final Writer out;
|
|
private final JCTree.JCCompilationUnit compilationUnit;
|
|
private List<CommentInfo> comments;
|
|
private final int[] textBlockStarts;
|
|
private final FormatPreferences formatPreferences;
|
|
private final Map<JCTree, String> docComments;
|
|
private final DocCommentTable docTable;
|
|
private boolean needsAlign;
|
|
private boolean needsNewLine;
|
|
private boolean needsSpace;
|
|
private boolean aligned;
|
|
private Name __INIT__;
|
|
private Name __VALUE__;
|
|
private Name currentTypeName;
|
|
private static final long DEFAULT = 8796093022208L;
|
|
private static final int PREFIX = 14;
|
|
private static final Method getEndPosition;
|
|
private static final Method storeEnd;
|
|
private static final Map<Class<?>, Map<String, Field>> reflectionCache;
|
|
private static /* synthetic */ int[] $SWITCH_TABLE$lombok$javac$CommentInfo$StartConnection;
|
|
private static /* synthetic */ int[] $SWITCH_TABLE$lombok$javac$CommentInfo$EndConnection;
|
|
private static /* synthetic */ int[] $SWITCH_TABLE$com$sun$source$tree$Tree$Kind;
|
|
private static final String LINE_SEP = System.getProperty("line.separator");
|
|
private static final Method getExtendsClause = getMethod(JCTree.JCClassDecl.class, "getExtendsClause", new Class[0]);
|
|
private int indent = 0;
|
|
private boolean onNewLine = true;
|
|
private boolean innermostArrayBracketsAreVarargs = false;
|
|
private long flagMod = -1;
|
|
private boolean jcAnnotatedTypeInit = false;
|
|
private Class<?> jcAnnotatedTypeClass = null;
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/delombok/PrettyPrinter$UncheckedIOException.SCL.lombok */
|
|
public static final class UncheckedIOException extends RuntimeException {
|
|
UncheckedIOException(IOException iOException) {
|
|
super(toMsg(iOException));
|
|
setStackTrace(iOException.getStackTrace());
|
|
}
|
|
|
|
private static String toMsg(Throwable th) {
|
|
String message = th.getMessage();
|
|
String simpleName = th.getClass().getSimpleName();
|
|
return (message == null || message.isEmpty()) ? simpleName : String.valueOf(simpleName) + ": " + message;
|
|
}
|
|
}
|
|
|
|
static {
|
|
Method method;
|
|
HashMap hashMap = new HashMap();
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("POS"), BadgeDrawable.DEFAULT_EXCEED_MAX_BADGE_NUMBER_SUFFIX);
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("NEG"), "-");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("NOT"), "!");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("COMPL"), "~");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("PREINC"), "++");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("PREDEC"), "--");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("POSTINC"), "++");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("POSTDEC"), "--");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("NULLCHK"), "<*nullchk*>");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("OR"), "||");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("AND"), "&&");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("EQ"), "==");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("NE"), "!=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("LT"), "<");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("GT"), ">");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("LE"), "<=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("GE"), ">=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITOR"), "|");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITXOR"), "^");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITAND"), "&");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("SL"), "<<");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("SR"), ">>");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("USR"), ">>>");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("PLUS"), BadgeDrawable.DEFAULT_EXCEED_MAX_BADGE_NUMBER_SUFFIX);
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MINUS"), "-");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MUL"), "*");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("DIV"), AutocompleteViewModel.COMMAND_DISCOVER_TOKEN);
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MOD"), "%");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITOR_ASG"), "|=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITXOR_ASG"), "^=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("BITAND_ASG"), "&=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("SL_ASG"), "<<=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("SR_ASG"), ">>=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("USR_ASG"), ">>>=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("PLUS_ASG"), "+=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MINUS_ASG"), "-=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MUL_ASG"), "*=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("DIV_ASG"), "/=");
|
|
hashMap.put(JavacTreeMaker.TreeTag.treeTag("MOD_ASG"), "%=");
|
|
OPERATORS = hashMap;
|
|
if (Javac.getJavaCompilerVersion() < 8) {
|
|
getEndPosition = getMethod(JCDiagnostic.DiagnosticPosition.class, "getEndPosition", Map.class);
|
|
storeEnd = getMethod(Map.class, "put", Object.class, Object.class);
|
|
} else {
|
|
getEndPosition = getMethod(JCDiagnostic.DiagnosticPosition.class, "getEndPosition", "com.sun.tools.javac.tree.EndPosTable");
|
|
try {
|
|
try {
|
|
method = Permit.getMethod(Class.forName("com.sun.tools.javac.tree.EndPosTable"), "storeEnd", JCTree.class, Integer.TYPE);
|
|
} catch (NoSuchMethodException unused) {
|
|
try {
|
|
method = Permit.getMethod(Class.forName("com.sun.tools.javac.parser.JavacParser$AbstractEndPosTable"), "storeEnd", JCTree.class, Integer.TYPE);
|
|
} catch (ClassNotFoundException e) {
|
|
throw sneakyThrow(e);
|
|
} catch (NoSuchMethodException e2) {
|
|
throw sneakyThrow(e2);
|
|
}
|
|
}
|
|
storeEnd = method;
|
|
} catch (ClassNotFoundException e3) {
|
|
throw sneakyThrow(e3);
|
|
}
|
|
}
|
|
Permit.setAccessible(getEndPosition);
|
|
Permit.setAccessible(storeEnd);
|
|
reflectionCache = new HashMap();
|
|
}
|
|
|
|
public PrettyPrinter(Writer writer, JCTree.JCCompilationUnit jCCompilationUnit, List<CommentInfo> list, int[] iArr, FormatPreferences formatPreferences) {
|
|
this.out = writer;
|
|
this.comments = list;
|
|
this.textBlockStarts = iArr;
|
|
this.compilationUnit = jCCompilationUnit;
|
|
this.formatPreferences = formatPreferences;
|
|
Object docComments = Javac.getDocComments(this.compilationUnit);
|
|
if (docComments instanceof Map) {
|
|
this.docComments = (Map) docComments;
|
|
this.docTable = null;
|
|
} else if (docComments instanceof DocCommentTable) {
|
|
this.docComments = null;
|
|
this.docTable = (DocCommentTable) docComments;
|
|
} else {
|
|
this.docComments = null;
|
|
this.docTable = null;
|
|
}
|
|
}
|
|
|
|
private int endPos(JCTree jCTree) {
|
|
return Javac.getEndPosition(jCTree, this.compilationUnit);
|
|
}
|
|
|
|
private void align() {
|
|
if (this.onNewLine) {
|
|
for (int i = 0; i < this.indent; i++) {
|
|
try {
|
|
this.out.write(this.formatPreferences.indent());
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
}
|
|
this.onNewLine = false;
|
|
this.aligned = true;
|
|
this.needsAlign = false;
|
|
}
|
|
}
|
|
|
|
private void print(JCTree jCTree) {
|
|
if (jCTree == null) {
|
|
print("/*missing*/");
|
|
return;
|
|
}
|
|
consumeComments(jCTree);
|
|
jCTree.accept(this);
|
|
consumeTrailingComments(endPos(jCTree));
|
|
}
|
|
|
|
private void print(List<? extends JCTree> list, String str) {
|
|
boolean z2 = true;
|
|
JCTree jCTree = null;
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree jCTree2 = (JCTree) it.next();
|
|
if (!suppress(jCTree2)) {
|
|
if (!z2 && str != null && !str.isEmpty()) {
|
|
if ("\n".equals(str)) {
|
|
println(jCTree);
|
|
} else {
|
|
print(str);
|
|
}
|
|
}
|
|
z2 = false;
|
|
print(jCTree2);
|
|
jCTree = jCTree2;
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean suppress(JCTree jCTree) {
|
|
if (jCTree instanceof JCTree.JCBlock) {
|
|
JCTree.JCBlock jCBlock = (JCTree.JCBlock) jCTree;
|
|
return -1 == jCBlock.pos && jCBlock.stats.isEmpty();
|
|
} else if (!(jCTree instanceof JCTree.JCExpressionStatement)) {
|
|
return false;
|
|
} else {
|
|
JCTree.JCMethodInvocation jCMethodInvocation = ((JCTree.JCExpressionStatement) jCTree).expr;
|
|
if (!(jCMethodInvocation instanceof JCTree.JCMethodInvocation)) {
|
|
return false;
|
|
}
|
|
JCTree.JCMethodInvocation jCMethodInvocation2 = jCMethodInvocation;
|
|
if (!jCMethodInvocation2.typeargs.isEmpty() || !jCMethodInvocation2.args.isEmpty() || !(jCMethodInvocation2.meth instanceof JCTree.JCIdent) || jCTree.pos != ((JCTree.JCExpression) jCMethodInvocation).pos) {
|
|
return false;
|
|
}
|
|
return jCMethodInvocation2.meth.name.toString().equals("super");
|
|
}
|
|
}
|
|
|
|
private void print(CharSequence charSequence) {
|
|
boolean z2 = this.needsAlign;
|
|
if (this.needsNewLine && !this.onNewLine) {
|
|
println();
|
|
}
|
|
if (z2 && !this.aligned) {
|
|
align();
|
|
}
|
|
try {
|
|
if (this.needsSpace && !this.onNewLine && !this.aligned) {
|
|
this.out.write(32);
|
|
}
|
|
this.out.write(charSequence.toString());
|
|
this.needsSpace = false;
|
|
this.onNewLine = false;
|
|
this.aligned = false;
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
}
|
|
|
|
private void println() {
|
|
try {
|
|
this.out.write(LINE_SEP);
|
|
this.onNewLine = true;
|
|
this.aligned = false;
|
|
this.needsNewLine = false;
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
}
|
|
|
|
private void println(JCTree jCTree) {
|
|
if (jCTree != null) {
|
|
consumeTrailingComments(endPos(jCTree));
|
|
}
|
|
try {
|
|
this.out.write(LINE_SEP);
|
|
this.onNewLine = true;
|
|
this.aligned = false;
|
|
this.needsNewLine = false;
|
|
} catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
}
|
|
|
|
private void println(CharSequence charSequence) {
|
|
print(charSequence);
|
|
println();
|
|
}
|
|
|
|
private void println(CharSequence charSequence, JCTree jCTree) {
|
|
print(charSequence);
|
|
println(jCTree);
|
|
}
|
|
|
|
private void aPrint(CharSequence charSequence) {
|
|
align();
|
|
print(charSequence);
|
|
}
|
|
|
|
private void aPrintln(CharSequence charSequence) {
|
|
align();
|
|
print(charSequence);
|
|
println();
|
|
}
|
|
|
|
private void aPrintln(CharSequence charSequence, JCTree jCTree) {
|
|
align();
|
|
print(charSequence);
|
|
println(jCTree);
|
|
}
|
|
|
|
private void consumeComments(int i) {
|
|
Object obj = this.comments.head;
|
|
while (true) {
|
|
CommentInfo commentInfo = (CommentInfo) obj;
|
|
if (this.comments.nonEmpty() && commentInfo.pos < i) {
|
|
printComment(commentInfo);
|
|
this.comments = this.comments.tail;
|
|
obj = this.comments.head;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void consumeComments(JCTree jCTree) {
|
|
consumeComments(jCTree.pos);
|
|
}
|
|
|
|
private void consumeTrailingComments(int i) {
|
|
boolean z2 = this.onNewLine;
|
|
CommentInfo commentInfo = (CommentInfo) this.comments.head;
|
|
boolean z3 = false;
|
|
while (this.comments.nonEmpty() && commentInfo.prevEndPos == i && !z3 && commentInfo.start != CommentInfo.StartConnection.ON_NEXT_LINE && commentInfo.start != CommentInfo.StartConnection.START_OF_LINE) {
|
|
i = commentInfo.endPos;
|
|
printComment(commentInfo);
|
|
z3 = commentInfo.end == CommentInfo.EndConnection.ON_NEXT_LINE;
|
|
this.comments = this.comments.tail;
|
|
commentInfo = (CommentInfo) this.comments.head;
|
|
}
|
|
if (!this.onNewLine && z2) {
|
|
println();
|
|
}
|
|
}
|
|
|
|
private String getJavadocFor(JCTree jCTree) {
|
|
if (this.docComments != null) {
|
|
return this.docComments.get(jCTree);
|
|
}
|
|
if (this.docTable != null) {
|
|
return this.docTable.getCommentText(jCTree);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private int dims(JCTree.JCExpression jCExpression) {
|
|
if (jCExpression instanceof JCTree.JCArrayTypeTree) {
|
|
return 1 + dims(((JCTree.JCArrayTypeTree) jCExpression).elemtype);
|
|
}
|
|
if (!isJcAnnotatedType(jCExpression)) {
|
|
return 0;
|
|
}
|
|
JCTree.JCArrayTypeTree jCArrayTypeTree = (JCTree) readObject(jCExpression, "underlyingType", null);
|
|
if (jCArrayTypeTree instanceof JCTree.JCArrayTypeTree) {
|
|
return 1 + dims(jCArrayTypeTree.elemtype);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private void printComment(CommentInfo commentInfo) {
|
|
switch ($SWITCH_TABLE$lombok$javac$CommentInfo$StartConnection()[commentInfo.start.ordinal()]) {
|
|
case 1:
|
|
this.needsNewLine = true;
|
|
this.needsAlign = false;
|
|
break;
|
|
case 2:
|
|
if (this.onNewLine) {
|
|
if (!this.aligned) {
|
|
this.needsAlign = true;
|
|
break;
|
|
}
|
|
} else {
|
|
this.needsNewLine = true;
|
|
this.needsAlign = true;
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
this.needsSpace = false;
|
|
break;
|
|
case 4:
|
|
this.needsSpace = true;
|
|
break;
|
|
}
|
|
if (this.onNewLine && !this.aligned && commentInfo.start != CommentInfo.StartConnection.START_OF_LINE) {
|
|
this.needsAlign = true;
|
|
}
|
|
print(commentInfo.content);
|
|
switch ($SWITCH_TABLE$lombok$javac$CommentInfo$EndConnection()[commentInfo.end.ordinal()]) {
|
|
case 1:
|
|
default:
|
|
return;
|
|
case 2:
|
|
this.needsSpace = true;
|
|
return;
|
|
case 3:
|
|
if (!this.aligned) {
|
|
this.needsNewLine = true;
|
|
this.needsAlign = true;
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void printDocComment(JCTree jCTree) {
|
|
String[] split;
|
|
String javadocFor = getJavadocFor(jCTree);
|
|
if (javadocFor != null) {
|
|
aPrintln("/**");
|
|
boolean z2 = true;
|
|
for (String str : javadocFor.split("\\r?\\n")) {
|
|
if (!z2 || !str.trim().isEmpty()) {
|
|
z2 = false;
|
|
aPrint(" *");
|
|
if (!str.isEmpty() && !Character.isWhitespace(str.charAt(0))) {
|
|
print(" ");
|
|
}
|
|
println(str);
|
|
} else {
|
|
z2 = false;
|
|
}
|
|
}
|
|
aPrintln(" */");
|
|
}
|
|
}
|
|
|
|
private Name name_init(Name name) {
|
|
if (this.__INIT__ == null) {
|
|
this.__INIT__ = name.table.fromChars("<init>".toCharArray(), 0, 6);
|
|
}
|
|
return this.__INIT__;
|
|
}
|
|
|
|
private Name name_value(Name name) {
|
|
if (this.__VALUE__ == null) {
|
|
this.__VALUE__ = name.table.fromChars("value".toCharArray(), 0, 5);
|
|
}
|
|
return this.__VALUE__;
|
|
}
|
|
|
|
public void visitTopLevel(JCTree.JCCompilationUnit jCCompilationUnit) {
|
|
printDocComment(jCCompilationUnit);
|
|
JCTree packageNode = PackageName.getPackageNode(jCCompilationUnit);
|
|
if (packageNode != null) {
|
|
consumeComments((JCTree) jCCompilationUnit);
|
|
aPrint("package ");
|
|
print(packageNode);
|
|
println(";", packageNode);
|
|
}
|
|
boolean z2 = true;
|
|
Iterator it = jCCompilationUnit.defs.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree jCTree = (JCTree) it.next();
|
|
if (jCTree instanceof JCTree.JCImport) {
|
|
if (z2) {
|
|
println();
|
|
}
|
|
z2 = false;
|
|
print(jCTree);
|
|
}
|
|
}
|
|
Iterator it2 = jCCompilationUnit.defs.iterator();
|
|
while (it2.hasNext()) {
|
|
JCTree jCTree2 = (JCTree) it2.next();
|
|
if (!(jCTree2 instanceof JCTree.JCImport)) {
|
|
print(jCTree2);
|
|
}
|
|
}
|
|
consumeComments(Integer.MAX_VALUE);
|
|
}
|
|
|
|
public void visitImport(JCTree.JCImport jCImport) {
|
|
if (jCImport.qualid instanceof JCTree.JCFieldAccess) {
|
|
JCTree.JCFieldAccess jCFieldAccess = jCImport.qualid;
|
|
if (jCFieldAccess.name.length() == 1 && jCFieldAccess.name.contentEquals("*") && (jCFieldAccess.selected instanceof JCTree.JCFieldAccess)) {
|
|
JCTree.JCFieldAccess jCFieldAccess2 = jCFieldAccess.selected;
|
|
if (jCFieldAccess2.name.contentEquals("experimental") && (jCFieldAccess2.selected instanceof JCTree.JCIdent) && jCFieldAccess2.selected.name.contentEquals("lombok")) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
aPrint("import ");
|
|
if (jCImport.staticImport) {
|
|
print("static ");
|
|
}
|
|
print(jCImport.qualid);
|
|
println(";", jCImport);
|
|
}
|
|
|
|
public void visitClassDef(JCTree.JCClassDecl jCClassDecl) {
|
|
println();
|
|
printDocComment(jCClassDecl);
|
|
align();
|
|
print((JCTree) jCClassDecl.mods);
|
|
boolean z2 = (jCClassDecl.mods.flags & 512) != 0;
|
|
boolean z3 = z2 && (jCClassDecl.mods.flags & Permission.MANAGE_MESSAGES) != 0;
|
|
boolean z4 = (jCClassDecl.mods.flags & Permission.EMBED_LINKS) != 0;
|
|
if (z3) {
|
|
print("@interface ");
|
|
} else if (z2) {
|
|
print("interface ");
|
|
} else if (z4) {
|
|
print("enum ");
|
|
} else {
|
|
print("class ");
|
|
}
|
|
print((CharSequence) jCClassDecl.name);
|
|
Name name = this.currentTypeName;
|
|
this.currentTypeName = jCClassDecl.name;
|
|
if (jCClassDecl.typarams.nonEmpty()) {
|
|
print("<");
|
|
print(jCClassDecl.typarams, ", ");
|
|
print(">");
|
|
}
|
|
JCTree extendsClause = getExtendsClause(jCClassDecl);
|
|
if (extendsClause != null) {
|
|
print(" extends ");
|
|
print(extendsClause);
|
|
}
|
|
if (jCClassDecl.implementing.nonEmpty()) {
|
|
print(z2 ? " extends " : " implements ");
|
|
print(jCClassDecl.implementing, ", ");
|
|
}
|
|
println(" {");
|
|
this.indent++;
|
|
printClassMembers(jCClassDecl.defs, z4, z2);
|
|
consumeComments(endPos(jCClassDecl));
|
|
this.indent--;
|
|
aPrintln("}", jCClassDecl);
|
|
this.currentTypeName = name;
|
|
}
|
|
|
|
private void printClassMembers(List<JCTree> list, boolean z2, boolean z3) {
|
|
Class<?> cls = null;
|
|
char c = z2 ? (char) 3 : (char) 0;
|
|
boolean z4 = z2;
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree.JCMethodDecl jCMethodDecl = (JCTree) it.next();
|
|
if (c != 3 || !(jCMethodDecl instanceof JCTree.JCMethodDecl) || (jCMethodDecl.mods.flags & Permission.CREATE_PRIVATE_THREADS) == 0) {
|
|
boolean z5 = z2 && (jCMethodDecl instanceof JCTree.JCVariableDecl) && (((JCTree.JCVariableDecl) jCMethodDecl).mods.flags & Permission.EMBED_LINKS) != 0;
|
|
if (!z5 && z4) {
|
|
z4 = false;
|
|
if (c == 3) {
|
|
align();
|
|
}
|
|
println(";");
|
|
}
|
|
if (z5) {
|
|
if (!(cls == null || cls == JCTree.JCVariableDecl.class)) {
|
|
println();
|
|
}
|
|
switch (c) {
|
|
case 1:
|
|
print(", ");
|
|
break;
|
|
case 2:
|
|
println(",");
|
|
align();
|
|
break;
|
|
}
|
|
print((JCTree) jCMethodDecl);
|
|
JCTree.JCNewClass jCNewClass = ((JCTree.JCVariableDecl) jCMethodDecl).init;
|
|
c = (!(jCNewClass instanceof JCTree.JCNewClass) || jCNewClass.def == null) ? (char) 1 : (char) 2;
|
|
} else if (jCMethodDecl instanceof JCTree.JCVariableDecl) {
|
|
if (!(cls == null || cls == JCTree.JCVariableDecl.class)) {
|
|
println();
|
|
}
|
|
if (z3) {
|
|
this.flagMod = -26L;
|
|
}
|
|
print((JCTree) jCMethodDecl);
|
|
} else if (jCMethodDecl instanceof JCTree.JCMethodDecl) {
|
|
if ((jCMethodDecl.mods.flags & Permission.CREATE_PRIVATE_THREADS) == 0) {
|
|
if (cls != null) {
|
|
println();
|
|
}
|
|
if (z3) {
|
|
this.flagMod = -1026L;
|
|
}
|
|
print((JCTree) jCMethodDecl);
|
|
}
|
|
} else if (jCMethodDecl instanceof JCTree.JCClassDecl) {
|
|
if (cls != null) {
|
|
println();
|
|
}
|
|
if (z3) {
|
|
this.flagMod = -10L;
|
|
}
|
|
print((JCTree) jCMethodDecl);
|
|
} else {
|
|
if (cls != null) {
|
|
println();
|
|
}
|
|
print((JCTree) jCMethodDecl);
|
|
}
|
|
cls = jCMethodDecl.getClass();
|
|
}
|
|
}
|
|
if (z4) {
|
|
if (c == 3) {
|
|
align();
|
|
}
|
|
println(";");
|
|
}
|
|
}
|
|
|
|
public void visitTypeParameter(JCTree.JCTypeParameter jCTypeParameter) {
|
|
List<? extends JCTree> list = (List) readObject(jCTypeParameter, "annotations", List.nil());
|
|
if (!list.isEmpty()) {
|
|
print(list, " ");
|
|
print(" ");
|
|
}
|
|
print((CharSequence) jCTypeParameter.name);
|
|
if (jCTypeParameter.bounds.nonEmpty()) {
|
|
print(" extends ");
|
|
print(jCTypeParameter.bounds, " & ");
|
|
}
|
|
consumeComments((JCTree) jCTypeParameter);
|
|
}
|
|
|
|
public void visitVarDef(JCTree.JCVariableDecl jCVariableDecl) {
|
|
printDocComment(jCVariableDecl);
|
|
align();
|
|
if ((jCVariableDecl.mods.flags & Permission.EMBED_LINKS) != 0) {
|
|
printEnumMember(jCVariableDecl);
|
|
return;
|
|
}
|
|
printAnnotations(jCVariableDecl.mods.annotations, true);
|
|
printModifierKeywords(jCVariableDecl.mods);
|
|
printVarDef0(jCVariableDecl);
|
|
println(";", jCVariableDecl);
|
|
}
|
|
|
|
private void printVarDefInline(JCTree.JCVariableDecl jCVariableDecl) {
|
|
printAnnotations(jCVariableDecl.mods.annotations, false);
|
|
printModifierKeywords(jCVariableDecl.mods);
|
|
printVarDef0(jCVariableDecl);
|
|
}
|
|
|
|
/* JADX WARN: Finally extract failed */
|
|
private void printVarDef0(JCTree.JCVariableDecl jCVariableDecl) {
|
|
try {
|
|
this.innermostArrayBracketsAreVarargs = (jCVariableDecl.mods.flags & Permission.MANAGE_THREADS) != 0;
|
|
if (jCVariableDecl.vartype == null || jCVariableDecl.vartype.pos == -1) {
|
|
print("var");
|
|
} else {
|
|
print((JCTree) jCVariableDecl.vartype);
|
|
}
|
|
this.innermostArrayBracketsAreVarargs = false;
|
|
print(" ");
|
|
print((CharSequence) jCVariableDecl.name);
|
|
if (jCVariableDecl.init != null) {
|
|
print(" = ");
|
|
print((JCTree) jCVariableDecl.init);
|
|
}
|
|
} catch (Throwable th) {
|
|
this.innermostArrayBracketsAreVarargs = false;
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
private void printEnumMember(JCTree.JCVariableDecl jCVariableDecl) {
|
|
printAnnotations(jCVariableDecl.mods.annotations, true);
|
|
print((CharSequence) jCVariableDecl.name);
|
|
if (jCVariableDecl.init instanceof JCTree.JCNewClass) {
|
|
JCTree.JCNewClass jCNewClass = jCVariableDecl.init;
|
|
if (jCNewClass.args != null && jCNewClass.args.nonEmpty()) {
|
|
print("(");
|
|
print(jCNewClass.args, ", ");
|
|
print(")");
|
|
}
|
|
if (jCNewClass.def != null && jCNewClass.def.defs != null) {
|
|
println(" {");
|
|
this.indent++;
|
|
printClassMembers(jCNewClass.def.defs, false, false);
|
|
consumeComments(endPos(jCVariableDecl));
|
|
this.indent--;
|
|
aPrint("}");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void visitTypeApply(JCTree.JCTypeApply jCTypeApply) {
|
|
print((JCTree) jCTypeApply.clazz);
|
|
print("<");
|
|
boolean z2 = this.innermostArrayBracketsAreVarargs;
|
|
this.innermostArrayBracketsAreVarargs = false;
|
|
print(jCTypeApply.arguments, ", ");
|
|
this.innermostArrayBracketsAreVarargs = z2;
|
|
print(">");
|
|
}
|
|
|
|
public void visitWildcard(JCTree.JCWildcard jCWildcard) {
|
|
switch ($SWITCH_TABLE$com$sun$source$tree$Tree$Kind()[jCWildcard.getKind().ordinal()]) {
|
|
case 88:
|
|
default:
|
|
print("?");
|
|
return;
|
|
case 89:
|
|
print("? extends ");
|
|
print(jCWildcard.inner);
|
|
return;
|
|
case 90:
|
|
print("? super ");
|
|
print(jCWildcard.inner);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void visitLiteral(JCTree.JCLiteral jCLiteral) {
|
|
JavacTreeMaker.TypeTag typeTag = JavacTreeMaker.TypeTag.typeTag((JCTree) jCLiteral);
|
|
if (Javac.CTC_INT.equals(typeTag)) {
|
|
print(new StringBuilder().append(jCLiteral.value).toString());
|
|
} else if (Javac.CTC_LONG.equals(typeTag)) {
|
|
print(jCLiteral.value + "L");
|
|
} else if (Javac.CTC_FLOAT.equals(typeTag)) {
|
|
print(jCLiteral.value + "F");
|
|
} else if (Javac.CTC_DOUBLE.equals(typeTag)) {
|
|
print(new StringBuilder().append(jCLiteral.value).toString());
|
|
} else if (Javac.CTC_CHAR.equals(typeTag)) {
|
|
print("'" + quoteChar((char) ((Number) jCLiteral.value).intValue()) + "'");
|
|
} else if (Javac.CTC_BOOLEAN.equals(typeTag)) {
|
|
print(((Number) jCLiteral.value).intValue() == 1 ? "true" : "false");
|
|
} else if (Javac.CTC_BOT.equals(typeTag)) {
|
|
print("null");
|
|
} else if (Arrays.binarySearch(this.textBlockStarts, jCLiteral.pos) < 0) {
|
|
print("\"" + quoteChars(jCLiteral.value.toString()) + "\"");
|
|
} else {
|
|
printTextBlock(jCLiteral.value.toString());
|
|
}
|
|
}
|
|
|
|
private void printTextBlock(String str) {
|
|
println("\"\"\"");
|
|
this.needsAlign = true;
|
|
this.indent++;
|
|
StringBuilder sb = new StringBuilder();
|
|
boolean z2 = true;
|
|
for (int i = 0; i < str.length(); i++) {
|
|
char charAt = str.charAt(i);
|
|
if (!(charAt == ' ' || charAt == '\t')) {
|
|
z2 = false;
|
|
}
|
|
if (charAt == '\n') {
|
|
println(sb);
|
|
sb.setLength(0);
|
|
this.needsAlign = true;
|
|
z2 = true;
|
|
} else if (charAt != '\t' || !z2) {
|
|
sb.append(quoteChar(str.charAt(i)));
|
|
} else {
|
|
sb.append("\t");
|
|
}
|
|
}
|
|
print(sb);
|
|
print("\"\"\"");
|
|
this.indent--;
|
|
}
|
|
|
|
public void visitMethodDef(JCTree.JCMethodDecl jCMethodDecl) {
|
|
boolean z2 = jCMethodDecl.name == name_init(jCMethodDecl.name);
|
|
if (!z2 || (jCMethodDecl.mods.flags & Permission.CREATE_PRIVATE_THREADS) == 0) {
|
|
printDocComment(jCMethodDecl);
|
|
align();
|
|
print((JCTree) jCMethodDecl.mods);
|
|
if (jCMethodDecl.typarams != null && jCMethodDecl.typarams.nonEmpty()) {
|
|
print("<");
|
|
print(jCMethodDecl.typarams, ", ");
|
|
print("> ");
|
|
}
|
|
if (z2) {
|
|
print(this.currentTypeName == null ? "<init>" : this.currentTypeName);
|
|
} else {
|
|
print((JCTree) jCMethodDecl.restype);
|
|
print(" ");
|
|
print((CharSequence) jCMethodDecl.name);
|
|
}
|
|
boolean z3 = true;
|
|
print("(");
|
|
JCTree.JCVariableDecl jCVariableDecl = (JCTree.JCVariableDecl) readObject(jCMethodDecl, "recvparam", null);
|
|
if (jCVariableDecl != null) {
|
|
printVarDefInline(jCVariableDecl);
|
|
z3 = false;
|
|
}
|
|
Iterator it = jCMethodDecl.params.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree.JCVariableDecl jCVariableDecl2 = (JCTree.JCVariableDecl) it.next();
|
|
if (!z3) {
|
|
print(", ");
|
|
}
|
|
z3 = false;
|
|
printVarDefInline(jCVariableDecl2);
|
|
}
|
|
print(")");
|
|
if (jCMethodDecl.thrown.nonEmpty()) {
|
|
print(" throws ");
|
|
print(jCMethodDecl.thrown, ", ");
|
|
}
|
|
if (jCMethodDecl.defaultValue != null) {
|
|
print(" default ");
|
|
print((JCTree) jCMethodDecl.defaultValue);
|
|
}
|
|
if (jCMethodDecl.body != null) {
|
|
print(" ");
|
|
print((JCTree) jCMethodDecl.body);
|
|
return;
|
|
}
|
|
println(";", jCMethodDecl);
|
|
}
|
|
}
|
|
|
|
public void visitSkip(JCTree.JCSkip jCSkip) {
|
|
if (this.onNewLine && !this.aligned) {
|
|
align();
|
|
}
|
|
println(";");
|
|
}
|
|
|
|
public void visitAnnotation(JCTree.JCAnnotation jCAnnotation) {
|
|
print("@");
|
|
print(jCAnnotation.annotationType);
|
|
if (!jCAnnotation.args.isEmpty()) {
|
|
print("(");
|
|
boolean z2 = false;
|
|
if (jCAnnotation.args.length() == 1 && (jCAnnotation.args.get(0) instanceof JCTree.JCAssign)) {
|
|
JCTree.JCAssign jCAssign = (JCTree.JCAssign) jCAnnotation.args.get(0);
|
|
JCTree.JCIdent jCIdent = jCAssign.lhs instanceof JCTree.JCIdent ? (JCTree.JCIdent) jCAssign.lhs : null;
|
|
if (jCIdent != null && jCIdent.name == name_value(jCIdent.name)) {
|
|
print((JCTree) jCAssign.rhs);
|
|
z2 = true;
|
|
}
|
|
}
|
|
if (!z2) {
|
|
print(jCAnnotation.args, ", ");
|
|
}
|
|
print(")");
|
|
}
|
|
}
|
|
|
|
public void visitTypeArray(JCTree.JCArrayTypeTree jCArrayTypeTree) {
|
|
printTypeArray0(jCArrayTypeTree);
|
|
}
|
|
|
|
public void visitNewArray(JCTree.JCNewArray jCNewArray) {
|
|
JCTree.JCExpression jCExpression = jCNewArray.elemtype;
|
|
int i = 0;
|
|
if (jCExpression != null) {
|
|
print("new ");
|
|
while (jCExpression instanceof JCTree.JCArrayTypeTree) {
|
|
i++;
|
|
jCExpression = ((JCTree.JCArrayTypeTree) jCExpression).elemtype;
|
|
}
|
|
print((JCTree) jCExpression);
|
|
Iterator it = jCNewArray.dims.iterator();
|
|
while (it.hasNext()) {
|
|
print("[");
|
|
print((JCTree) ((JCTree.JCExpression) it.next()));
|
|
print("]");
|
|
}
|
|
}
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
print("[]");
|
|
}
|
|
if (jCNewArray.elems != null) {
|
|
if (jCExpression != null) {
|
|
print("[] ");
|
|
}
|
|
print("{");
|
|
print(jCNewArray.elems, ", ");
|
|
print("}");
|
|
}
|
|
}
|
|
|
|
public void visitNewClass(JCTree.JCNewClass jCNewClass) {
|
|
if (jCNewClass.encl != null) {
|
|
print((JCTree) jCNewClass.encl);
|
|
print(".");
|
|
}
|
|
boolean z2 = jCNewClass.args.nonEmpty() && (jCNewClass.args.head instanceof JCTree.JCUnary) && ((JCTree.JCExpression) jCNewClass.args.head).toString().startsWith("<*nullchk*>");
|
|
if (z2) {
|
|
print((JCTree) ((JCTree.JCUnary) jCNewClass.args.head).arg);
|
|
print(".");
|
|
}
|
|
print("new ");
|
|
if (!jCNewClass.typeargs.isEmpty()) {
|
|
print("<");
|
|
print(jCNewClass.typeargs, ", ");
|
|
print(">");
|
|
}
|
|
print((JCTree) jCNewClass.clazz);
|
|
print("(");
|
|
if (z2) {
|
|
print(jCNewClass.args.tail, ", ");
|
|
} else {
|
|
print(jCNewClass.args, ", ");
|
|
}
|
|
print(")");
|
|
if (jCNewClass.def != null) {
|
|
Name name = this.currentTypeName;
|
|
this.currentTypeName = null;
|
|
println(" {");
|
|
this.indent++;
|
|
print(jCNewClass.def.defs, "");
|
|
this.indent--;
|
|
aPrint("}");
|
|
this.currentTypeName = name;
|
|
}
|
|
}
|
|
|
|
public void visitIndexed(JCTree.JCArrayAccess jCArrayAccess) {
|
|
print((JCTree) jCArrayAccess.indexed);
|
|
print("[");
|
|
print((JCTree) jCArrayAccess.index);
|
|
print("]");
|
|
}
|
|
|
|
public void visitTypeIdent(JCTree.JCPrimitiveTypeTree jCPrimitiveTypeTree) {
|
|
JavacTreeMaker.TypeTag typeTag = JavacTreeMaker.TypeTag.typeTag((JCTree) jCPrimitiveTypeTree);
|
|
if (Javac.CTC_BYTE.equals(typeTag)) {
|
|
print("byte");
|
|
} else if (Javac.CTC_CHAR.equals(typeTag)) {
|
|
print("char");
|
|
} else if (Javac.CTC_SHORT.equals(typeTag)) {
|
|
print("short");
|
|
} else if (Javac.CTC_INT.equals(typeTag)) {
|
|
print("int");
|
|
} else if (Javac.CTC_LONG.equals(typeTag)) {
|
|
print(Constants.LONG);
|
|
} else if (Javac.CTC_FLOAT.equals(typeTag)) {
|
|
print("float");
|
|
} else if (Javac.CTC_DOUBLE.equals(typeTag)) {
|
|
print("double");
|
|
} else if (Javac.CTC_BOOLEAN.equals(typeTag)) {
|
|
print("boolean");
|
|
} else if (Javac.CTC_VOID.equals(typeTag)) {
|
|
print("void");
|
|
} else {
|
|
print("error");
|
|
}
|
|
}
|
|
|
|
public void visitLabelled(JCTree.JCLabeledStatement jCLabeledStatement) {
|
|
aPrint(jCLabeledStatement.label);
|
|
print(":");
|
|
if ((jCLabeledStatement.body instanceof JCTree.JCSkip) || suppress(jCLabeledStatement)) {
|
|
println(" ;", jCLabeledStatement);
|
|
} else if (jCLabeledStatement.body instanceof JCTree.JCBlock) {
|
|
print(" ");
|
|
print((JCTree) jCLabeledStatement.body);
|
|
} else {
|
|
println((JCTree) jCLabeledStatement);
|
|
print((JCTree) jCLabeledStatement.body);
|
|
}
|
|
}
|
|
|
|
public void visitModifiers(JCTree.JCModifiers jCModifiers) {
|
|
printAnnotations(jCModifiers.annotations, true);
|
|
printModifierKeywords(jCModifiers);
|
|
}
|
|
|
|
private void printAnnotations(List<JCTree.JCAnnotation> list, boolean z2) {
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
print((JCTree) ((JCTree.JCAnnotation) it.next()));
|
|
if (z2) {
|
|
println();
|
|
align();
|
|
} else {
|
|
print(" ");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void printModifierKeywords(JCTree.JCModifiers jCModifiers) {
|
|
long j = this.flagMod & jCModifiers.flags;
|
|
this.flagMod = -1L;
|
|
if ((j & Permission.SEND_TTS_MESSAGES) != 0) {
|
|
print("/* synthetic */ ");
|
|
}
|
|
if ((j & 1) != 0) {
|
|
print("public ");
|
|
}
|
|
if ((j & 2) != 0) {
|
|
print("private ");
|
|
}
|
|
if ((j & 4) != 0) {
|
|
print("protected ");
|
|
}
|
|
if ((j & 8) != 0) {
|
|
print("static ");
|
|
}
|
|
if ((j & 16) != 0) {
|
|
print("final ");
|
|
}
|
|
if ((j & 32) != 0) {
|
|
print("synchronized ");
|
|
}
|
|
if ((j & 64) != 0) {
|
|
print("volatile ");
|
|
}
|
|
if ((j & 128) != 0) {
|
|
print("transient ");
|
|
}
|
|
if ((j & 256) != 0) {
|
|
print("native ");
|
|
}
|
|
if ((j & Permission.VIEW_CHANNEL) != 0) {
|
|
print("abstract ");
|
|
}
|
|
if ((j & Permission.SEND_MESSAGES) != 0) {
|
|
print("strictfp ");
|
|
}
|
|
if ((j & DEFAULT) != 0 && (j & 512) == 0) {
|
|
print("default ");
|
|
}
|
|
}
|
|
|
|
public void visitSelect(JCTree.JCFieldAccess jCFieldAccess) {
|
|
print((JCTree) jCFieldAccess.selected);
|
|
print(".");
|
|
print((CharSequence) jCFieldAccess.name);
|
|
}
|
|
|
|
public void visitIdent(JCTree.JCIdent jCIdent) {
|
|
print((CharSequence) jCIdent.name);
|
|
}
|
|
|
|
public void visitApply(JCTree.JCMethodInvocation jCMethodInvocation) {
|
|
if (!jCMethodInvocation.typeargs.nonEmpty()) {
|
|
print((JCTree) jCMethodInvocation.meth);
|
|
} else if (jCMethodInvocation.meth instanceof JCTree.JCFieldAccess) {
|
|
JCTree.JCFieldAccess jCFieldAccess = jCMethodInvocation.meth;
|
|
print((JCTree) jCFieldAccess.selected);
|
|
print(".<");
|
|
print(jCMethodInvocation.typeargs, ", ");
|
|
print(">");
|
|
print((CharSequence) jCFieldAccess.name);
|
|
} else {
|
|
print("<");
|
|
print(jCMethodInvocation.typeargs, ", ");
|
|
print(">");
|
|
print((JCTree) jCMethodInvocation.meth);
|
|
}
|
|
print("(");
|
|
print(jCMethodInvocation.args, ", ");
|
|
print(")");
|
|
}
|
|
|
|
public void visitAssert(JCTree.JCAssert jCAssert) {
|
|
aPrint("assert ");
|
|
print((JCTree) jCAssert.cond);
|
|
if (jCAssert.detail != null) {
|
|
print(" : ");
|
|
print((JCTree) jCAssert.detail);
|
|
}
|
|
println(";", jCAssert);
|
|
}
|
|
|
|
public void visitAssign(JCTree.JCAssign jCAssign) {
|
|
print((JCTree) jCAssign.lhs);
|
|
print(" = ");
|
|
print((JCTree) jCAssign.rhs);
|
|
}
|
|
|
|
public void visitAssignop(JCTree.JCAssignOp jCAssignOp) {
|
|
print((JCTree) jCAssignOp.lhs);
|
|
print(" " + operator(JavacTreeMaker.TreeTag.treeTag((JCTree) jCAssignOp)) + " ");
|
|
print((JCTree) jCAssignOp.rhs);
|
|
}
|
|
|
|
public void visitUnary(JCTree.JCUnary jCUnary) {
|
|
String operator = operator(JavacTreeMaker.TreeTag.treeTag((JCTree) jCUnary));
|
|
if (JavacTreeMaker.TreeTag.treeTag((JCTree) jCUnary).getOperatorPrecedenceLevel() == 14) {
|
|
print(operator);
|
|
print((JCTree) jCUnary.arg);
|
|
return;
|
|
}
|
|
print((JCTree) jCUnary.arg);
|
|
print(operator);
|
|
}
|
|
|
|
public void visitBinary(JCTree.JCBinary jCBinary) {
|
|
String operator = operator(JavacTreeMaker.TreeTag.treeTag((JCTree) jCBinary));
|
|
print((JCTree) jCBinary.lhs);
|
|
print(" ");
|
|
print(operator);
|
|
print(" ");
|
|
print((JCTree) jCBinary.rhs);
|
|
}
|
|
|
|
public void visitTypeTest(JCTree.JCInstanceOf jCInstanceOf) {
|
|
print((JCTree) jCInstanceOf.expr);
|
|
print(" instanceof ");
|
|
JCTree jCTree = (JCTree) readObject(jCInstanceOf, "clazz", null);
|
|
if (jCTree == null) {
|
|
jCTree = (JCTree) readObject(jCInstanceOf, "pattern", null);
|
|
}
|
|
print(jCTree);
|
|
}
|
|
|
|
public void visitTypeCast(JCTree.JCTypeCast jCTypeCast) {
|
|
print("(");
|
|
print(jCTypeCast.clazz);
|
|
print(") ");
|
|
print((JCTree) jCTypeCast.expr);
|
|
}
|
|
|
|
public void visitBlock(JCTree.JCBlock jCBlock) {
|
|
if (jCBlock.pos != -1 || !jCBlock.stats.isEmpty()) {
|
|
if (this.onNewLine) {
|
|
align();
|
|
}
|
|
if ((jCBlock.flags & 8) != 0) {
|
|
print("static ");
|
|
}
|
|
println("{");
|
|
this.indent++;
|
|
print(jCBlock.stats, "");
|
|
consumeComments(endPos(jCBlock));
|
|
this.indent--;
|
|
aPrintln("}", jCBlock);
|
|
}
|
|
}
|
|
|
|
public void visitBreak(JCTree.JCBreak jCBreak) {
|
|
aPrint("break");
|
|
JCTree.JCExpression jCExpression = (JCTree.JCExpression) readObject(jCBreak, "value", null);
|
|
if (jCExpression != null) {
|
|
print(" ");
|
|
print((JCTree) jCExpression);
|
|
} else {
|
|
Name name = (Name) readObject(jCBreak, "label", null);
|
|
if (name != null) {
|
|
print(" ");
|
|
print((CharSequence) name);
|
|
}
|
|
}
|
|
println(";", jCBreak);
|
|
}
|
|
|
|
public void visitContinue(JCTree.JCContinue jCContinue) {
|
|
aPrint("continue");
|
|
if (jCContinue.label != null) {
|
|
print(" ");
|
|
print((CharSequence) jCContinue.label);
|
|
}
|
|
println(";", jCContinue);
|
|
}
|
|
|
|
public void visitConditional(JCTree.JCConditional jCConditional) {
|
|
print((JCTree) jCConditional.cond);
|
|
print(" ? ");
|
|
print((JCTree) jCConditional.truepart);
|
|
print(" : ");
|
|
print((JCTree) jCConditional.falsepart);
|
|
}
|
|
|
|
public void visitParens(JCTree.JCParens jCParens) {
|
|
print("(");
|
|
print((JCTree) jCParens.expr);
|
|
print(")");
|
|
}
|
|
|
|
public void visitReturn(JCTree.JCReturn jCReturn) {
|
|
aPrint("return");
|
|
if (jCReturn.expr != null) {
|
|
print(" ");
|
|
print((JCTree) jCReturn.expr);
|
|
}
|
|
println(";", jCReturn);
|
|
}
|
|
|
|
public void visitThrow(JCTree.JCThrow jCThrow) {
|
|
aPrint("throw ");
|
|
print((JCTree) jCThrow.expr);
|
|
println(";", jCThrow);
|
|
}
|
|
|
|
public void visitWhileLoop(JCTree.JCWhileLoop jCWhileLoop) {
|
|
aPrint("while ");
|
|
if (jCWhileLoop.cond instanceof JCTree.JCParens) {
|
|
print((JCTree) jCWhileLoop.cond);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCWhileLoop.cond);
|
|
print(")");
|
|
}
|
|
print(" ");
|
|
print((JCTree) jCWhileLoop.body);
|
|
}
|
|
|
|
public void visitForLoop(JCTree.JCForLoop jCForLoop) {
|
|
aPrint("for (");
|
|
if (jCForLoop.init.nonEmpty()) {
|
|
if (jCForLoop.init.head instanceof JCTree.JCVariableDecl) {
|
|
boolean z2 = true;
|
|
int i = 0;
|
|
Iterator it = jCForLoop.init.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree.JCVariableDecl jCVariableDecl = (JCTree.JCVariableDecl) ((JCTree.JCStatement) it.next());
|
|
if (z2) {
|
|
printVarDefInline(jCVariableDecl);
|
|
i = dims(jCVariableDecl.vartype);
|
|
} else {
|
|
print(", ");
|
|
print((CharSequence) jCVariableDecl.name);
|
|
int dims = dims(jCVariableDecl.vartype) - i;
|
|
for (int i2 = 0; i2 < dims; i2++) {
|
|
print("[]");
|
|
}
|
|
if (jCVariableDecl.init != null) {
|
|
print(" = ");
|
|
print((JCTree) jCVariableDecl.init);
|
|
}
|
|
}
|
|
z2 = false;
|
|
}
|
|
} else {
|
|
boolean z3 = true;
|
|
Iterator it2 = jCForLoop.init.iterator();
|
|
while (it2.hasNext()) {
|
|
JCTree.JCExpressionStatement jCExpressionStatement = (JCTree.JCStatement) it2.next();
|
|
if (!z3) {
|
|
print(", ");
|
|
}
|
|
z3 = false;
|
|
print((JCTree) jCExpressionStatement.expr);
|
|
}
|
|
}
|
|
}
|
|
print("; ");
|
|
if (jCForLoop.cond != null) {
|
|
print((JCTree) jCForLoop.cond);
|
|
}
|
|
print("; ");
|
|
boolean z4 = true;
|
|
Iterator it3 = jCForLoop.step.iterator();
|
|
while (it3.hasNext()) {
|
|
JCTree.JCExpressionStatement jCExpressionStatement2 = (JCTree.JCExpressionStatement) it3.next();
|
|
if (!z4) {
|
|
print(", ");
|
|
}
|
|
z4 = false;
|
|
print((JCTree) jCExpressionStatement2.expr);
|
|
}
|
|
print(") ");
|
|
print((JCTree) jCForLoop.body);
|
|
}
|
|
|
|
public void visitForeachLoop(JCTree.JCEnhancedForLoop jCEnhancedForLoop) {
|
|
aPrint("for (");
|
|
printVarDefInline(jCEnhancedForLoop.var);
|
|
print(" : ");
|
|
print((JCTree) jCEnhancedForLoop.expr);
|
|
print(") ");
|
|
print((JCTree) jCEnhancedForLoop.body);
|
|
}
|
|
|
|
public void visitIf(JCTree.JCIf jCIf) {
|
|
aPrint("if ");
|
|
if (jCIf.cond instanceof JCTree.JCParens) {
|
|
print((JCTree) jCIf.cond);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCIf.cond);
|
|
print(")");
|
|
}
|
|
print(" ");
|
|
if (jCIf.thenpart instanceof JCTree.JCBlock) {
|
|
println("{");
|
|
this.indent++;
|
|
print(jCIf.thenpart.stats, "");
|
|
this.indent--;
|
|
if (jCIf.elsepart == null) {
|
|
aPrintln("}", jCIf);
|
|
} else {
|
|
aPrint("}");
|
|
}
|
|
} else {
|
|
print((JCTree) jCIf.thenpart);
|
|
}
|
|
if (jCIf.elsepart != null) {
|
|
aPrint(" else ");
|
|
print((JCTree) jCIf.elsepart);
|
|
}
|
|
}
|
|
|
|
public void visitExec(JCTree.JCExpressionStatement jCExpressionStatement) {
|
|
align();
|
|
print((JCTree) jCExpressionStatement.expr);
|
|
println(";", jCExpressionStatement);
|
|
}
|
|
|
|
public void visitDoLoop(JCTree.JCDoWhileLoop jCDoWhileLoop) {
|
|
aPrint("do ");
|
|
if (jCDoWhileLoop.body instanceof JCTree.JCBlock) {
|
|
println("{");
|
|
this.indent++;
|
|
print(jCDoWhileLoop.body.stats, "");
|
|
this.indent--;
|
|
aPrint("}");
|
|
} else {
|
|
print((JCTree) jCDoWhileLoop.body);
|
|
}
|
|
print(" while ");
|
|
if (jCDoWhileLoop.cond instanceof JCTree.JCParens) {
|
|
print((JCTree) jCDoWhileLoop.cond);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCDoWhileLoop.cond);
|
|
print(")");
|
|
}
|
|
println(";", jCDoWhileLoop);
|
|
}
|
|
|
|
public void visitSynchronized(JCTree.JCSynchronized jCSynchronized) {
|
|
aPrint("synchronized ");
|
|
if (jCSynchronized.lock instanceof JCTree.JCParens) {
|
|
print((JCTree) jCSynchronized.lock);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCSynchronized.lock);
|
|
print(")");
|
|
}
|
|
print(" ");
|
|
print((JCTree) jCSynchronized.body);
|
|
}
|
|
|
|
public void visitCase(JCTree.JCCase jCCase) {
|
|
List<? extends JCTree> list = (List) readObject(jCCase, "pats", null);
|
|
if (list == null) {
|
|
JCTree.JCExpression jCExpression = (JCTree.JCExpression) readObject(jCCase, "pat", null);
|
|
list = jCExpression == null ? List.nil() : List.of(jCExpression);
|
|
}
|
|
if (list.isEmpty()) {
|
|
aPrint("default");
|
|
} else {
|
|
aPrint("case ");
|
|
print(list, ", ");
|
|
}
|
|
Enum r0 = (Enum) readObject(jCCase, "caseKind", null);
|
|
if (r0 == null || !r0.name().equalsIgnoreCase("RULE")) {
|
|
println(": ");
|
|
this.indent++;
|
|
print(jCCase.stats, "");
|
|
this.indent--;
|
|
return;
|
|
}
|
|
print(" -> ");
|
|
if (jCCase.stats.head instanceof JCTree.JCBreak) {
|
|
print((JCTree) ((JCTree.JCExpression) readObject((JCTree.JCBreak) jCCase.stats.head, "value", null)));
|
|
print(";");
|
|
this.needsNewLine = true;
|
|
this.needsAlign = true;
|
|
} else if (((JCTree.JCStatement) jCCase.stats.head).getClass().getName().endsWith("$JCYield")) {
|
|
print((JCTree) ((JCTree.JCExpression) readObject((JCTree) jCCase.stats.head, "value", null)));
|
|
print(";");
|
|
this.needsNewLine = true;
|
|
this.needsAlign = true;
|
|
} else {
|
|
print((JCTree) jCCase.stats.head);
|
|
if (jCCase.stats.head instanceof JCTree.JCBlock) {
|
|
this.needsNewLine = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void visitCatch(JCTree.JCCatch jCCatch) {
|
|
print(" catch (");
|
|
print((JCTree) jCCatch.param);
|
|
print(") ");
|
|
print((JCTree) jCCatch.body);
|
|
}
|
|
|
|
public void visitSwitch(JCTree.JCSwitch jCSwitch) {
|
|
aPrint("switch ");
|
|
if (jCSwitch.selector instanceof JCTree.JCParens) {
|
|
print((JCTree) jCSwitch.selector);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCSwitch.selector);
|
|
print(")");
|
|
}
|
|
println(" {");
|
|
boolean isCaseRuleStyle = isCaseRuleStyle((JCTree.JCCase) jCSwitch.cases.head);
|
|
if (isCaseRuleStyle) {
|
|
this.indent++;
|
|
}
|
|
print(jCSwitch.cases, "");
|
|
if (isCaseRuleStyle) {
|
|
this.indent--;
|
|
}
|
|
aPrintln("}", jCSwitch);
|
|
}
|
|
|
|
void printSwitchExpression(JCTree jCTree) {
|
|
aPrint("switch ");
|
|
JCTree.JCExpression jCExpression = (JCTree.JCExpression) readObject(jCTree, "selector", null);
|
|
if (jCExpression instanceof JCTree.JCParens) {
|
|
print((JCTree) jCExpression);
|
|
} else {
|
|
print("(");
|
|
print((JCTree) jCExpression);
|
|
print(")");
|
|
}
|
|
println(" {");
|
|
List<? extends JCTree> list = (List) readObject(jCTree, "cases", null);
|
|
boolean isCaseRuleStyle = isCaseRuleStyle((JCTree.JCCase) list.head);
|
|
if (isCaseRuleStyle) {
|
|
this.indent++;
|
|
}
|
|
print(list, "");
|
|
if (isCaseRuleStyle) {
|
|
this.indent--;
|
|
}
|
|
aPrint("}");
|
|
}
|
|
|
|
void printYieldExpression(JCTree jCTree) {
|
|
aPrint("yield ");
|
|
print((JCTree) ((JCTree.JCExpression) readObject(jCTree, "value", null)));
|
|
println(";", jCTree);
|
|
}
|
|
|
|
void printBindingPattern(JCTree jCTree) {
|
|
print((JCTree) ((JCTree.JCExpression) readObject(jCTree, "vartype", null)));
|
|
print(" ");
|
|
print((CharSequence) ((Name) readObject(jCTree, ModelAuditLogEntry.CHANGE_KEY_NAME, null)));
|
|
}
|
|
|
|
public void visitTry(JCTree.JCTry jCTry) {
|
|
aPrint("try ");
|
|
List list = (List) readObject(jCTry, "resources", List.nil());
|
|
int length = list.length();
|
|
switch (length) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
print("(");
|
|
JCTree jCTree = (JCTree) list.get(0);
|
|
if (jCTree instanceof JCTree.JCVariableDecl) {
|
|
this.flagMod = -17L;
|
|
printVarDefInline((JCTree.JCVariableDecl) jCTree);
|
|
} else {
|
|
print(jCTree);
|
|
}
|
|
print(") ");
|
|
break;
|
|
default:
|
|
println("(");
|
|
this.indent++;
|
|
int i = 0;
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
Object next = it.next();
|
|
align();
|
|
if (next instanceof JCTree.JCVariableDecl) {
|
|
this.flagMod = -17L;
|
|
printVarDefInline((JCTree.JCVariableDecl) next);
|
|
} else {
|
|
print((JCTree) next);
|
|
}
|
|
i++;
|
|
if (i == length) {
|
|
print(") ");
|
|
} else {
|
|
println(";", (JCTree) next);
|
|
}
|
|
}
|
|
this.indent--;
|
|
break;
|
|
}
|
|
println("{");
|
|
this.indent++;
|
|
Iterator it2 = jCTry.body.stats.iterator();
|
|
while (it2.hasNext()) {
|
|
print((JCTree) ((JCTree.JCStatement) it2.next()));
|
|
}
|
|
this.indent--;
|
|
aPrint("}");
|
|
Iterator it3 = jCTry.catchers.iterator();
|
|
while (it3.hasNext()) {
|
|
printCatch((JCTree.JCCatch) it3.next());
|
|
}
|
|
if (jCTry.finalizer != null) {
|
|
println(" finally {");
|
|
this.indent++;
|
|
Iterator it4 = jCTry.finalizer.stats.iterator();
|
|
while (it4.hasNext()) {
|
|
print((JCTree) ((JCTree.JCStatement) it4.next()));
|
|
}
|
|
this.indent--;
|
|
aPrint("}");
|
|
}
|
|
println((JCTree) jCTry);
|
|
}
|
|
|
|
private void printCatch(JCTree.JCCatch jCCatch) {
|
|
print(" catch (");
|
|
printVarDefInline(jCCatch.param);
|
|
println(") {");
|
|
this.indent++;
|
|
Iterator it = jCCatch.body.stats.iterator();
|
|
while (it.hasNext()) {
|
|
print((JCTree) ((JCTree.JCStatement) it.next()));
|
|
}
|
|
this.indent--;
|
|
aPrint("}");
|
|
}
|
|
|
|
public void visitErroneous(JCTree.JCErroneous jCErroneous) {
|
|
print("(ERROR)");
|
|
}
|
|
|
|
private static String operator(JavacTreeMaker.TreeTag treeTag) {
|
|
String str = OPERATORS.get(treeTag);
|
|
return str == null ? "(?op?)" : str;
|
|
}
|
|
|
|
private static String quoteChars(String str) {
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int i = 0; i < str.length(); i++) {
|
|
sb.append(quoteChar(str.charAt(i)));
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private static String quoteChar(char c) {
|
|
switch (c) {
|
|
case '\b':
|
|
return "\\b";
|
|
case '\t':
|
|
return "\\t";
|
|
case '\n':
|
|
return "\\n";
|
|
case '\f':
|
|
return "\\f";
|
|
case '\r':
|
|
return "\\r";
|
|
case '\"':
|
|
return "\\\"";
|
|
case '\'':
|
|
return "\\'";
|
|
case '\\':
|
|
return "\\\\";
|
|
default:
|
|
return c < ' ' ? String.format("\\%03o", Integer.valueOf(c)) : String.valueOf(c);
|
|
}
|
|
}
|
|
|
|
private static Method getMethod(Class<?> cls, String str, Class<?>... clsArr) {
|
|
try {
|
|
return Permit.getMethod(cls, str, clsArr);
|
|
} catch (NoSuchMethodException e) {
|
|
throw sneakyThrow(e);
|
|
}
|
|
}
|
|
|
|
private static Method getMethod(Class<?> cls, String str, String... strArr) {
|
|
try {
|
|
Class[] clsArr = new Class[strArr.length];
|
|
for (int i = 0; i < strArr.length; i++) {
|
|
clsArr[i] = Class.forName(strArr[i]);
|
|
}
|
|
return Permit.getMethod(cls, str, clsArr);
|
|
} catch (ClassNotFoundException e) {
|
|
throw sneakyThrow(e);
|
|
} catch (NoSuchMethodException e2) {
|
|
throw sneakyThrow(e2);
|
|
}
|
|
}
|
|
|
|
public static JCTree getExtendsClause(JCTree.JCClassDecl jCClassDecl) {
|
|
try {
|
|
return (JCTree) getExtendsClause.invoke(jCClassDecl, new Object[0]);
|
|
} catch (IllegalAccessException e) {
|
|
throw sneakyThrow(e);
|
|
} catch (InvocationTargetException e2) {
|
|
throw sneakyThrow(e2.getCause());
|
|
}
|
|
}
|
|
|
|
static RuntimeException sneakyThrow(Throwable th) {
|
|
if (th == null) {
|
|
throw new NullPointerException("t");
|
|
}
|
|
sneakyThrow0(th);
|
|
return null;
|
|
}
|
|
|
|
private static <T extends Throwable> void sneakyThrow0(Throwable th) throws Throwable {
|
|
throw th;
|
|
}
|
|
|
|
private <T> T readObject(JCTree jCTree, String str, T t) {
|
|
Class<?> cls = jCTree.getClass();
|
|
Map<String, Field> map = reflectionCache.get(cls);
|
|
if (map == null) {
|
|
Map<Class<?>, Map<String, Field>> map2 = reflectionCache;
|
|
HashMap hashMap = new HashMap();
|
|
map = hashMap;
|
|
map2.put(cls, hashMap);
|
|
}
|
|
Field field = map.get(str);
|
|
if (field == null) {
|
|
try {
|
|
field = Permit.getField(cls, str);
|
|
map.put(str, field);
|
|
} catch (Exception unused) {
|
|
return t;
|
|
}
|
|
}
|
|
try {
|
|
return (T) field.get(jCTree);
|
|
} catch (Exception unused2) {
|
|
return t;
|
|
}
|
|
}
|
|
|
|
public void visitTypeBoundKind(JCTree.TypeBoundKind typeBoundKind) {
|
|
print(String.valueOf(typeBoundKind.kind));
|
|
}
|
|
|
|
public void visitTree(JCTree jCTree) {
|
|
String name = jCTree.getClass().getName();
|
|
if (name.endsWith("$JCTypeUnion")) {
|
|
print((List) readObject(jCTree, "alternatives", List.nil()), " | ");
|
|
} else if (name.endsWith("$JCTypeIntersection")) {
|
|
print((List) readObject(jCTree, "bounds", List.nil()), " & ");
|
|
} else if (name.endsWith("$JCMemberReference")) {
|
|
printMemberReference0(jCTree);
|
|
} else if (name.endsWith("$JCLambda")) {
|
|
printLambda0(jCTree);
|
|
} else if (name.endsWith("$JCAnnotatedType")) {
|
|
printAnnotatedType0(jCTree);
|
|
} else if (name.endsWith("$JCPackageDecl")) {
|
|
} else {
|
|
if (name.endsWith("$JCSwitchExpression")) {
|
|
printSwitchExpression(jCTree);
|
|
} else if (name.endsWith("$JCYield")) {
|
|
printYieldExpression(jCTree);
|
|
} else if (name.endsWith("$JCBindingPattern")) {
|
|
printBindingPattern(jCTree);
|
|
} else {
|
|
throw new AssertionError("Unhandled tree type: " + jCTree.getClass() + ": " + jCTree);
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isCaseRuleStyle(JCTree.JCCase jCCase) {
|
|
Enum r0;
|
|
return (jCCase == null || (r0 = (Enum) readObject(jCCase, "caseKind", null)) == null || !r0.name().equalsIgnoreCase("RULE")) ? false : true;
|
|
}
|
|
|
|
private boolean isJcAnnotatedType(Object obj) {
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
if (this.jcAnnotatedTypeInit) {
|
|
return this.jcAnnotatedTypeClass == obj.getClass();
|
|
}
|
|
Class<?> cls = obj.getClass();
|
|
if (!cls.getName().endsWith("$JCAnnotatedType")) {
|
|
return false;
|
|
}
|
|
this.jcAnnotatedTypeClass = cls;
|
|
this.jcAnnotatedTypeInit = true;
|
|
return true;
|
|
}
|
|
|
|
private void printMemberReference0(JCTree jCTree) {
|
|
print((JCTree) readObject(jCTree, "expr", null));
|
|
print("::");
|
|
List<? extends JCTree> list = (List) readObject(jCTree, "typeargs", List.nil());
|
|
if (list != null && !list.isEmpty()) {
|
|
print("<");
|
|
print(list, ", ");
|
|
print(">");
|
|
}
|
|
print(readObject(jCTree, "mode", new Object()).toString().equals("INVOKE") ? (CharSequence) readObject(jCTree, ModelAuditLogEntry.CHANGE_KEY_NAME, null) : "new");
|
|
}
|
|
|
|
private void printLambda0(JCTree jCTree) {
|
|
List list = (List) readObject(jCTree, "params", List.nil());
|
|
boolean z2 = true;
|
|
int size = list.size();
|
|
try {
|
|
z2 = readObject(jCTree, "paramKind", new Object()).toString().equals("EXPLICIT");
|
|
} catch (Exception unused) {
|
|
}
|
|
boolean z3 = size != 1 || z2;
|
|
if (z3) {
|
|
print("(");
|
|
}
|
|
if (z2) {
|
|
boolean z4 = true;
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
JCTree.JCVariableDecl jCVariableDecl = (JCTree.JCVariableDecl) it.next();
|
|
if (!z4) {
|
|
print(", ");
|
|
}
|
|
z4 = false;
|
|
printVarDefInline(jCVariableDecl);
|
|
}
|
|
} else {
|
|
String str = "";
|
|
Iterator it2 = list.iterator();
|
|
while (it2.hasNext()) {
|
|
print(str);
|
|
print((CharSequence) ((JCTree.JCVariableDecl) it2.next()).name);
|
|
str = ", ";
|
|
}
|
|
}
|
|
if (z3) {
|
|
print(")");
|
|
}
|
|
print(" -> ");
|
|
JCTree.JCBlock jCBlock = (JCTree) readObject(jCTree, "body", null);
|
|
if (jCBlock instanceof JCTree.JCBlock) {
|
|
println("{");
|
|
this.indent++;
|
|
print(jCBlock.stats, "");
|
|
this.indent--;
|
|
aPrint("}");
|
|
return;
|
|
}
|
|
print((JCTree) jCBlock);
|
|
}
|
|
|
|
private void printAnnotatedType0(JCTree jCTree) {
|
|
JCTree.JCFieldAccess jCFieldAccess = (JCTree) readObject(jCTree, "underlyingType", null);
|
|
if (jCFieldAccess instanceof JCTree.JCFieldAccess) {
|
|
print((JCTree) jCFieldAccess.selected);
|
|
print(".");
|
|
print((List) readObject(jCTree, "annotations", List.nil()), " ");
|
|
print(" ");
|
|
print((CharSequence) jCFieldAccess.name);
|
|
} else if (jCFieldAccess instanceof JCTree.JCArrayTypeTree) {
|
|
printTypeArray0(jCTree);
|
|
} else {
|
|
print((List) readObject(jCTree, "annotations", List.nil()), " ");
|
|
print(" ");
|
|
print((JCTree) jCFieldAccess);
|
|
}
|
|
}
|
|
|
|
private void printTypeArray0(JCTree jCTree) {
|
|
JCTree jCTree2 = jCTree;
|
|
int i = 0;
|
|
while (true) {
|
|
if (!(jCTree2 instanceof JCTree.JCArrayTypeTree)) {
|
|
if (!isJcAnnotatedType(jCTree2)) {
|
|
break;
|
|
}
|
|
JCTree.JCArrayTypeTree jCArrayTypeTree = (JCTree) readObject(jCTree2, "underlyingType", null);
|
|
if (!(jCArrayTypeTree instanceof JCTree.JCArrayTypeTree)) {
|
|
break;
|
|
}
|
|
jCTree2 = jCArrayTypeTree.elemtype;
|
|
i++;
|
|
} else {
|
|
jCTree2 = ((JCTree.JCArrayTypeTree) jCTree2).elemtype;
|
|
i++;
|
|
}
|
|
}
|
|
print(jCTree2);
|
|
JCTree jCTree3 = jCTree;
|
|
while (true) {
|
|
if (jCTree3 instanceof JCTree.JCArrayTypeTree) {
|
|
i--;
|
|
print((i != 0 || !this.innermostArrayBracketsAreVarargs) ? "[]" : "...");
|
|
jCTree3 = ((JCTree.JCArrayTypeTree) jCTree3).elemtype;
|
|
} else if (isJcAnnotatedType(jCTree3)) {
|
|
JCTree.JCArrayTypeTree jCArrayTypeTree2 = (JCTree) readObject(jCTree3, "underlyingType", null);
|
|
if (jCArrayTypeTree2 instanceof JCTree.JCArrayTypeTree) {
|
|
i--;
|
|
print(" ");
|
|
print((List) readObject(jCTree3, "annotations", List.nil()), " ");
|
|
print(" ");
|
|
print((i != 0 || !this.innermostArrayBracketsAreVarargs) ? "[]" : "...");
|
|
jCTree3 = jCArrayTypeTree2.elemtype;
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static /* synthetic */ int[] $SWITCH_TABLE$lombok$javac$CommentInfo$StartConnection() {
|
|
int[] iArr = $SWITCH_TABLE$lombok$javac$CommentInfo$StartConnection;
|
|
if (iArr != null) {
|
|
return iArr;
|
|
}
|
|
int[] iArr2 = new int[CommentInfo.StartConnection.values().length];
|
|
try {
|
|
iArr2[CommentInfo.StartConnection.AFTER_PREVIOUS.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
iArr2[CommentInfo.StartConnection.DIRECT_AFTER_PREVIOUS.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
iArr2[CommentInfo.StartConnection.ON_NEXT_LINE.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
iArr2[CommentInfo.StartConnection.START_OF_LINE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
$SWITCH_TABLE$lombok$javac$CommentInfo$StartConnection = iArr2;
|
|
return iArr2;
|
|
}
|
|
|
|
static /* synthetic */ int[] $SWITCH_TABLE$lombok$javac$CommentInfo$EndConnection() {
|
|
int[] iArr = $SWITCH_TABLE$lombok$javac$CommentInfo$EndConnection;
|
|
if (iArr != null) {
|
|
return iArr;
|
|
}
|
|
int[] iArr2 = new int[CommentInfo.EndConnection.values().length];
|
|
try {
|
|
iArr2[CommentInfo.EndConnection.AFTER_COMMENT.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
iArr2[CommentInfo.EndConnection.DIRECT_AFTER_COMMENT.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
iArr2[CommentInfo.EndConnection.ON_NEXT_LINE.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
$SWITCH_TABLE$lombok$javac$CommentInfo$EndConnection = iArr2;
|
|
return iArr2;
|
|
}
|
|
|
|
static /* synthetic */ int[] $SWITCH_TABLE$com$sun$source$tree$Tree$Kind() {
|
|
int[] iArr = $SWITCH_TABLE$com$sun$source$tree$Tree$Kind;
|
|
if (iArr != null) {
|
|
return iArr;
|
|
}
|
|
int[] iArr2 = new int[Tree.Kind.values().length];
|
|
try {
|
|
iArr2[Tree.Kind.AND.ordinal()] = 64;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.AND_ASSIGNMENT.ordinal()] = 77;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ANNOTATION.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ARRAY_ACCESS.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ARRAY_TYPE.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ASSERT.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ASSIGNMENT.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.BITWISE_COMPLEMENT.ordinal()] = 48;
|
|
} catch (NoSuchFieldError unused8) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.BLOCK.ordinal()] = 6;
|
|
} catch (NoSuchFieldError unused9) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.BOOLEAN_LITERAL.ordinal()] = 84;
|
|
} catch (NoSuchFieldError unused10) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.BREAK.ordinal()] = 7;
|
|
} catch (NoSuchFieldError unused11) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CASE.ordinal()] = 8;
|
|
} catch (NoSuchFieldError unused12) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CATCH.ordinal()] = 9;
|
|
} catch (NoSuchFieldError unused13) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CHAR_LITERAL.ordinal()] = 85;
|
|
} catch (NoSuchFieldError unused14) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CLASS.ordinal()] = 10;
|
|
} catch (NoSuchFieldError unused15) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.COMPILATION_UNIT.ordinal()] = 11;
|
|
} catch (NoSuchFieldError unused16) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CONDITIONAL_AND.ordinal()] = 67;
|
|
} catch (NoSuchFieldError unused17) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CONDITIONAL_EXPRESSION.ordinal()] = 12;
|
|
} catch (NoSuchFieldError unused18) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CONDITIONAL_OR.ordinal()] = 68;
|
|
} catch (NoSuchFieldError unused19) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.CONTINUE.ordinal()] = 13;
|
|
} catch (NoSuchFieldError unused20) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.DIVIDE.ordinal()] = 51;
|
|
} catch (NoSuchFieldError unused21) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.DIVIDE_ASSIGNMENT.ordinal()] = 70;
|
|
} catch (NoSuchFieldError unused22) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.DOUBLE_LITERAL.ordinal()] = 83;
|
|
} catch (NoSuchFieldError unused23) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.DO_WHILE_LOOP.ordinal()] = 14;
|
|
} catch (NoSuchFieldError unused24) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.EMPTY_STATEMENT.ordinal()] = 32;
|
|
} catch (NoSuchFieldError unused25) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ENHANCED_FOR_LOOP.ordinal()] = 15;
|
|
} catch (NoSuchFieldError unused26) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.EQUAL_TO.ordinal()] = 62;
|
|
} catch (NoSuchFieldError unused27) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.ERRONEOUS.ordinal()] = 91;
|
|
} catch (NoSuchFieldError unused28) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.EXPRESSION_STATEMENT.ordinal()] = 16;
|
|
} catch (NoSuchFieldError unused29) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.EXTENDS_WILDCARD.ordinal()] = 89;
|
|
} catch (NoSuchFieldError unused30) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.FLOAT_LITERAL.ordinal()] = 82;
|
|
} catch (NoSuchFieldError unused31) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.FOR_LOOP.ordinal()] = 18;
|
|
} catch (NoSuchFieldError unused32) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.GREATER_THAN.ordinal()] = 59;
|
|
} catch (NoSuchFieldError unused33) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.GREATER_THAN_EQUAL.ordinal()] = 61;
|
|
} catch (NoSuchFieldError unused34) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.IDENTIFIER.ordinal()] = 19;
|
|
} catch (NoSuchFieldError unused35) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.IF.ordinal()] = 20;
|
|
} catch (NoSuchFieldError unused36) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.IMPORT.ordinal()] = 21;
|
|
} catch (NoSuchFieldError unused37) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.INSTANCE_OF.ordinal()] = 22;
|
|
} catch (NoSuchFieldError unused38) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.INT_LITERAL.ordinal()] = 80;
|
|
} catch (NoSuchFieldError unused39) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LABELED_STATEMENT.ordinal()] = 23;
|
|
} catch (NoSuchFieldError unused40) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LEFT_SHIFT.ordinal()] = 55;
|
|
} catch (NoSuchFieldError unused41) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LEFT_SHIFT_ASSIGNMENT.ordinal()] = 74;
|
|
} catch (NoSuchFieldError unused42) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LESS_THAN.ordinal()] = 58;
|
|
} catch (NoSuchFieldError unused43) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LESS_THAN_EQUAL.ordinal()] = 60;
|
|
} catch (NoSuchFieldError unused44) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LOGICAL_COMPLEMENT.ordinal()] = 49;
|
|
} catch (NoSuchFieldError unused45) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.LONG_LITERAL.ordinal()] = 81;
|
|
} catch (NoSuchFieldError unused46) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MEMBER_SELECT.ordinal()] = 17;
|
|
} catch (NoSuchFieldError unused47) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.METHOD.ordinal()] = 24;
|
|
} catch (NoSuchFieldError unused48) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.METHOD_INVOCATION.ordinal()] = 25;
|
|
} catch (NoSuchFieldError unused49) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MINUS.ordinal()] = 54;
|
|
} catch (NoSuchFieldError unused50) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MINUS_ASSIGNMENT.ordinal()] = 73;
|
|
} catch (NoSuchFieldError unused51) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MODIFIERS.ordinal()] = 26;
|
|
} catch (NoSuchFieldError unused52) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MULTIPLY.ordinal()] = 50;
|
|
} catch (NoSuchFieldError unused53) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.MULTIPLY_ASSIGNMENT.ordinal()] = 69;
|
|
} catch (NoSuchFieldError unused54) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.NEW_ARRAY.ordinal()] = 27;
|
|
} catch (NoSuchFieldError unused55) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.NEW_CLASS.ordinal()] = 28;
|
|
} catch (NoSuchFieldError unused56) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.NOT_EQUAL_TO.ordinal()] = 63;
|
|
} catch (NoSuchFieldError unused57) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.NULL_LITERAL.ordinal()] = 87;
|
|
} catch (NoSuchFieldError unused58) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.OR.ordinal()] = 66;
|
|
} catch (NoSuchFieldError unused59) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.OR_ASSIGNMENT.ordinal()] = 79;
|
|
} catch (NoSuchFieldError unused60) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.OTHER.ordinal()] = 92;
|
|
} catch (NoSuchFieldError unused61) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PARAMETERIZED_TYPE.ordinal()] = 37;
|
|
} catch (NoSuchFieldError unused62) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PARENTHESIZED.ordinal()] = 29;
|
|
} catch (NoSuchFieldError unused63) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PLUS.ordinal()] = 53;
|
|
} catch (NoSuchFieldError unused64) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PLUS_ASSIGNMENT.ordinal()] = 72;
|
|
} catch (NoSuchFieldError unused65) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.POSTFIX_DECREMENT.ordinal()] = 43;
|
|
} catch (NoSuchFieldError unused66) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.POSTFIX_INCREMENT.ordinal()] = 42;
|
|
} catch (NoSuchFieldError unused67) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PREFIX_DECREMENT.ordinal()] = 45;
|
|
} catch (NoSuchFieldError unused68) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PREFIX_INCREMENT.ordinal()] = 44;
|
|
} catch (NoSuchFieldError unused69) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.PRIMITIVE_TYPE.ordinal()] = 30;
|
|
} catch (NoSuchFieldError unused70) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.REMAINDER.ordinal()] = 52;
|
|
} catch (NoSuchFieldError unused71) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.REMAINDER_ASSIGNMENT.ordinal()] = 71;
|
|
} catch (NoSuchFieldError unused72) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.RETURN.ordinal()] = 31;
|
|
} catch (NoSuchFieldError unused73) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.RIGHT_SHIFT.ordinal()] = 56;
|
|
} catch (NoSuchFieldError unused74) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.RIGHT_SHIFT_ASSIGNMENT.ordinal()] = 75;
|
|
} catch (NoSuchFieldError unused75) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.STRING_LITERAL.ordinal()] = 86;
|
|
} catch (NoSuchFieldError unused76) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.SUPER_WILDCARD.ordinal()] = 90;
|
|
} catch (NoSuchFieldError unused77) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.SWITCH.ordinal()] = 33;
|
|
} catch (NoSuchFieldError unused78) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.SYNCHRONIZED.ordinal()] = 34;
|
|
} catch (NoSuchFieldError unused79) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.THROW.ordinal()] = 35;
|
|
} catch (NoSuchFieldError unused80) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.TRY.ordinal()] = 36;
|
|
} catch (NoSuchFieldError unused81) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.TYPE_CAST.ordinal()] = 38;
|
|
} catch (NoSuchFieldError unused82) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.TYPE_PARAMETER.ordinal()] = 39;
|
|
} catch (NoSuchFieldError unused83) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.UNARY_MINUS.ordinal()] = 47;
|
|
} catch (NoSuchFieldError unused84) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.UNARY_PLUS.ordinal()] = 46;
|
|
} catch (NoSuchFieldError unused85) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.UNBOUNDED_WILDCARD.ordinal()] = 88;
|
|
} catch (NoSuchFieldError unused86) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.UNSIGNED_RIGHT_SHIFT.ordinal()] = 57;
|
|
} catch (NoSuchFieldError unused87) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT.ordinal()] = 76;
|
|
} catch (NoSuchFieldError unused88) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.VARIABLE.ordinal()] = 40;
|
|
} catch (NoSuchFieldError unused89) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.WHILE_LOOP.ordinal()] = 41;
|
|
} catch (NoSuchFieldError unused90) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.XOR.ordinal()] = 65;
|
|
} catch (NoSuchFieldError unused91) {
|
|
}
|
|
try {
|
|
iArr2[Tree.Kind.XOR_ASSIGNMENT.ordinal()] = 78;
|
|
} catch (NoSuchFieldError unused92) {
|
|
}
|
|
$SWITCH_TABLE$com$sun$source$tree$Tree$Kind = iArr2;
|
|
return iArr2;
|
|
}
|
|
}
|