xdsUpdater XDSUpdater

	// just to ensure NetworkGateways and Unresolved are updated together
	mu sync.RWMutex
	// embedded NetworkGateways only includes gateways with IPs
	// hostnames are resolved in control plane (or filtered out if feature is disabled)
	*NetworkGateways
	// includes all gateways with no DNS resolution or filtering, regardless of feature flags
	Unresolved *NetworkGateways
}

    private Multimap<Expression, Expression> tokensFor;

    boolean isUnresolved(Expression expression) {
        return broken != null && broken.contains(expression);
    }

    void unresolved(Expression expression) {
        if (broken == null) {
            broken = new HashSet<Expression>();
        }
        broken.add(expression);
    }

    Collection<Expression> tokensFor(Expression expression) {

 *
 * @since 2.0
 */
public interface ComponentArtifactsResult extends ComponentResult {
    /**
     * <p>Returns the artifacts of the specified type that belong to this component. Includes resolved and unresolved artifacts (if any).
     *
     * <p>The elements of the returned collection are declared as {@link ArtifactResult}, however the artifact instances will also implement one of the
     * following instances:</p>
     *

        logger.debug("Could not resolve: " + dep.getAttempted(), dep.getFailure());
    }

    public File asFile(UnresolvedDependencyResult dep, File parent) {
        return new File(parent, "unresolved dependency - " + dep.getAttempted().getDisplayName().replaceAll(":", " "));
    }

        then:
        resolvedComponents.size() == 2
        resolvedComponents.each { assert it instanceof ComponentArtifactsResult }
    }

    def "gets resolved components for unresolved artifact results"() {
        ArtifactResolutionResult artifactResolutionResult = new DefaultArtifactResolutionResult([unresolvedComponentResult1, unresolvedComponentResult2] as LinkedHashSet)

        when:

	}

	fileNode = file
	fileSize = int64(len(src))

	for _, decl := range file.Decls {
		// The first global variable, which is pretty short:
		//
		//	var unresolved = new(ast.Object)
		if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.VAR {
			declNode = decl
			declSize = int64(fset.Position(decl.End()).Offset - fset.Position(decl.Pos()).Offset)
			break
		}

	}

        and:
        assertModelMatchesBuildSpec(model, spec)

        and:
        assertHasExceptionMessage(
            model,
            spec.scripts.init,
            "Unresolved reference: script_body_compilation_error"
        )
    }

        and:
        assertModelMatchesBuildSpec(model, spec)

        and:
        assertHasExceptionMessage(
            model,
            spec.scripts.init,
            "Unresolved reference: script_body_compilation_error"
        )
    }

     */
    Set<UnresolvedDependency> getUnresolvedDependencies();

    /**
     * Returns an optional failure describing an error that occurred during resolution.
     * This failure does not encompass unresolved dependencies and is _not_ captured in the resolution result.
     */
    Optional<ResolveException> getResolutionFailure();

    /**
     * Returns the root of the dependency graph.
     */

stderr '\n\nTo upgrade to the versions selected by go 1.16, leaving some packages unresolved:\n\tgo mod tidy -e -go=1\.16 && go mod tidy -e -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/doc/modules/pruning\n'