238 lines
11 KiB
Java
238 lines
11 KiB
Java
package lombok.core;
|
|
|
|
import java.io.File;
|
|
import java.io.PrintWriter;
|
|
import java.io.StringWriter;
|
|
import java.io.Writer;
|
|
import java.lang.reflect.InvocationHandler;
|
|
import java.lang.reflect.Proxy;
|
|
import java.net.URL;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import javax.annotation.processing.AbstractProcessor;
|
|
import javax.annotation.processing.ProcessingEnvironment;
|
|
import javax.annotation.processing.Processor;
|
|
import javax.annotation.processing.RoundEnvironment;
|
|
import javax.annotation.processing.SupportedAnnotationTypes;
|
|
import javax.lang.model.SourceVersion;
|
|
import javax.lang.model.element.Element;
|
|
import javax.lang.model.element.TypeElement;
|
|
import javax.tools.Diagnostic;
|
|
import lombok.patcher.ClassRootFinder;
|
|
import lombok.permit.Permit;
|
|
@SupportedAnnotationTypes({"*"})
|
|
/* loaded from: com.discord-118107.apk:lombok/core/AnnotationProcessor.SCL.lombok */
|
|
public class AnnotationProcessor extends AbstractProcessor {
|
|
private final List<ProcessorDescriptor> registered = Arrays.asList(new JavacDescriptor(), new EcjDescriptor());
|
|
private final List<ProcessorDescriptor> active = new ArrayList();
|
|
private final List<String> delayedWarnings = new ArrayList();
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/AnnotationProcessor$EcjDescriptor.SCL.lombok */
|
|
static class EcjDescriptor extends ProcessorDescriptor {
|
|
EcjDescriptor() {
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
String getName() {
|
|
return "ECJ";
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
boolean want(ProcessingEnvironment processingEnvironment, List<String> list) {
|
|
return processingEnvironment.getClass().getName().startsWith("org.eclipse.jdt.");
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/AnnotationProcessor$JavacDescriptor.SCL.lombok */
|
|
static class JavacDescriptor extends ProcessorDescriptor {
|
|
private Processor processor;
|
|
|
|
JavacDescriptor() {
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
String getName() {
|
|
return "OpenJDK javac";
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
boolean want(ProcessingEnvironment processingEnvironment, List<String> list) {
|
|
ProcessingEnvironment javacProcessingEnvironment;
|
|
if (processingEnvironment.getClass().getName().startsWith("org.eclipse.jdt.") || (javacProcessingEnvironment = AnnotationProcessor.getJavacProcessingEnvironment(processingEnvironment, list)) == null) {
|
|
return false;
|
|
}
|
|
try {
|
|
this.processor = (Processor) Class.forName("lombok.javac.apt.LombokProcessor", false, findAndPatchClassLoader(javacProcessingEnvironment)).getConstructor(new Class[0]).newInstance(new Object[0]);
|
|
try {
|
|
this.processor.init(processingEnvironment);
|
|
return true;
|
|
} catch (Exception e) {
|
|
list.add("lombok.javac.apt.LombokProcessor could not be initialized. Lombok will not run during this compilation: " + AnnotationProcessor.access$0(e));
|
|
return false;
|
|
} catch (NoClassDefFoundError e2) {
|
|
list.add("Can't initialize javac processor due to (most likely) a class loader problem: " + AnnotationProcessor.access$0(e2));
|
|
return false;
|
|
}
|
|
} catch (Exception e3) {
|
|
list.add("You found a bug in lombok; lombok.javac.apt.LombokProcessor is not available. Lombok will not run during this compilation: " + AnnotationProcessor.access$0(e3));
|
|
return false;
|
|
} catch (NoClassDefFoundError e4) {
|
|
list.add("Can't load javac processor due to (most likely) a class loader problem: " + AnnotationProcessor.access$0(e4));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private ClassLoader findAndPatchClassLoader(ProcessingEnvironment processingEnvironment) throws Exception {
|
|
ClassLoader classLoader = processingEnvironment.getClass().getClassLoader();
|
|
if (classLoader != null && classLoader.getClass().getCanonicalName().equals("org.codehaus.plexus.compiler.javac.IsolatedClassLoader") && !Augments.ClassLoader_lombokAlreadyAddedTo.getAndSet(classLoader, true).booleanValue()) {
|
|
Permit.getMethod(classLoader.getClass(), "addURL", URL.class).invoke(classLoader, new File(ClassRootFinder.findClassRootOfClass(AnnotationProcessor.class)).toURI().toURL());
|
|
}
|
|
ClassLoader classLoader2 = JavacDescriptor.class.getClassLoader();
|
|
return classLoader2 == null ? ClassLoader.getSystemClassLoader() : classLoader2;
|
|
}
|
|
|
|
@Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
|
|
boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
|
|
return this.processor.process(set, roundEnvironment);
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/AnnotationProcessor$ProcessorDescriptor.SCL.lombok */
|
|
static abstract class ProcessorDescriptor {
|
|
ProcessorDescriptor() {
|
|
}
|
|
|
|
abstract boolean want(ProcessingEnvironment processingEnvironment, List<String> list);
|
|
|
|
abstract String getName();
|
|
|
|
abstract boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment);
|
|
}
|
|
|
|
private static String trace(Throwable th) {
|
|
StringWriter stringWriter = new StringWriter();
|
|
th.printStackTrace(new PrintWriter((Writer) stringWriter, true));
|
|
return stringWriter.toString();
|
|
}
|
|
|
|
public static ProcessingEnvironment getJavacProcessingEnvironment(ProcessingEnvironment processingEnvironment, List<String> list) {
|
|
return tryRecursivelyObtainJavacProcessingEnvironment(processingEnvironment);
|
|
}
|
|
|
|
private static ProcessingEnvironment tryRecursivelyObtainJavacProcessingEnvironment(ProcessingEnvironment processingEnvironment) {
|
|
Object tryGetDelegateField;
|
|
if (processingEnvironment.getClass().getName().equals("com.sun.tools.javac.processing.JavacProcessingEnvironment")) {
|
|
return processingEnvironment;
|
|
}
|
|
for (Class<?> cls = processingEnvironment.getClass(); cls != null; cls = cls.getSuperclass()) {
|
|
try {
|
|
tryGetDelegateField = tryGetDelegateField(cls, processingEnvironment);
|
|
if (tryGetDelegateField == null) {
|
|
tryGetDelegateField = tryGetProcessingEnvField(cls, processingEnvironment);
|
|
}
|
|
if (tryGetDelegateField == null) {
|
|
tryGetDelegateField = tryGetProxyDelegateToField(cls, processingEnvironment);
|
|
}
|
|
} catch (Exception unused) {
|
|
}
|
|
if (tryGetDelegateField != null) {
|
|
return tryRecursivelyObtainJavacProcessingEnvironment((ProcessingEnvironment) tryGetDelegateField);
|
|
}
|
|
continue;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Object tryGetDelegateField(Class<?> cls, Object obj) {
|
|
try {
|
|
return Permit.getField(cls, "delegate").get(obj);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static Object tryGetProcessingEnvField(Class<?> cls, Object obj) {
|
|
try {
|
|
return Permit.getField(cls, "processingEnv").get(obj);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static Object tryGetProxyDelegateToField(Class<?> cls, Object obj) {
|
|
try {
|
|
InvocationHandler invocationHandler = Proxy.getInvocationHandler(obj);
|
|
return Permit.getField(invocationHandler.getClass(), "val$delegateTo").get(invocationHandler);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public void init(ProcessingEnvironment processingEnvironment) {
|
|
AnnotationProcessor.super.init(processingEnvironment);
|
|
Iterator<ProcessorDescriptor> it = this.registered.iterator();
|
|
while (it.hasNext()) {
|
|
ProcessorDescriptor next = it.next();
|
|
if (next.want(processingEnvironment, this.delayedWarnings)) {
|
|
this.active.add(next);
|
|
}
|
|
}
|
|
if (this.active.isEmpty() && this.delayedWarnings.isEmpty()) {
|
|
StringBuilder sb = new StringBuilder();
|
|
Iterator<ProcessorDescriptor> it2 = this.registered.iterator();
|
|
while (it2.hasNext()) {
|
|
ProcessorDescriptor next2 = it2.next();
|
|
if (sb.length() > 0) {
|
|
sb.append(", ");
|
|
}
|
|
sb.append(next2.getName());
|
|
}
|
|
processingEnvironment.getMessager().printMessage(Diagnostic.Kind.WARNING, String.format("You aren't using a compiler supported by lombok, so lombok will not work and has been disabled.\nYour processor is: %s\nLombok supports: %s", processingEnvironment.getClass().getName(), sb));
|
|
}
|
|
}
|
|
|
|
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
|
|
if (!this.delayedWarnings.isEmpty()) {
|
|
Set rootElements = roundEnvironment.getRootElements();
|
|
if (!rootElements.isEmpty()) {
|
|
Element element = (Element) rootElements.iterator().next();
|
|
Iterator<String> it = this.delayedWarnings.iterator();
|
|
while (it.hasNext()) {
|
|
this.processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, it.next(), element);
|
|
}
|
|
this.delayedWarnings.clear();
|
|
}
|
|
}
|
|
Iterator<ProcessorDescriptor> it2 = this.active.iterator();
|
|
while (it2.hasNext()) {
|
|
it2.next().process(set, roundEnvironment);
|
|
}
|
|
boolean z2 = true;
|
|
boolean z3 = true;
|
|
Iterator<? extends TypeElement> it3 = set.iterator();
|
|
while (it3.hasNext()) {
|
|
z3 = false;
|
|
if (!((TypeElement) it3.next()).getQualifiedName().toString().startsWith("lombok.")) {
|
|
z2 = false;
|
|
}
|
|
}
|
|
return z2 && !z3;
|
|
}
|
|
|
|
public SourceVersion getSupportedSourceVersion() {
|
|
return SourceVersion.values()[SourceVersion.values().length - 1];
|
|
}
|
|
|
|
static /* synthetic */ String access$0(Throwable th) {
|
|
return trace(th);
|
|
}
|
|
}
|