@Override
    public ComponentMetadata getMetadata() {
        if (metadataProvider.isUsable()) {
            return metadataProvider.getComponentMetadata();
        } else {
            return null;
        }

    }

    @Nullable
    @Override
    public <T> T getDescriptor(Class<T> descriptorClass) {
        if (metadataProvider.isUsable()) {
            if (IvyModuleDescriptor.class.isAssignableFrom(descriptorClass)) {

        componentSelection = new DefaultComponentSelection(componentIdentifier, metadataProvider)
    }

    def "all non-rejecting rules are evaluated"() {
        metadataProvider.isUsable() >> true
        metadataProvider.getComponentMetadata() >> Mock(ComponentMetadata)
        metadataProvider.getIvyModuleDescriptor() >> Mock(IvyModuleDescriptor)

        def closureCalled = []
        when:

import javax.annotation.Nullable;

public interface MetadataProvider {
    @Nullable
    ComponentMetadata getComponentMetadata();

    @Nullable
    IvyModuleDescriptor getIvyModuleDescriptor();

    boolean isUsable();

            return new DefaultIvyModuleDescriptor(ivyMetadata.getExtraAttributes(), ivyMetadata.getBranch(), ivyMetadata.getStatus());
        }
        return null;
    }

    @Override
    public boolean isUsable() {
        return usable;
    }

        if (inputTypes.size() == 0) {
            return Collections.emptyList();
        }

        if (!metadataProvider.isUsable()) {
            return null;
        }

        List<Object> inputs = new ArrayList<>(inputTypes.size());
        for (Class<?> inputType : inputTypes) {
            if (inputType == ComponentMetadata.class) {

            cachedResult = resolveState.resolve();
        }
        return cachedResult.getState() == BuildableModuleComponentMetaDataResolveResult.State.Resolved;
    }

    @Override
    public boolean isUsable() {
        return cachedResult == null || cachedResult.getState() == BuildableModuleComponentMetaDataResolveResult.State.Resolved;
    }

    public BuildableModuleComponentMetaDataResolveResult<?> getResult() {

     * @return true if metadata is not usable
     */
    private boolean metadataIsNotUsable(ComponentSelectionContext result, DefaultMetadataProvider metadataProvider) {
        if (!metadataProvider.isUsable()) {
            applyTo(metadataProvider, result);
            return true;
        }
        return false;
    }

                val smartCastInfo = expression.getSmartCastInfo()
                buildString {
                    appendLine("expression: ${expression.text}")
                    appendLine("isStable: ${smartCastInfo?.isStable}")
                    appendLine("smartCastType: ${smartCastInfo?.smartCastType?.render(position = Variance.INVARIANT)}")

                    val receiverSmartCasts = expression.getImplicitReceiverSmartCast()

import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
import org.jetbrains.kotlin.analysis.project.structure.isStable
import org.jetbrains.kotlin.analysis.api.platform.lifetime.KotlinReadActionConfinementLifetimeToken
import org.jetbrains.kotlin.psi.KtElement
import java.util.concurrent.ConcurrentMap
import kotlin.reflect.KClass

/**

	isAccessor := true
	if _, err := meta.Accessor(obj); err != nil {
		isAccessor = false
	}
	isList := meta.IsListType(obj)
	_, isTable := obj.(*metav1.Table)
	if !isAccessor && !isList && !isTable {
		return nil, false, nil
	}

	// TODO a deep copy isn't really needed here, figure out how we can reliably
	//  use shallow copy here to omit the manageFields.