CAUSEWAY-3991: Metamodel Introspection Policy not honored for Java

Records as Viewmodels

Task-Url: https://issues.apache.org/jira/browse/CAUSEWAY-3991

Author: andi-huber

core/metamodel/src/main/java/org/apache/causeway/core/metamodel/facets/object/ignore/annotation/RemoveAnnotatedMethodsFacetFactory.java

@@ -18,10 +18,13 @@
  */
 package org.apache.causeway.core.metamodel.facets.object.ignore.annotation;
 
+import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 import jakarta.inject.Inject;
 
+import org.jspecify.annotations.NonNull;
+
 import org.apache.causeway.commons.internal.functions._Predicates;
 import org.apache.causeway.commons.internal.reflection._ClassCache.Attribute;
 import org.apache.causeway.commons.internal.reflection._GenericResolver.ResolvedMethod;
@@ -31,8 +34,6 @@
 import org.apache.causeway.core.metamodel.facets.FacetFactoryAbstract;
 import org.apache.causeway.core.metamodel.spec.ObjectSpecification;
 
-import org.jspecify.annotations.NonNull;
-
 public class RemoveAnnotatedMethodsFacetFactory
 extends FacetFactoryAbstract {
 
@@ -46,45 +47,55 @@ public void process(final ProcessClassContext processClassContext) {
 
         var policy = getMetaModelContext().getConfiguration().core().metaModel().introspector().policy();
         switch (policy) {
-            case ENCAPSULATION_ENABLED:
-                getClassCache()
-                        .streamResolvedMethods(processClassContext.getCls())
-                        /* honor exclude markers (always) */
-                        .filter(method->{
-                            if(ProgrammingModelConstants.MethodExcludeMarker.anyMatchOn(method)) {
-                                processClassContext.removeMethod(method);
-                                return false; // stop processing
-                            }
-                            return true; // continue processing
-                        })
-                        /* don't throw away mixin main methods,
-                         * those we keep irrespective of IntrospectionPolicy */
-                        .filter(_Predicates.not(isMixinMainMethod(processClassContext)))
-                        .forEach(method -> {
-                            if (!ProgrammingModelConstants.MethodIncludeMarker.anyMatchOn(method)) {
-                                processClassContext.removeMethod(method);
-                            }
-                        });
-                break;
-
-            case ANNOTATION_REQUIRED:
-                // TODO: this could probably be more precise and insist on @Domain.Include for members.
+            case ENCAPSULATION_ENABLED -> getClassCache()
+                .streamResolvedMethods(processClassContext.getCls())
+                /* honor exclude markers (always) */
+                .filter(filterAndRemoveExclusions(processClassContext))
+                /* don't throw away mixin main methods,
+                 * those we keep irrespective of IntrospectionPolicy */
+                .filter(_Predicates.not(isMixinMainMethod(processClassContext)))
+                .forEach(removeNonInclusions(processClassContext));
+            case ANNOTATION_REQUIRED -> getClassCache()
+                .streamPublicMethods(processClassContext.getCls())
+                /* honor exclude markers (always) */
+                .filter(filterAndRemoveExclusions(processClassContext))
+                /* don't throw away mixin main methods,
+                 * those we keep irrespective of IntrospectionPolicy */
+                .filter(_Predicates.not(isMixinMainMethod(processClassContext)))
+                .forEach(removeNonInclusions(processClassContext));
+            case ANNOTATION_OPTIONAL -> getClassCache()
+                .streamPublicMethods(processClassContext.getCls())
+                .forEach(removeExclusions(processClassContext));
+            }
+    }
 
-            case ANNOTATION_OPTIONAL:
+    // -- HELPER
 
-                getClassCache()
-                        .streamPublicMethods(processClassContext.getCls())
-                        .forEach(method->{
-                            if(ProgrammingModelConstants.MethodExcludeMarker.anyMatchOn(method)) {
-                                processClassContext.removeMethod(method);
-                            }
-                        });
+    private Predicate<? super ResolvedMethod> filterAndRemoveExclusions(final ProcessClassContext processClassContext) {
+        return method->{
+            if(ProgrammingModelConstants.MethodExcludeMarker.anyMatchOn(method)) {
+                processClassContext.removeMethod(method);
+                return false; // stop processing
+            }
+            return true; // continue processing
+        };
+    }
 
-                break;
-        }
+    private Consumer<? super ResolvedMethod> removeExclusions(final ProcessClassContext processClassContext) {
+        return method->{
+            if(ProgrammingModelConstants.MethodExcludeMarker.anyMatchOn(method)) {
+                processClassContext.removeMethod(method);
+            }
+        };
     }
 
-    // -- HELPER
+    private Consumer<? super ResolvedMethod> removeNonInclusions(final ProcessClassContext processClassContext) {
+        return method->{
+            if(!ProgrammingModelConstants.MethodIncludeMarker.anyMatchOn(method)) {
+                processClassContext.removeMethod(method);
+            }
+        };
+    }
 
     /**
      * We have no MixinFacet yet, so we need to revert to low level introspection tactics.
@@ -94,9 +105,8 @@ private Predicate<ResolvedMethod> isMixinMainMethod(final @NonNull ProcessClassC
         // shortcut, when we already know the class is not a mixin
         if(processClassContext.getFacetHolder() instanceof ObjectSpecification) {
             var spec = (ObjectSpecification) processClassContext.getFacetHolder();
-            if(!spec.getBeanSort().isMixin()) {
+            if(!spec.getBeanSort().isMixin())
                 return method->false;
-            }
         }
         // lookup attribute from class-cache as it should have been already processed by the BeanTypeClassifier
         var cls = processClassContext.getCls();

core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/FacetedMethodsBuilder.java

@@ -385,18 +385,19 @@ private boolean isAllParamTypesValid(final MethodFacade actionMethod) {
     }
 
     /**
-     * At time of writing only filtering for Java Records, 
-     * because those have not type-hierarchy 
-     * (except potentially interfaces), 
+     * At time of writing only filtering for Java Records,
+     * because those have not type-hierarchy
+     * (except potentially interfaces),
      * where the check for explicit annotations is simple.
      */
     private <A extends Annotation> boolean satisfiesIntrospectionPolicy(
             final ResolvedMethod accessorMethod,
             final Class<A> requiredAnnotationType) {
-        return inspectedTypeSpec.getCorrespondingClass().isRecord()
-                && introspectionPolicy().getMemberAnnotationPolicy().isMemberAnnotationsRequired()
-            ? _Annotations.isPresent(accessorMethod.method(), requiredAnnotationType)
-            : true;
+        return true;
+//                inspectedTypeSpec.getCorrespondingClass().isRecord()
+//                && introspectionPolicy().getMemberAnnotationPolicy().isMemberAnnotationsRequired()
+//            ? _Annotations.isPresent(accessorMethod.method(), requiredAnnotationType)
+//            : true;
     }
 
     private boolean representsAction(final ResolvedMethod actionMethod) {