600 lines
24 KiB
Java
600 lines
24 KiB
Java
package lombok.javac;
|
|
|
|
import com.sun.tools.javac.code.BoundKind;
|
|
import com.sun.tools.javac.code.Symbol;
|
|
import com.sun.tools.javac.code.Symtab;
|
|
import com.sun.tools.javac.code.Type;
|
|
import com.sun.tools.javac.code.Types;
|
|
import com.sun.tools.javac.comp.Attr;
|
|
import com.sun.tools.javac.comp.AttrContext;
|
|
import com.sun.tools.javac.comp.Enter;
|
|
import com.sun.tools.javac.comp.Env;
|
|
import com.sun.tools.javac.comp.MemberEnter;
|
|
import com.sun.tools.javac.tree.JCTree;
|
|
import com.sun.tools.javac.util.Context;
|
|
import com.sun.tools.javac.util.List;
|
|
import com.sun.tools.javac.util.ListBuffer;
|
|
import com.sun.tools.javac.util.Log;
|
|
import com.sun.tools.javac.util.Name;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayDeque;
|
|
import java.util.Collection;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.NoSuchElementException;
|
|
import javax.lang.model.type.TypeKind;
|
|
import javax.tools.JavaFileObject;
|
|
import lombok.Lombok;
|
|
import lombok.core.debug.AssertionLogger;
|
|
import lombok.javac.JavacTreeMaker;
|
|
import lombok.permit.Permit;
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution.SCL.lombok */
|
|
public class JavacResolution {
|
|
private final Attr attr;
|
|
private final CompilerMessageSuppressor messageSuppressor;
|
|
private static Field memberEnterDotEnv;
|
|
private static /* synthetic */ int[] $SWITCH_TABLE$javax$lang$model$type$TypeKind;
|
|
|
|
/* renamed from: lombok.javac.JavacResolution$1 reason: invalid class name */
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution$1.SCL.lombok */
|
|
class AnonymousClass1 implements Iterable<Type> {
|
|
private final /* synthetic */ Collection val$ts;
|
|
private final /* synthetic */ Type val$t;
|
|
|
|
/* renamed from: lombok.javac.JavacResolution$1$1 reason: invalid class name and collision with other inner class name */
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution$1$1.SCL.lombok */
|
|
class C04171 implements Iterator<Type> {
|
|
private boolean first = true;
|
|
private Iterator<? extends Type> wrap;
|
|
private final /* synthetic */ Type val$t;
|
|
|
|
C04171(Collection collection, Type type) {
|
|
this.val$t = type;
|
|
this.wrap = collection == null ? null : collection.iterator();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public boolean hasNext() {
|
|
if (this.first) {
|
|
return true;
|
|
}
|
|
if (this.wrap == null) {
|
|
return false;
|
|
}
|
|
return this.wrap.hasNext();
|
|
}
|
|
|
|
/* JADX WARN: Can't rename method to resolve collision */
|
|
@Override // java.util.Iterator
|
|
public Type next() {
|
|
if (this.first) {
|
|
this.first = false;
|
|
return this.val$t;
|
|
} else if (this.wrap != null) {
|
|
return (Type) this.wrap.next();
|
|
} else {
|
|
throw new NoSuchElementException();
|
|
}
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public void remove() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
AnonymousClass1(Collection collection, Type type) {
|
|
this.val$ts = collection;
|
|
this.val$t = type;
|
|
}
|
|
|
|
@Override // java.lang.Iterable
|
|
public Iterator<Type> iterator() {
|
|
return new C04171(this.val$ts, this.val$t);
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution$EnvFinder.SCL.lombok */
|
|
private static final class EnvFinder extends JCTree.Visitor {
|
|
private Enter enter;
|
|
private MemberEnter memberEnter;
|
|
private Env<AttrContext> env = null;
|
|
private JCTree copyAt = null;
|
|
|
|
EnvFinder(Context context) {
|
|
this.enter = Enter.instance(context);
|
|
this.memberEnter = MemberEnter.instance(context);
|
|
}
|
|
|
|
Env<AttrContext> get() {
|
|
return this.env;
|
|
}
|
|
|
|
JCTree copyAt() {
|
|
return this.copyAt;
|
|
}
|
|
|
|
public void visitTopLevel(JCTree.JCCompilationUnit jCCompilationUnit) {
|
|
if (this.copyAt == null) {
|
|
this.env = this.enter.getTopLevelEnv(jCCompilationUnit);
|
|
}
|
|
}
|
|
|
|
public void visitClassDef(JCTree.JCClassDecl jCClassDecl) {
|
|
if (this.copyAt == null && jCClassDecl.sym != null) {
|
|
this.env = this.enter.getClassEnv(jCClassDecl.sym);
|
|
}
|
|
}
|
|
|
|
public void visitMethodDef(JCTree.JCMethodDecl jCMethodDecl) {
|
|
if (this.copyAt == null) {
|
|
this.env = this.memberEnter.getMethodEnv(jCMethodDecl, this.env);
|
|
this.copyAt = jCMethodDecl;
|
|
}
|
|
}
|
|
|
|
public void visitVarDef(JCTree.JCVariableDecl jCVariableDecl) {
|
|
if (this.copyAt == null) {
|
|
this.env = this.memberEnter.getInitEnv(jCVariableDecl, this.env);
|
|
this.copyAt = jCVariableDecl;
|
|
}
|
|
}
|
|
|
|
public void visitBlock(JCTree.JCBlock jCBlock) {
|
|
if (this.copyAt == null) {
|
|
this.copyAt = jCBlock;
|
|
}
|
|
}
|
|
|
|
public void visitTree(JCTree jCTree) {
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution$ReflectiveAccess.SCL.lombok */
|
|
private static class ReflectiveAccess {
|
|
private static Method UPPER_BOUND;
|
|
|
|
static {
|
|
Method method = null;
|
|
try {
|
|
method = Permit.getMethod(Types.class, "upperBound", Type.class);
|
|
} catch (Throwable unused) {
|
|
}
|
|
if (method == null) {
|
|
try {
|
|
method = Permit.getMethod(Types.class, "wildUpperBound", Type.class);
|
|
} catch (Throwable unused2) {
|
|
}
|
|
}
|
|
UPPER_BOUND = method;
|
|
}
|
|
|
|
private ReflectiveAccess() {
|
|
}
|
|
|
|
public static Type Types_upperBound(Types types, Type type) {
|
|
try {
|
|
return (Type) UPPER_BOUND.invoke(types, type);
|
|
} catch (InvocationTargetException e) {
|
|
throw Lombok.sneakyThrow(e.getCause());
|
|
} catch (Exception e2) {
|
|
throw Lombok.sneakyThrow(e2);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-121110.apk:lombok/javac/JavacResolution$TypeNotConvertibleException.SCL.lombok */
|
|
public static class TypeNotConvertibleException extends Exception {
|
|
public TypeNotConvertibleException(String str) {
|
|
super(str);
|
|
}
|
|
}
|
|
|
|
public JavacResolution(Context context) {
|
|
this.attr = Attr.instance(context);
|
|
this.messageSuppressor = new CompilerMessageSuppressor(context);
|
|
}
|
|
|
|
public Map<JCTree, JCTree> resolveMethodMember(JavacNode javacNode) {
|
|
ArrayDeque arrayDeque = new ArrayDeque();
|
|
for (JavacNode javacNode2 = javacNode; javacNode2 != null; javacNode2 = javacNode2.up()) {
|
|
arrayDeque.push(javacNode2.get());
|
|
}
|
|
this.messageSuppressor.disableLoggers();
|
|
try {
|
|
EnvFinder envFinder = new EnvFinder(javacNode.getContext());
|
|
while (!arrayDeque.isEmpty()) {
|
|
((JCTree) arrayDeque.pop()).accept(envFinder);
|
|
}
|
|
TreeMirrorMaker treeMirrorMaker = new TreeMirrorMaker(javacNode.getTreeMaker(), javacNode.getContext());
|
|
JCTree copy = treeMirrorMaker.copy((TreeMirrorMaker) envFinder.copyAt());
|
|
Log instance = Log.instance(javacNode.getContext());
|
|
JavaFileObject useSource = instance.useSource(javacNode.top().get().getSourceFile());
|
|
memberEnterAndAttribute(copy, envFinder.get(), javacNode.getContext());
|
|
Map<JCTree, JCTree> originalToCopyMap = treeMirrorMaker.getOriginalToCopyMap();
|
|
instance.useSource(useSource);
|
|
return originalToCopyMap;
|
|
} finally {
|
|
this.messageSuppressor.enableLoggers();
|
|
}
|
|
}
|
|
|
|
private static Field getMemberEnterDotEnv() {
|
|
if (memberEnterDotEnv != null) {
|
|
return memberEnterDotEnv;
|
|
}
|
|
try {
|
|
Field field = Permit.getField(MemberEnter.class, "env");
|
|
memberEnterDotEnv = field;
|
|
return field;
|
|
} catch (NoSuchFieldException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static Env<AttrContext> getEnvOfMemberEnter(MemberEnter memberEnter) {
|
|
try {
|
|
return (Env) getMemberEnterDotEnv().get(memberEnter);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static void setEnvOfMemberEnter(MemberEnter memberEnter, Env<AttrContext> env) {
|
|
try {
|
|
getMemberEnterDotEnv().set(memberEnter, env);
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
|
|
private void memberEnterAndAttribute(JCTree jCTree, Env<AttrContext> env, Context context) {
|
|
MemberEnter instance = MemberEnter.instance(context);
|
|
Env<AttrContext> envOfMemberEnter = getEnvOfMemberEnter(instance);
|
|
setEnvOfMemberEnter(instance, env);
|
|
try {
|
|
jCTree.accept(instance);
|
|
} catch (Exception e) {
|
|
AssertionLogger.assertLog("member enter failed.", e);
|
|
} finally {
|
|
setEnvOfMemberEnter(instance, envOfMemberEnter);
|
|
}
|
|
attrib(jCTree, env);
|
|
}
|
|
|
|
public void resolveClassMember(JavacNode javacNode) {
|
|
ArrayDeque arrayDeque = new ArrayDeque();
|
|
for (JavacNode javacNode2 = javacNode; javacNode2 != null; javacNode2 = javacNode2.up()) {
|
|
arrayDeque.push(javacNode2.get());
|
|
}
|
|
this.messageSuppressor.disableLoggers();
|
|
try {
|
|
EnvFinder envFinder = new EnvFinder(javacNode.getContext());
|
|
while (!arrayDeque.isEmpty()) {
|
|
((JCTree) arrayDeque.pop()).accept(envFinder);
|
|
}
|
|
attrib(javacNode.get(), envFinder.get());
|
|
} finally {
|
|
this.messageSuppressor.enableLoggers();
|
|
}
|
|
}
|
|
|
|
private void attrib(JCTree jCTree, Env<AttrContext> env) {
|
|
if (env.enclClass.type == null) {
|
|
try {
|
|
env.enclClass.type = Type.noType;
|
|
} catch (Throwable unused) {
|
|
}
|
|
}
|
|
if (jCTree instanceof JCTree.JCBlock) {
|
|
this.attr.attribStat(jCTree, env);
|
|
} else if (jCTree instanceof JCTree.JCMethodDecl) {
|
|
this.attr.attribStat(((JCTree.JCMethodDecl) jCTree).body, env);
|
|
} else if (jCTree instanceof JCTree.JCVariableDecl) {
|
|
this.attr.attribStat(jCTree, env);
|
|
} else {
|
|
throw new IllegalStateException("Called with something that isn't a block, method decl, or variable decl");
|
|
}
|
|
}
|
|
|
|
public static Type ifTypeIsIterableToComponent(Type type, JavacAST javacAST) {
|
|
if (type == null) {
|
|
return null;
|
|
}
|
|
Types instance = Types.instance(javacAST.getContext());
|
|
Symtab instance2 = Symtab.instance(javacAST.getContext());
|
|
Type Types_upperBound = ReflectiveAccess.Types_upperBound(instance, type);
|
|
Type elemtype = instance.elemtype(Types_upperBound);
|
|
if (elemtype != null) {
|
|
return elemtype;
|
|
}
|
|
Type asSuper = instance.asSuper(Types_upperBound, instance2.iterableType.tsym);
|
|
if (asSuper == null) {
|
|
return instance2.objectType;
|
|
}
|
|
List allparams = asSuper.allparams();
|
|
return allparams.isEmpty() ? instance2.objectType : ReflectiveAccess.Types_upperBound(instance, (Type) allparams.head);
|
|
}
|
|
|
|
public static JCTree.JCExpression typeToJCTree(Type type, JavacAST javacAST, boolean z2) throws TypeNotConvertibleException {
|
|
return typeToJCTree(type, javacAST, false, z2, false);
|
|
}
|
|
|
|
public static JCTree.JCExpression createJavaLangObject(JavacAST javacAST) {
|
|
JavacTreeMaker treeMaker = javacAST.getTreeMaker();
|
|
return treeMaker.Select(treeMaker.Select(treeMaker.Ident(javacAST.toName("java")), javacAST.toName("lang")), javacAST.toName("Object"));
|
|
}
|
|
|
|
private static JCTree.JCExpression typeToJCTree(Type type, JavacAST javacAST, boolean z2, boolean z3, boolean z4) throws TypeNotConvertibleException {
|
|
int i = 0;
|
|
Type type2 = type;
|
|
while (type2 instanceof Type.ArrayType) {
|
|
i++;
|
|
type2 = ((Type.ArrayType) type2).elemtype;
|
|
}
|
|
JCTree.JCArrayTypeTree typeToJCTree0 = typeToJCTree0(type2, javacAST, z2, z3, z4);
|
|
while (i > 0) {
|
|
typeToJCTree0 = javacAST.getTreeMaker().TypeArray(typeToJCTree0);
|
|
i--;
|
|
}
|
|
return typeToJCTree0;
|
|
}
|
|
|
|
private static Iterable<? extends Type> concat(Type type, Collection<? extends Type> collection) {
|
|
return type == null ? collection : new AnonymousClass1(collection, type);
|
|
}
|
|
|
|
private static int compare(Name name, Name name2) {
|
|
return name.compareTo(name2);
|
|
}
|
|
|
|
private static JCTree.JCExpression typeToJCTree0(Type type, JavacAST javacAST, boolean z2, boolean z3, boolean z4) throws TypeNotConvertibleException {
|
|
Type type2;
|
|
Type type3;
|
|
String str;
|
|
JavacTreeMaker treeMaker = javacAST.getTreeMaker();
|
|
if (Javac.CTC_BOT.equals(JavacTreeMaker.TypeTag.typeTag(type))) {
|
|
return createJavaLangObject(javacAST);
|
|
}
|
|
if (Javac.CTC_VOID.equals(JavacTreeMaker.TypeTag.typeTag(type))) {
|
|
return z3 ? primitiveToJCTree(type.getKind(), treeMaker) : createJavaLangObject(javacAST);
|
|
}
|
|
if (type.isPrimitive()) {
|
|
return primitiveToJCTree(type.getKind(), treeMaker);
|
|
}
|
|
if (type.isErroneous()) {
|
|
throw new TypeNotConvertibleException("Type cannot be resolved");
|
|
}
|
|
Symbol.TypeSymbol asElement = type.asElement();
|
|
List typeArguments = type.getTypeArguments();
|
|
JCTree.JCExpression jCExpression = null;
|
|
if (asElement == null) {
|
|
throw new TypeNotConvertibleException("Null or compound type");
|
|
} else if (asElement.name.length() == 0) {
|
|
if (type instanceof Type.ClassType) {
|
|
Type type4 = null;
|
|
char c = 0;
|
|
Iterator<? extends Type> it = concat(((Type.ClassType) type).supertype_field, ((Type.ClassType) type).interfaces_field).iterator();
|
|
while (it.hasNext()) {
|
|
Type type5 = (Type) it.next();
|
|
char c2 = type5 instanceof Type.ArrayType ? 'd' : type5 instanceof Type.TypeVar ? (char) 20 : type5 instanceof Type.WildcardType ? (char) 15 : type5.isInterface() ? '\n' : isObject(type5) ? (char) 1 : type5 instanceof Type.ClassType ? '2' : (char) 5;
|
|
if (c <= c2) {
|
|
if (c < c2) {
|
|
type4 = type5;
|
|
c = c2;
|
|
} else if (compare(type4.tsym.getQualifiedName(), type5.tsym.getQualifiedName()) < 0) {
|
|
type4 = type5;
|
|
}
|
|
}
|
|
}
|
|
return type4 == null ? createJavaLangObject(javacAST) : typeToJCTree(type4, javacAST, z2, z3, z4);
|
|
}
|
|
throw new TypeNotConvertibleException("Anonymous inner class");
|
|
} else if ((type instanceof Type.WildcardType) || (type instanceof Type.CapturedType)) {
|
|
if (type instanceof Type.WildcardType) {
|
|
type2 = ((Type.WildcardType) type).getExtendsBound();
|
|
type3 = ((Type.WildcardType) type).getSuperBound();
|
|
} else {
|
|
type3 = type.getLowerBound();
|
|
type2 = type.getUpperBound();
|
|
if (z4) {
|
|
BoundKind boundKind = ((Type.CapturedType) type).wildcard.kind;
|
|
if (boundKind == BoundKind.UNBOUND) {
|
|
return treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null);
|
|
}
|
|
if (boundKind == BoundKind.EXTENDS) {
|
|
type3 = null;
|
|
type2 = ((Type.CapturedType) type).wildcard.type;
|
|
} else if (boundKind == BoundKind.SUPER) {
|
|
type3 = ((Type.CapturedType) type).wildcard.type;
|
|
type2 = null;
|
|
}
|
|
}
|
|
}
|
|
if (!z2) {
|
|
return type2 != null ? type2.getTypeArguments().contains(type) ? treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null) : typeToJCTree(type2, javacAST, z2, z3, true) : createJavaLangObject(javacAST);
|
|
}
|
|
if (type3 != null && !Javac.CTC_BOT.equals(JavacTreeMaker.TypeTag.typeTag(type3))) {
|
|
JCTree.JCExpression typeToJCTree = typeToJCTree(type3, javacAST, false, false, true);
|
|
return typeToJCTree instanceof JCTree.JCWildcard ? treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null) : treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.SUPER), typeToJCTree);
|
|
} else if (type2 == null || type2.toString().equals("java.lang.Object")) {
|
|
return treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null);
|
|
} else {
|
|
if (type2.getTypeArguments().contains(type)) {
|
|
return treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null);
|
|
}
|
|
JCTree.JCExpression typeToJCTree2 = typeToJCTree(type2, javacAST, false, false, true);
|
|
return typeToJCTree2 instanceof JCTree.JCWildcard ? treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null) : treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.EXTENDS), typeToJCTree2);
|
|
}
|
|
} else {
|
|
if (asElement.isLocal()) {
|
|
str = asElement.getSimpleName().toString();
|
|
} else if (asElement.type == null || asElement.type.getEnclosingType() == null || !JavacTreeMaker.TypeTag.typeTag(asElement.type.getEnclosingType()).equals(JavacTreeMaker.TypeTag.typeTag("CLASS"))) {
|
|
str = asElement.getQualifiedName().toString();
|
|
} else {
|
|
jCExpression = typeToJCTree0(type.getEnclosingType(), javacAST, false, false, false);
|
|
str = asElement.getSimpleName().toString();
|
|
}
|
|
if (str.isEmpty()) {
|
|
throw new TypeNotConvertibleException("unknown type");
|
|
} else if (str.startsWith("<")) {
|
|
throw new TypeNotConvertibleException(str);
|
|
} else {
|
|
String[] split = str.split("\\.");
|
|
int i = 0;
|
|
if (jCExpression == null) {
|
|
jCExpression = treeMaker.Ident(javacAST.toName(split[0]));
|
|
i = 1;
|
|
}
|
|
while (i < split.length) {
|
|
jCExpression = treeMaker.Select(jCExpression, javacAST.toName(split[i]));
|
|
i++;
|
|
}
|
|
return genericsToJCTreeNodes(typeArguments, javacAST, jCExpression);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean isObject(Type type) {
|
|
return type.tsym.toString().equals("java.lang.Object");
|
|
}
|
|
|
|
private static JCTree.JCExpression genericsToJCTreeNodes(List<Type> list, JavacAST javacAST, JCTree.JCExpression jCExpression) throws TypeNotConvertibleException {
|
|
if (list == null || list.isEmpty()) {
|
|
return jCExpression;
|
|
}
|
|
ListBuffer listBuffer = new ListBuffer();
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
listBuffer.append(typeToJCTree((Type) it.next(), javacAST, true, false, true));
|
|
}
|
|
return javacAST.getTreeMaker().TypeApply(jCExpression, listBuffer.toList());
|
|
}
|
|
|
|
private static JCTree.JCExpression primitiveToJCTree(TypeKind typeKind, JavacTreeMaker javacTreeMaker) throws TypeNotConvertibleException {
|
|
switch ($SWITCH_TABLE$javax$lang$model$type$TypeKind()[typeKind.ordinal()]) {
|
|
case 1:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_BOOLEAN);
|
|
case 2:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_BYTE);
|
|
case 3:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_SHORT);
|
|
case 4:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_INT);
|
|
case 5:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_LONG);
|
|
case 6:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_CHAR);
|
|
case 7:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_FLOAT);
|
|
case 8:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_DOUBLE);
|
|
case 9:
|
|
return javacTreeMaker.TypeIdent(Javac.CTC_VOID);
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
default:
|
|
throw new TypeNotConvertibleException("Nulltype");
|
|
}
|
|
}
|
|
|
|
public static boolean platformHasTargetTyping() {
|
|
return Javac.getJavaCompilerVersion() >= 8;
|
|
}
|
|
|
|
static /* synthetic */ int[] $SWITCH_TABLE$javax$lang$model$type$TypeKind() {
|
|
int[] iArr = $SWITCH_TABLE$javax$lang$model$type$TypeKind;
|
|
if (iArr != null) {
|
|
return iArr;
|
|
}
|
|
int[] iArr2 = new int[TypeKind.values().length];
|
|
try {
|
|
iArr2[TypeKind.ARRAY.ordinal()] = 12;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.BOOLEAN.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.BYTE.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.CHAR.ordinal()] = 6;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.DECLARED.ordinal()] = 13;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.DOUBLE.ordinal()] = 8;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.ERROR.ordinal()] = 14;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.EXECUTABLE.ordinal()] = 18;
|
|
} catch (NoSuchFieldError unused8) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.FLOAT.ordinal()] = 7;
|
|
} catch (NoSuchFieldError unused9) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.INT.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused10) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.LONG.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused11) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.NONE.ordinal()] = 10;
|
|
} catch (NoSuchFieldError unused12) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.NULL.ordinal()] = 11;
|
|
} catch (NoSuchFieldError unused13) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.OTHER.ordinal()] = 19;
|
|
} catch (NoSuchFieldError unused14) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.PACKAGE.ordinal()] = 17;
|
|
} catch (NoSuchFieldError unused15) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.SHORT.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused16) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.TYPEVAR.ordinal()] = 15;
|
|
} catch (NoSuchFieldError unused17) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.VOID.ordinal()] = 9;
|
|
} catch (NoSuchFieldError unused18) {
|
|
}
|
|
try {
|
|
iArr2[TypeKind.WILDCARD.ordinal()] = 16;
|
|
} catch (NoSuchFieldError unused19) {
|
|
}
|
|
$SWITCH_TABLE$javax$lang$model$type$TypeKind = iArr2;
|
|
return iArr2;
|
|
}
|
|
}
|