if (resolveContext.hasDependencies()) {
            return delegate.resolveBuildDependencies(resolveContext);
        }

        resolveContext.markAsObserved();
        VisitedGraphResults graphResults = emptyGraphResults(resolveContext);
        return DefaultResolverResults.buildDependenciesResolved(graphResults, EmptyResults.INSTANCE,

            if (targetConfig != null) {
                // Can be null when dependency metadata for target project has been loaded from cache
                targetConfig.markAsObserved(requestedState);
            }
        }
    }

    private static class ResolvedProjectConfiguration {
        private final Path projectIdentity;
        private final String targetConfiguration;

    /**
     * Marks this resolve context as observed, meaning its state has been seen by some external operation
     * and further changes to this context that would change its public state are forbidden.
     */
    void markAsObserved();

    FailureResolutions getFailureResolutions();

    /**
     * Details about this resolve context to provide additional context during failure cases.
     */
    interface FailureResolutions {

     * Actions may mutate the dependency set for this configuration.
     * After execution, all actions are de-registered, so execution will only occur once.
     */
    void runDependencyActions();

    void markAsObserved(InternalState requestedState);

    void addMutationValidator(MutationValidator validator);

    void removeMutationValidator(MutationValidator validator);

    /**

        this.action = Actions.composite(this.action, action);
    }

    public void collectVariants(Consumer<UsageContext> collector) {
        outgoingConfiguration.runDependencyActions();
        outgoingConfiguration.markAsObserved();
        String outgoingConfigurationName = outgoingConfiguration.getName();

        if (!outgoingConfiguration.isTransitive()) {

        // After we observe a configuration (by building its metadata), its state should not change.
        configuration.runDependencyActions();
        configuration.markAsObserved();

        String configurationName = configuration.getName();
        String description = configuration.getDescription();

    }

    def "wraps attribute container to throw a custom exception"() {
        given:
        def conf = conf()
        def a1 = Attribute.of('a1', String)

        when:
        conf.markAsObserved()
        conf.getAttributes().attribute(a1, "a1")

        then:
        IllegalStateException t = thrown()

            ),
            false,
            getResolutionHost(),
            taskDependencyFactory
        );
    }

    @Override
    public void markAsObserved(InternalState requestedState) {
        markThisObserved(requestedState);
        markParentsObserved(requestedState);
    }

    private void markThisObserved(InternalState requestedState) {