} else {
                return locationFromStackTrace(exception, true, true, NO_OP);
            }
        }

        @Override
        public ProblemDiagnostics forCurrentCaller() {
            return locationFromStackTrace(getImplicitThrowable(EXCEPTION_FACTORY), false, false, NO_OP);
        }

        @Override

    private static final CancellationExceptionTransformer NO_OP = new CancellationExceptionTransformer() {
        @Override
        public RuntimeException transform(RuntimeException e) {
            return e;
        }
    };

    static CancellationExceptionTransformer transformerFor(VersionDetails versionDetails) {
        if (versionDetails.honorsContractOnCancel()) {
            return NO_OP;
        }

    InternalProblems getProblemsService();

    List<Problem> getProblems();

    ImmutableSet<Class<?>> getValidatedTypes();

    interface TypeOriginInspector {
        TypeOriginInspector NO_OP = type -> Optional.empty();

        Optional<PluginId> findPluginDefining(Class<?> type);
    }

#include "mlir/IR/Value.h"  // from @llvm-project

namespace mlir {
namespace odml {
// The following 5 different forms of mhlo::iota will be matched:
// 1. IotaOp.
// 2. IotaOp + BroadCastInDim.
// 3. IotaOp + Reshape.
// 4. Constant (folded Iota) + BroadCastInDim.
// 5. Constant (folded result).
// Moreover, the dimensions has to match the iota_dimension.

 * limitations under the License.
 */

package org.gradle.model.internal.asm;

import org.objectweb.asm.MethodVisitor;

public interface BytecodeFragment {

    BytecodeFragment NO_OP = visitor -> {};

    void emit(MethodVisitor visitor);

 * @see CacheBuilder#withCleanupStrategy(CacheCleanupStrategy)
 */
public interface CleanupAction {

    void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor);

    CleanupAction NO_OP = new CleanupAction() {
        @Override
        public void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor) {
            // no-op
        }
    };

        }
        if (subscriptions.isRequested(OperationType.GENERIC)) {
            return new ClientForwardingBuildOperationListener(progressEventConsumer);
        }
        return NO_OP;
    }

    @Nonnull
    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {

import org.gradle.internal.state.ModelObject;

import javax.annotation.Nullable;

@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface PropertyHost {
    PropertyHost NO_OP = producer -> null;

    /**
     * Returns null if the host allows reads of its state, or a string that explains why reads are not allowed.
     */
    @Nullable
    String beforeRead(@Nullable ModelObject producer);

import javax.inject.Inject;
import java.util.List;

import static org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionApplicator.NO_OP;

/**
 * Resolves a dependency graph and visits it. Essentially, this class is a {@link DependencyGraphBuilder} executor.
 */
public class DependencyGraphResolver {

@ServiceScope(Scope.BuildTree.class)
public interface VcsMappingsStore {
    VcsResolver asResolver();

    void addRule(Action<? super VcsMapping> rule, Gradle gradle);

    VcsResolver NO_OP = new VcsResolver() {
        @Nullable
        @Override
        public VersionControlSpec locateVcsFor(ModuleComponentSelector selector) {
            return null;
        }

        @Override