HV-1831 Enhance ExecutableMetaData with tracking information

HV-1831 Create ProcessedBeansTrackingVoter contract

This contract allows to override the default bean process tracking
behavior without exposing our internal structures.

It needs a bit more love on the config side so that we can define it via
XML too and some documentation.

HV-1831 New zero cost approach to processed bean tracking strategy

I removed it from the traditional VF for now as I would like us to focus
on the case where it is useful first.

We will reintroduce it later once we have validated the approach where
it is the most useful.

I'm a bit unclear right now if we should use the same contract for
traditional and predefined scope VF as we are dealing with different
things and they won't be evaluated at the same moment.

I'm thinking that maybe this needs to be a different contract.

HV-1831 : Wrap a `BeanMetaData` in a `NonTrackedBeanMetaDataImpl` if tracking is not required

HV-1831 Add some guidance about next step

HV-1831 Specific benchmark infrastructure for predefined scope

HV-1831 : Update Cascade tests to use PredefinedScopeHibernateValidator with -p=predefined=true

HV-1831 : Experiment detecting cycles in bean classes

Add test for Map

HV-1831 : Experiment detecting cycles in bean classes

Add support for containers; add tests for List w/ and w/o duplicated values

HV-1831 : Experiment detecting cycles in bean classes

HV-1831 Copy nodes when changing the nature of the leaf

HV-1831 Add the same bean to List twice

HV-1831 Clean up another experiment that shouldn't have been committed

HV-1831 Add a couple of examples illustrating various cases

HV-1831 Unfinished experiments

Author: gsmet

engine/src/main/java/org/hibernate/validator/BaseHibernateValidatorConfiguration.java

@@ -31,6 +31,7 @@
 import org.hibernate.validator.spi.resourceloading.ResourceBundleLocator;
 import org.hibernate.validator.spi.scripting.ScriptEvaluator;
 import org.hibernate.validator.spi.scripting.ScriptEvaluatorFactory;
+import org.hibernate.validator.spi.tracking.ProcessedBeansTrackingVoter;
 
 /**
  * Base interface for Hibernate Validator specific configurations.
@@ -486,4 +487,7 @@ default S locales(Locale... locales) {
 	 */
 	@Incubating
 	S failFastOnPropertyViolation(boolean failFastOnPropertyViolation);
+
+	@Incubating
+	S processedBeansTrackingVoter(ProcessedBeansTrackingVoter processedBeanTrackingVoter);
 }

engine/src/main/java/org/hibernate/validator/internal/engine/AbstractConfigurationImpl.java

@@ -62,6 +62,7 @@
 import org.hibernate.validator.spi.properties.GetterPropertySelectionStrategy;
 import org.hibernate.validator.spi.resourceloading.ResourceBundleLocator;
 import org.hibernate.validator.spi.scripting.ScriptEvaluatorFactory;
