failureReasons += FailuresInLanguageTree(languageModel.allFailures)
        }
        val initialResolution = resolver.resolve(evaluationSchema.analysisSchema, languageModel.imports, languageModel.topLevelBlock)
        if (initialResolution.errors.isNotEmpty()) {
            failureReasons += NotEvaluated.StageFailure.FailuresInResolution(initialResolution.errors)
        }

# packages have Go code but no tests, and other packages have tests
# but no Go code. Package breakdown:
#
# Package         Code?           Tests?          Stmts           Imports
# a               yes             yes             2               f
# b               yes             yes             1               a, d
# c               yes             yes             3               ---

                                  absl::string_view calibration_data_dir,
                                  bool force_regenerate_calibration_data,
                                  absl::string_view dst_saved_model_path);

  // Imports the SavedModel at `calibrated_saved_model_path` to `ModuleOp` after
  // running calibration.
  absl::StatusOr<ModuleOp> ImportCalibratedSavedModel(
      absl::string_view calibrated_saved_model_path);

	//
	// - Implicit allocation is disallowed.
	//
	// - Various runtime pragmas are enabled.
	//
	// - Optimizations are always enabled.
	//
	// This should be set for runtime and all packages it imports, and may be
	// set for additional packages.
	Runtime bool

	// NoInstrument indicates this package should not receive sanitizer
	// instrumentation. In many of these, instrumentation could cause infinite

[[sec:enabling_and_disabling_tasks]]
=== 3. Enabling and Disabling tasks

Every task has an `enabled` flag, which defaults to `true`.

		{"Package.IgnoredGoFiles", Field, 1},
		{"Package.IgnoredOtherFiles", Field, 16},
		{"Package.ImportComment", Field, 4},
		{"Package.ImportPath", Field, 0},
		{"Package.ImportPos", Field, 0},
		{"Package.Imports", Field, 0},
		{"Package.InvalidGoFiles", Field, 6},
		{"Package.MFiles", Field, 3},
		{"Package.Name", Field, 0},
		{"Package.PkgObj", Field, 0},
		{"Package.PkgRoot", Field, 0},

  Tf2XlaRewriter(mlir::Operation* op, mlir::PatternRewriter& rewriter,
                 const std::string& device_type);

  ~Tf2XlaRewriter();

  // Compiles the given Operation with XlaBuilder and imports the generated HLO
  // via the HLO -> MHLO importer.
  absl::StatusOr<mhlo::TupleOp> CompileWithHloImporter(
      tensorflow::OpKernelContext& op_context);

// source: k8s.io/apimachinery/pkg/api/resource/generated.proto

package resource

import (
	fmt "fmt"

	math "math"

	proto "github.com/gogo/protobuf/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file

        String getterPrefix = originalType == "boolean" ? "is" : "get"
        def generatedClass = source """
            package $GENERATED_CLASSES_PACKAGE_NAME;
            ${imports.collect { "import $it.name;" }.join("\n")}
            import org.gradle.internal.deprecation.DeprecationLogger;
            import org.gradle.test.Task;

            @Generated
            public class Task_Adapter {

sed -i 's/out.initJwksResolver()/\/\/out.initJwksResolver()/g' "${SRC}"/istio/pilot/pkg/xds/discovery.go
# Create empty file that imports "github.com/AdamKorcz/go-118-fuzz-build/testing"
# This is a small hack to install this dependency, since it is not used anywhere,
# and Go would therefore remove it from go.mod once we run "go mod tidy && go mod vendor".