result = collectorResult;
        } else {
            List<Node> nodes = flatten(session, collectorResult.getRoot(), request.getPathScope());
            List<ArtifactCoordinate> coordinates = nodes.stream()
                    .map(Node::getDependency)
                    .filter(Objects::nonNull)
                    .map(Artifact::toCoordinate)

    @Nullable
    Artifact getArtifact();

    /**
     * @return dependency for this node
     */
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull

        return decodePreservingSharedIdentity {
            val targetVariant = readNonNull<ComponentVariantIdentifier>()
            val nodes: List<TransformStepNode> = readList().uncheckedCast()
            TransformedProjectArtifactSet(targetVariant, nodes)
        }
    }

    private
    val targetProjects = mutableSetOf<ProjectState>()

    fun relevantProjects(nodes: List<Node>): Set<ProjectState> {
        val result = mutableSetOf<ProjectState>()
        for (project in targetProjects) {
            collect(project, result)
        }
        for (node in nodes) {
            val project = projectStateOf(node)
            if (project != null && isLocalProject(project)) {

		// case *SwitchStmt:
		// case *SelectStmt:

		// helper nodes
		case *RangeClause:
			if n.Lhs != nil {
				m = n.Lhs
				continue
			}
			m = n.X
		// case *CaseClause:
		// case *CommClause:

		default:
			return n.Pos()
		}
	}
}

// EndPos returns the approximate end position of n in the source.
// For some nodes (*Name, *BasicLit) it returns the position immediately

<!-- CL 577715, CL 579076 -->
By default, go/types now produces [Alias] type nodes for type aliases.
This behavior can be controlled by the `GODEBUG` `gotypesalias` flag.

	return
}

// PreScore builds and writes cycle state used by Score and NormalizeScore.
func (pl *TaintToleration) PreScore(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodes []*framework.NodeInfo) *framework.Status {
	if len(nodes) == 0 {
		return nil
	}
	tolerationsPreferNoSchedule := getAllTolerationPreferNoSchedule(pod.Spec.Tolerations)
	state := &preScoreState{

     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**
     * The ordered list of the flattened dependency nodes.
     *
     * @return the ordered list of the flattened dependency nodes
     */
    @Nonnull
    List<Node> getNodes();

    /**
     * Returns the file paths of all dependencies, regardless on which tool option those paths should be placed.

// sync instances from cloudprovider.
// This method returns an error if it is unable to initialize the CIDR bitmap with
// podCIDRs it has already allocated to nodes. Since we don't allow podCIDR changes
// currently, this should be handled as a fatal error.
func NewNodeIpamController(
	ctx context.Context,
	nodeInformer coreinformers.NodeInformer,
	cloud cloudprovider.Interface,

        override val scheduledWork: ScheduledWork
            get() {
                lateinit var work: ScheduledWork
                gradle.taskGraph.visitScheduledNodes { nodes, entryNodes -> work = ScheduledWork(nodes, entryNodes) }
                return work
            }
    }

    private
    inner class DefaultConfigurationCacheBuild(
        override val state: BuildState,