outputDir.resolve("$kotlinDslPackagePath/BuiltinPluginIdExtensions.kt").apply {
        parentFile.mkdirs()
    }


private
fun hashTypeSourceName(typeSourceName: String): String =
    Hashing.hashString(typeSourceName).toCompactString()


private
val GradleApiMetadata.apiSpec: (String) -> Boolean
    get() = { sourceName ->
        val relativeSourcePath = relativeSourcePathOf(sourceName)

	// hash (just in case there are multiple instrumented executables
	// in play). See issue #57924 for more on this.
	hashstring := fmt.Sprintf("%x", finalHash)
	importpaths := make(map[string]struct{})
	for _, p := range podlist {
		if !strings.Contains(p.MetaFile, hashstring) {
			continue
		}
		if err := ts.processPod(p, importpaths); err != nil {
			return err
		}
	}

        // For empty metadata, we use a hash based on the identifier
        HashCode descriptorHash = Hashing.md5().hashString(moduleComponentIdentifier.toString());
        metadata.getSources().add(new ModuleDescriptorHashModuleSource(descriptorHash, false));
        return metadata;
    }

    }

    private CompiledScript<Script, BuildScriptData> parse(String script) {
        def source = new TextResourceScriptSource(new StringTextResource("test script", script))
        def sourceHashCode = Hashing.hashString(script)
        def target = Mock(ScriptTarget) {
            getClasspathBlockName() >> "buildscript"
        }
        def targetScope = Stub(ClassLoaderScope) {

    val compiledScriptTypeName by lazy {
        packagePrefixed(scriptClassNameForFile(scriptFile))
    }

    val packageName: String? by lazy {
        packageNameOf(scriptText)
    }

    val hashString by lazy {
        PrecompiledScriptDependenciesResolver.hashOfNormalisedString(scriptText)
    }

    val scriptText: String
        get() = convertLineSeparatorsToUnix(scriptFile.readText())

    private

	return xxh3.HashString(f.TransitionedObject.Tier + f.TransitionedObject.Name)
}

func (n newerNoncurrentTask) OpHash() uint64 {
	return xxh3.HashString(n.bucket + n.versions[0].ObjectV.ObjectName)
}

func (j jentry) OpHash() uint64 {
	return xxh3.HashString(j.TierName + j.ObjName)
}

func (e expiryTask) OpHash() uint64 {
	return xxh3.HashString(e.objInfo.Bucket + e.objInfo.Name)
}

      process(readBuffer);
    }

    // Finally stick the remainder back in our usual buffer
    buffer.put(readBuffer);
    return this;
  }

  /*
   * Note: hashString(CharSequence, Charset) is intentionally not overridden.
   *
   * While intuitively, using CharsetEncoder to encode the CharSequence directly to the buffer (or

		// differently on each nodes, update skipEnvs()
		// map if there are such environment values
		if _, ok := skipEnvs[envK]; ok {
			continue
		}
		envValues[envK] = logger.HashString(env.Get(envK, ""))
	}
	scfg := &ServerSystemConfig{NEndpoints: globalEndpoints.NEndpoints(), MinioEnv: envValues}
	var cmdLines []string
	for _, ep := range globalEndpoints {
		cmdLines = append(cmdLines, ep.CmdLine)

    fun eval(script: String, target: Any, topLevelScript: Boolean = false) {
        Interpreter(InterpreterHost()).eval(
            target,
            scriptSourceFor(script),
            Hashing.md5().hashString(script),
            mock(),
            targetScope,
            baseScope,
            topLevelScript
        )
    }

    override fun close() {

      process(readBuffer);
    }

    // Finally stick the remainder back in our usual buffer
    buffer.put(readBuffer);
    return this;
  }

  /*
   * Note: hashString(CharSequence, Charset) is intentionally not overridden.
   *
   * While intuitively, using CharsetEncoder to encode the CharSequence directly to the buffer (or