implab/gradle-common Commit - r58:a4138749793f

variants: expose compile unit source set specs...

cin -

r58:a4138749793f default

parent child

Context file:

r58:a4138749793f

Collapse all files

variants/src/main/java/org/implab/gradle/variants/sources/CompileUnitSourceSetSpec.java created 644 +69 0

@@ -0,0 +1,69
	1	package org.implab.gradle.variants.sources;
	2
	3	import org.gradle.api.Action;
	4	import org.implab.gradle.common.core.lang.Closures;
	5	import org.implab.gradle.variants.core.Layer;
	6	import org.implab.gradle.variants.core.Variant;
	7
	8	import groovy.lang.Closure;
	9
	10	/**
	11	* Source-set materialization context for one compile unit.
	12	*
	13	* <p>This type keeps compile-unit identity next to the materialized
	14	* {@link GenericSourceSet} without turning the selector DSL into a second
	15	* source-set API. Use {@link #getCompileUnit()} for selection metadata and
	16	* {@link #sourceSet(Action)} when the underlying source set body must be
	17	* configured.
	18	*/
	19	public interface CompileUnitSourceSetSpec {
	20	/**
	21	* Returns the compile unit represented by this source set.
	22	*
	23	* @return compile-unit identity
	24	*/
	25	CompileUnit getCompileUnit();
	26
	27	/**
	28	* Returns the variant part of the compile-unit identity.
	29	*
	30	* @return variant identity
	31	*/
	32	default Variant getVariant() {
	33	return getCompileUnit().variant();
	34	}
	35
	36	/**
	37	* Returns the layer part of the compile-unit identity.
	38	*
	39	* @return layer identity
	40	*/
	41	default Layer getLayer() {
	42	return getCompileUnit().layer();
	43	}
	44
	45	/**
	46	* Returns the materialized source set body.
	47	*
	48	* @return source set body
	49	*/
	50	GenericSourceSet getSourceSet();
	51
	52	/**
	53	* Configures the materialized source set body.
	54	*
	55	* @param action source set configuration action
	56	*/
	57	default void sourceSet(Action<? super GenericSourceSet> action) {
	58	action.execute(getSourceSet());
	59	}
	60
	61	/**
	62	* Configures the materialized source set body.
	63	*
	64	* @param closure source set configuration closure
	65	*/
	66	default void sourceSet(Closure<?> closure) {
	67	sourceSet(Closures.action(closure));
	68	}
	69	}

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultCompileUnitSourceSetSpec.java created 644 +25 0

@@ -0,0 +1,25
	1	package org.implab.gradle.variants.sources.internal;
	2
	3	import org.implab.gradle.variants.sources.CompileUnit;
	4	import org.implab.gradle.variants.sources.CompileUnitSourceSetSpec;
	5	import org.implab.gradle.variants.sources.GenericSourceSet;
	6
	7	class DefaultCompileUnitSourceSetSpec implements CompileUnitSourceSetSpec {
	8	private final CompileUnit compileUnit;
	9	private final GenericSourceSet sourceSet;
	10
	11	DefaultCompileUnitSourceSetSpec(CompileUnit compileUnit, GenericSourceSet sourceSet) {
	12	this.compileUnit = compileUnit;
	13	this.sourceSet = sourceSet;
	14	}
	15
	16	@Override
	17	public CompileUnit getCompileUnit() {
	18	return compileUnit;
	19	}
	20
	21	@Override
	22	public GenericSourceSet getSourceSet() {
	23	return sourceSet;
	24	}
	25	}

variants/src/main/java/org/implab/gradle/variants/VariantSourcesPlugin.java +13 -4

             package org.implab.gradle.variants;
             import java.util.Objects;
             import java.util.function.Predicate;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.sources.CompileUnit;
+            import org.implab.gradle.variants.sources.CompileUnitSourceSetSpec;
             import org.implab.gradle.variants.sources.CompileUnitsView;
