/**
     * Returns the Eclipse natures configured on the project.
     * <p>
     * Some natures are automatically added to the result based on the Gradle plugins applied on the project.
     * For example, if the project applies the 'java' plugin the result will contain the
     * {@code "org.eclipse.jdt.core.javanature"} entry. Note, that the exact list of automatically added

          "static-range-ptq-to-all", "Applies `StaticRangePtq` to all quantizable units."),
        clEnumValN(mlir::quant::stablehlo::testing::TestQuantizationSpecs::kStaticRangePtqToComputeHeavy,
          "static-range-ptq-to-compute-heavy", "Applies `StaticRangePtq` to only compute heavy units.")
      )}]>
  ];
  let dependentDialects = [

	// Zero the permutation's state.
	for i := range d.a {
		d.a[i] = 0
	}
	d.state = spongeAbsorbing
	d.i, d.n = 0, 0
}

func (d *state) clone() *state {
	ret := *d
	return &ret
}

// permute applies the KeccakF-1600 permutation. It handles
// any input-output buffering.
func (d *state) permute() {
	switch d.state {
	case spongeAbsorbing:
		// If we're absorbing, we need to xor the input into the state

	default:
		r := int64(*v.Int)
		if r < 0 {
			return -1, errBadLimitSpecified
		}
		return r, nil
	}
}

// EvalFrom evaluates the From clause on the input record. It only
// applies to JSON input data format (currently).
func (e *SelectStatement) EvalFrom(format string, input Record) ([]*Record, error) {
	if !e.selectAST.From.HasKeypath() {
		return []*Record{&input}, nil
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check go:noescape annotations.

package p

// The noescape comment only applies to the next func,
// which must not have a body.

//go:noescape

func F1([]byte)

func F2([]byte)

func G() {
	var buf1 [10]byte
	F1(buf1[:])

	var buf2 [10]byte // ERROR "moved to heap: buf2"

    }

    void applyPlugin() {
        settingsFile << fixture.plugins()
    }

    def "automatically applies plugin when --scan is provided on command-line"() {
        when:
        runBuildWithScanRequest()

        then:
        pluginAppliedOnce()
    }

    def "only applies once when -b used"() {
        when:
        file("other-build.gradle") << "task dummy {}"

import static org.gradle.util.internal.WrapUtil.toLinkedSet

class JavaBasePluginTest extends AbstractProjectBuilderSpec {
    @Rule
    public SetSystemProperties sysProperties = new SetSystemProperties()

    def "applies base plugins and adds convention and extensions"() {
        when:
        project.pluginManager.apply(JavaBasePlugin)

        then:
        project.plugins.hasPlugin(ReportingBasePlugin)

import org.gradle.api.initialization.Settings
import org.gradle.api.plugins.PluginAware
import org.gradle.kotlin.dsl.support.serviceOf

import kotlin.reflect.KProperty


/**
 * Applies the plugin of the given type [T]. Does nothing if the plugin has already been applied.
 *
 * The given class should implement the [Plugin] interface, and be parameterized for a
 * compatible type of `this`.
 *
 * @param T the plugin type.

 */
package org.gradle.kotlin.dsl

import org.gradle.api.Plugin
import org.gradle.api.invocation.Gradle
import org.gradle.api.plugins.PluginAware


/**
 * Applies the plugin of the given type [T]. Does nothing if the plugin has already been applied.
 *
 * The given class should implement the [Plugin] interface, and be parameterized for a
 * compatible type of `this`.
 *
 * @param T the plugin type.

import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.registry.ModelRegistry;

import java.util.List;

public interface ExtractedRuleSource<T> {
    /**
     * Applies the rules of this rule source to the given element.
     */
    void apply(ModelRegistry modelRegistry, MutableModelNode target);

    /**
     * Returns the set of plugins required by the rules of this rule source.