#                     ; groupComment=[comment]
#                     ; elementList=list:{[the list of classification element's name]}
#                 }
#             }
#         }
#         # classification elements for implicit classification
#         ; map:{
#             ; code=[code]; name=[name]; alias=[alias]; comment=[comment]
#             ; sisterCode=[code or code-list]; subItemMap=map:{[free-map]}
#         }

		check.needsCleanup(typ)
	}
	return typ
}

// MarkImplicit marks the interface t as implicit, meaning this interface
// corresponds to a constraint literal such as ~T or A|B without explicit
// interface embedding. MarkImplicit should be called before any concurrent use
// of implicit interfaces.
func (t *Interface) MarkImplicit() {
	t.implicit = true
}

rootProject.name = "implicit-task-input-dependency"...

// sequence of selection operations x.a.b.c.f. The SelectionKind
// describes the kind of the final (explicit) operation; all the
// previous (implicit) operations are always field selections.
// Each element of Indices specifies an implicit field (a, b, c)
// by its index in the struct type of the field selection operand.
//
// For a FieldVal operation, the final selection refers to the field

rootProject.name = 'implicit-task-input-file-dependency'...

rootProject.name = "implicit-task-input-dependency"...

rootProject.name = "implicit-task-input-file-dependency"...

     */
    Path getIdentityPath();

    /**
     * Is this an implicit build? An implicit build is one that is managed by Gradle and which is not addressable by user build logic.
     */
    boolean isImplicitBuild();

    /**
     * Should this build be imported into an IDE? Some implicit builds, such as source dependency builds, are not intended to be imported into the IDE or editable by users.
     */

// `sysAlloc`, `persistentalloc`, r`fixalloc`, or from a manually-managed span).
//
// Specifically:
//
// 1. `new(T)`, `make([]T)`, `append([]T, ...)` and implicit heap
// allocation of T are disallowed. (Though implicit allocations are
// disallowed in the runtime anyway.)
//
// 2. A pointer to a regular type (other than `unsafe.Pointer`) cannot be

	(f[ /* ERROR "function instantiation requires go1.18 or later" */ int])(0)   // parentheses (different code path)
	f( /* ERROR "implicit function instantiation requires go1.18 or later" */ x) // implicit instantiation
}

type C1 interface {
	comparable // ERROR "predeclared comparable requires go1.18 or later"
}

type C2 interface {