# Security Policy

## Supported Versions

Security updates are applied only to the latest release.

## Reporting a Vulnerability

If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization;

/**
 * Fired once a build in the tree is discovered and before any other build operations reference that build are executed.
 *
 * @since 8.0
 */
public interface BuildIdentifiedProgressDetails {
    String getBuildPath();

abstract class ModelListener extends ModelPredicate {
    /**
     * Invoked once for each node when the node reaches the {@link org.gradle.model.internal.core.ModelNode.State#Discovered} state
     * if the node matches the criteria specified by this listener.
     */
    public abstract void onDiscovered(ModelNodeInternal node);

     *
     * <p>Note that not every method is known. Some methods may require an attempt invoke it in order for them to be discovered.</p>
     */
    boolean hasMethod(String name, @Nullable Object... arguments);

    /**
     * Invokes the method with the given name and arguments.
     */

// Check the compiler's switch handling that happens
// at typechecking time.
// This must be separate from other checks,
// because errors during typechecking
// prevent other errors from being discovered.

package main

// Verify that type switch statements with impossible cases are detected by the compiler.
func f0(e error) {
	switch e.(type) {

        then:
        1 * listener.onDiscovered(graph.root)
        1 * listener.onDiscovered(a)
        1 * listener.onDiscovered(b)
        0 * listener.onDiscovered(_)

        when:
        graph.add(c)
        graph.add(d)

        then:
        1 * listener.onDiscovered(c)
        1 * listener.onDiscovered(d)
        0 * listener.onDiscovered(_)
    }

    enum State {
        Registered(true), // Initial state. Only path and some projections are known here
        Discovered(true), // All projections are defined
        Created(true), // Private data has been created, initial rules discovered
        DefaultsApplied(true), // Default values have been applied
        Initialized(true),
        Mutated(true),
        Finalized(false),

        this.bindAction = bindAction;
    }

    @Override
    public boolean canBindInState(ModelNode.State state) {
        return predicate.getReference().isUntyped() || state.isAtLeast(ModelNode.State.Discovered);
    }

    @Override
    public void doOnBind(ModelNodeInternal node) {
        if (predicate.matches(node)) {
            boundTo = node;
            bindAction.execute(this);
        } else {

import org.gradle.api.Action;
import org.gradle.api.internal.project.ProjectInternal;

/**
 * Can be implemented by plugins to auto-configure each project.
 *
 * <p>Implementations are discovered using the JAR service locator mechanism (see {@link org.gradle.internal.service.ServiceLocator}).
 * Each action is invoked for each project that is to be configured, before the project has been configured. Actions are executed

            }
        }
    }

    private void maybeNotify(ModelNodeInternal node, ModelListener listener) {
        if (!node.isAtLeast(ModelNode.State.Discovered)) {
            return;
        }
        listener.onDiscovered(node);
    }

    @Nullable
    public ModelNodeInternal find(ModelPath path) {
        return flattened.get(path);
    }