Add AccessVisibility detection support

Add `AccessVisibility` enum which can be used to determine the access visibility of `Member` or `ResolvableType`. See gh-28414
2022-04-13 17:38:40 -07:00
parent 9c12833e16
commit a605d3f6ed
5 changed files with 456 additions and 0 deletions
--- a/spring-core/src/test/java/org/springframework/aot/generate/AccessVisibilityTests.java
+++ b/spring-core/src/test/java/org/springframework/aot/generate/AccessVisibilityTests.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.generate;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.core.ResolvableType;
+import org.springframework.core.testfixture.aot.generator.visibility.ProtectedGenericParameter;
+import org.springframework.core.testfixture.aot.generator.visibility.ProtectedParameter;
+import org.springframework.core.testfixture.aot.generator.visibility.PublicFactoryBean;
+import org.springframework.util.ReflectionUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link AccessVisibility}.
+ *
+ * @author Phillip Webb
+ * @author Stephane Nicoll
+ */
+class AccessVisibilityTests {
+
+	@Test
+	void forMemberWhenPublicConstructor() throws NoSuchMethodException {
+		Member member = PublicClass.class.getConstructor();
+		assertThat(AccessVisibility.forMember(member)).isEqualTo(AccessVisibility.PUBLIC);
+	}
+
+	@Test
+	void forMemberWhenPackagePrivateConstructor() {
+		Member member = ProtectedAccessor.class.getDeclaredConstructors()[0];
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPackagePrivateClassWithPublicConstructor() {
+		Member member = PackagePrivateClass.class.getDeclaredConstructors()[0];
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPackagePrivateClassWithPublicMethod() {
+		Member member = method(PackagePrivateClass.class, "stringBean");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateConstructorParameter() {
+		Member member = ProtectedParameter.class.getConstructors()[0];
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateGenericOnConstructorParameter() {
+		Member member = ProtectedGenericParameter.class.getConstructors()[0];
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateMethod() {
+		Member member = method(PublicClass.class, "getProtectedMethod");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateMethodReturnType() {
+		Member member = method(ProtectedAccessor.class, "methodWithProtectedReturnType");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateMethodParameter() {
+		Member member = method(ProtectedAccessor.class, "methodWithProtectedParameter",
+				PackagePrivateClass.class);
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateField() {
+		Field member = field(PublicClass.class, "protectedField");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPublicFieldAndPackagePrivateFieldType() {
+		Member member = field(PublicClass.class, "protectedClassField");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPublicMethodAndPackagePrivateGenericOnReturnType() {
+		Member member = method(PublicFactoryBean.class, "protectedTypeFactoryBean");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPackagePrivateArrayComponent() {
+		Member member = field(PublicClass.class, "packagePrivateClasses");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forResolvableTypeWhenPackagePrivateGeneric() {
+		ResolvableType resolvableType = PublicFactoryBean
+				.resolveToProtectedGenericParameter();
+		assertThat(AccessVisibility.forResolvableType(resolvableType))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forResolvableTypeWhenRecursiveType() {
+		ResolvableType resolvableType = ResolvableType
+				.forClassWithGenerics(SelfReference.class, SelfReference.class);
+		assertThat(AccessVisibility.forResolvableType(resolvableType))
+				.isEqualTo(AccessVisibility.PACKAGE_PRIVATE);
+	}
+
+	@Test
+	void forMemberWhenPublicClassWithPrivateField() {
+		Member member = field(PublicClass.class, "privateField");
+		assertThat(AccessVisibility.forMember(member))
+				.isEqualTo(AccessVisibility.PRIVATE);
+	}
+
+	private static Method method(Class<?> type, String name, Class<?>... parameterTypes) {
+		Method method = ReflectionUtils.findMethod(type, name, parameterTypes);
+		assertThat(method).isNotNull();
+		return method;
+	}
+
+	private static Field field(Class<?> type, String name) {
+		Field field = ReflectionUtils.findField(type, name);
+		assertThat(field).isNotNull();
+		return field;
+	}
+
+	static class SelfReference<T extends SelfReference<T>> {
+
+		@SuppressWarnings("unchecked")
+		T getThis() {
+			return (T) this;
+		}
+
+	}
+}
--- a/spring-core/src/test/java/org/springframework/aot/generate/PackagePrivateClass.java
+++ b/spring-core/src/test/java/org/springframework/aot/generate/PackagePrivateClass.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.generate;
+
+@SuppressWarnings("unused")
+class PackagePrivateClass {
+
+	public PackagePrivateClass() {
+	}
+
+	public String stringBean() {
+		return "public";
+	}
+
+}
--- a/spring-core/src/test/java/org/springframework/aot/generate/ProtectedAccessor.java
+++ b/spring-core/src/test/java/org/springframework/aot/generate/ProtectedAccessor.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.generate;
+
+@SuppressWarnings("unused")
+public class ProtectedAccessor {
+
+	ProtectedAccessor() {
+	}
+
+	public String methodWithProtectedParameter(PackagePrivateClass type) {
+		return "test";
+	}
+
+	public PackagePrivateClass methodWithProtectedReturnType() {
+		return new PackagePrivateClass();
+	}
+}
--- a/spring-core/src/test/java/org/springframework/aot/generate/PublicClass.java
+++ b/spring-core/src/test/java/org/springframework/aot/generate/PublicClass.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.generate;
+
+@SuppressWarnings("unused")
+public class PublicClass {
+
+	private String privateField;
+
+	String protectedField;
+
+	public PackagePrivateClass[] packagePrivateClasses;
+
+	public PackagePrivateClass protectedClassField;
+
+	String getProtectedMethod() {
+		return this.protectedField;
+	}
+
+}