-            import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             import org.implab.gradle.variants.sources.VariantSourcesExtension;
             import org.implab.gradle.variants.sources.internal.CompileUnitNamer;
             import org.implab.gradle.variants.sources.internal.DefaultCompileUnitNamingPolicy;
             import org.implab.gradle.variants.sources.internal.DefaultLateConfigurationPolicySpec;
             import org.implab.gradle.variants.sources.internal.DefaultVariantSourcesContext;
             import org.implab.gradle.variants.sources.internal.SourceSetConfigurationRegistry;
             import org.implab.gradle.variants.sources.internal.SourceSetRegistry;
             @NonNullByDefault
             public abstract class VariantSourcesPlugin implements Plugin<Project> {
                 public static final String VARIANT_SOURCES_EXTENSION = "variantSources";
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     target.getPlugins().apply(VariantsPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var objectFactory = target.getObjects();
                     var deferred = new Deferred<VariantSourcesContext>();
                     var lateConfigurationPolicy = new DefaultLateConfigurationPolicySpec();
                     var namingPolicy = new DefaultCompileUnitNamingPolicy();
                     variantsExtension.whenFinalized(variants -> {
                         // create variant views
                         var compileUnits = CompileUnitsView.of(variants);
                         var roleProjections = RoleProjectionsView.of(variants);
                         // create registries
                         var sourceSetRegistry = new SourceSetRegistry(objectFactory);
                         lateConfigurationPolicy.finalizePolicy();
                         var sourceSetConfiguration = new SourceSetConfigurationRegistry(lateConfigurationPolicy::mode);
                         // build compile unit namer
                         var compileUnitNamer = CompileUnitNamer.builder()
                             .addUnits(compileUnits.getUnits())
                             .nameCollisionPolicy(namingPolicy.policy())
                             .build();
                         // create the context
                         var context = new DefaultVariantSourcesContext(
                             variants,
                             compileUnits,
                             roleProjections,
                             compileUnitNamer,
                             sourceSetRegistry,
                             sourceSetConfiguration
                         );
                         deferred.resolve(context);
                     });
                     var variantSourcesExtension = new VariantSourcesExtension() {
                         @Override
                         public void whenAvailable(Action<? super VariantSourcesContext> action) {
                             deferred.whenResolved(action::execute);
                         }
                         @Override
                         public void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action) {
                             action.execute(lateConfigurationPolicy);
                         }
                         @Override
                         public void namingPolicy(Action<? super NamingPolicySpec> action) {
                             action.execute(namingPolicy);
                         }
                         @Override
-                        public void variant(String variantName, Action<? super GenericSourceSet> action) {
+                        public void variant(String variantName, Action<? super CompileUnitSourceSetSpec> action) {
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenAvailable(ctx -> ctx.configureVariant(resolveVariant(ctx.getVariants(), variantName), action));
                         }
                         @Override
-                        public void layer(String layerName, Action<? super GenericSourceSet> action) {
+                        public void layer(String layerName, Action<? super CompileUnitSourceSetSpec> action) {
                             // protect external DSL
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenAvailable(ctx -> ctx.configureLayer(resolveLayer(ctx.getVariants(), layerName), action));
                         }
                         @Override
-                        public void unit(String variantName, String layerName, Action<? super GenericSourceSet> action) {
+                        public void unit(String variantName, String layerName, Action<? super CompileUnitSourceSetSpec> action) {
                             Strings.argumentNotNullOrBlank(layerName, "layerName");
                             Strings.argumentNotNullOrBlank(variantName, "variantName");
                             Objects.requireNonNull(action, "action can't be null");
                             lateConfigurationPolicy.finalizePolicy();
                             whenAvailable(ctx -> ctx.configureUnit(resolveCompileUnit(ctx, variantName, layerName), action));
                         }
+                        @Override
+                        public void configureEach(Action<? super CompileUnitSourceSetSpec> action) {
+                            Objects.requireNonNull(action, "action can't be null");
+                            lateConfigurationPolicy.finalizePolicy();
+                            whenAvailable(ctx -> ctx.configureEach(action));
+                        }
                     };
                     extensions.add(VariantSourcesExtension.class, VARIANT_SOURCES_EXTENSION, variantSourcesExtension);
                 }
                 private static Layer resolveLayer(VariantsView variants, String name) {
                     return variants.getLayers().stream()
                             .filter(named(name))
                             .findAny()
                             .orElseThrow(() -> new InvalidUserDataException("Layer '" + name + "' isn't declared"));
                 }
                 private static Variant resolveVariant(VariantsView variants, String name) {
                     return variants.getVariants().stream()
                             .filter(named(name))
                             .findAny()
                             .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't declared"));
                 }
                 private static CompileUnit resolveCompileUnit(VariantSourcesContext ctx, String variantName, String layerName) {
                     return ctx.getCompileUnits().findUnit(
                             resolveVariant(ctx.getVariants(), variantName),
                             resolveLayer(ctx.getVariants(), layerName))
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "The CompileUnit isn't declared for variant '" + variantName + "', layer '" + layerName + "'"));
                 }
                 private static Predicate<Named> named(String name) {
                     return named -> named.getName().equals(name);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/GenericSourceSet.java +1 -16

             package org.implab.gradle.variants.sources;
             import java.io.File;
             import java.nio.file.Paths;
             import java.util.HashSet;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Set;
             import java.util.concurrent.Callable;
             import java.util.function.Function;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Task;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.file.SourceDirectorySet;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.tasks.TaskProvider;
-            import org.gradle.util.Configurable;
-            import org.implab.gradle.common.core.lang.Closures;
-            import groovy.lang.Closure;
             /**
              * A configurable source set abstraction with named outputs.
              *
              * <p>
              * Each instance aggregates multiple {@link SourceDirectorySet source sets}
              * under a shared name and exposes typed outputs that must be declared up front.
              * Default locations are {@code src/<name>} for sources and
              * {@code build/<name>} for outputs, both of which can be customized via the
              * exposed {@link DirectoryProperty} setters.
              * </p>
              *
              * <p>
              * Outputs are grouped by names to make task wiring explicit. An output must be
              * declared with {@link #declareOutputs(String, String...)} before files can be
              * registered against it. Attempting to register or retrieve an undeclared
              * output results in
              * {@link InvalidUserDataException}.
              * </p>
              */
-            public abstract class GenericSourceSet
+            public abstract class GenericSourceSet implements Named {
-                    implements Named, Configurable<GenericSourceSet> {
                 private final String name;
                 private final NamedDomainObjectContainer<SourceDirectorySet> sourceDirectorySets;
                 private final Map<String, ConfigurableFileCollection> outputs;
                 private final FileCollection allOutputs;
                 private final FileCollection allSourceDirectories;
                 private final ObjectFactory objects;
                 private final Set<String> declaredOutputs = new HashSet<>();
                 @Inject
                 public GenericSourceSet(String name, ObjectFactory objects, ProjectLayout layout) {
                     this.name = name;
                     this.objects = objects;
                     sourceDirectorySets = objects.domainObjectContainer(
                             SourceDirectorySet.class,
                             this::createSourceDirectorySet);
                     outputs = new LinkedHashMap<>();
                     allSourceDirectories = objects.fileCollection().from(sourceDirectoriesProvider());
                     allOutputs = objects.fileCollection().from(outputsProvider());
                     getSourceSetDir().convention(layout
                             .getProjectDirectory()
                             .dir(Paths.get("src", name).toString()));
                     getOutputsDir().convention(layout
                             .getBuildDirectory()
                             .dir(name));
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 /**
                  * Base directory for this source set. Defaults to {@code src/<name>} under
                  * the project directory.
                  */
                 public abstract DirectoryProperty getSourceSetDir();
                 /**
                  * Base directory for outputs of this source set. Defaults to
                  * {@code build/<name>}.
                  */
                 public abstract DirectoryProperty getOutputsDir();
                 /**
                  * The container of {@link SourceDirectorySet} instances that belong to this
                  * logical source set.
                  */
                 public NamedDomainObjectContainer<SourceDirectorySet> getSets() {
                     return sourceDirectorySets;
                 }
                 /**
                  * All registered outputs grouped across output names.
                  */
                 public FileCollection getAllOutputs() {
                     return allOutputs;
                 }
                 /**
                  * All source directories from every contained {@link SourceDirectorySet}.
                  */
                 public FileCollection getAllSourceDirectories() {
                     return allSourceDirectories;
                 }
                 /**
                  * Returns the file collection for the specified output name, creating it
                  * if necessary.
                  *
                  * @throws InvalidUserDataException if the output was not declared
                  */
                 public FileCollection output(String name) {
                     return configurableOutput(name);
                 }
                 private ConfigurableFileCollection configurableOutput(String name) {
                     requireDeclaredOutput(name);
                     return outputs.computeIfAbsent(name, key -> objects.fileCollection());
                 }
                 /**
                  * Declares allowed output names. Outputs must be declared before registering
                  * files under them.
                  */
                 public void declareOutputs(String name, String... extra) {
                     Stream.concat(Stream.of(name), Stream.of(extra))
                             .map(Objects::requireNonNull)
                             .forEach(declaredOutputs::add);
                 }
                 /**
                  * Registers files produced elsewhere under the given output.
                  */
                 public void registerOutput(String name, Object... files) {
                     configurableOutput(name).from(files);
                 }
                 /**
                  * Registers output files produced by a task, using a mapper to extract the
                  * output from the task. The task will be added as a build dependency of this
                  * output.
                  */
                 public <T extends Task> void registerOutput(String name, TaskProvider<T> task,
                         Function<? super T, ?> mapper) {
                     configurableOutput(name).from(task.map(mapper::apply))
                             .builtBy(task);
                 }
-                /**
-                 * Applies a Groovy closure to this source set, enabling DSL-style
-                 * configuration.
-                 */
-                @Override
-                public GenericSourceSet configure(Closure configure) {
-                    Closures.apply(configure, this);
-                    return this;
                 private SourceDirectorySet createSourceDirectorySet(String name) {
                     return objects.sourceDirectorySet(name, name);
                 }
                 private void requireDeclaredOutput(String outputName) {
                     if (!declaredOutputs.contains(outputName)) {
                         throw new InvalidUserDataException(
                                 "Output '" + outputName + "' is not declared for source set '" + name + "'");
                     }
                 }
                 private Callable<List<? extends FileCollection>> outputsProvider() {
                     return () -> outputs.values().stream().toList();
                 }
                 private Callable<Set<File>> sourceDirectoriesProvider() {
                     return () -> sourceDirectorySets.stream()
                             .flatMap(x -> x.getSrcDirs().stream())
                             .collect(Collectors.toSet());
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesContext.java +18 -6

             package org.implab.gradle.variants.sources;
             import org.gradle.api.Action;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             /**
              * Registry of symbolic source set names produced by sources projection.
              *
              * <p>Identity in this registry is the {@link GenericSourceSet} name assigned
              * by the finalized
              * {@link VariantSourcesExtension#namingPolicy(org.gradle.api.Action)}.
              */
             public interface VariantSourcesContext {
                /**
                  * Finalized core model.
                  */
                 VariantsView getVariants();
                 /**
                  * Derived compile-side view.
                  */
                 CompileUnitsView getCompileUnits();
                 /**
                  * Derived role-side view.
                  */
                 RoleProjectionsView getRoleProjections();
                 /**
                  * Lazy source set provider service.
                  */
                 SourceSetMaterializer getSourceSets();
                 /**
-                 * Configures all GenericSourceSets produced from the given layer.
+                 * Configures all source sets produced from the given layer.
                  *
                  * The action is applied:
                  * - to already materialized source sets of this layer
                  * - to all future source sets of this layer
                  *
                  * <p>For future source sets, selector precedence and registration order are
                  * preserved by the materializer.
                  *
                  * <p>For already materialized source sets, behavior is governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  * In warn/allow modes the action is applied as a late imperative step and does
                  * not retroactively restore selector precedence.
                  *
                  * @throws org.gradle.api.InvalidUserDataException if the layer is not part of
                  *         the finalized variant model
                  */
-                void configureLayer(Layer layer, Action<? super GenericSourceSet> action);
+                void configureLayer(Layer layer, Action<? super CompileUnitSourceSetSpec> action);
                 /**
-                 * Configures all GenericSourceSets produced from the given variant.
+                 * Configures all source sets produced from the given variant.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  *
                  * @throws org.gradle.api.InvalidUserDataException if the variant is not part
                  *         of the finalized variant model
                  */
-                void configureVariant(Variant variant, Action<? super GenericSourceSet> action);
+                void configureVariant(Variant variant, Action<? super CompileUnitSourceSetSpec> action);
                 /**
-                 * Configures the GenericSourceSet produced from the given compile unit.
+                 * Configures the source set produced from the given compile unit.
                  *
                  * <p>Late application semantics for already materialized source sets are
                  * governed by
                  * {@link VariantSourcesExtension#lateConfigurationPolicy(org.gradle.api.Action)}.
                  *
                  * @throws org.gradle.api.InvalidUserDataException if the compile unit is not
                  *         part of the finalized variant model
                  */
-                void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action);
+                void configureUnit(CompileUnit unit, Action<? super CompileUnitSourceSetSpec> action);
+                /**
+                 * Configures every source set materialized from the finalized compile-unit
+                 * model.
+                 *
+                 * <p>This selector is applied before variant-, layer-, and unit-specific
+                 * selectors.
+                 *
+                 * @throws org.gradle.api.InvalidUserDataException if late configuration is
+                 *         rejected by the selected policy
+                 */
+                void configureEach(Action<? super CompileUnitSourceSetSpec> action);
             }

variants/src/main/java/org/implab/gradle/variants/sources/VariantSourcesExtension.java +18 -4

             package org.implab.gradle.variants.sources;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             @NonNullByDefault
             public interface VariantSourcesExtension {
                 /**
                  * Selects how selector rules behave when they target an already materialized
-                 * {@link GenericSourceSet}.
+                 * source set.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the first selector rule is registered via
                  * {@link #variant(String, Action)}, {@link #layer(String, Action)} or
                  * {@link #unit(String, String, Action)};</li>
                  * <li>it must be selected before the source context becomes observable via
                  * {@link #whenAvailable(Action)};</li>
                  * <li>once selected or once source context creation begins, it cannot
                  * be changed later;</li>
                  * <li>the policy controls both diagnostics and late-application semantics.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link LateConfigurationPolicySpec#failOnLateConfiguration()}.
                  */
                 void lateConfigurationPolicy(Action<? super LateConfigurationPolicySpec> action);
                 default void lateConfigurationPolicy(Closure<?> closure) {
                     lateConfigurationPolicy(Closures.action(closure));
                 }
                 /**
                  * Selects how compile-unit name collisions are handled when the source
                  * context is created from the finalized variant model.
                  *
                  * <p>This policy is single-valued:
                  * <ul>
                  * <li>it must be selected before the
                  * {@link VariantSourcesContext} becomes observable through
                  * {@link #whenAvailable(Action)};</li>
                  * <li>once the context is being created, the policy is fixed and cannot be
                  * changed later;</li>
                  * <li>the policy governs validation of compile-unit names produced by the
                  * source-set materializer.</li>
                  * </ul>
                  *
                  * <p>If not selected explicitly, the default is
                  * {@link NamingPolicySpec#failOnNameCollision()}.
                  */
                 void namingPolicy(Action<? super NamingPolicySpec> action);
                 default void namingPolicy(Closure<?> closure) {
                     namingPolicy(Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given layer.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
-                void layer(String layerName, Action<? super GenericSourceSet> action);
+                void layer(String layerName, Action<? super CompileUnitSourceSetSpec> action);
                 default void layer(String layerName, Closure<?> closure) {
                     layer(layerName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for all compile units of the given variant.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
-                void variant(String variantName, Action<? super GenericSourceSet> action);
+                void variant(String variantName, Action<? super CompileUnitSourceSetSpec> action);
                 default void variant(String variantName, Closure<?> closure) {
                     variant(variantName, Closures.action(closure));
                 }
                 /**
                  * Registers a selector rule for one exact compile unit.
                  *
                  * <p>Registering the first selector rule fixes the selected
                  * {@link #lateConfigurationPolicy(Action)} for the remaining extension
                  * lifecycle.
                  */
-                void unit(String variantName, String layerName, Action<? super GenericSourceSet> action);
+                void unit(String variantName, String layerName, Action<? super CompileUnitSourceSetSpec> action);
                 default void unit(String variantName, String layerName, Closure<?> closure) {
                     unit(variantName, layerName, Closures.action(closure));
                 }
                 /**
+                 * Registers a selector rule for every materialized compile-unit source set.
+                 *
+                 * <p>Registering the first selector rule fixes the selected
+                 * {@link #lateConfigurationPolicy(Action)} for the remaining extension
+                 * lifecycle. This selector is applied before variant-, layer-, and unit-specific
+                 * selectors.
+                 */
+                void configureEach(Action<? super CompileUnitSourceSetSpec> action);
+                default void configureEach(Closure<?> closure) {
+                    configureEach(Closures.action(closure));
+                }
+                /**
                  * Invoked when the variants-derived source context becomes available.
                  *
                  * Replayable:
                  * <ul>
                  * <li>if called before variants finalization, action is queued
                  * <li>if called after variants finalization, action is invoked immediately
                  * </ul>
                  *
                  * <p>By the time this callback becomes observable, compile-unit naming
                  * policy has already been fixed and symbolic source-set names for finalized
                  * compile units are determined.
                  */
                 void whenAvailable(Action<? super VariantSourcesContext> action);
                 default void whenAvailable(Closure<?> closure) {
                     whenAvailable(Closures.action(closure));
                 }
                 /**
                  * Imperative selector for the late-configuration mode.
                  *
                  * <p>Exactly one mode is expected to be chosen for the extension lifecycle.
                  */
                 interface LateConfigurationPolicySpec {
                     /**
                      * Rejects selector registration if it targets any already materialized
                      * source set.
                      */
                     void failOnLateConfiguration();
                     /**
                      * Allows late selector registration, but emits a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void warnOnLateConfiguration();
                     /**
                      * Allows late selector registration without a warning when it targets an
                      * already materialized source set.
                      *
                      * <p>For such targets, selector precedence is not re-established
                      * retroactively. The action is applied as a late imperative step, after the
                      * state already produced at the materialization moment.
                      */
                     void allowLateConfiguration();
                 }
                 interface NamingPolicySpec {
                     /**
                      * Rejects finalized compile-unit models that project the same source-set
                      * name for different compile units.
                      */
                     void failOnNameCollision();
                     /**
                      * Resolves name collisions deterministically for the finalized
                      * compile-unit model.
                      *
                      * <p>Conflicting compile units are ordered canonically by
                      * {@code (variant.name, layer.name)}. The first unit keeps the base
                      * projected name, and each next unit receives a numeric suffix
                      * ({@code 2}, {@code 3}, ...).
                      */
                     void resolveNameCollision();
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/DefaultVariantSourcesContext.java +10 -3

             package org.implab.gradle.variants.sources.internal;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.sources.CompileUnit;
+            import org.implab.gradle.variants.sources.CompileUnitSourceSetSpec;
             import org.implab.gradle.variants.sources.CompileUnitsView;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.SourceSetMaterializer;
             import org.implab.gradle.variants.sources.VariantSourcesContext;
             public class DefaultVariantSourcesContext implements VariantSourcesContext {
                 private final VariantsView variantsView;
                 private final CompileUnitsView compileUnitsView;
                 private final RoleProjectionsView roleProjectionsView;
                 private final SourceSetMaterializer sourceSetMaterializer;
                 private final SourceSetRegistry sourceSetRegistry;
                 private final CompileUnitNamer compileUnitNamer;
                 private final SourceSetConfigurationRegistry sourceSetConfigurationRegistry;
                 public DefaultVariantSourcesContext(
                         VariantsView variantsView,
                         CompileUnitsView compileUnitsView,
                         RoleProjectionsView roleProjectionsView,
                         CompileUnitNamer compileUnitNamer,
                         SourceSetRegistry sourceSetRegistry,
                         SourceSetConfigurationRegistry sourceSetConfigurationRegistry) {
                     this.variantsView = variantsView;
                     this.compileUnitNamer = compileUnitNamer;
                     this.compileUnitsView = compileUnitsView;
                     this.roleProjectionsView = roleProjectionsView;
                     this.sourceSetRegistry = sourceSetRegistry;
                     this.sourceSetConfigurationRegistry = sourceSetConfigurationRegistry;
                     sourceSetMaterializer = new LocalSourceSetMaterializer();
                 }
                 @Override
                 public VariantsView getVariants() {
                     return variantsView;
                 }
                 @Override
                 public CompileUnitsView getCompileUnits() {
                     return compileUnitsView;
                 }
                 @Override
                 public RoleProjectionsView getRoleProjections() {
                     return roleProjectionsView;
                 }
                 @Override
                 public SourceSetMaterializer getSourceSets() {
                     return sourceSetMaterializer;
                 }
                 @Override
-                public void configureLayer(Layer layer, Action<? super GenericSourceSet> action) {
+                public void configureLayer(Layer layer, Action<? super CompileUnitSourceSetSpec> action) {
                     variantsView.assertLayer(layer);
                     Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addLayerAction(layer, action);
                 }
                 @Override
-                public void configureVariant(Variant variant, Action<? super GenericSourceSet> action) {
+                public void configureVariant(Variant variant, Action<? super CompileUnitSourceSetSpec> action) {
                     variantsView.assertVariant(variant);
                     Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addVariantAction(variant, action);
                 }
                 @Override
-                public void configureUnit(CompileUnit unit, Action<? super GenericSourceSet> action) {
+                public void configureUnit(CompileUnit unit, Action<? super CompileUnitSourceSetSpec> action) {
                     assertCompileUnit(unit);
                     Objects.requireNonNull(action, "action can't be null");
                     sourceSetConfigurationRegistry.addCompileUnitAction(unit, action);
                 }
+                @Override
+                public void configureEach(Action<? super CompileUnitSourceSetSpec> action) {
+                    Objects.requireNonNull(action, "action can't be null");
+                    sourceSetConfigurationRegistry.addAction(action);
+                }
                 private void assertCompileUnit(CompileUnit unit) {
                     Objects.requireNonNull(unit, "unit can't be null");
                     variantsView.assertVariant(unit.variant());
                     variantsView.assertLayer(unit.layer());
                     compileUnitsView.requireUnit(unit.variant(), unit.layer());
                 }
                 class LocalSourceSetMaterializer implements SourceSetMaterializer {
                     private final Map<CompileUnit, NamedDomainObjectProvider<GenericSourceSet>> registeredSources = new HashMap<>();
                     @Override
                     public NamedDomainObjectProvider<GenericSourceSet> getSourceSet(CompileUnit unit) {
                         assertCompileUnit(unit);
                         return registeredSources.computeIfAbsent(unit, k -> {
                             var sourcesName = compileUnitNamer.resolveName(unit);
                             sourceSetRegistry.whenMaterialized(sourcesName,
                                     sourceSet -> sourceSetConfigurationRegistry.applyConfiguration(unit, sourceSet));
                             return sourceSetRegistry.sourceSets().register(sourcesName);
                         });
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/SourceSetConfigurationRegistry.java +27 -13

             package org.implab.gradle.variants.sources.internal;
             import java.text.MessageFormat;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.sources.CompileUnit;
+            import org.implab.gradle.variants.sources.CompileUnitSourceSetSpec;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             @NonNullByDefault
             public class SourceSetConfigurationRegistry {
                 private static final Logger logger = Logging.getLogger(SourceSetConfigurationRegistry.class);
-                private final Map<Layer, ReplayableQueue<GenericSourceSet>> sourcesByLayer = new LinkedHashMap<>();
+                private final ReplayableQueue<CompileUnitSourceSetSpec> sources = new ReplayableQueue<>();
-                private final Map<Variant, ReplayableQueue<GenericSourceSet>> sourcesByVariant = new LinkedHashMap<>();
+                private final Map<Layer, ReplayableQueue<CompileUnitSourceSetSpec>> sourcesByLayer = new LinkedHashMap<>();
-                private final Map<CompileUnit, ReplayableQueue<GenericSourceSet>> sourcesByUnit = new LinkedHashMap<>();
+                private final Map<Variant, ReplayableQueue<CompileUnitSourceSetSpec>> sourcesByVariant = new LinkedHashMap<>();
+                private final Map<CompileUnit, ReplayableQueue<CompileUnitSourceSetSpec>> sourcesByUnit = new LinkedHashMap<>();
                 private final Supplier<LateConfigurationMode> lateConfigurationMode;
                 public SourceSetConfigurationRegistry(Supplier<LateConfigurationMode> lateConfigurationMode) {
                     this.lateConfigurationMode = lateConfigurationMode;
                 }
-                public void addLayerAction(Layer layer, Action<? super GenericSourceSet> action) {
+                public void addAction(Action<? super CompileUnitSourceSetSpec> action) {
+                    addToActions(
+                            sources,
+                            action,
+                            "Source sets already materialized");
+                }
+                public void addLayerAction(Layer layer, Action<? super CompileUnitSourceSetSpec> action) {
                     addToActions(
                             sourcesByLayer.computeIfAbsent(layer, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [layer={0}] layer already materialized",
                                     layer.getName()));
                 }
-                public void addVariantAction(Variant variant, Action<? super GenericSourceSet> action) {
+                public void addVariantAction(Variant variant, Action<? super CompileUnitSourceSetSpec> action) {
                     addToActions(
                             sourcesByVariant.computeIfAbsent(variant, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [variant={0}] variant already materialized",
                                     variant.getName()));
                 }
-                public void addCompileUnitAction(CompileUnit unit, Action<? super GenericSourceSet> action) {
+                public void addCompileUnitAction(CompileUnit unit, Action<? super CompileUnitSourceSetSpec> action) {
                     addToActions(
                             sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source set for [variant={0}, layer={1}] already materialized",
                                     unit.variant().getName(),
                                     unit.layer().getName()));
                 }
                 private void addToActions(
-                        ReplayableQueue<GenericSourceSet> actions,
+                        ReplayableQueue<CompileUnitSourceSetSpec> actions,
-                        Action<? super GenericSourceSet> action,
+                        Action<? super CompileUnitSourceSetSpec> action,
                         String assertMessage) {
                     assertLazyConfiguration(actions.values(), assertMessage);
                     actions.forEach(action::execute);
                 }
-                void assertLazyConfiguration(List<GenericSourceSet> sets, String message) {
+                void assertLazyConfiguration(List<CompileUnitSourceSetSpec> sets, String message) {
                     if (sets.size() == 0)
                         return;
-                    var names = sets.stream().map(Named::getName).collect(Collectors.joining(", "));
+                    var names = sets.stream()
+                            .map(CompileUnitSourceSetSpec::getSourceSet)
+                            .map(Named::getName)
+                            .collect(Collectors.joining(", "));
                     switch (lateConfigurationMode.get()) {
                         case FAIL:
                             throw new InvalidUserDataException(message + " [" + names + "]");
                         case WARN:
                             logger.warn(message + "\n\t" + names);
                             break;
                         default:
                             break;
                     }
                 }
                 public void applyConfiguration(CompileUnit unit, GenericSourceSet sourceSet) {
-                    sourcesByVariant.computeIfAbsent(unit.variant(), key -> new ReplayableQueue<>()).add(sourceSet);
+                    var spec = new DefaultCompileUnitSourceSetSpec(unit, sourceSet);
-                    sourcesByLayer.computeIfAbsent(unit.layer(), key -> new ReplayableQueue<>()).add(sourceSet);
+                    sources.add(spec);
-                    sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()).add(sourceSet);
+                    sourcesByVariant.computeIfAbsent(unit.variant(), key -> new ReplayableQueue<>()).add(spec);
+                    sourcesByLayer.computeIfAbsent(unit.layer(), key -> new ReplayableQueue<>()).add(spec);
+                    sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()).add(spec);
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java +12 0

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.junit.jupiter.api.Test;
             class VariantArtifactsPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void gradleReferenceLazyOutgoingConfigurationAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-outgoing-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 println('reference: registered browserElements provider')
                                 browserElements.configure { configuration ->
                                     println('reference: configuring browserElements')
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.create('js') { secondary ->
                                         println('reference: creating js outgoing variant')
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         println('reference: resolving primary files')
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         println('reference: resolving secondary files')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     var output = result.getOutput();
                     var registered = output.indexOf("reference: registered browserElements provider");
                     var resolvingPrimary = output.indexOf("reference: resolving primary files");
                     var configuring = output.indexOf("reference: configuring browserElements");
                     var creatingSecondary = output.indexOf("reference: creating js outgoing variant");
                     var resolvingSecondary = output.indexOf("reference: resolving secondary files");
                     assertTrue(registered >= 0);
                     assertTrue(resolvingPrimary >= 0);
                     assertTrue(configuring >= 0);
                     assertTrue(creatingSecondary >= 0);
                     assertTrue(resolvingSecondary >= 0);
                     assertTrue(registered < resolvingPrimary);
                     assertTrue(resolvingPrimary < configuring);
                     assertTrue(configuring < creatingSecondary);
                     assertTrue(creatingSecondary < resolvingSecondary);
                     assertTrue(output.contains("compileFiles=typesPackage"));
                     assertTrue(output.contains("jsFiles=js"));
                 }
                 @Test
                 void gradleReferenceRegisteredSecondaryArtifactVariantIsNotRealizedBeforeResolution() throws Exception {
                     // Gradle issue: https://github.com/gradle/gradle/issues/27441
                     // Registered outgoing artifact variants are not realized before dependency resolution.
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-registered-secondary-variant'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeFile("build.gradle", """
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 browserElements.configure { configuration ->
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.register('js') { secondary ->
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Cannot create variant 'js' after dependency configuration ':producer:browserElements' has been resolved",
                             ":consumer:probe");
                 }
                 @Test
                 void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
                     writeSettings("variant-artifacts-slots");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/amd.js", "console.log('amd')\n");
                     writeFile("inputs/mainJs.txt", "mainJs marker\n");
                     writeFile("inputs/amdJs.txt", "amdJs marker\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('mainBase')
                             variants.layers.create('mainAmd')
                             variants.roles.create('main')
                             variants.roles.create('test')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                             variantSources {
                                 layer('mainBase') {
+                                    sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                     }
+                                }
                                 layer('mainAmd') {
+                                    sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                     }
                                 }
+                            }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('mainJs') {
                                         fromRole('main') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/mainJs.txt'))
                                     }
                                     slot('amdJs') {
                                         fromLayer('mainAmd') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/amdJs.txt'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         attributes.attribute(variantAttr, publication.variant.name)
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     def slotName = publication.artifactSlot.slot.name
                                     publication.artifactAttributes {
                                         attribute(slotAttr, slotName)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_mainJs'
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s5_amdJs'
                                 doLast {
                                     def mainDir = layout.buildDirectory.dir('variant-assemblies/browser/mainJs').get().asFile
                                     def amdDir = layout.buildDirectory.dir('variant-assemblies/browser/amdJs').get().asFile
                                     assert new File(mainDir, 'base.js').exists()
                                     assert new File(mainDir, 'amd.js').exists()
                                     assert new File(mainDir, 'mainJs.txt').exists()
                                     assert !new File(amdDir, 'base.js').exists()
                                     assert new File(amdDir, 'amd.js').exists()
                                     assert new File(amdDir, 'amdJs.txt').exists()
                                     def elements = configurations.getByName('browserElements')
                                     def amdVariant = elements.outgoing.variants.getByName('amdJs')
                                     println('variantAttr=' + elements.attributes.getAttribute(variantAttr))
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('amdSlotAttr=' + amdVariant.attributes.getAttribute(slotAttr))
                                     println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
                                     println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("variantAttr=browser"));
                     assertTrue(result.getOutput().contains("primarySlotAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdSlotAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void outgoingSlotHookFollowsMaterializedGradleArtifactVariants() throws Exception {
                     writeSettings("variant-artifacts-materialized-gradle-variant");
                     writeFile("inputs/typesPackage", "types\n");
                     writeFile("inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('typesPackage') {
                                         from(layout.projectDirectory.file('inputs/typesPackage'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         outgoing.variants.create('js') { secondary ->
                                             secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                         }
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     publication.artifactAttributes {
                                         attribute(slotAttr, publication.artifactSlot.slot.name)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def elements = configurations.getByName('browserElements')
                                     def jsVariant = elements.outgoing.variants.getByName('js')
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('jsSlotAttr=' + jsVariant.attributes.getAttribute(slotAttr))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primarySlotAttr=typesPackage"));
                     assertTrue(result.getOutput().contains("jsSlotAttr=js"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeSettings("variant-artifacts-single-slot");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
+                                sourceSet {
                                     declareOutputs('types')
                                 }
+                            }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         println('primary=' + ctx.findOutgoing(browser).get().primarySlot.get().name)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeSettings("variant-artifacts-direct-input");
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         from(layout.projectDirectory.file('inputs/bundle.js'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'bundle.js').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeSettings("variant-artifacts-combined-inputs");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
+                                sourceSet {
                                     declareOutputs('js')
                                     registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                 }
+                            }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         fromVariant {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/marker.txt'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'base.js').exists()
                                     assert new File(bundleDir, 'marker.txt').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void failsOnUnknownVariantReference() throws Exception {
                     writeSettings("variant-artifacts-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     writeSettings("variant-artifacts-missing-role");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromRole('test') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Role projection for variant 'browser' and role 'test' not found", "help");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     writeSettings("variant-artifacts-missing-primary");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
+                                sourceSet {
                                     declareOutputs('types', 'js')
                                 }
+                            }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                     slot('js') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         ctx.findOutgoing(browser).get().primarySlot.get()
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Multiple slots declared for browser, please specify primary slot explicitly", "probe");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     writeSettings("variant-artifacts-layer-outside-topology");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('mainBase')
                             variants.layers.create('extra')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('extraJs') {
                                         fromLayer('extra') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'extra' not found", "help");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'variant-artifacts-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             subprojects {
                                 apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             }
                             project(':producer') {
                                 variants.layers.create('main')
                                 variants.roles.create('main')
                                 variants.variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                                 variantSources.layer('main') {
+                                    sourceSet {
                                         declareOutputs('types', 'js')
                                         registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
                                         registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
                                     }
+                                }
                                 variantArtifacts {
                                     variant('browser') {
                                         primarySlot('typesPackage') {
                                             fromVariant {
                                                 output('types')
                                             }
                                         }
                                         slot('js') {
                                             fromVariant {
                                                 output('js')
                                             }
                                         }
                                     }
                                     whenOutgoingConfiguration { publication ->
                                         publication.configuration {
                                             attributes.attribute(variantAttr, publication.variant.name)
                                         }
                                     }
                                     whenOutgoingSlot { publication ->
                                         publication.artifactAttributes {
                                             attribute(slotAttr, publication.artifactSlot.slot.name)
                                         }
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantSourcesPluginFunctionalTest.java +36 -10

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.junit.jupiter.api.Test;
             class VariantSourcesPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void exposesDerivedViewsAndStableSourceSetProvider() throws Exception {
                     writeSettings("variant-sources-derived-views");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             def lines = []
                             variantSources.whenAvailable { ctx ->
                                 lines << "units=" + ctx.compileUnits.units
                                     .collect { "${it.variant().name}:${it.layer().name}" }
                                     .sort()
                                     .join(',')
                                 def browser = ctx.variants.variants.find { it.name == 'browser' }
                                 def production = ctx.variants.roles.find { it.name == 'production' }
                                 def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                 def projection = ctx.roleProjections.requireProjection(browser, production)
                                 def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                 def left = ctx.sourceSets.getSourceSet(unit)
                                 def right = ctx.sourceSets.getSourceSet(unit)
                                 lines << "projectionUnits=" + ctx.roleProjections.getUnits(projection)
                                     .collect { it.layer().name }
                                     .sort()
                                     .join(',')
                                 lines << "mainSourceSet=" + left.name
                                 lines << "sameProvider=" + left.is(right)
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     lines << "late:variants=" + ctx.variants.variants.collect { it.name }.sort().join(',')
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     lines.each { println(it) }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("units=browser:main,browser:test"));
                     assertTrue(result.getOutput().contains("projectionUnits=main"));
                     assertTrue(result.getOutput().contains("mainSourceSet=browserMain"));
                     assertTrue(result.getOutput().contains("sameProvider=true"));
                     assertTrue(result.getOutput().contains("late:variants=browser"));
                 }
                 @Test
                 void appliesSelectorPrecedenceForFutureMaterialization() throws Exception {
                     writeSettings("variant-sources-precedence");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.roles.create('test')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                                 role('test') { layers('main', 'test') }
                             }
                             variantsExt.variant('node') {
                                 role('production') { layers('main') }
                             }
                             def events = []
                             variantSources {
+                                configureEach {
+                                    events << "all:" + sourceSet.name
+                                    events << "context:" + sourceSet.name + ":" + variant.name + ":" + layer.name
+                                }
                                 variant('browser') {
-                                    events << "variant:" + name
+                                    events << "variant:" + sourceSet.name
                                 }
                                 layer('main') {
-                                    events << "layer:" + name
+                                    events << "layer:" + sourceSet.name
                                 }
                                 unit('browser', 'main') {
-                                    events << "unit:" + name
+                                    events << "unit:" + sourceSet.name
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def node = ctx.variants.variants.find { it.name == 'node' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def testLayer = ctx.variants.layers.find { it.name == 'test' }
                                     def browserMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, mainLayer)).get()
                                     def browserTest = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(browser, testLayer)).get()
                                     def nodeMain = ctx.sourceSets.getSourceSet(ctx.compileUnits.requireUnit(node, mainLayer)).get()
                                     def bySourceSet = events.groupBy { it.split(':', 2)[1] }
                                     println("browserMain=" + bySourceSet[browserMain.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("browserTest=" + bySourceSet[browserTest.name].collect { it.split(':', 2)[0] }.join(','))
                                     println("nodeMain=" + bySourceSet[nodeMain.name].collect { it.split(':', 2)[0] }.join(','))
+                                    println("context=" + events.find { it.startsWith("context:" + browserMain.name + ":") })
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
-                    assertTrue(result.getOutput().contains("browserMain=variant,layer,unit"));
+                    assertTrue(result.getOutput().contains("browserMain=all,variant,layer,unit"));
-                    assertTrue(result.getOutput().contains("browserTest=variant"));
+                    assertTrue(result.getOutput().contains("browserTest=all,variant"));
-                    assertTrue(result.getOutput().contains("nodeMain=layer"));
+                    assertTrue(result.getOutput().contains("nodeMain=all,layer"));
+                    assertTrue(result.getOutput().contains("context=context:browserMain:browser:main"));
                 }
                 @Test
                 void failsLateConfigurationByDefaultAfterMaterialization() throws Exception {
                     writeSettings("variant-sources-late-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
                                     ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
+                                        sourceSet {
                                             declareOutputs('late')
                                         }
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("Source sets for [layer=main] layer already materialized", "help");
                 }
                 @Test
                 void allowsLateConfigurationWhenSelectedBeforeFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-allow");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
-                                    def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
+                                    def unitSourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
+                                        sourceSet {
                                             declareOutputs('late')
                                         }
-                                    sourceSet.output('late')
+                                    unitSourceSet.output('late')
                                     println('lateAllowed=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("lateAllowed=ok"));
                 }
                 @Test
                 void warnsAndAppliesLateConfigurationWhenWarnModeSelected() throws Exception {
                     writeSettings("variant-sources-late-warn");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 lateConfigurationPolicy {
                                     warnOnLateConfiguration()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     def browser = ctx.variants.variants.find { it.name == 'browser' }
                                     def mainLayer = ctx.variants.layers.find { it.name == 'main' }
                                     def unit = ctx.compileUnits.requireUnit(browser, mainLayer)
-                                    def sourceSet = ctx.sourceSets.getSourceSet(unit).get()
+                                    def unitSourceSet = ctx.sourceSets.getSourceSet(unit).get()
                                     variantSources.layer('main') {
+                                        sourceSet {
                                             declareOutputs('late')
                                         }
-                                    sourceSet.output('late')
+                                    unitSourceSet.output('late')
                                     println('lateWarn=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("Source sets for [layer=main] layer already materialized"));
                     assertTrue(result.getOutput().contains("lateWarn=ok"));
                 }
                 @Test
                 void rejectsChangingLateConfigurationPolicyAfterFirstSelector() throws Exception {
                     writeSettings("variant-sources-late-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('browser') {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
+                                }
                                 lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
                 @Test
                 void failsOnProjectedNameCollisionByDefault() throws Exception {
                     writeSettings("variant-sources-name-collision-fail");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             """);
                     assertBuildFails("The same source set names are produced by different compile units", "help");
                 }
                 @Test
                 void resolvesProjectedNameCollisionDeterministicallyWhenConfigured() throws Exception {
                     writeSettings("variant-sources-name-collision-resolve");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('variantBar')
                             variantsExt.layers.create('bar')
                             variantsExt.roles.create('production')
                             variantsExt.variant('foo') {
                                 role('production') { layers('variantBar') }
                             }
                             variantsExt.variant('fooVariant') {
                                 role('production') { layers('bar') }
                             }
                             variantSources {
                                 namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             afterEvaluate {
                                 variantSources.whenAvailable { ctx ->
                                     def foo = ctx.variants.variants.find { it.name == 'foo' }
                                     def fooVariant = ctx.variants.variants.find { it.name == 'fooVariant' }
                                     def variantBar = ctx.variants.layers.find { it.name == 'variantBar' }
                                     def bar = ctx.variants.layers.find { it.name == 'bar' }
                                     def later = ctx.compileUnits.requireUnit(fooVariant, bar)
                                     def earlier = ctx.compileUnits.requireUnit(foo, variantBar)
                                     println("map1=" + later.variant().name + ":" + later.layer().name + "->" + ctx.sourceSets.getSourceSet(later).name)
                                     println("map2=" + earlier.variant().name + ":" + earlier.layer().name + "->" + ctx.sourceSets.getSourceSet(earlier).name)
                                 }
                             }
                             """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("map1=fooVariant:bar->fooVariantBar2"));
                     assertTrue(result.getOutput().contains("map2=foo:variantBar->fooVariantBar"));
                 }
                 @Test
                 void failsOnUnknownVariantSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 variant('missing') {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("Variant 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownVariantContextSelectorTarget() throws Exception {
                     writeSettings("variant-sources-context-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable { ctx ->
                                 def missing = objects.named(org.implab.gradle.variants.core.Variant, 'missing')
                                 ctx.configureVariant(missing) {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("The specified variant 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownLayerSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-layer");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 layer('missing') {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("Layer 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownLayerContextSelectorTarget() throws Exception {
                     writeSettings("variant-sources-context-missing-layer");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable { ctx ->
                                 def missing = objects.named(org.implab.gradle.variants.core.Layer, 'missing')
                                 ctx.configureLayer(missing) {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("The specified layer 'missing' isn't declared", "help");
                 }
                 @Test
                 void failsOnUndeclaredCompileUnitSelectorTarget() throws Exception {
                     writeSettings("variant-sources-missing-unit");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources {
                                 unit('browser', 'test') {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("The CompileUnit isn't declared for variant 'browser', layer 'test'", "help");
                 }
                 @Test
                 void failsOnUndeclaredCompileUnitContextSelectorTarget() throws Exception {
                     writeSettings("variant-sources-context-missing-unit");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable { ctx ->
                                 def browser = ctx.variants.variants.find { it.name == 'browser' }
                                 def testLayer = ctx.variants.layers.find { it.name == 'test' }
                                 def unit = new org.implab.gradle.variants.sources.CompileUnit(browser, testLayer)
                                 ctx.configureUnit(unit) {
+                                    sourceSet {
                                         declareOutputs('js')
                                     }
                                 }
+                            }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'test' not found", "help");
                 }
                 @Test
                 void failsOnUndeclaredCompileUnitMaterializerTarget() throws Exception {
                     writeSettings("variant-sources-materializer-missing-unit");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.layers.create('test')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable { ctx ->
                                 def browser = ctx.variants.variants.find { it.name == 'browser' }
                                 def testLayer = ctx.variants.layers.find { it.name == 'test' }
                                 def unit = new org.implab.gradle.variants.sources.CompileUnit(browser, testLayer)
                                 ctx.sourceSets.getSourceSet(unit)
                             }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'test' not found", "help");
                 }
                 @Test
                 void rejectsChangingNamingPolicyAfterContextBecomesObservable() throws Exception {
                     writeSettings("variant-sources-name-policy-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable {
                                 variantSources.namingPolicy {
                                     resolveNameCollision()
                                 }
                             }
                             """);
                     assertBuildFails("Naming policy already applied", "help");
                 }
                 @Test
                 void rejectsChangingLateConfigurationPolicyAfterContextBecomesObservable() throws Exception {
                     writeSettings("variant-sources-late-policy-context-fixed");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantSourcesPlugin
                             def variantsExt = extensions.getByType(org.implab.gradle.variants.core.VariantsExtension)
                             variantsExt.layers.create('main')
                             variantsExt.roles.create('production')
                             variantsExt.variant('browser') {
                                 role('production') { layers('main') }
                             }
                             variantSources.whenAvailable {
                                 variantSources.lateConfigurationPolicy {
                                     allowLateConfiguration()
                                 }
                             }
                             """);
                     assertBuildFails("Lazy configuration policy already applied", "help");
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages