// goroutines, which indicates goroutine creation. In this particular case,
	// a Stack here would refer to the starting stack of the new goroutine, and
	// an (Event).Stack would refer to the stack trace of whoever created the
	// goroutine.
	Stack Stack

	// The actual transition data. Stored in a neutral form so that
	// we don't need fields for every kind of resource.
	id       int64
	oldState uint8

		return tcUnsafeString(n)

	case ir.OUNSAFESTRINGDATA:
		n := n.(*ir.UnaryExpr)
		return tcUnsafeData(n)

	case ir.OITAB:
		n := n.(*ir.UnaryExpr)
		return tcITab(n)

	case ir.OIDATA:
		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
		// usually by just having checked the OITAB.
		n := n.(*ir.UnaryExpr)
		base.Fatalf("cannot typecheck interface data %v", n)

	// Look for the function of interest ("main.singleInstruction")
	// and verify that the line table has an entry not just for the
	// single instruction but also a dummy instruction following it,
	// so as to test that whoever is emitting the DWARF doesn't
	// emit an end-sequence op immediately after the last instruction
	// in the translation unit.
	//
	// NB: another way to write this test would have been to run the

are!  I'm never sure what I'm going to be, from one minute to
another!  However, I've got back to my right size:  the next
thing is, to get into that beautiful garden--how IS that to be
done, I wonder?'  As she said this, she came suddenly upon an
open place, with a little house in it about four feet high.
`Whoever lives there,' thought Alice, `it'll never do to come

are!  I'm never sure what I'm going to be, from one minute to
another!  However, I've got back to my right size:  the next
thing is, to get into that beautiful garden--how IS that to be
done, I wonder?'  As she said this, she came suddenly upon an
open place, with a little house in it about four feet high.
`Whoever lives there,' thought Alice, `it'll never do to come

/**
 * Notifies the task properties of the start and completion of task execution, so they may finalize and cache whatever state is required to efficiently fingerprint inputs and outputs, apply validation or whatever.
 *
 * Currently, this is applied prior to validation, so that all properties are finalized before their value is validated, however we should finalize and validate any property whose value is used to finalize the value of another property.
 */

- "give me a scripting engine"
- "give me a scripting engine that supports Groovy"

By modeling _capabilities_, the dependency management engine can be smarter and tell you whenever you have _incompatible capabilities_ in a dependency graph, or ask you to choose whenever different modules in a graph provide the same _capability_.

[[sec:declaring-capabilities-external-modules]]
== Declaring capabilities for external modules

 * variants: in case of platforms we want to make sure we can select
 * both the platform and library. For this we use different capabilities.
 * However, we still want to make sure we can select the platform component
 * whenever no explicit capability is required. In this case, and only in
 * this case, we use the "shadowed" capability to check.
 * <p>
 * It remains deeply immutable.
 */

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
   * {@link Predicate} that it considers <i>interchangeable</i> with this one. "Interchangeable"

 * will use the strict mode, which means that it will verify dependencies
 * and fail <i>as soon as possible</i>, to avoid as much compromising of
 * the builds as possible.
 *
 * There are, however, two additional modes which can be used: the lenient
 * one will collect all errors but only log them to the CLI. This is useful
 * when updating the file and you want to collect as many errors as possible
 * before failing.
 *