diff --git a/src/core/lombok/core/AST.java b/src/core/lombok/core/AST.java index fe7a4330..afbba1e8 100644 --- a/src/core/lombok/core/AST.java +++ b/src/core/lombok/core/AST.java @@ -39,6 +39,7 @@ import java.util.concurrent.ConcurrentMap; import lombok.core.configuration.ConfigurationKey; import lombok.core.debug.HistogramTracker; +import lombok.permit.Permit; /** * Lombok wraps the AST produced by a target platform into its own AST system, mostly because both Eclipse and javac @@ -252,7 +253,7 @@ public abstract class AST, L extends LombokNode, } if (shouldDrill(c, t, f.getName())) { - f.setAccessible(true); + Permit.setAccessible(f); fields.add(new FieldAccess(f, dim)); } } diff --git a/src/core/lombok/core/AnnotationProcessor.java b/src/core/lombok/core/AnnotationProcessor.java index 293bfef6..363952a4 100644 --- a/src/core/lombok/core/AnnotationProcessor.java +++ b/src/core/lombok/core/AnnotationProcessor.java @@ -46,6 +46,7 @@ import javax.lang.model.element.TypeElement; import javax.tools.Diagnostic.Kind; import lombok.patcher.ClassRootFinder; +import lombok.permit.Permit; @SupportedAnnotationTypes("*") public class AnnotationProcessor extends AbstractProcessor { @@ -82,8 +83,7 @@ public class AnnotationProcessor extends AbstractProcessor { for (Class procEnvClass = procEnv.getClass(); procEnvClass != null; procEnvClass = procEnvClass.getSuperclass()) { try { - Field field = procEnvClass.getDeclaredField("delegate"); - field.setAccessible(true); + Field field = Permit.getField(procEnvClass, "delegate"); Object delegate = field.get(procEnv); return tryRecursivelyObtainJavacProcessingEnvironment((ProcessingEnvironment) delegate); @@ -136,7 +136,7 @@ public class AnnotationProcessor extends AbstractProcessor { ClassLoader environmentClassLoader = procEnv.getClass().getClassLoader(); if (environmentClassLoader != null && environmentClassLoader.getClass().getCanonicalName().equals("org.codehaus.plexus.compiler.javac.IsolatedClassLoader")) { if (!ClassLoader_lombokAlreadyAddedTo.getAndSet(environmentClassLoader, true)) { - Method m = environmentClassLoader.getClass().getDeclaredMethod("addURL", URL.class); + Method m = Permit.getMethod(environmentClassLoader.getClass(), "addURL", URL.class); URL selfUrl = new File(ClassRootFinder.findClassRootOfClass(AnnotationProcessor.class)).toURI().toURL(); m.invoke(environmentClassLoader, selfUrl); } diff --git a/src/core/lombok/core/AnnotationValues.java b/src/core/lombok/core/AnnotationValues.java index a24330fa..eec5abd8 100644 --- a/src/core/lombok/core/AnnotationValues.java +++ b/src/core/lombok/core/AnnotationValues.java @@ -33,6 +33,7 @@ import java.util.List; import java.util.Map; import lombok.core.AST.Kind; +import lombok.permit.Permit; /** * Represents a single annotation in a source file and can be used to query the parameters present on it. @@ -210,7 +211,7 @@ public class AnnotationValues { public T getDefaultIf(String methodName, Class type, T defaultValue) { try { - return type.cast(type.getMethod(methodName).getDefaultValue()); + return type.cast(Permit.getMethod(type, methodName).getDefaultValue()); } catch (Exception e) { return defaultValue; } diff --git a/src/core/lombok/eclipse/EclipseAST.java b/src/core/lombok/eclipse/EclipseAST.java index 7cd2e400..1ba26338 100644 --- a/src/core/lombok/eclipse/EclipseAST.java +++ b/src/core/lombok/eclipse/EclipseAST.java @@ -34,6 +34,7 @@ import lombok.Lombok; import lombok.core.AST; import lombok.core.LombokImmutableList; import lombok.eclipse.handlers.EclipseHandlerUtil; +import lombok.permit.Permit; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.Path; @@ -497,7 +498,7 @@ public class EclipseAST extends AST { Throwable problem_ = null; Method m = null; try { - m = EclipseAstProblemView.class.getMethod("addProblemToCompilationResult", char[].class, Class.forName(COMPILATIONRESULT_TYPE), boolean.class, String.class, int.class, int.class); + m = Permit.getMethod(EclipseAstProblemView.class, "addProblemToCompilationResult", char[].class, Class.forName(COMPILATIONRESULT_TYPE), boolean.class, String.class, int.class, int.class); } catch (Throwable t) { // That's problematic, but as long as no local classes are used we don't actually need it. // Better fail on local classes than crash altogether. diff --git a/src/core/lombok/eclipse/TransformEclipseAST.java b/src/core/lombok/eclipse/TransformEclipseAST.java index 323fc171..e5edba64 100644 --- a/src/core/lombok/eclipse/TransformEclipseAST.java +++ b/src/core/lombok/eclipse/TransformEclipseAST.java @@ -30,6 +30,7 @@ import lombok.core.LombokConfiguration; import lombok.core.debug.DebugSnapshotStore; import lombok.core.debug.HistogramTracker; import lombok.patcher.Symbols; +import lombok.permit.Permit; import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; import org.eclipse.jdt.internal.compiler.ast.Annotation; @@ -90,7 +91,7 @@ public class TransformEclipseAST { disableLombok = true; } try { - f = CompilationUnitDeclaration.class.getDeclaredField("$lombokAST"); + f = Permit.getField(CompilationUnitDeclaration.class, "$lombokAST"); } catch (Throwable t) { //I guess we're in an ecj environment; we'll just not cache stuff then. } diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java index 5d582aad..c69b3d0f 100644 --- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java +++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java @@ -56,6 +56,7 @@ import lombok.eclipse.EclipseAST; import lombok.eclipse.EclipseNode; import lombok.experimental.Accessors; import lombok.experimental.Tolerate; +import lombok.permit.Permit; import org.eclipse.jdt.internal.compiler.ast.ASTNode; import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; @@ -337,9 +338,7 @@ public class EclipseHandlerUtil { private static Field getField(Class c, String fName) { try { - Field f = c.getDeclaredField(fName); - f.setAccessible(true); - return f; + return Permit.getField(c, fName); } catch (Exception e) { return null; } @@ -1931,12 +1930,12 @@ public class EclipseHandlerUtil { Constructor intLiteralConstructor_ = null; Method intLiteralFactoryMethod_ = null; try { - intLiteralConstructor_ = IntLiteral.class.getConstructor(parameterTypes); + intLiteralConstructor_ = Permit.getConstructor(IntLiteral.class, parameterTypes); } catch (Throwable ignore) { // probably eclipse 3.7++ } try { - intLiteralFactoryMethod_ = IntLiteral.class.getMethod("buildIntLiteral", parameterTypes); + intLiteralFactoryMethod_ = Permit.getMethod(IntLiteral.class, "buildIntLiteral", parameterTypes); } catch (Throwable ignore) { // probably eclipse versions before 3.7 } diff --git a/src/core/lombok/javac/CompilerMessageSuppressor.java b/src/core/lombok/javac/CompilerMessageSuppressor.java index 391ec64a..02dc6c26 100644 --- a/src/core/lombok/javac/CompilerMessageSuppressor.java +++ b/src/core/lombok/javac/CompilerMessageSuppressor.java @@ -39,6 +39,8 @@ import com.sun.tools.javac.util.JCDiagnostic; import com.sun.tools.javac.util.ListBuffer; import com.sun.tools.javac.util.Log; +import lombok.permit.Permit; + /** * During resolution, the resolver will emit resolution errors, but without appropriate file names and line numbers. If these resolution errors stick around * then they will be generated AGAIN, this time with proper names and line numbers, at the end. Therefore, we want to suppress the logger. @@ -89,11 +91,8 @@ public final class CompilerMessageSuppressor { static Field getDeclaredField(Class c, String fieldName) { try { - Field field = c.getDeclaredField(fieldName); - field.setAccessible(true); - return field; - } - catch (Throwable t) { + return Permit.getField(c, fieldName); + } catch (Throwable t) { return null; } } diff --git a/src/core/lombok/javac/Javac6BasedLombokOptions.java b/src/core/lombok/javac/Javac6BasedLombokOptions.java index cefb89ff..fc73181c 100644 --- a/src/core/lombok/javac/Javac6BasedLombokOptions.java +++ b/src/core/lombok/javac/Javac6BasedLombokOptions.java @@ -25,6 +25,7 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import lombok.Lombok; +import lombok.permit.Permit; import com.sun.tools.javac.util.Context; import com.sun.tools.javac.util.Options; @@ -36,8 +37,8 @@ public class Javac6BasedLombokOptions extends LombokOptions { static { try { Class optionNameClass = Class.forName("com.sun.tools.javac.main.OptionName"); - optionName_valueOf = optionNameClass.getMethod("valueOf", String.class); - options_put = Class.forName("com.sun.tools.javac.util.Options").getMethod("put", optionNameClass, String.class); + optionName_valueOf = Permit.getMethod(optionNameClass, "valueOf", String.class); + options_put = Permit.getMethod(Class.forName("com.sun.tools.javac.util.Options"), "put", optionNameClass, String.class); } catch (Exception e) { throw new IllegalArgumentException("Can't initialize Javac6-based lombok options due to reflection issue.", e); } diff --git a/src/core/lombok/javac/JavacAST.java b/src/core/lombok/javac/JavacAST.java index 091612cc..9a5305a6 100644 --- a/src/core/lombok/javac/JavacAST.java +++ b/src/core/lombok/javac/JavacAST.java @@ -37,6 +37,7 @@ import javax.tools.JavaFileObject; import com.sun.tools.javac.util.JCDiagnostic; import lombok.core.AST; +import lombok.permit.Permit; import com.sun.tools.javac.code.Source; import com.sun.tools.javac.code.Symtab; @@ -243,7 +244,7 @@ public class JavacAST extends AST { private static List getResourcesForTryNode(JCTry tryNode) { if (!JCTRY_RESOURCES_FIELD_INITIALIZED) { try { - JCTRY_RESOURCES_FIELD = JCTry.class.getField("resources"); + JCTRY_RESOURCES_FIELD = Permit.getField(JCTry.class, "resources"); } catch (NoSuchFieldException ignore) { // Java 1.6 or lower won't have this at all. } catch (Exception ignore) { @@ -343,7 +344,7 @@ public class JavacAST extends AST { return m; } try { - m = c.getMethod("getBody"); + m = Permit.getMethod(c, "getBody"); } catch (NoSuchMethodException e) { throw Javac.sneakyThrow(e); } @@ -501,12 +502,11 @@ public class JavacAST extends AST { } static ErrorLog create(Messager messager, Log log) { - Field errorCount = null; - try { - Field f = messager.getClass().getDeclaredField("errorCount"); - f.setAccessible(true); - errorCount = f; - } catch (Throwable t) {} + Field errorCount; try { + errorCount = Permit.getField(messager.getClass(), "errorCount"); + } catch (Throwable t) { + errorCount = null; + } boolean hasMultipleErrors = false; for (Field field : log.getClass().getFields()) { if (field.getName().equals("multipleErrors")) { @@ -515,14 +515,13 @@ public class JavacAST extends AST { } } if (hasMultipleErrors) return new JdkBefore9(log, messager, errorCount); - - Field warningCount = null; - try { - Field f = messager.getClass().getDeclaredField("warningCount"); - f.setAccessible(true); - warningCount = f; - } catch (Throwable t) {} - + + Field warningCount; try { + warningCount = Permit.getField(messager.getClass(), "warningCount"); + } catch (Throwable t) { + warningCount = null; + } + return new Jdk9Plus(log, messager, errorCount, warningCount); } } @@ -577,21 +576,18 @@ public class JavacAST extends AST { Class noteCls = Class.forName(jcd + "$Note"); Class lc = log.getClass(); - this.errorMethod = lc.getMethod("error", df, DiagnosticPosition.class, errorCls); - this.warningMethod = lc.getMethod("warning", DiagnosticPosition.class, warningCls); - this.mandatoryWarningMethod = lc.getMethod("mandatoryWarning", DiagnosticPosition.class, warningCls); - this.noteMethod = lc.getMethod("note", DiagnosticPosition.class, noteCls); + this.errorMethod = Permit.getMethod(lc, "error", df, DiagnosticPosition.class, errorCls); + this.warningMethod = Permit.getMethod(lc, "warning", DiagnosticPosition.class, warningCls); + this.mandatoryWarningMethod = Permit.getMethod(lc, "mandatoryWarning", DiagnosticPosition.class, warningCls); + this.noteMethod = Permit.getMethod(lc, "note", DiagnosticPosition.class, noteCls); - Field diagsField = lc.getSuperclass().getDeclaredField("diags"); - diagsField.setAccessible(true); - this.diags = (JCDiagnostic.Factory)diagsField.get(log); + Field diagsField = Permit.getField(lc.getSuperclass(), "diags"); + this.diags = (JCDiagnostic.Factory) diagsField.get(log); Class dc = this.diags.getClass(); - this.errorKey = dc.getMethod("errorKey", String.class, Object[].class); - this.warningKey = dc.getDeclaredMethod("warningKey", String.class, Object[].class); - this.warningKey.setAccessible(true); - this.noteKey = dc.getDeclaredMethod("noteKey", String.class, Object[].class); - this.noteKey.setAccessible(true); + this.errorKey = Permit.getMethod(dc, "errorKey", String.class, Object[].class); + this.warningKey = Permit.getMethod(dc, "warningKey", String.class, Object[].class); + this.noteKey = Permit.getMethod(dc, "noteKey", String.class, Object[].class); } catch (Throwable t) { //t.printStackTrace(); } diff --git a/src/core/lombok/javac/JavacResolution.java b/src/core/lombok/javac/JavacResolution.java index 8cc239e1..abbf6726 100644 --- a/src/core/lombok/javac/JavacResolution.java +++ b/src/core/lombok/javac/JavacResolution.java @@ -35,6 +35,7 @@ import javax.tools.JavaFileObject; import lombok.Lombok; import lombok.core.debug.AssertionLogger; +import lombok.permit.Permit; import com.sun.tools.javac.code.BoundKind; import com.sun.tools.javac.code.Symbol.TypeSymbol; @@ -162,14 +163,10 @@ public class JavacResolution { private static Field getMemberEnterDotEnv() { if (memberEnterDotEnv != null) return memberEnterDotEnv; try { - Field f = MemberEnter.class.getDeclaredField("env"); - f.setAccessible(true); - memberEnterDotEnv = f; + return memberEnterDotEnv = Permit.getField(MemberEnter.class, "env"); } catch (NoSuchFieldException e) { return null; } - - return memberEnterDotEnv; } @SuppressWarnings("unchecked") @@ -252,10 +249,10 @@ public class JavacResolution { static { Method upperBound = null; try { - upperBound = Types.class.getMethod("upperBound", Type.class); + upperBound = Permit.getMethod(Types.class, "upperBound", Type.class); } catch (Throwable ignore) {} if (upperBound == null) try { - upperBound = Types.class.getMethod("wildUpperBound", Type.class); + upperBound = Permit.getMethod(Types.class, "wildUpperBound", Type.class); } catch (Throwable ignore) {} UPPER_BOUND = upperBound; diff --git a/src/core/lombok/javac/apt/LombokFileObjects.java b/src/core/lombok/javac/apt/LombokFileObjects.java index aba10540..28d3c9fa 100644 --- a/src/core/lombok/javac/apt/LombokFileObjects.java +++ b/src/core/lombok/javac/apt/LombokFileObjects.java @@ -39,6 +39,7 @@ import javax.tools.JavaFileObject; import javax.tools.JavaFileObject.Kind; import lombok.core.DiagnosticsReceiver; +import lombok.permit.Permit; import com.sun.tools.javac.file.BaseFileManager; @@ -87,16 +88,14 @@ final class LombokFileObjects { } static Method getDecoderMethod(String className) { - Method m = null; try { - m = Class.forName(className).getDeclaredMethod("getDecoder", boolean.class); - m.setAccessible(true); + return Permit.getMethod(Class.forName(className), "getDecoder", boolean.class); } catch (NoSuchMethodException e) { // Intentional fallthrough - getDecoder(boolean) is not always present. } catch (ClassNotFoundException e) { // Intentional fallthrough - getDecoder(boolean) is not always present. } - return m; + return null; } private LombokFileObjects() {} diff --git a/src/core/lombok/javac/apt/LombokProcessor.java b/src/core/lombok/javac/apt/LombokProcessor.java index 247d0560..a3d1dfcf 100644 --- a/src/core/lombok/javac/apt/LombokProcessor.java +++ b/src/core/lombok/javac/apt/LombokProcessor.java @@ -52,6 +52,7 @@ import javax.tools.JavaFileObject; import lombok.Lombok; import lombok.core.DiagnosticsReceiver; import lombok.javac.JavacTransformer; +import lombok.permit.Permit; import com.sun.source.util.TreePath; import com.sun.source.util.Trees; @@ -112,10 +113,7 @@ public class LombokProcessor extends AbstractProcessor { private static final Field getFieldAccessor(String typeName, String fieldName) { try { - Class c = Class.forName(typeName); - Field f = c.getDeclaredField(fieldName); - f.setAccessible(true); - return f; + return Permit.getField(Class.forName(typeName), fieldName); } catch (ClassNotFoundException e) { return null; } catch (NoSuchFieldException e) { @@ -156,11 +154,9 @@ public class LombokProcessor extends AbstractProcessor { Context context = javacProcessingEnv.getContext(); disablePartialReparseInNetBeansEditor(context); try { - Method keyMethod = Context.class.getDeclaredMethod("key", Class.class); - keyMethod.setAccessible(true); + Method keyMethod = Permit.getMethod(Context.class, "key", Class.class); Object key = keyMethod.invoke(context, JavaFileManager.class); - Field htField = Context.class.getDeclaredField("ht"); - htField.setAccessible(true); + Field htField = Permit.getField(Context.class, "ht"); @SuppressWarnings("unchecked") Map ht = (Map) htField.get(context); final JavaFileManager originalFiler = (JavaFileManager) ht.get(key); @@ -170,8 +166,7 @@ public class LombokProcessor extends AbstractProcessor { JavaFileManager newFilerManager = new InterceptingJavaFileManager(originalFiler, receiver); ht.put(key, newFilerManager); - Field filerFileManagerField = JavacFiler.class.getDeclaredField("fileManager"); - filerFileManagerField.setAccessible(true); + Field filerFileManagerField = Permit.getField(JavacFiler.class, "fileManager"); filerFileManagerField.set(javacFiler, newFilerManager); if (lombok.javac.Javac.getJavaCompilerVersion() > 8 @@ -186,20 +181,17 @@ public class LombokProcessor extends AbstractProcessor { private void replaceFileManagerJdk9(Context context, JavaFileManager newFiler) { try { - JavaCompiler compiler = (JavaCompiler) JavaCompiler.class.getDeclaredMethod("instance", Context.class).invoke(null, context); + JavaCompiler compiler = (JavaCompiler) Permit.getMethod(JavaCompiler.class, "instance", Context.class).invoke(null, context); try { - Field fileManagerField = JavaCompiler.class.getDeclaredField("fileManager"); - fileManagerField.setAccessible(true); + Field fileManagerField = Permit.getField(JavaCompiler.class, "fileManager"); fileManagerField.set(compiler, newFiler); } catch (Exception e) {} try { - Field writerField = JavaCompiler.class.getDeclaredField("writer"); - writerField.setAccessible(true); + Field writerField = Permit.getField(JavaCompiler.class, "writer"); ClassWriter writer = (ClassWriter) writerField.get(compiler); - Field fileManagerField = ClassWriter.class.getDeclaredField("fileManager"); - fileManagerField.setAccessible(true); + Field fileManagerField = Permit.getField(ClassWriter.class, "fileManager"); fileManagerField.set(writer, newFiler); } catch (Exception e) {} @@ -210,8 +202,7 @@ public class LombokProcessor extends AbstractProcessor { private void forceMultipleRoundsInNetBeansEditor() { try { - Field f = JavacProcessingEnvironment.class.getDeclaredField("isBackgroundCompilation"); - f.setAccessible(true); + Field f = Permit.getField(JavacProcessingEnvironment.class, "isBackgroundCompilation"); f.set(javacProcessingEnv, true); } catch (NoSuchFieldException e) { // only NetBeans has it @@ -223,14 +214,12 @@ public class LombokProcessor extends AbstractProcessor { private void disablePartialReparseInNetBeansEditor(Context context) { try { Class cancelServiceClass = Class.forName("com.sun.tools.javac.util.CancelService"); - Method cancelServiceInstace = cancelServiceClass.getDeclaredMethod("instance", Context.class); + Method cancelServiceInstace = Permit.getMethod(cancelServiceClass, "instance", Context.class); Object cancelService = cancelServiceInstace.invoke(null, context); if (cancelService == null) return; - Field parserField = cancelService.getClass().getDeclaredField("parser"); - parserField.setAccessible(true); + Field parserField = Permit.getField(cancelService.getClass(), "parser"); Object parser = parserField.get(cancelService); - Field supportsReparseField = parser.getClass().getDeclaredField("supportsReparse"); - supportsReparseField.setAccessible(true); + Field supportsReparseField = Permit.getField(parser.getClass(), "supportsReparse"); supportsReparseField.set(parser, false); } catch (ClassNotFoundException e) { // only NetBeans has it @@ -284,8 +273,7 @@ public class LombokProcessor extends AbstractProcessor { private void stopJavacProcessingEnvironmentFromClosingOurClassloader() { try { - Field f = JavacProcessingEnvironment.class.getDeclaredField("processorClassLoader"); - f.setAccessible(true); + Field f = Permit.getField(JavacProcessingEnvironment.class, "processorClassLoader"); ClassLoader unwrapped = (ClassLoader) f.get(javacProcessingEnv); if (unwrapped == null) return; ClassLoader wrapped = wrapClassLoader(unwrapped); @@ -377,7 +365,7 @@ public class LombokProcessor extends AbstractProcessor { } catch (Exception e) { e.printStackTrace(); processingEnv.getMessager().printMessage(Kind.WARNING, - "Can't force a new processing round. Lombok won't work."); + "Can't force a new processing round. Lombok won't work."); } } } @@ -414,16 +402,14 @@ public class LombokProcessor extends AbstractProcessor { @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latest(); } - + /** * This class casts the given processing environment to a JavacProcessingEnvironment. In case of * gradle incremental compilation, the delegate ProcessingEnvironment of the gradle wrapper is returned. */ public JavacProcessingEnvironment getJavacProcessingEnvironment(Object procEnv) { - if (procEnv instanceof JavacProcessingEnvironment) { - return (JavacProcessingEnvironment) procEnv; - } - + if (procEnv instanceof JavacProcessingEnvironment) return (JavacProcessingEnvironment) procEnv; + // try to find a "delegate" field in the object, and use this to try to obtain a JavacProcessingEnvironment for (Class procEnvClass = procEnv.getClass(); procEnvClass != null; procEnvClass = procEnvClass.getSuperclass()) { try { @@ -432,9 +418,9 @@ public class LombokProcessor extends AbstractProcessor { // delegate field was not found, try on superclass } } - + processingEnv.getMessager().printMessage(Kind.WARNING, - "Can't get the delegate of the gradle IncrementalProcessingEnvironment. Lombok won't work."); + "Can't get the delegate of the gradle IncrementalProcessingEnvironment. Lombok won't work."); return null; } @@ -444,10 +430,8 @@ public class LombokProcessor extends AbstractProcessor { * (directly or through a delegate field again) */ public JavacFiler getJavacFiler(Object filer) { - if (filer instanceof JavacFiler) { - return (JavacFiler) filer; - } - + if (filer instanceof JavacFiler) return (JavacFiler) filer; + // try to find a "delegate" field in the object, and use this to check for a JavacFiler for (Class filerClass = filer.getClass(); filerClass != null; filerClass = filerClass.getSuperclass()) { try { @@ -456,15 +440,13 @@ public class LombokProcessor extends AbstractProcessor { // delegate field was not found, try on superclass } } - + processingEnv.getMessager().printMessage(Kind.WARNING, - "Can't get a JavacFiler from " + filer.getClass().getName() + ". Lombok won't work."); + "Can't get a JavacFiler from " + filer.getClass().getName() + ". Lombok won't work."); return null; } private Object tryGetDelegateField(Class delegateClass, Object instance) throws Exception { - Field field = delegateClass.getDeclaredField("delegate"); - field.setAccessible(true); - return field.get(instance); + return Permit.getField(delegateClass, "delegate").get(instance); } } diff --git a/src/core/lombok/javac/apt/Processor.java b/src/core/lombok/javac/apt/Processor.java index 7a187148..f15bf74c 100644 --- a/src/core/lombok/javac/apt/Processor.java +++ b/src/core/lombok/javac/apt/Processor.java @@ -53,6 +53,8 @@ import com.sun.tools.javac.processing.JavacFiler; import com.sun.tools.javac.processing.JavacProcessingEnvironment; import com.sun.tools.javac.util.Options; +import lombok.permit.Permit; + /** * This processor should not be used. It used to be THE processor. This class is only there to warn people that something went wrong, and for the * lombok developers to see if what the reason for those failures is. @@ -101,8 +103,7 @@ public class Processor extends AbstractProcessor { try { JavacProcessingEnvironment environment = (JavacProcessingEnvironment) procEnv; Options instance = Options.instance(environment.getContext()); - Field field = Options.class.getDeclaredField("values"); - field.setAccessible(true); + Field field = Permit.getField(Options.class, "values"); @SuppressWarnings("unchecked") Map values = (Map) field.get(instance); if (values.isEmpty()) { message.append("Options: empty\n\n"); @@ -125,8 +126,7 @@ public class Processor extends AbstractProcessor { private void findServices(StringBuilder message, Filer filer) { try { - Field filerFileManagerField = JavacFiler.class.getDeclaredField("fileManager"); - filerFileManagerField.setAccessible(true); + Field filerFileManagerField = Permit.getField(JavacFiler.class, "fileManager"); JavaFileManager jfm = (JavaFileManager) filerFileManagerField.get(filer); ClassLoader processorClassLoader = jfm.hasLocation(ANNOTATION_PROCESSOR_PATH) ? jfm.getClassLoader(ANNOTATION_PROCESSOR_PATH) : jfm.getClassLoader(CLASS_PATH); Enumeration resources = processorClassLoader.getResources("META-INF/services/javax.annotation.processing.Processor"); diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java index e4e40095..c97c7ede 100644 --- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java +++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java @@ -58,6 +58,7 @@ import lombok.experimental.Tolerate; import lombok.javac.Javac; import lombok.javac.JavacNode; import lombok.javac.JavacTreeMaker; +import lombok.permit.Permit; import com.sun.tools.javac.code.BoundKind; import com.sun.tools.javac.code.Flags; @@ -1049,10 +1050,9 @@ public class JavacHandlerUtil { if (TYPE != null) return; if (!in.getName().equals("com.sun.tools.javac.tree.JCTree$JCAnnotatedType")) return; try { - CONSTRUCTOR = in.getDeclaredConstructor(List.class, JCExpression.class); - CONSTRUCTOR.setAccessible(true); - ANNOTATIONS = in.getDeclaredField("annotations"); - UNDERLYING_TYPE = in.getDeclaredField("underlyingType"); + CONSTRUCTOR = Permit.getConstructor(in, List.class, JCExpression.class); + ANNOTATIONS = Permit.getField(in, "annotations"); + UNDERLYING_TYPE = Permit.getField(in, "underlyingType"); TYPE = in; } catch (Exception ignore) {} } @@ -1102,9 +1102,9 @@ public class JavacHandlerUtil { Method r = null; Method e = null; try { - f = ClassSymbol.class.getField("members_field"); - r = f.getType().getMethod("remove", Symbol.class); - e = f.getType().getMethod("enter", Symbol.class); + f = Permit.getField(ClassSymbol.class, "members_field"); + r = Permit.getMethod(f.getType(), "remove", Symbol.class); + e = Permit.getMethod(f.getType(), "enter", Symbol.class); } catch (Exception ex) {} membersField = f; removeMethod = r; diff --git a/src/delombok/lombok/delombok/Delombok.java b/src/delombok/lombok/delombok/Delombok.java index 0b97b4be..69898668 100644 --- a/src/delombok/lombok/delombok/Delombok.java +++ b/src/delombok/lombok/delombok/Delombok.java @@ -61,6 +61,7 @@ import lombok.javac.CommentCatcher; import lombok.javac.Javac; import lombok.javac.LombokOptions; import lombok.javac.apt.LombokProcessor; +import lombok.permit.Permit; import com.sun.tools.javac.code.Symtab; import com.sun.tools.javac.comp.Todo; @@ -638,7 +639,7 @@ public class Delombok { private static final Field MODULE_FIELD = getModuleField(); private static Field getModuleField() { try { - return JCCompilationUnit.class.getField("modle"); + return Permit.getField(JCCompilationUnit.class, "modle"); } catch (NoSuchFieldException e) { return null; } catch (SecurityException e) { @@ -808,10 +809,10 @@ public class Delombok { private static Object callAttributeMethodOnJavaCompiler(JavaCompiler compiler, Todo arg) { if (attributeMethod == null) { try { - attributeMethod = JavaCompiler.class.getDeclaredMethod("attribute", java.util.Queue.class); + attributeMethod = Permit.getMethod(JavaCompiler.class, "attribute", java.util.Queue.class); } catch (NoSuchMethodException e) { try { - attributeMethod = JavaCompiler.class.getDeclaredMethod("attribute", com.sun.tools.javac.util.ListBuffer.class); + attributeMethod = Permit.getMethod(JavaCompiler.class, "attribute", com.sun.tools.javac.util.ListBuffer.class); } catch (NoSuchMethodException e2) { throw Lombok.sneakyThrow(e2); } @@ -830,10 +831,10 @@ public class Delombok { private static void callFlowMethodOnJavaCompiler(JavaCompiler compiler, Object arg) { if (flowMethod == null) { try { - flowMethod = JavaCompiler.class.getDeclaredMethod("flow", java.util.Queue.class); + flowMethod = Permit.getMethod(JavaCompiler.class, "flow", java.util.Queue.class); } catch (NoSuchMethodException e) { try { - flowMethod = JavaCompiler.class.getDeclaredMethod("flow", com.sun.tools.javac.util.List.class); + flowMethod = Permit.getMethod(JavaCompiler.class, "flow", com.sun.tools.javac.util.List.class); } catch (NoSuchMethodException e2) { throw Lombok.sneakyThrow(e2); } diff --git a/src/delombok/lombok/delombok/DelombokApp.java b/src/delombok/lombok/delombok/DelombokApp.java index 2ba4c6ed..da1975b4 100644 --- a/src/delombok/lombok/delombok/DelombokApp.java +++ b/src/delombok/lombok/delombok/DelombokApp.java @@ -36,6 +36,7 @@ import java.util.jar.JarEntry; import java.util.jar.JarFile; import lombok.core.LombokApp; +import lombok.permit.Permit; import org.mangosdk.spi.ProviderFor; @@ -52,7 +53,7 @@ public class DelombokApp extends LombokApp { return 1; } try { - loadDelombok(args).getMethod("main", String[].class).invoke(null, new Object[] {args.toArray(new String[0])}); + Permit.getMethod(loadDelombok(args), "main", String[].class).invoke(null, new Object[] {args.toArray(new String[0])}); } catch (InvocationTargetException e1) { Throwable t = e1.getCause(); if (t instanceof Error) throw (Error)t; diff --git a/src/delombok/lombok/delombok/PrettyPrinter.java b/src/delombok/lombok/delombok/PrettyPrinter.java index 4261a558..3fb1f1b1 100644 --- a/src/delombok/lombok/delombok/PrettyPrinter.java +++ b/src/delombok/lombok/delombok/PrettyPrinter.java @@ -93,6 +93,7 @@ import com.sun.tools.javac.util.Position; import lombok.javac.CommentInfo; import lombok.javac.PackageName; +import lombok.permit.Permit; import lombok.javac.CommentInfo.EndConnection; import lombok.javac.CommentInfo.StartConnection; import lombok.javac.JavacTreeMaker.TreeTag; @@ -1335,7 +1336,6 @@ public class PrettyPrinter extends JCTree.Visitor { static { getExtendsClause = getMethod(JCClassDecl.class, "getExtendsClause", new Class[0]); - getExtendsClause.setAccessible(true); if (getJavaCompilerVersion() < 8) { getEndPosition = getMethod(DiagnosticPosition.class, "getEndPosition", java.util.Map.class); @@ -1350,11 +1350,11 @@ public class PrettyPrinter extends JCTree.Visitor { throw sneakyThrow(ex); } try { - storeEndMethodTemp = endPosTable.getMethod("storeEnd", JCTree.class, int.class); + storeEndMethodTemp = Permit.getMethod(endPosTable, "storeEnd", JCTree.class, int.class); } catch (NoSuchMethodException e) { try { endPosTable = Class.forName("com.sun.tools.javac.parser.JavacParser$AbstractEndPosTable"); - storeEndMethodTemp = endPosTable.getDeclaredMethod("storeEnd", JCTree.class, int.class); + storeEndMethodTemp = Permit.getMethod(endPosTable, "storeEnd", JCTree.class, int.class); } catch (NoSuchMethodException ex) { throw sneakyThrow(ex); } catch (ClassNotFoundException ex) { @@ -1363,13 +1363,13 @@ public class PrettyPrinter extends JCTree.Visitor { } storeEnd = storeEndMethodTemp; } - getEndPosition.setAccessible(true); - storeEnd.setAccessible(true); + Permit.setAccessible(getEndPosition); + Permit.setAccessible(storeEnd); } private static Method getMethod(Class clazz, String name, Class... paramTypes) { try { - return clazz.getMethod(name, paramTypes); + return Permit.getMethod(clazz, name, paramTypes); } catch (NoSuchMethodException e) { throw sneakyThrow(e); } @@ -1379,7 +1379,7 @@ public class PrettyPrinter extends JCTree.Visitor { try { Class[] c = new Class[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) c[i] = Class.forName(paramTypes[i]); - return clazz.getMethod(name, c); + return Permit.getMethod(clazz, name, c); } catch (NoSuchMethodException e) { throw sneakyThrow(e); } catch (ClassNotFoundException e) { @@ -1418,11 +1418,10 @@ public class PrettyPrinter extends JCTree.Visitor { Field f = c.get(fieldName); if (f == null) { try { - f = tClass.getDeclaredField(fieldName); + f = Permit.getField(tClass, fieldName); } catch (Exception e) { return defaultValue; } - f.setAccessible(true); c.put(fieldName, f); } diff --git a/src/delombok/lombok/delombok/ant/DelombokTask.java b/src/delombok/lombok/delombok/ant/DelombokTask.java index adaf43dd..3828a5db 100644 --- a/src/delombok/lombok/delombok/ant/DelombokTask.java +++ b/src/delombok/lombok/delombok/ant/DelombokTask.java @@ -30,6 +30,7 @@ import java.util.ArrayList; import java.util.List; import lombok.Lombok; +import lombok.permit.Permit; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.Location; @@ -176,8 +177,7 @@ class Tasks { } catch (ClassNotFoundException e) { // If we get here, it isn't, and we should use the shadowloader. Class launcherMain = Class.forName("lombok.launch.Main"); - Method m = launcherMain.getDeclaredMethod("createShadowClassLoader"); - m.setAccessible(true); + Method m = Permit.getMethod(launcherMain, "createShadowClassLoader"); shadowLoader = (ClassLoader) m.invoke(null); } } @@ -195,10 +195,9 @@ class Tasks { try { Object instance = shadowLoadClass("lombok.delombok.ant.DelombokTaskImpl").newInstance(); for (Field selfField : getClass().getDeclaredFields()) { + Permit.setAccessible(selfField); if (selfField.isSynthetic() || Modifier.isStatic(selfField.getModifiers())) continue; - Field otherField = instance.getClass().getDeclaredField(selfField.getName()); - otherField.setAccessible(true); - selfField.setAccessible(true); + Field otherField = Permit.getField(instance.getClass(), selfField.getName()); if (selfField.getName().equals("formatOptions")) { List rep = new ArrayList(); for (Format f : formatOptions) { @@ -211,8 +210,7 @@ class Tasks { } } - Method m = instance.getClass().getMethod("execute", Location.class); - m.setAccessible(true); + Method m = Permit.getMethod(instance.getClass(), "execute", Location.class); m.invoke(instance, loc); } catch (InvocationTargetException e) { throw Lombok.sneakyThrow(e.getCause()); diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java index c11a49cd..ace97a4d 100644 --- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java +++ b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java @@ -33,6 +33,7 @@ import java.util.List; import lombok.eclipse.EclipseNode; import lombok.eclipse.agent.PatchExtensionMethod.Extension; import lombok.experimental.ExtensionMethod; +import lombok.permit.Permit; import org.eclipse.jdt.core.CompletionProposal; import org.eclipse.jdt.internal.codeassist.InternalCompletionContext; @@ -220,7 +221,7 @@ public class PatchExtensionMethodCompletionProposal { return null; } } - + private static Method accessMethod(Class clazz, String methodName, Class parameter) { try { return makeAccessible(clazz.getDeclaredMethod(methodName, parameter)); @@ -228,10 +229,9 @@ public class PatchExtensionMethodCompletionProposal { return null; } } - + private static T makeAccessible(T object) { - object.setAccessible(true); - return object; + return Permit.setAccessible(object); } } } diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java index fee104d3..8d581819 100644 --- a/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java +++ b/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java @@ -43,6 +43,8 @@ import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; import org.eclipse.jdt.internal.compiler.lookup.TypeConstants; import org.eclipse.jdt.internal.compiler.lookup.TypeIds; +import lombok.permit.Permit; + import java.lang.reflect.Field; import static lombok.eclipse.Eclipse.poss; @@ -196,8 +198,8 @@ public class PatchVal { Field a = null, b = null; try { - a = LocalDeclaration.class.getDeclaredField("$initCopy"); - b = LocalDeclaration.class.getDeclaredField("$iterableCopy"); + a = Permit.getField(LocalDeclaration.class, "$initCopy"); + b = Permit.getField(LocalDeclaration.class, "$iterableCopy"); } catch (Throwable t) { //ignore - no $initCopy exists when running in ecj. } diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchValEclipse.java b/src/eclipseAgent/lombok/eclipse/agent/PatchValEclipse.java index 99447bae..fc6e7de2 100644 --- a/src/eclipseAgent/lombok/eclipse/agent/PatchValEclipse.java +++ b/src/eclipseAgent/lombok/eclipse/agent/PatchValEclipse.java @@ -30,6 +30,7 @@ import java.lang.reflect.Method; import java.util.List; import lombok.Lombok; +import lombok.permit.Permit; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.IExtendedModifier; @@ -277,8 +278,7 @@ public class PatchValEclipse { static { Field f = null; try { - f = Name.class.getDeclaredField("index"); - f.setAccessible(true); + f = Permit.getField(Name.class, "index"); } catch (Throwable t) { // Leave it null, in which case we don't set index. That'll result in error log messages but its better than crashing here. } @@ -308,24 +308,19 @@ public class PatchValEclipse { Method h = null; try { - a = LocalDeclaration.class.getDeclaredField("$initCopy"); - b = LocalDeclaration.class.getDeclaredField("$iterableCopy"); + a = Permit.getField(LocalDeclaration.class, "$initCopy"); + b = Permit.getField(LocalDeclaration.class, "$iterableCopy"); } catch (Throwable t) { //ignore - no $initCopy exists when running in ecj. } try { - c = Parser.class.getDeclaredField("astStack"); - c.setAccessible(true); - d = Parser.class.getDeclaredField("astPtr"); - d.setAccessible(true); - f = Modifier.class.getDeclaredConstructor(AST.class); - f.setAccessible(true); - g = MarkerAnnotation.class.getDeclaredConstructor(AST.class); - g.setAccessible(true); + c = Permit.getField(Parser.class, "astStack"); + d = Permit.getField(Parser.class, "astPtr"); + f = Permit.getConstructor(Modifier.class, AST.class); + g = Permit.getConstructor(MarkerAnnotation.class, AST.class); Class z = Class.forName("org.eclipse.jdt.core.dom.ASTConverter"); - h = z.getDeclaredMethod("recordNodes", org.eclipse.jdt.core.dom.ASTNode.class, org.eclipse.jdt.internal.compiler.ast.ASTNode.class); - h.setAccessible(true); + h = Permit.getMethod(z, "recordNodes", org.eclipse.jdt.core.dom.ASTNode.class, org.eclipse.jdt.internal.compiler.ast.ASTNode.class); } catch (Throwable t) { // Most likely we're in ecj or some other plugin usage of the eclipse compiler. No need for this. } diff --git a/src/utils/lombok/core/FieldAugment.java b/src/utils/lombok/core/FieldAugment.java index ee8acf4d..4a32ad04 100644 --- a/src/utils/lombok/core/FieldAugment.java +++ b/src/utils/lombok/core/FieldAugment.java @@ -27,6 +27,8 @@ import java.lang.reflect.Modifier; import java.util.Map; import java.util.WeakHashMap; +import lombok.permit.Permit; + public abstract class FieldAugment { private static Object getDefaultValue(Class type) { if (type == boolean.class) return false; @@ -101,10 +103,9 @@ public abstract class FieldAugment { private static Field findField(Class type, Class wantedType, String name) { try { - Field f = type.getDeclaredField(name); + Field f = Permit.getField(type, name); if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) return null; if (!typeIsAssignmentCompatible(f.getType(), wantedType)) return null; - f.setAccessible(true); return f; } catch (Exception e) { return null; diff --git a/src/utils/lombok/javac/CommentCatcher.java b/src/utils/lombok/javac/CommentCatcher.java index afbd7b52..f8b73b0a 100644 --- a/src/utils/lombok/javac/CommentCatcher.java +++ b/src/utils/lombok/javac/CommentCatcher.java @@ -26,6 +26,7 @@ import java.util.Collections; import java.util.List; import lombok.core.FieldAugment; +import lombok.permit.Permit; import com.sun.tools.javac.main.JavaCompiler; import com.sun.tools.javac.tree.JCTree.JCCompilationUnit; @@ -79,7 +80,7 @@ public class CommentCatcher { } else { scannerFactory = Class.forName("lombok.javac.java8.CommentCollectingScannerFactory"); } - scannerFactory.getMethod("preRegister", Context.class).invoke(null, context); + Permit.getMethod(scannerFactory, "preRegister", Context.class).invoke(null, context); } catch (InvocationTargetException e) { throw Javac.sneakyThrow(e.getCause()); } catch (Exception e) { @@ -100,7 +101,7 @@ public class CommentCatcher { } else { parserFactory = Class.forName("lombok.javac.java9.CommentCollectingParserFactory"); } - parserFactory.getMethod("setInCompiler", JavaCompiler.class, Context.class).invoke(null, compiler, context); + Permit.getMethod(parserFactory, "setInCompiler", JavaCompiler.class, Context.class).invoke(null, compiler, context); } catch (InvocationTargetException e) { throw Javac.sneakyThrow(e.getCause()); } catch (Exception e) { diff --git a/src/utils/lombok/javac/Javac.java b/src/utils/lombok/javac/Javac.java index 92961726..a2cb32c6 100644 --- a/src/utils/lombok/javac/Javac.java +++ b/src/utils/lombok/javac/Javac.java @@ -40,6 +40,7 @@ import lombok.core.ClassLiteral; import lombok.core.FieldSelect; import lombok.javac.JavacTreeMaker.TreeTag; import lombok.javac.JavacTreeMaker.TypeTag; +import lombok.permit.Permit; import com.sun.tools.javac.code.Source; import com.sun.tools.javac.code.Symtab; @@ -199,7 +200,6 @@ public class Javac { static { getExtendsClause = getMethod(JCClassDecl.class, "getExtendsClause", new Class[0]); - getExtendsClause.setAccessible(true); if (getJavaCompilerVersion() < 8) { getEndPosition = getMethod(DiagnosticPosition.class, "getEndPosition", java.util.Map.class); @@ -214,11 +214,11 @@ public class Javac { throw sneakyThrow(ex); } try { - storeEndMethodTemp = endPosTable.getMethod("storeEnd", JCTree.class, int.class); + storeEndMethodTemp = Permit.getMethod(endPosTable, "storeEnd", JCTree.class, int.class); } catch (NoSuchMethodException e) { try { endPosTable = Class.forName("com.sun.tools.javac.parser.JavacParser$AbstractEndPosTable"); - storeEndMethodTemp = endPosTable.getDeclaredMethod("storeEnd", JCTree.class, int.class); + storeEndMethodTemp = Permit.getMethod(endPosTable, "storeEnd", JCTree.class, int.class); } catch (NoSuchMethodException ex) { throw sneakyThrow(ex); } catch (ClassNotFoundException ex) { @@ -227,13 +227,13 @@ public class Javac { } storeEnd = storeEndMethodTemp; } - getEndPosition.setAccessible(true); - storeEnd.setAccessible(true); + Permit.setAccessible(getEndPosition); + Permit.setAccessible(storeEnd); } private static Method getMethod(Class clazz, String name, Class... paramTypes) { try { - return clazz.getMethod(name, paramTypes); + return Permit.getMethod(clazz, name, paramTypes); } catch (NoSuchMethodException e) { throw sneakyThrow(e); } @@ -243,7 +243,7 @@ public class Javac { try { Class[] c = new Class[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) c[i] = Class.forName(paramTypes[i]); - return clazz.getMethod(name, c); + return Permit.getMethod(clazz, name, c); } catch (NoSuchMethodException e) { throw sneakyThrow(e); } catch (ClassNotFoundException e) { @@ -320,7 +320,7 @@ public class Javac { private static Field getFieldIfExists(Class c, String fieldName) { try { - return c.getField("voidType"); + return Permit.getField(c, "voidType"); } catch (Exception e) { return null; } @@ -370,13 +370,13 @@ public class Javac { static { Field f = null; try { - f = JCCompilationUnit.class.getDeclaredField("endPositions"); + f = Permit.getField(JCCompilationUnit.class, "endPositions"); } catch (NoSuchFieldException e) {} JCCOMPILATIONUNIT_ENDPOSITIONS = f; f = null; try { - f = JCCompilationUnit.class.getDeclaredField("docComments"); + f = Permit.getField(JCCompilationUnit.class, "docComments"); } catch (NoSuchFieldException e) {} JCCOMPILATIONUNIT_DOCCOMMENTS = f; } diff --git a/src/utils/lombok/javac/JavacTreeMaker.java b/src/utils/lombok/javac/JavacTreeMaker.java index 5f4fb09c..68a16af2 100644 --- a/src/utils/lombok/javac/JavacTreeMaker.java +++ b/src/utils/lombok/javac/JavacTreeMaker.java @@ -88,6 +88,8 @@ import com.sun.tools.javac.tree.TreeMaker; import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Name; +import lombok.permit.Permit; + public class JavacTreeMaker { private final TreeMaker tm; @@ -153,7 +155,7 @@ public class JavacTreeMaker { Object value = cache.get(fieldName); if (value != null) return value; try { - value = Class.forName(className).getField(fieldName).get(null); + value = Permit.getField(Class.forName(className), fieldName).get(null); } catch (NoSuchFieldException e) { throw Javac.sneakyThrow(e); } catch (IllegalAccessException e) { @@ -169,7 +171,7 @@ public class JavacTreeMaker { private static Field NOSUCHFIELDEX_MARKER; static { try { - NOSUCHFIELDEX_MARKER = SchroedingerType.class.getDeclaredField("NOSUCHFIELDEX_MARKER"); + NOSUCHFIELDEX_MARKER = Permit.getField(SchroedingerType.class, "NOSUCHFIELDEX_MARKER"); } catch (NoSuchFieldException e) { throw Javac.sneakyThrow(e); } @@ -180,12 +182,12 @@ public class JavacTreeMaker { Field field = cache.get(c); if (field == null) { try { - field = c.getField(fieldName); + field = Permit.getField(c, fieldName); } catch (NoSuchFieldException e) { cache.putIfAbsent(c, NOSUCHFIELDEX_MARKER); throw Javac.sneakyThrow(e); } - field.setAccessible(true); + Permit.setAccessible(field); Field old = cache.putIfAbsent(c, field); if (old != null) field = old; } @@ -207,8 +209,7 @@ public class JavacTreeMaker { static { Method m = null; try { - m = Type.class.getDeclaredMethod("getTag"); - m.setAccessible(true); + m = Permit.getMethod(Type.class, "getTag"); } catch (NoSuchMethodException e) {} TYPE_TYPETAG_METHOD = m; } @@ -255,8 +256,7 @@ public class JavacTreeMaker { static { Method m = null; try { - m = JCTree.class.getDeclaredMethod("getTag"); - m.setAccessible(true); + m = Permit.getMethod(JCTree.class, "getTag"); } catch (NoSuchMethodException e) {} if (m != null) { @@ -265,8 +265,7 @@ public class JavacTreeMaker { } else { Field f = null; try { - f = JCTree.class.getDeclaredField("tag"); - f.setAccessible(true); + f = Permit.getField(JCTree.class, "tag"); } catch (NoSuchFieldException e) {} TAG_FIELD = f; TAG_METHOD = null; @@ -381,7 +380,7 @@ public class JavacTreeMaker { else throw new IllegalStateException("Lombok TreeMaker frontend issue: multiple matches when looking for method: " + m); } if (found == null) throw new IllegalStateException("Lombok TreeMaker frontend issue: no match when looking for method: " + m); - found.setAccessible(true); + Permit.setAccessible(found); Object marker = METHOD_CACHE.putIfAbsent(m, found); if (marker == null) return found; return METHOD_CACHE.get(m); diff --git a/src/utils/lombok/javac/PackageName.java b/src/utils/lombok/javac/PackageName.java index e4dd6b20..72892cca 100644 --- a/src/utils/lombok/javac/PackageName.java +++ b/src/utils/lombok/javac/PackageName.java @@ -28,13 +28,15 @@ import com.sun.tools.javac.tree.JCTree.JCCompilationUnit; import com.sun.tools.javac.tree.JCTree.JCFieldAccess; import com.sun.tools.javac.tree.JCTree.JCIdent; +import lombok.permit.Permit; + // Supports JDK6-9 public class PackageName { private static final Method packageNameMethod = getPackageNameMethod(); private static Method getPackageNameMethod() { try { - return JCCompilationUnit.class.getDeclaredMethod("getPackageName"); + return Permit.getMethod(JCCompilationUnit.class, "getPackageName"); } catch (Exception e) { return null; } diff --git a/src/utils/lombok/javac/java6/CommentCollectingParserFactory.java b/src/utils/lombok/javac/java6/CommentCollectingParserFactory.java index 0cf8fdcd..5d96f9d1 100644 --- a/src/utils/lombok/javac/java6/CommentCollectingParserFactory.java +++ b/src/utils/lombok/javac/java6/CommentCollectingParserFactory.java @@ -28,6 +28,8 @@ import com.sun.tools.javac.parser.Lexer; import com.sun.tools.javac.parser.Parser; import com.sun.tools.javac.util.Context; +import lombok.permit.Permit; + public class CommentCollectingParserFactory extends Parser.Factory { static Context.Key key() { return parserFactoryKey; @@ -49,8 +51,7 @@ public class CommentCollectingParserFactory extends Parser.Factory { context.put(CommentCollectingParserFactory.key(), (Parser.Factory)null); Field field; try { - field = JavaCompiler.class.getDeclaredField("parserFactory"); - field.setAccessible(true); + field = Permit.getField(JavaCompiler.class, "parserFactory"); field.set(compiler, new CommentCollectingParserFactory(context)); } catch (Exception e) { throw new IllegalStateException("Could not set comment sensitive parser in the compiler", e); diff --git a/src/utils/lombok/javac/java7/CommentCollectingParserFactory.java b/src/utils/lombok/javac/java7/CommentCollectingParserFactory.java index ffd68f55..7ef937cd 100644 --- a/src/utils/lombok/javac/java7/CommentCollectingParserFactory.java +++ b/src/utils/lombok/javac/java7/CommentCollectingParserFactory.java @@ -30,6 +30,8 @@ import com.sun.tools.javac.parser.ParserFactory; import com.sun.tools.javac.parser.ScannerFactory; import com.sun.tools.javac.util.Context; +import lombok.permit.Permit; + public class CommentCollectingParserFactory extends ParserFactory { private final Context context; @@ -56,8 +58,7 @@ public class CommentCollectingParserFactory extends ParserFactory { context.put(CommentCollectingParserFactory.key(), (ParserFactory)null); Field field; try { - field = JavaCompiler.class.getDeclaredField("parserFactory"); - field.setAccessible(true); + field = Permit.getField(JavaCompiler.class, "parserFactory"); field.set(compiler, new CommentCollectingParserFactory(context)); } catch (Exception e) { throw new IllegalStateException("Could not set comment sensitive parser in the compiler", e); diff --git a/src/utils/lombok/javac/java8/CommentCollectingParserFactory.java b/src/utils/lombok/javac/java8/CommentCollectingParserFactory.java index 2fdaddfe..0988ce6d 100644 --- a/src/utils/lombok/javac/java8/CommentCollectingParserFactory.java +++ b/src/utils/lombok/javac/java8/CommentCollectingParserFactory.java @@ -30,6 +30,8 @@ import com.sun.tools.javac.parser.ParserFactory; import com.sun.tools.javac.parser.ScannerFactory; import com.sun.tools.javac.util.Context; +import lombok.permit.Permit; + public class CommentCollectingParserFactory extends ParserFactory { private final Context context; @@ -66,8 +68,7 @@ public class CommentCollectingParserFactory extends ParserFactory { context.put(CommentCollectingParserFactory.key(), (ParserFactory) null); Field field; try { - field = JavaCompiler.class.getDeclaredField("parserFactory"); - field.setAccessible(true); + field = Permit.getField(JavaCompiler.class, "parserFactory"); field.set(compiler, new CommentCollectingParserFactory(context)); } catch (Exception e) { throw new IllegalStateException("Could not set comment sensitive parser in the compiler", e); diff --git a/src/utils/lombok/javac/java9/CommentCollectingParserFactory.java b/src/utils/lombok/javac/java9/CommentCollectingParserFactory.java index 5af4a419..208d2570 100644 --- a/src/utils/lombok/javac/java9/CommentCollectingParserFactory.java +++ b/src/utils/lombok/javac/java9/CommentCollectingParserFactory.java @@ -30,6 +30,8 @@ import com.sun.tools.javac.parser.ParserFactory; import com.sun.tools.javac.parser.ScannerFactory; import com.sun.tools.javac.util.Context; +import lombok.permit.Permit; + public class CommentCollectingParserFactory extends ParserFactory { private final Context context; @@ -60,8 +62,7 @@ public class CommentCollectingParserFactory extends ParserFactory { context.put(CommentCollectingParserFactory.key(), (ParserFactory) null); Field field; try { - field = JavaCompiler.class.getDeclaredField("parserFactory"); - field.setAccessible(true); + field = Permit.getField(JavaCompiler.class, "parserFactory"); field.set(compiler, new CommentCollectingParserFactory(context)); } catch (Exception e) { throw new IllegalStateException("Could not set comment sensitive parser in the compiler", e); diff --git a/src/utils/lombok/permit/Permit.java b/src/utils/lombok/permit/Permit.java new file mode 100644 index 00000000..00b8274c --- /dev/null +++ b/src/utils/lombok/permit/Permit.java @@ -0,0 +1,100 @@ +package lombok.permit; + +import java.lang.reflect.AccessibleObject; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +import com.sun.tools.javac.tree.JCTree.JCExpression; +import com.sun.tools.javac.util.List; + +// sunapi suppresses javac's warning about using Unsafe; 'all' suppresses eclipse's warning about the unspecified 'sunapi' key. Leave them both. +// Yes, javac's definition of the word 'all' is quite contrary to what the dictionary says it means. 'all' does NOT include 'sunapi' according to javac. +@SuppressWarnings({"sunapi", "all"}) +public class Permit { + private Permit() {} + + + private static final long ACCESSIBLE_OVERRIDE_FIELD_OFFSET; + private static final IllegalAccessException INIT_ERROR; + private static final sun.misc.Unsafe UNSAFE = (sun.misc.Unsafe) reflectiveStaticFieldAccess(sun.misc.Unsafe.class, "theUnsafe"); + + static { + Field f; + long g; + Throwable ex; + + try { + f = AccessibleObject.class.getDeclaredField("override"); + g = UNSAFE.objectFieldOffset(f); + ex = null; + } catch (Throwable t) { + f = null; + g = -1L; + ex = t; + } + + ACCESSIBLE_OVERRIDE_FIELD_OFFSET = g; + if (ex == null) INIT_ERROR = null; + else if (ex instanceof IllegalAccessException) INIT_ERROR = (IllegalAccessException) ex; + else { + INIT_ERROR = new IllegalAccessException("Cannot initialize Unsafe-based permit"); + INIT_ERROR.initCause(ex); + } + } + + public static T setAccessible(T accessor) { + if (INIT_ERROR == null) { + UNSAFE.putBoolean(accessor, ACCESSIBLE_OVERRIDE_FIELD_OFFSET, true); + } else { + accessor.setAccessible(true); + } + + return accessor; + } + + public static Method getMethod(Class c, String mName, Class... parameterTypes) throws NoSuchMethodException { + Method m = null; + Class oc = c; + while (c != null) { + try { + m = c.getDeclaredMethod(mName, parameterTypes); + break; + } catch (NoSuchMethodException e) {} + c = c.getSuperclass(); + } + + if (m == null) throw new NoSuchMethodException(oc.getName() + " :: " + mName + "(args)"); + return setAccessible(m); + } + + public static Field getField(Class c, String fName) throws NoSuchFieldException { + Field f = null; + Class oc = c; + while (c != null) { + try { + f = c.getDeclaredField(fName); + break; + } catch (NoSuchFieldException e) {} + c = c.getSuperclass(); + } + + if (f == null) throw new NoSuchFieldException(oc.getName() + " :: " + fName); + + return setAccessible(f); + } + + public static Constructor getConstructor(Class c, Class... parameterTypes) throws NoSuchMethodException { + return setAccessible(c.getDeclaredConstructor(parameterTypes)); + } + + private static Object reflectiveStaticFieldAccess(Class c, String fName) { + try { + Field f = c.getDeclaredField(fName); + f.setAccessible(true); + return f.get(null); + } catch (Exception e) { + return null; + } + } +} diff --git a/src/utils/lombok/permit/package-info.java b/src/utils/lombok/permit/package-info.java new file mode 100644 index 00000000..a28f7160 --- /dev/null +++ b/src/utils/lombok/permit/package-info.java @@ -0,0 +1,8 @@ +/** + * This is a reduced copy of the nqzero Permit-reflect project. + * https://github.com/nqzero/permit-reflect + * + * Many thanks to nqzero. The permit-reflect project is, like lombok itself, licensed under the MIT license. + * See https://github.com/nqzero/permit-reflect/blob/master/License for license info. + */ +package lombok.permit; \ No newline at end of file