def "can have zero originating elements"() {
        when:
        filer.createSourceFile("Foo")
        filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "foo.txt")

        then:
        !result.fullRebuildCause
    }

    def "can have many originating elements"() {
        when:
        filer.createSourceFile("Foo", type("Bar"), type("Baz"))

    }

    def "adds originating types to the processing result"() {
        when:
        filer.createSourceFile("Foo", pkg("pkg"), type("A"), methodInside("B"))
        filer.createSourceFile("Bar", type("B"))

        filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "foo.txt", pkg("pkg"), type("A"), methodInside("B"))
        filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "bar.txt", type("B"))

        then:

      // For a Location to be surfaced in the stack, it must evaluate to true.
      // For any Location that is a FileLineColLoc:
      if (FileLineColLoc fileLoc = mlir::dyn_cast<FileLineColLoc>(loc)) {
        return !tensorflow::IsInternalFrameForFilename(
            fileLoc.getFilename().str());
      } else {
        // If this is a non-FileLineColLoc, go ahead and include it.
        return true;
      }
    };
  }

    private final ProcessingEnvironment delegate;
    private final IncrementalFiler filer;

    IncrementalProcessingEnvironment(ProcessingEnvironment delegate, IncrementalFiler filer) {
        this.delegate = delegate;
        this.filer = filer;
    }

    @Override
    public Map<String, String> getOptions() {
        return delegate.getOptions();
    }

    @Override

// filename returns a filename suitable for debugging output.
func (check *Checker) filename(fileNo int) string {
	file := check.files[fileNo]
	if pos := file.Pos(); pos.IsKnown() {
		// return check.fset.File(pos).Name()
		// TODO(gri) do we need the actual file name here?
		return pos.RelFilename()
	}
	return fmt.Sprintf("file[%d]", fileNo)
}

func (check *Checker) importPackage(pos syntax.Pos, path, dir string) *Package {

}

// filename returns a filename suitable for debugging output.
func (check *Checker) filename(fileNo int) string {
	file := check.files[fileNo]
	if pos := file.Pos(); pos.IsValid() {
		return check.fset.File(pos).Name()
	}
	return fmt.Sprintf("file[%d]", fileNo)
}

func (check *Checker) importPackage(at positioner, path, dir string) *Package {

	}
	return crdclient.New(s.kubeClient, opts)
}

func (s *Server) makeFileMonitor(fileDir string, domainSuffix string, configController model.ConfigStore) error {
	fileSnapshot := configmonitor.NewFileSnapshot(fileDir, collections.Pilot, domainSuffix)
	fileMonitor := configmonitor.NewMonitor("file-monitor", configController, fileSnapshot.ReadConfigFiles, fileDir)

	// Defer starting the file monitor until after the service is created.

	if err := r.readFileHeader(); err != nil {
		return nil, err
	}
	return r, nil
}

func (r *CoverageMetaFileReader) readFileHeader() error {
	var err error

	r.fileRdr = bufio.NewReader(r.f)

	// Read file header.
	if err := binary.Read(r.fileRdr, binary.LittleEndian, &r.hdr); err != nil {
		return err
	}

	// Verify magic string
	m := r.hdr.Magic
	g := coverage.CovMetaMagic

public class IncrementalFiler implements Filer {
    private final Filer delegate;
    private final IncrementalProcessingStrategy strategy;

    IncrementalFiler(Filer delegate, IncrementalProcessingStrategy strategy) {
        this.delegate = delegate;
        if (strategy == null) {
            throw new NullPointerException("strategy");
        }
        this.strategy = strategy;
    }

    @Override

    "useless_cast",
    "unchecked_cast",
    "extension_shadowed_by_member",
    "redundant_projection",
    "RemoveRedundantBackticks",
    "ObjectPropertyName",
    "deprecation"
)
@file:org.gradle.api.Generated${if (isIncubating) "\n@file:org.gradle.api.Incubating" else ""}

/* ktlint-disable */

package $packageName
"""


const val kotlinDslPackageName = "org.gradle.kotlin.dsl"