endPos = failure.indexOfStackFrame(startPos + 1, GRADLE_CODE);
            if (endPos == -1) {
                endPos = stack.size();
            }
        }

        lock.lock();
        try {
            return locationFromStackRange(startPos, endPos, stack);
        } finally {
            lock.unlock();
        }
    }

// startPos returns the start position of node n.
func startPos(n syntax.Node) syntax.Pos { return syntax.StartPos(n) }

// endPos returns the position of the first character immediately after node n.
func endPos(n syntax.Node) syntax.Pos { return syntax.EndPos(n) }

// makeFromLiteral returns the constant value for the given literal string and kind.
func makeFromLiteral(lit string, kind syntax.LitKind) constant.Value {

// the returned position is the end position of the last enclosed
// expression.
// Thus, EndPos should not be used for exact demarcation of the
// end of a node in the source; it is mostly useful to determine
// scope ranges where there is some leeway.
func EndPos(n Node) Pos {
	for m := n; ; {
		switch n := m.(type) {
		case nil:
			panic("nil node")

		// packages
		case *File:

// startPos returns the start position of node n.
func startPos(n ast.Node) token.Pos { return n.Pos() }

// endPos returns the position of the first character immediately after node n.
func endPos(n ast.Node) token.Pos { return n.End() }

// makeFromLiteral returns the constant value for the given literal string and kind.

		}
		// Check that start pos is on a valid token boundary.
		if sp > 0 && !isTokenBoundary(v[sp-1]) {
			continue
		}
		// Check that end pos is on a valid token boundary.
		if endPos := sp + len(token); endPos != len(v) && !isTokenBoundary(v[endPos]) {
			continue
		}
		if ascii.EqualFold(v[sp:sp+len(token)], token) {
			return true
		}
	}
	return false
}

func isTokenBoundary(b byte) bool {

	}
	specs = deduped

	// Fix up comment positions
	for i, s := range specs {
		s := s.(*ImportSpec)
		if s.Name != nil {
			s.Name.NamePos = pos[i].Start
		}
		s.Path.ValuePos = pos[i].Start
		s.EndPos = pos[i].End
		for _, g := range importComments[s] {
			for _, c := range g.cg.List {
				if g.left {
					c.Slash = pos[i].Start - 1
				} else {

	. "internal/types/errors"
)

// labels checks correct label use in body.
func (check *Checker) labels(body *syntax.BlockStmt) {
	// set of all labels in this body
	all := NewScope(nil, body.Pos(), syntax.EndPos(body), "label")

	fwdJumps := check.blockBranches(all, nil, nil, body.List)

	// If there are any forward jumps left, no label was found for
	// the corresponding goto statements. Either those labels were

    // Add some strings to the domain object set
    void addString(String value) {
        myStrings.add(value)
    }
}
// end::dos[]

// tag::ndos[]
// tag::ndol[]
// tag::ndoc[]
abstract class Person {
    String name
}
// end::ndol[]
// end::ndoc[]

abstract class MyPluginExtensionNamedDomainObjectSet {

    // Add some strings to the domain object set
    fun addString(value: String) {
        myStrings.add(value)
    }
}
// end::dos[]

// tag::ndos[]
// tag::ndol[]
// tag::ndoc[]
abstract class Person(val name: String)
// end::ndol[]
// end::ndoc[]

abstract class MyPluginExtensionNamedDomainObjectSet {

====
include::sample[dir="snippets/providers/collections/kotlin",files="build.gradle.kts[tags=ndos]"]
include::sample[dir="snippets/providers/collections/groovy",files="build.gradle[tags=ndos]"]
====

[[nameddomainobjectlist]]
== 3. `NamedDomainObjectList`