for _, r := range modFile.Require {
					isExplicit[r.Mod] = true
				}
			}

		}
		includeAllReplacements = true
	}
	if gover.Compare(gv, "1.17") >= 0 {
		// If the Go version is at least 1.17, annotate all modules with their
		// 'go' version directives.
		includeGoVersions = true
	}

	var vendorMods []module.Version
	for m := range isExplicit {
		vendorMods = append(vendorMods, m)
	}

        }
    }

    public void disallowChangesAndFinalizeOnNextGet() {
        disallowChanges();
        finalizeOnNextGet();
    }

    public abstract boolean isExplicit();

    /**
     * Retrieves the current convention.
     */
    public abstract S convention();

    /**
     * Marks this value as being explicitly set with

        init(initialValue, initialValue);
    }

    @Override
    public boolean isFinalized() {
        return state.isFinalized();
    }

    protected boolean isExplicit() {
        return state.isExplicit();
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {

    }

    private Configurer getConfigurer() {
        return new Configurer();
    }

    @VisibleForTesting
    protected boolean isExplicit() {
        return valueState.isExplicit();
    }

    /**

        // Isolated projects also implies configuration cache
        if (startParameter.isolatedProjects.get() && !startParameter.configurationCache.get()) {
            if (startParameter.configurationCache.isExplicit) {
                throw GradleException("The configuration cache cannot be disabled when isolated projects is enabled.")
            }
        }

            includedBuildsByRootDir.put(buildDir, includedBuild);
            nestedBuildsByRootDir.put(buildDir, includedBuild);
            pendingIncludedBuilds.add(includedBuild);
            addBuild(includedBuild);
        } else {
            if (includedBuild.isImplicitBuild() != isImplicit) {

        reportActiveExternalHost = getInitParameter("reportActiveExternalHost", null, String.class);
        useEPSVwithIPv4 = getInitParameter("useEPSVwithIPv4", false, Boolean.class);
        isImplicit = getInitParameter("isImplicit", null, Boolean.class);
        trustManager = getInitParameter("trustManager", null, String.class);

        // ftp auth
        final FtpAuthenticationHolder holder = new FtpAuthenticationHolder();

@ServiceScope(Scope.BuildTree.class)
public interface IncludedBuildFactory {
    IncludedBuildState createBuild(BuildIdentifier buildIdentifier, BuildDefinition buildDefinition, boolean isImplicit, BuildState owner);

        return when (val explicitReceiver = qualifiedAccess.explicitReceiver) {
            is FirThisReceiverExpression -> {
                shortenOptions.removeThis &&
                        !explicitReceiver.isImplicit &&
                        explicitReceiver.calleeReference.referencesClosestReceiver()
            }

            is FirResolvedQualifier -> qualifiedAccess.extensionReceiver == null

                } else {
                    result
                }
            }
            this is FirThisReceiverExpression && this.isImplicit -> {
                val implicitPartiallyAppliedSymbol = when (val partiallyAppliedSymbol = calleeReference.boundSymbol) {
                    is FirClassSymbol<*> -> partiallyAppliedSymbol.toKtSymbol()