2022-03-02 20:59:20 +00:00
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 ( { " * " } )
2022-03-22 15:40:06 +00:00
/* loaded from: com.discord-119010.apk:lombok/core/AnnotationProcessor.SCL.lombok */
2022-03-02 20:59:20 +00:00
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 ( ) ;
2022-03-22 15:40:06 +00:00
/* loaded from: com.discord-119010.apk:lombok/core/AnnotationProcessor$EcjDescriptor.SCL.lombok */
2022-03-02 20:59:20 +00:00
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 ;
}
}
2022-03-22 15:40:06 +00:00
/* loaded from: com.discord-119010.apk:lombok/core/AnnotationProcessor$JavacDescriptor.SCL.lombok */
2022-03-02 20:59:20 +00:00
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 ) ;
}
}
2022-03-22 15:40:06 +00:00
/* loaded from: com.discord-119010.apk:lombok/core/AnnotationProcessor$ProcessorDescriptor.SCL.lombok */
2022-03-02 20:59:20 +00:00
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 ) ;
}
}