import org.gradle.internal.declarativedsl.analysis.AnalysisStatementFilterUtils.isTopLevelElement
import org.gradle.internal.declarativedsl.analysis.and
import org.gradle.internal.declarativedsl.analysis.implies
import org.gradle.internal.declarativedsl.common.gradleDslGeneralSchema
import org.gradle.internal.declarativedsl.evaluationSchema.DefaultStepIdentifier

          "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 = [

kind: VirtualService
metadata:
  name: all
  namespace: testns
spec:
  hosts:
  - service3.default.svc.cluster.local
  - uk.bookinfo.com
  - eu.bookinfo.com
  gateways:
  - my-gateway
  - mesh # applies to all the sidecars in the mesh
  http:
  - match:
    - headers:
        cookie:
          regex: "^(.*?;)?(user=dev-123)(;.*)?"
    route:
    - destination:
        port:
          number: 81

      mode: SIMPLE #enables HTTPS on this port
      serverCertificate: /etc/certs/servercert.pem
      privateKey: /etc/certs/privatekey.pem
#  - port:
#      number: 9080
#      name: http-wildcard

### What are Rules?

A `rule` defines a policy to be enforced on packages which are depended on by
the package in question.  It consists of three parts:
  - A `SelectorRegexp`, to select the import paths that the rule applies to.
  - A list of `AllowedPrefixes`
  - A list of `ForbiddenPrefixes`

An import is allowed if it matches at least one allowed prefix and does not
match any forbidden prefixes.

// 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"

//go:build !ppc64 && !ppc64le && !riscv64

package reflect

import "unsafe"

// This file implements a straightforward conversion of a float32
// value into its representation in a register. This conversion
// applies for amd64 and arm64. It is also chosen for the case of
// zero argument registers, but is not used.

func archFloat32FromReg(reg uint64) float32 {
	i := uint32(reg)
	return *(*float32)(unsafe.Pointer(&i))
}

env GO111MODULE=off

# Test that the user can override default code generation flags.

[compiler:gccgo] skip  # gccgo does not use -gcflags
[!cgo] skip
[!GOOS:linux] skip  # test only works if c-archive implies -shared
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.
go build -x -n -buildmode=c-archive -gcflags=all=-shared=false ./override.go
stderr '^.*/compile (.* )?-shared (.* )?-shared=false'

// limitations under the License.

[[java_gradle_plugin]]
= Gradle Plugin Development Plugin

The Java Gradle Plugin development plugin can be used to assist in the development of Gradle plugins.
It automatically applies the <<java_library_plugin.adoc#java_library_plugin,Java Library (`java-library`)>> plugin, adds the `gradleApi()` dependency to the `api` configuration and performs validation of plugin metadata during `jar` task execution.

# Tests that initial failures to not block subsequent applies.
# Initial apply for Widget fails, since CRD is not applied yet,
# but the CRD apply should succeed. Subsequent custom resource
# apply of Widget should succeed.
apiVersion: example.com/v1
kind: Widget
metadata:
  name: foo
---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: widgets.example.com
spec:
  group: example.com
  scope: Namespaced