{
  "extends": ["stylelint-config-standard"],
  "rules": {
    "declaration-property-value-allowed-list": {
      "/color/": ["/^var\\(--/", "transparent"]
    },
    "unit-disallowed-list": ["px"],
    "selector-class-pattern": "^[a-zA-Z\\-]+$"
  },
  "ignoreFiles": ["**/*.min.css"]

    : public PassWrapper<SmuggleDisallowedOpsPass,
                         OperationPass<func::FuncOp>> {
 public:
  StringRef getArgument() const final { return "smuggle-disallowed-ops-pass"; }
  StringRef getDescription() const final {
    return "Smuggle disallowed ops via stablehlo.custom_calls";
  }
  void getDependentDialects(DialectRegistry& registry) const final {
    registry.insert<mlir::stablehlo::StablehloDialect>();
  }

//go:build go1.21

package countertest

import "testing"

func init() {
	// Extra safety check for go1.21+.
	if !testing.Testing() {
		panic("use of this package is disallowed in non-testing code")
	}

import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.BuildTree.class)
public interface ExecutionAccessListener {

    /**
     * Called when accessing the injected service of type that disallowed during execution phase (eg. Project).
     */
    void disallowedAtExecutionInjectedServiceAccessed(Class<?> injectedServiceType, String getterName, String consumer);

 */
class SimpleIdnaMappingTable internal constructor(
  internal val mappings: List<Mapping>,
) {
  /**
   * Returns true if the [codePoint] was applied successfully. Returns false if it was disallowed.
   */
  fun map(
    codePoint: Int,
    sink: BufferedSink,
  ): Boolean {
    val index =
      mappings.binarySearch {
        when {
          it.sourceCodePoint1 < codePoint -> -1

//go:build purego

// Package alias implements memory aliasing tests.
package alias

// This is the Google App Engine standard variant based on reflect
// because the unsafe package and cgo are disallowed.

import "reflect"

// AnyOverlap reports whether x and y share memory at any (not necessarily
// corresponding) index. The memory beyond the slice length is ignored.
func AnyOverlap(x, y []byte) bool {

// `skip_resize` enables or disables skipping conversion of tf.ResizeBilinear
// and tf.ResizeNearestNeighbor ops.
// `smuggle_disallowed_ops` enables or disables converting disallowed ops
// like tf.ResizeBilinear or tf.ResizeNearestNeighbor to mhlo.custom_call ops.
void AddTFToStablehloPasses(OpPassManager& pm, bool skip_resize,
                            bool smuggle_disallowed_ops);

 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].

code.
For backward compatibility, existing usages of `//go:linkname` found in
a large open-source code corpus remain supported.
Any new references to standard library internal symbols will be disallowed.

A linker command line flag `-checklinkname=0` can be used to disable
this check, for debugging and experimenting purposes.

<!-- CL 473495 -->
When building a dynamically linked ELF binary (including PIE binary), the

class CopyTaskChildSpecIntegrationTest extends AbstractIntegrationSpec implements DirectoryBuildCacheFixture {

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "changing child specs of the copy task while executing is disallowed"() {
        given:
        file("some-dir/input.txt") << "Data"
        buildScript """
            task copy(type: Copy) {
                outputs.cacheIf { true }
                from ("some-dir")