// DUMP_IR

// FILE: data/PodcastWithExtraInfo.kt
package data

class PodcastWithExtraInfo {
    lateinit var url: String
    var lastEpisodeDate: kotlin.time.TimeSource? = null
    operator fun component1() = url
    operator fun component2() = lastEpisodeDate
}

// FILE: main.kt
package home

import data.PodcastWithExtraInfo

fun preview(featuredPodcast: PodcastWithExtraInfo) {

        final Map<String, Map<String, String>> components = new HashMap<>();
        eachElement(rootSource.get(), component -> components.put(
            component.getId().getDisplayName(),
            Collections.singletonMap("repoId", getRepositoryId(component))
        ), Actions.doNothing(), new HashSet<>());
        model.put("components", components);

        val file = readFile()
        val artifactName = IvyArtifactNameSerializer.INSTANCE.read(this)
        val componentId = componentIdSerializer.read(this)
        val artifactId = ComponentFileArtifactIdentifier(componentId, file.name)

}

absl::StatusOr<ModuleOp> StaticRangePtqComponent::Run(
    ModuleOp module_op, const QuantizationConfig& config) {
  // Runs sub-components in sequence: PreCalibrationComponent ->
  // CalibrationComponent -> PostCalibrationComponents.
  for (std::unique_ptr<Component>& sub_component : sub_components_) {
    TF_ASSIGN_OR_RETURN(module_op, sub_component->Run(module_op, config));
  }

  return module_op;
}

	components := c.component.All()
	assert.Equal(t, []bool{false, false, false}, slices.Map(components, func(e testHandler) bool {
		return e.Closed.Load()
	}))

	// Remove secret, it should be marked as closed
	c.DeleteSecret("s0")
	fetchClosed := func() map[string]bool {
		res := map[string]bool{}
		for _, c := range components {
			res[string(c.ID)] = c.Closed.Load()
		}

import org.gradle.internal.component.local.model.DefaultProjectDependencyMetadata;
import org.gradle.internal.component.model.ComponentGraphResolveState;
import org.gradle.internal.component.model.DependencyMetadata;
import org.gradle.internal.component.model.ExcludeMetadata;
import org.gradle.internal.component.model.ForcingDependencyMetadata;
import org.gradle.internal.component.model.GraphVariantSelectionResult;

 * limitations under the License.
 */

package org.gradle.internal.component.model;

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.component.ArtifactType;
import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;

/**
 * State for a component instance that is used to perform artifact resolution.
 *

		// The next path component is in path[start:end].
		if end == start {
			// No more path components.
			break
		} else if path[start:end] == "." && !isWindowsDot {
			// Ignore path component ".".
			continue
		} else if path[start:end] == ".." {
			// Back up to previous component if possible.
			// Note that volLen includes any leading slash.

                            @Override
                            public void reject() {
                                ComponentState component = node.getComponent();
                                component.rejectForCapabilityConflict(capability, conflictedNodes(node, conflict.nodes));
                                component.selectAndRestartModule();
                            }

                            @Override

import org.gradle.internal.Describables;
import org.gradle.internal.component.ResolutionFailureHandler;
import org.gradle.internal.component.external.model.ExternalComponentGraphResolveMetadata;
import org.gradle.internal.component.external.model.ExternalComponentGraphResolveState;
import org.gradle.internal.component.external.model.ExternalComponentResolveMetadata;
import org.gradle.internal.component.external.model.ImmutableCapabilities;