This is an automated email from the ASF dual-hosted git repository. sunlan pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 99ad81a95ef39d52ee0ee4e36e02018e03be5ac0 Author: Daniel Sun <[email protected]> AuthorDate: Fri May 10 22:52:37 2019 +0800 Trivial refactoring: Rename variable names and simplify code --- .../org/codehaus/groovy/vmplugin/VMPlugin.java | 4 +-- .../org/codehaus/groovy/vmplugin/v5/Java5.java | 5 ++- .../org/codehaus/groovy/vmplugin/v9/Java9.java | 38 ++++++++++------------ 3 files changed, 21 insertions(+), 26 deletions(-) diff --git a/src/main/java/org/codehaus/groovy/vmplugin/VMPlugin.java b/src/main/java/org/codehaus/groovy/vmplugin/VMPlugin.java index 2848615..103d185 100644 --- a/src/main/java/org/codehaus/groovy/vmplugin/VMPlugin.java +++ b/src/main/java/org/codehaus/groovy/vmplugin/VMPlugin.java @@ -67,10 +67,10 @@ public interface VMPlugin { * Check whether invoking {@link AccessibleObject#setAccessible(boolean)} on the accessible object will be completed successfully * * @param accessibleObject the accessible object to check - * @param caller the caller to invoke {@code setAccessible} + * @param callerClass the callerClass to invoke {@code setAccessible} * @return the check result */ - boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> caller); + boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> callerClass); /** * Set the {@code accessible} flag for this reflected object to {@code true} diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java b/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java index b8182d1..56dd1e4 100644 --- a/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java +++ b/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java @@ -547,12 +547,11 @@ public class Java5 implements VMPlugin { * 2) the accessible object is a Constructor object for the Class class * * @param accessibleObject the accessible object to check - * @param caller the caller to invoke {@code setAccessible} + * @param callerClass the callerClass to invoke {@code setAccessible} * @return the check result */ @Override - public boolean checkCanSetAccessible(AccessibleObject accessibleObject, - Class<?> caller) { + public boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> callerClass) { SecurityManager sm = System.getSecurityManager(); try { if (sm != null) { diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java b/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java index 882d900..f6412f3 100644 --- a/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java +++ b/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java @@ -130,15 +130,14 @@ public class Java9 extends Java8 { * 4) D is in a package that the module containing D opens to at least the module containing C. All packages in unnamed and open modules are open to all modules and so this method always succeeds when D is in an unnamed or open module. * * @param accessibleObject the accessible object to check - * @param caller the caller to invoke {@code setAccessible} + * @param callerClass the callerClass to invoke {@code setAccessible} * @return the check result */ - public boolean checkCanSetAccessible(AccessibleObject accessibleObject, - Class<?> caller) { + public boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> callerClass) { - if (!super.checkCanSetAccessible(accessibleObject, caller)) return false; + if (!super.checkCanSetAccessible(accessibleObject, callerClass)) return false; - if (caller == MethodHandle.class) { + if (callerClass == MethodHandle.class) { throw new IllegalCallerException(); // should not happen } @@ -148,21 +147,18 @@ public class Java9 extends Java8 { Class<?> declaringClass = ((Member) accessibleObject).getDeclaringClass(); - Module callerModule = caller.getModule(); + Module callerModule = callerClass.getModule(); Module declaringModule = declaringClass.getModule(); if (callerModule == declaringModule) return true; if (callerModule == Object.class.getModule()) return true; if (!declaringModule.isNamed()) return true; - int modifiers; - if (accessibleObject instanceof Executable) { - modifiers = ((Executable) accessibleObject).getModifiers(); - } else { - modifiers = ((Field) accessibleObject).getModifiers(); - } + int modifiers = accessibleObject instanceof Executable + ? ((Executable) accessibleObject).getModifiers() + : ((Field) accessibleObject).getModifiers(); - return checkAccessible(caller, declaringClass, modifiers, true); + return checkAccessible(callerClass, declaringClass, modifiers, true); } @@ -243,21 +239,21 @@ public class Java9 extends Java8 { return optionalMethod.stream().map(CachedMethod::new).collect(Collectors.toList()); } - private static boolean checkAccessible(Class<?> caller, Class<?> declaringClass, int modifiers, boolean allowIllegalAccess) { - Module callerModule = caller.getModule(); + private static boolean checkAccessible(Class<?> callerClass, Class<?> declaringClass, int modifiers, boolean allowIllegalAccess) { + Module callerModule = callerClass.getModule(); Module declaringModule = declaringClass.getModule(); String pn = declaringClass.getPackageName(); boolean unnamedModuleAccessNamedModule = !callerModule.isNamed() && declaringModule.isNamed(); boolean toCheckIllegalAccess = !allowIllegalAccess && unnamedModuleAccessNamedModule; - // class is public and package is exported to caller + // class is public and package is exported to callerClass boolean isClassPublic = Modifier.isPublic(declaringClass.getModifiers()); if (isClassPublic && declaringModule.isExported(pn, callerModule)) { // member is public if (Modifier.isPublic(modifiers)) { if (toCheckIllegalAccess) { - if (isExportedForIllegalAccess(declaringModule, pn)) return false; + return !isExportedForIllegalAccess(declaringModule, pn); } return true; @@ -266,19 +262,19 @@ public class Java9 extends Java8 { // member is protected-static if (Modifier.isProtected(modifiers) && Modifier.isStatic(modifiers) - && isSubclassOf(caller, declaringClass)) { + && isSubclassOf(callerClass, declaringClass)) { if (toCheckIllegalAccess) { - if (isExportedForIllegalAccess(declaringModule, pn)) return false; + return !isExportedForIllegalAccess(declaringModule, pn); } return true; } } - // package is open to caller + // package is open to callerClass if (declaringModule.isOpen(pn, callerModule)) { if (toCheckIllegalAccess) { - if (isOpenedForIllegalAccess(declaringModule, pn)) return false; + return !isOpenedForIllegalAccess(declaringModule, pn); } return true;
