// The buffer must live for the duration of the function call,
// The caller receives ownership of the module.
// `base_loc` is used for error reporting and debug info.
// If ordered_output_arrays is not empty, then the imported mlir function will
// only return nodes in ordered_output_arrays in the same order. Returns nullptr
// on failure, and more specific errors will be emitted via the context.

        "org/gradle/testing/**",
        "org/gradle/vcs/**",
        "org/gradle/work/**",
        "org/gradle/workers/**",
        "org/gradle/util/**", // contains Path that clashes with `org.gradle.api.model.Path` imported above. This line should not appear before "org/gradle/api/**"
    )

    val excludes = listOf("**/internal/**")

    private val includePackagePatterns: List<Pattern> by lazy {
        includes.map {

import java.util.List;
import java.util.Map;

@ServiceScope(Scope.Global.class)
public interface ImportsReader {
    /**
     * Returns the list of packages that are imported by default into each Gradle build script.
     * This list is only meant for concise presentation to the user (e.g. in documentation). For
     * machine consumption, use the {@link #getSimpleNameToFullClassNamesMapping()} method, as it

	// object and process the Envoy listener or RDS based on the imported
	// services/virtual services in that listener.
	EgressListeners []*IstioEgressListenerWrapper

	// Union of services imported across all egress listeners for use by CDS code.
	services           []*Service
	servicesByHostname map[host.Name]*Service

	// Destination rules imported across all egress listeners. This

  // Prepare the imported graph.
  func_pm.addPass(mlir::CreateExecutorDialectToFunctionalConversionPass());

  // Run TFR lowering, inlining and raising to tf.
  func_pm.addPass(mlir::TFR::CreateDecomposeTFOpsPass(tfr_module_));
  func_pm.addPass(mlir::TFR::CreateRaiseToTFOpsPass(
      tfr_module_, /*materialize_derived_attrs=*/true));

  // Prepare to be exported.

	imports       []*PkgName                  // list of imported packages
	dotImportMap  map[dotImportKey]*PkgName   // maps dot-imported objects to the package they were dot-imported through
	recvTParamMap map[*syntax.Name]*TypeParam // maps blank receiver type parameters to their type

          - "!**/pkg/test/framework/**"
          - "!**/tests/fuzz/**"
        deny:
          - pkg: istio.io/istio/operator
            desc: "operator should not be imported"
          - pkg: istio.io/istio/istioctl
            desc: "istioctl should not be imported"
      DenyOpenTelemetry:
        files:
          - $all
          - "!**/pkg/monitoring/**"
          - "!**/pkg/tracing/**"
        deny:

                    .details("The imported dependency doesn't resolve into any file")
                    .solution("Check the import statement, it should resolve into a single file")));
        }
    }

    private void addImportsToResolvableConfiguration(DependencyResolutionServices drs, Configuration cnf, Import imported) {
        Object notation = imported.notation;

`,
	} {
		files = append(files, mustParse(fset, src))
	}

	// Type-check a package consisting of these files.
	// Type information for the imported "fmt" package
	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("temperature", fset, files, nil)
	if err != nil {
		log.Fatal(err)
	}

	// Print the tree of scopes.

		// vendor/modules.txt. That includes all direct dependencies and all modules
		// that provide any imported packages.
		//
		// It's ok if there are undetected differences in modules that do not
		// provide imported packages: we will not have to pull in any backports of
		// fixes to those modules anyway.
		vendor, err := os.ReadFile(filepath.Join(m.Dir, "vendor", "modules.txt"))