stdout 'example.com/a false'
stdout 'example.com/b false'
stdout 'rsc.io/sampler false'
stdout 'golang.org/x/text true'
stdout 'example.com/c true' # Uses the information in go.mod without checking imports.

# Check that 'go list all' correctly populates "indirect" module annotation.
go list -f '{{.ImportPath}} {{with .Module}}{{.Indirect}}{{end}}' all
stdout 'example.com/a false'
stdout 'example.com/b false'

import org.gradle.api.internal.file.FileCollectionInternal;
import org.gradle.api.provider.Provider;

/**
 * Internal counterpart of {@link ResolutionOutputs} that exposes the results as
 * their internal types, as well as the raw results before conversion to user-facing types.
 */
public interface ResolutionOutputsInternal extends ResolutionOutputs {

    /**

        if (descriptor?.canBeReferencedViaImport() != true) return null

        return descriptor.getImportableDescriptor().fqNameSafe
    }

    /**
     * Copy of `org.jetbrains.kotlin.idea.imports.ImportsUtils.canBeReferencedViaImport`.
     */
    private fun DeclarationDescriptor.canBeReferencedViaImport(): Boolean {
        if (this is PackageViewDescriptor ||
            DescriptorUtils.isTopLevelDeclaration(this) ||

 */

package org.gradle.api.project;

import org.gradle.api.Incubating;
import org.gradle.api.Project;
import org.gradle.api.file.Directory;

/**
 * An isolated view of {@link Project} that exposes only those properties that are safe to access from outside of
 * <code>this</code> project, from the perspective of isolated projects.
 *
 * @since 8.8
 */
@Incubating
public interface IsolatedProject {

    /**

	interfaceType
	typeParamType
	instanceType
	unionType
)

// iImportData imports a package from the serialized package data
// and returns the number of bytes consumed and a reference to the package.
// If the export data version is not recognized or the format is otherwise
// compromised, an error is returned.

fun AnalysisStatementFilter.or(other: AnalysisStatementFilter): AnalysisStatementFilter = AnalysisStatementFiltersImplementations.DefaultOrFilter(this, other)


fun AnalysisStatementFilter.implies(other: AnalysisStatementFilter) = this.not().or(other)


fun AnalysisStatementFilter.not(): AnalysisStatementFilter = AnalysisStatementFiltersImplementations.DefaultNotFilter(this)


internal

(which implies that it may not return a string, slice, channel, and so
forth). A Go function called by C code may take C pointers as arguments,
and it may store non-pointer data, C pointers, or Go pointers to pinned
memory through those pointers. It may not store a Go pointer to unpinned
memory in memory pointed to by a C pointer (which again, implies that it

// license that can be found in the LICENSE file.

// go mod tidy

package modcmd

import (
	"cmd/go/internal/base"
	"cmd/go/internal/cfg"
	"cmd/go/internal/gover"
	"cmd/go/internal/imports"
	"cmd/go/internal/modload"
	"cmd/go/internal/toolchain"
	"context"
	"fmt"

	"golang.org/x/mod/modfile"
)

var cmdTidy = &base.Command{

     * this method will not perform resolution.
     */
    ResolutionResultProvider<ResolverResults> getResults();

    /**
     * Get the public representation of {@link #getResults()}, which exposes the raw
     * results as well-known user-facing types like {@link org.gradle.api.file.FileCollection}.
     */
    ResolutionOutputsInternal getPublicView();

structured k8s.io/apiserver/pkg/server/options/encryptionconfig/.*

# The following packages have been migrated to contextual logging.
# Packages matched here do not have to be listed above because
# "contextual" implies "structured".
contextual k8s.io/api/.*
contextual k8s.io/apimachinery/pkg/util/runtime/.*
contextual k8s.io/client-go/metadata/.*
contextual k8s.io/client-go/tools/events/.*
contextual k8s.io/client-go/tools/record/.*