sourceDir.accessRules[0].kind == 0
        sourceDir.accessRules[0].pattern == 'id-accessible'
        sourceDir.accessRules[1].kind == 1
        sourceDir.accessRules[1].pattern == 'id-nonaccessible'
        sourceDir.accessRules[2].kind == 2
        sourceDir.accessRules[2].pattern == 'id-discouraged'
        sourceDir.accessRules[3].kind == 0
        sourceDir.accessRules[3].pattern == 'literal-accessible'

        String targetFileName = template.substring(template.lastIndexOf("/") + 1).replace(".template", "");
        return fromCppTemplate(template, targetFileName, settings, sourceSetName, sourceDir);
    }

    TemplateOperation fromCppTemplate(String template, String targetFileName, InitSettings settings, String sourceSetName, String sourceDir) {

                   file {
                       whenMerged { classpath ->
                           def sourceDir = classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }
                           sourceDir.accessRules.add(new AccessRule('0', 'accessibleFilesPattern'))
                           sourceDir.accessRules.add(new AccessRule('1', 'nonAccessibleFilesPattern'))
                       }
                   }

        String targetFileName = template.substring(template.lastIndexOf("/") + 1).replace(".template", "");
        return fromSwiftTemplate(template, targetFileName, settings, sourceSetName, sourceDir);
    }

    TemplateOperation fromSwiftTemplate(String template, String targetFileName, InitSettings settings, String sourceSetName, String sourceDir) {

        File file = new File(resource.toURI())
        return new SourceFile(path, name, file.text);
    }

    void writeSources(TestFile sourceDir) {
        gradleBuild.writeToDir(sourceDir)
        for (SourceFile srcFile : allFiles) {
            srcFile.writeToDir(sourceDir)
        }
    }

    List<SourceFile> sourceFiles(String baseDir, String rootDir = getName()) {
        List sourceFiles = new ArrayList()

	"unicode"
)

var gormSourceDir string

func init() {
	_, file, _, _ := runtime.Caller(0)
	// compatible solution to get gorm source directory with various operating systems
	gormSourceDir = sourceDir(file)
}

func sourceDir(file string) string {
	dir := filepath.Dir(file)
	dir = filepath.Dir(dir)

	s := filepath.Dir(dir)
	if filepath.Base(s) != "gorm.io" {
		s = dir
	}
	return filepath.ToSlash(s) + "/"
}

                return loadAlreadyProducedOutput(workspace);
            }
        };
    }

    private void instrument(File sourceDir, File destination) {
        ClasspathElementTransform transform = transformFactory.createTransformer(sourceDir, new InstrumentingClassTransform(), InstrumentationTypeRegistry.EMPTY);
        transform.transform(destination);
    }

    @Nullable
    @Override

        def matches = libs.findAll { it.jarName.contains(jarName) } + vars.findAll { it.jarName == jarName }
        assert matches.size() == 1
        return matches[0]
    }

    EclipseSourceDir sourceDir(String path) {
        def matches = getSourceDirs().findAll { it.path == path }
        assert matches.size() == 1
        return matches[0]
    }

    List<EclipseLibrary> getLibs() {

      return "";
    }
  }

  mlir::MLIRContext context;
  context.printOpOnDiagnostic(true);
  llvm::SourceMgr sourceMgr;
  sourceMgr.AddNewSourceBuffer(std::move(input), llvm::SMLoc());

  mlir::OwningOpRef<mlir::ModuleOp> module =
      FlatBufferFileToMlirTranslation(&sourceMgr, &context);
  if (!module || failed(verify(*module))) return "";

  std::string mlir_output;

      tensorflow::str_util::Split(source_dir, "/");
  auto source_tfroot_pos = std::find(source_path_components.begin(),
                                     source_path_components.end(), tf_root_dir);
  if (source_tfroot_pos != source_path_components.end()) {
    tf_prefix_dir =
        absl::StrJoin(source_path_components.begin(), source_tfroot_pos, "/");
  } else {
    tf_prefix_dir = source_dir;
  }