public IncludedBuildState createBuild(BuildIdentifier buildIdentifier, BuildDefinition buildDefinition, boolean isImplicit, BuildState owner) {
        validateBuildDirectory(buildDefinition.getBuildRootDir());
        return new DefaultIncludedBuild(
            buildIdentifier,
            buildDefinition,
            isImplicit,
            owner,
            buildTree,
            instantiator
        );
    }

            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);

// IsMethodSet reports whether the interface t is fully described by its method set.
func (t *Interface) IsMethodSet() bool { return t.typeSet().IsMethodSet() }

// IsImplicit reports whether the interface t is a wrapper for a type set literal.
func (t *Interface) IsImplicit() bool { return t.implicit }

func (t *Interface) Underlying() Type { return t }
func (t *Interface) String() string   { return TypeString(t, nil) }

// IsMethodSet reports whether the interface t is fully described by its method
// set.
func (t *Interface) IsMethodSet() bool { return t.typeSet().IsMethodSet() }

// IsImplicit reports whether the interface t is a wrapper for a type set literal.
func (t *Interface) IsImplicit() bool { return t.implicit }

// Complete computes the interface's type set. It must be called by users of

pkg go/types, method (*ArgumentError) Error() string
pkg go/types, method (*ArgumentError) Unwrap() error
pkg go/types, method (*Interface) IsComparable() bool
pkg go/types, method (*Interface) IsImplicit() bool
pkg go/types, method (*Interface) IsMethodSet() bool
pkg go/types, method (*Interface) MarkImplicit()
pkg go/types, method (*Named) Origin() *Named
pkg go/types, method (*Named) SetTypeParams([]*TypeParam)

        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()

		{"(*Interface).EmbeddedType", Method, 11},
		{"(*Interface).Empty", Method, 5},
		{"(*Interface).ExplicitMethod", Method, 5},
		{"(*Interface).IsComparable", Method, 18},
		{"(*Interface).IsImplicit", Method, 18},
		{"(*Interface).IsMethodSet", Method, 18},
		{"(*Interface).MarkImplicit", Method, 18},
		{"(*Interface).Method", Method, 5},
		{"(*Interface).NumEmbeddeds", Method, 5},