+import org.hibernate.validator.spi.tracking.ProcessedBeansTrackingVoter;
 
 /**
  * Hibernate specific {@code Configuration} implementation.
@@ -129,6 +130,7 @@ public abstract class AbstractConfigurationImpl<T extends BaseHibernateValidator
 	private BeanMetaDataClassNormalizer beanMetaDataClassNormalizer;
 	private ExpressionLanguageFeatureLevel constraintExpressionLanguageFeatureLevel;
 	private ExpressionLanguageFeatureLevel customViolationExpressionLanguageFeatureLevel;
+	private ProcessedBeansTrackingVoter processedBeansTrackingVoter;
 	private boolean showValidatedValuesInTraceLogs;
 
 	protected AbstractConfigurationImpl(BootstrapState state) {
@@ -673,6 +675,22 @@ public final boolean getShowValidatedValuesInTraceLogs() {
 		return this.showValidatedValuesInTraceLogs;
 	}
 
+	@Override
+	public T processedBeansTrackingVoter(ProcessedBeansTrackingVoter processedBeansTrackingVoter) {
+		if ( LOG.isDebugEnabled() ) {
+			if ( processedBeansTrackingVoter != null ) {
+				LOG.debug( "Setting custom ProcessedBeansTrackingVoter of type " + processedBeansTrackingVoter.getClass()
+						.getName() );
+			}
+		}
+		this.processedBeansTrackingVoter = processedBeansTrackingVoter;
+		return thisAsT();
+	}
+
+	public ProcessedBeansTrackingVoter getProcessedBeansTrackingVoter() {
+		return processedBeansTrackingVoter;
+	}
+
 	public final Set<DefaultConstraintMapping> getProgrammaticMappings() {
 		return programmaticMappings;
 	}

engine/src/main/java/org/hibernate/validator/internal/engine/PredefinedScopeValidatorFactoryImpl.java

@@ -46,8 +46,10 @@
 import org.hibernate.validator.PredefinedScopeHibernateValidatorFactory;
 import org.hibernate.validator.internal.cfg.context.DefaultConstraintMapping;
 import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorManager;
+import org.hibernate.validator.internal.engine.constraintvalidation.HibernateConstraintValidatorInitializationContextImpl;
 import org.hibernate.validator.internal.engine.constraintvalidation.PredefinedScopeConstraintValidatorManagerImpl;
 import org.hibernate.validator.internal.engine.groups.ValidationOrderGenerator;
+import org.hibernate.validator.internal.engine.tracking.DefaultProcessedBeansTrackingVoter;
 import org.hibernate.validator.internal.engine.valueextraction.ValueExtractorManager;
 import org.hibernate.validator.internal.metadata.PredefinedScopeBeanMetaDataManager;
 import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
@@ -118,6 +120,14 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 						determineAllowParallelMethodsDefineParameterConstraints( hibernateSpecificConfig, properties )
 				).build();
 
+		ExecutableParameterNameProvider parameterNameProvider = new ExecutableParameterNameProvider( configurationState.getParameterNameProvider() );
+		ScriptEvaluatorFactory scriptEvaluatorFactory = determineScriptEvaluatorFactory( configurationState, properties, externalClassLoader );
+		Duration temporalValidationTolerance = determineTemporalValidationTolerance( configurationState, properties );
+
+		HibernateConstraintValidatorInitializationContextImpl constraintValidatorInitializationContext = new HibernateConstraintValidatorInitializationContextImpl(
+				scriptEvaluatorFactory, configurationState.getClockProvider(), temporalValidationTolerance );
+
+
 		this.validatorFactoryScopedContext = new ValidatorFactoryScopedContext(
 				configurationState.getMessageInterpolator(),
 				configurationState.getTraversableResolver(),
@@ -128,15 +138,16 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 				determineFailFast( hibernateSpecificConfig, properties ),
 				determineFailFastOnPropertyViolation( hibernateSpecificConfig, properties ),
 				determineTraversableResolverResultCacheEnabled( hibernateSpecificConfig, properties ),
+				determineShowValidatedValuesInTraceLogs( hibernateSpecificConfig, properties ),
 				determineConstraintValidatorPayload( hibernateSpecificConfig ),
 				determineConstraintExpressionLanguageFeatureLevel( hibernateSpecificConfig, properties ),
 				determineCustomViolationExpressionLanguageFeatureLevel( hibernateSpecificConfig, properties ),
-				determineShowValidatedValuesInTraceLogs( hibernateSpecificConfig, properties )
+				constraintValidatorInitializationContext
 		);
 
 		this.constraintValidatorManager = new PredefinedScopeConstraintValidatorManagerImpl(
 				configurationState.getConstraintValidatorFactory(),
-				this.validatorFactoryScopedContext.getConstraintValidatorInitializationContext()
+				constraintValidatorInitializationContext
 		);
 
 		this.validationOrderGenerator = new ValidationOrderGenerator();
@@ -147,11 +158,14 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 		this.valueExtractorManager = new ValueExtractorManager( configurationState.getValueExtractors() );
 		ConstraintHelper constraintHelper = ConstraintHelper.forBuiltinConstraints(
 				hibernateSpecificConfig.getBuiltinConstraints(),
-				hibernateSpecificConfig.isIncludeBeansAndConstraintsDefinedOnlyInXml() );
+				hibernateSpecificConfig.isIncludeBeansAndConstraintsDefinedOnlyInXml()
+		);
 		TypeResolutionHelper typeResolutionHelper = new TypeResolutionHelper();
 
-		ConstraintCreationContext constraintCreationContext = new ConstraintCreationContext( constraintHelper,
-				constraintValidatorManager, typeResolutionHelper, valueExtractorManager );
+		ConstraintCreationContext constraintCreationContext = new ConstraintCreationContext(
+				constraintHelper,
+				constraintValidatorManager, typeResolutionHelper, valueExtractorManager
+		);
 
 		ExecutableHelper executableHelper = new ExecutableHelper( typeResolutionHelper );
 		JavaBeanHelper javaBeanHelper = new JavaBeanHelper( getterPropertySelectionStrategy, propertyNodeNameProvider );
@@ -164,15 +178,18 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 						javaBeanHelper,
 						externalClassLoader
 				),
-				constraintHelper );
+				constraintHelper
+		);
 
 		// we parse all XML mappings but only register constraint validators and delay constraint mappings building till
 		// we collect all the constraint validators.
 		// HV-302; don't load XmlMappingParser if not necessary
 		MappingXmlParser mappingParser = null;
 		if ( !configurationState.getMappingStreams().isEmpty() ) {
-			mappingParser = new MappingXmlParser( constraintCreationContext,
-					javaBeanHelper, externalClassLoader );
+			mappingParser = new MappingXmlParser(
+					constraintCreationContext,
+					javaBeanHelper, externalClassLoader
+			);
 			mappingParser.parse( configurationState.getMappingStreams() );
 		}
 
@@ -202,15 +219,32 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 			xmlMetaDataProvider = null;
 		}
 
+		// collect all metadata, I don't think we need this work to be in BeanMetaDataManager contract, it can be a specific class (or private method if simple enough)
+		// it's basically the content of PredefinedScopeBeanMetaDataManager constructor
+		// the metadata wouldn't be complete because we want to inject the tracking information
+
+		// then you build the tracking information from these incomplete metadata
+
+		// finally you create a PredefinedScopeBeanMetaDataManager with the augmented metadata pushed to it
+		// you will need to augment both BeanMetaData and ExecutableMetaData
+		// I would prototype BeanMetaData first then discuss it before going further
+
+		// Note: we want classes to be immutable
+		// Might be a good idea to push a default method to BeanMetaData as enabling tracking is the default behavior we want
+		// Maybe first try composition and benchmark it and if good enough, we keep it
+
 		this.beanMetaDataManager = new PredefinedScopeBeanMetaDataManager(
 				constraintCreationContext,
 				executableHelper,
-				validatorFactoryScopedContext.getParameterNameProvider(),
+				parameterNameProvider,
 				javaBeanHelper,
 				validationOrderGenerator,
 				buildMetaDataProviders( constraintCreationContext, xmlMetaDataProvider, constraintMappings ),
 				methodValidationConfiguration,
 				determineBeanMetaDataClassNormalizer( hibernateSpecificConfig ),
+				( hibernateSpecificConfig.getProcessedBeansTrackingVoter() != null )
+						? hibernateSpecificConfig.getProcessedBeansTrackingVoter()
+						: new DefaultProcessedBeansTrackingVoter(),
 				beanClassesToInitialize
 		);
 
@@ -281,6 +315,10 @@ public boolean isTraversableResolverResultCacheEnabled() {
 		return validatorFactoryScopedContext.isTraversableResolverResultCacheEnabled();
 	}
 
+	public PredefinedScopeBeanMetaDataManager getBeanMetaDataManager() {
+		return beanMetaDataManager;
+	}
+
 	@Override
 	public <T> T unwrap(Class<T> type) {
 		// allow unwrapping into public super types
@@ -322,7 +360,8 @@ Validator createValidator(ValidatorFactoryScopedContext validatorFactoryScopedCo
 	private static List<MetaDataProvider> buildMetaDataProviders(
 			ConstraintCreationContext constraintCreationContext,
 			XmlMetaDataProvider xmlMetaDataProvider,
-			Set<DefaultConstraintMapping> constraintMappings) {
+			Set<DefaultConstraintMapping> constraintMappings
+	) {
 		List<MetaDataProvider> metaDataProviders = newArrayList();
 		if ( xmlMetaDataProvider != null ) {
 			metaDataProviders.add( xmlMetaDataProvider );

engine/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryImpl.java

@@ -48,6 +48,7 @@
 import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorManager;
 import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorManagerImpl;
 import org.hibernate.validator.internal.engine.groups.ValidationOrderGenerator;
+import org.hibernate.validator.internal.engine.tracking.DefaultProcessedBeansTrackingVoter;
 import org.hibernate.validator.internal.engine.valueextraction.ValueExtractorManager;
 import org.hibernate.validator.internal.metadata.BeanMetaDataManager;
 import org.hibernate.validator.internal.metadata.BeanMetaDataManagerImpl;
@@ -68,6 +69,7 @@
 import org.hibernate.validator.spi.nodenameprovider.PropertyNodeNameProvider;
 import org.hibernate.validator.spi.properties.GetterPropertySelectionStrategy;
 import org.hibernate.validator.spi.scripting.ScriptEvaluatorFactory;
+import org.hibernate.validator.spi.tracking.ProcessedBeansTrackingVoter;
 
 /**
  * Factory returning initialized {@code Validator} instances. This is the Hibernate Validator default
@@ -133,6 +135,8 @@ public class ValidatorFactoryImpl implements HibernateValidatorFactory {
 
 	private final ValidationOrderGenerator validationOrderGenerator;
 
+	private final ProcessedBeansTrackingVoter processedBeansTrackingVoter;
+
 	public ValidatorFactoryImpl(ConfigurationState configurationState) {
 		ClassLoader externalClassLoader = determineExternalClassLoader( configurationState );
 
@@ -162,10 +166,10 @@ public ValidatorFactoryImpl(ConfigurationState configurationState) {
 				determineFailFast( hibernateSpecificConfig, properties ),
 				determineFailFastOnPropertyViolation( hibernateSpecificConfig, properties ),
 				determineTraversableResolverResultCacheEnabled( hibernateSpecificConfig, properties ),
+				determineShowValidatedValuesInTraceLogs( hibernateSpecificConfig, properties ),
 				determineConstraintValidatorPayload( hibernateSpecificConfig ),
 				determineConstraintExpressionLanguageFeatureLevel( hibernateSpecificConfig, properties ),
-				determineCustomViolationExpressionLanguageFeatureLevel( hibernateSpecificConfig, properties ),
-				determineShowValidatedValuesInTraceLogs( hibernateSpecificConfig, properties )
+				determineCustomViolationExpressionLanguageFeatureLevel( hibernateSpecificConfig, properties )
 		);
 
 		ConstraintValidatorManager constraintValidatorManager = new ConstraintValidatorManagerImpl(
@@ -226,6 +230,10 @@ public ValidatorFactoryImpl(ConfigurationState configurationState) {
 			this.xmlMetaDataProvider = null;
 		}
 
+		this.processedBeansTrackingVoter = ( hibernateSpecificConfig != null && hibernateSpecificConfig.getProcessedBeansTrackingVoter() != null )
+				? hibernateSpecificConfig.getProcessedBeansTrackingVoter()
+				: new DefaultProcessedBeansTrackingVoter();
+
 		if ( LOG.isDebugEnabled() ) {
 			logValidatorFactoryScopedConfiguration( validatorFactoryScopedContext );
 		}
@@ -349,7 +357,8 @@ Validator createValidator(ConstraintValidatorFactory constraintValidatorFactory,
 						beanMetadataClassNormalizer,
 						validationOrderGenerator,
 						buildMetaDataProviders(),
-						methodValidationConfiguration
+						methodValidationConfiguration,
+						processedBeansTrackingVoter
 				)
 		);
 

engine/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryScopedContext.java

@@ -101,18 +101,18 @@ public class ValidatorFactoryScopedContext {
 			boolean failFast,
 			boolean failFastOnPropertyViolation,
 			boolean traversableResolverResultCacheEnabled,
+			boolean showValidatedValuesInTraceLogs,
 			Object constraintValidatorPayload,
 			ExpressionLanguageFeatureLevel constraintExpressionLanguageFeatureLevel,
-			ExpressionLanguageFeatureLevel customViolationExpressionLanguageFeatureLevel,
-			boolean showValidatedValuesInTraceLogs) {
+			ExpressionLanguageFeatureLevel customViolationExpressionLanguageFeatureLevel) {
 		this( messageInterpolator, traversableResolver, parameterNameProvider, clockProvider, temporalValidationTolerance, scriptEvaluatorFactory, failFast,
 				failFastOnPropertyViolation, traversableResolverResultCacheEnabled, showValidatedValuesInTraceLogs, constraintValidatorPayload, constraintExpressionLanguageFeatureLevel,
 				customViolationExpressionLanguageFeatureLevel,
 				new HibernateConstraintValidatorInitializationContextImpl( scriptEvaluatorFactory, clockProvider,
 						temporalValidationTolerance ) );
 	}
 
-	private ValidatorFactoryScopedContext(MessageInterpolator messageInterpolator,
+	ValidatorFactoryScopedContext(MessageInterpolator messageInterpolator,
 			TraversableResolver traversableResolver,
 			ExecutableParameterNameProvider parameterNameProvider,
 			ClockProvider clockProvider,
@@ -121,7 +121,8 @@ private ValidatorFactoryScopedContext(MessageInterpolator messageInterpolator,
 			boolean failFast,
 			boolean failFastOnPropertyViolation,
 			boolean traversableResolverResultCacheEnabled,
-			boolean showValidatedValuesInTraceLogs, Object constraintValidatorPayload,
+			boolean showValidatedValuesInTraceLogs,
+			Object constraintValidatorPayload,
 			ExpressionLanguageFeatureLevel constraintExpressionLanguageFeatureLevel,
 			ExpressionLanguageFeatureLevel customViolationExpressionLanguageFeatureLevel,
 			HibernateConstraintValidatorInitializationContextImpl constraintValidatorInitializationContext) {
@@ -212,7 +213,6 @@ static class Builder {
 		private Object constraintValidatorPayload;
 		private ExpressionLanguageFeatureLevel constraintExpressionLanguageFeatureLevel;
 		private ExpressionLanguageFeatureLevel customViolationExpressionLanguageFeatureLevel;
-
 		private boolean showValidatedValuesInTraceLogs;
 		private HibernateConstraintValidatorInitializationContextImpl constraintValidatorInitializationContext;
 

engine/src/main/java/org/hibernate/validator/internal/engine/path/PathImpl.java

@@ -204,7 +204,7 @@ private NodeImpl addMethodNode(String name, Class<?>[] parameterTypes) {
 	}
 
 	public NodeImpl makeLeafNodeIterable() {
-		requiresWriteableNodeList();
+		copyNodeList();
 
 		currentLeafNode = NodeImpl.makeIterable( currentLeafNode );
 
@@ -214,7 +214,7 @@ public NodeImpl makeLeafNodeIterable() {
 	}
 
 	public NodeImpl makeLeafNodeIterableAndSetIndex(Integer index) {
-		requiresWriteableNodeList();
+		copyNodeList();
 
 		currentLeafNode = NodeImpl.makeIterableAndSetIndex( currentLeafNode, index );
 
@@ -224,7 +224,7 @@ public NodeImpl makeLeafNodeIterableAndSetIndex(Integer index) {
 	}
 
 	public NodeImpl makeLeafNodeIterableAndSetMapKey(Object key) {
-		requiresWriteableNodeList();
+		copyNodeList();
 
 		currentLeafNode = NodeImpl.makeIterableAndSetMapKey( currentLeafNode, key );
 
@@ -309,6 +309,10 @@ private void requiresWriteableNodeList() {
 			return;
 		}
 
+		copyNodeList();
+	}
+
+	private void copyNodeList() {
 		// Usually, the write operation is about adding one more node, so let's make the list one element larger.
 		List<Node> newNodeList = new ArrayList<>( nodeList.size() + 1 );
 		newNodeList.addAll( nodeList );

engine/src/main/java/org/hibernate/validator/internal/engine/tracking/DefaultProcessedBeansTrackingVoter.java

@@ -0,0 +1,25 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.validator.internal.engine.tracking;
+
+import org.hibernate.validator.spi.tracking.ProcessedBeansTrackingVoter;
+
+public class DefaultProcessedBeansTrackingVoter implements ProcessedBeansTrackingVoter {
+
+	@Override
+	public Vote isEnabledForBean(Class<?> beanClass, boolean hasCascadables) {
+		return Vote.DEFAULT;
+	}
+
+	@Override
+	public Vote isEnabledForReturnValue(Class<?> beanClass, String name, Class<?>[] parameterTypes, boolean hasCascadables) {
+		return Vote.DEFAULT;
+	}
+
+	@Override
+	public Vote isEnabledForParameters(Class<?> beanClass, String name, Class<?>[] parameterTypes, boolean hasCascadables) {
+		return Vote.DEFAULT;
+	}
+}