src/main/java/com/google/devtools/build/lib/analysis/producers/TargetAndConfigurationProducer.java - bazel - Git at Google

 // Copyright 2023 The Bazel Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 package com.google.devtools.build.lib.analysis.producers;

 import com.google.auto.value.AutoOneOf;
 import com.google.devtools.build.lib.actions.ActionLookupKey;
 import com.google.devtools.build.lib.analysis.ConfiguredTargetValue;
 import com.google.devtools.build.lib.analysis.InconsistentNullConfigException;
 import com.google.devtools.build.lib.analysis.InvalidVisibilityDependencyException;
 import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
 import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue;
 import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
 import com.google.devtools.build.lib.analysis.config.StarlarkTransitionCache;
 import com.google.devtools.build.lib.analysis.config.transitions.TransitionFactory;
 import com.google.devtools.build.lib.analysis.starlark.StarlarkTransition.TransitionException;
 import com.google.devtools.build.lib.buildeventstream.BuildEventIdUtil;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildEventId;
 import com.google.devtools.build.lib.events.ExtendedEventHandler;
 import com.google.devtools.build.lib.packages.NoSuchPackageException;
 import com.google.devtools.build.lib.packages.NoSuchTargetException;
 import com.google.devtools.build.lib.packages.PackageGroup;
 import com.google.devtools.build.lib.packages.Rule;
 import com.google.devtools.build.lib.packages.RuleTransitionData;
 import com.google.devtools.build.lib.packages.Target;
 import com.google.devtools.build.lib.skyframe.BuildConfigurationKey;
 import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey;
 import com.google.devtools.build.lib.skyframe.ConfiguredValueCreationException;
 import com.google.devtools.build.lib.util.DetailedExitCode;
 import com.google.devtools.build.skyframe.SkyValue;
 import com.google.devtools.build.skyframe.state.StateMachine;
 import com.google.devtools.common.options.OptionsParsingException;
 import java.util.function.Consumer;
 import javax.annotation.Nullable;
 import net.starlark.java.syntax.Location;

 /**
  * Computes the target and configuration for a configured target key.
  *
  * <p>If the key has a configuration and the target is configurable, attempts to apply a rule side
  * transition. If the target is not configurable, directly transitions to the null configuration. If
  * the resulting configuration already has an owner, delegates to the owner instead of recomputing
  * the configured target.
  *
  * <p>If the key does not have a configuration, it was requested as a visibility dependency.
  * Verifies that the {@link Target} is a {@link PackageGroup}, throwing {@link
  * InvalidVisibilityDependencyException} if that's not the case.
  */
 public final class TargetAndConfigurationProducer
     implements StateMachine, Consumer<SkyValue>, TargetProducer.ResultSink {
   /** Accepts results of this producer. */
   public interface ResultSink {
     void acceptTargetAndConfiguration(TargetAndConfiguration value, ConfiguredTargetKey fullKey);

     void acceptTargetAndConfigurationDelegatedValue(ConfiguredTargetValue value);

     void acceptTargetAndConfigurationError(TargetAndConfigurationError error);
   }

   /** Tagged union of possible errors. */
   @AutoOneOf(TargetAndConfigurationError.Kind.class)
   public abstract static class TargetAndConfigurationError {
     /** Tags the error type. */
     public enum Kind {
       CONFIGURED_VALUE_CREATION,
       INVALID_VISIBILITY_DEPENDENCY,
       INCONSISTENT_NULL_CONFIG
     }

     public abstract Kind kind();

     public abstract ConfiguredValueCreationException configuredValueCreation();

     public abstract InvalidVisibilityDependencyException invalidVisibilityDependency();

     public abstract InconsistentNullConfigException inconsistentNullConfig();

     private static TargetAndConfigurationError of(ConfiguredValueCreationException e) {
       return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
           .configuredValueCreation(e);
     }

     // TODO(b/261521010): enable this error once Rule transitions are removed from dependency
     // resolution.
     // private static TargetAndConfigurationError of(InvalidVisibilityDependencyException e) {
     // return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
     // .invalidVisibilityDependency(e);
     // }

     // TODO(b/261521010): delete this error once Rule transitions are removed from dependency
     // resolution.
     private static TargetAndConfigurationError of(InconsistentNullConfigException e) {
       return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
           .inconsistentNullConfig(e);
     }
   }

   // -------------------- Input --------------------
   private final ConfiguredTargetKey preRuleTransitionKey;
   @Nullable private final TransitionFactory<RuleTransitionData> trimmingTransitionFactory;
   private final StarlarkTransitionCache transitionCache;

   private final TransitiveDependencyState transitiveState;

   // -------------------- Output --------------------
   private final ResultSink sink;

   // -------------------- Internal State --------------------
   private Target target;

   public TargetAndConfigurationProducer(
       ConfiguredTargetKey preRuleTransitionKey,
       @Nullable TransitionFactory<RuleTransitionData> trimmingTransitionFactory,
       StarlarkTransitionCache transitionCache,
       TransitiveDependencyState transitiveState,
       ResultSink sink) {
     this.preRuleTransitionKey = preRuleTransitionKey;
     this.trimmingTransitionFactory = trimmingTransitionFactory;
     this.transitionCache = transitionCache;
     this.transitiveState = transitiveState;
     this.sink = sink;
   }

   @Override
   public StateMachine step(Tasks tasks, ExtendedEventHandler listener) {
     return new TargetProducer(
         preRuleTransitionKey.getLabel(),
         transitiveState,
         (TargetProducer.ResultSink) this,
         /* runAfter= */ this::determineConfiguration);
   }

   @Override
   public void acceptTarget(Target target) {
     this.target = target;
   }

   @Override
   public void acceptTargetError(NoSuchPackageException e) {
     emitError(e.getMessage(), /* location= */ null, e.getDetailedExitCode());
   }

   @Override
   public void acceptTargetError(NoSuchTargetException e, Location location) {
     emitError(e.getMessage(), location, e.getDetailedExitCode());
   }

   private StateMachine determineConfiguration(Tasks tasks, ExtendedEventHandler listener) {
     if (target == null) {
       return DONE; // There was an error.
     }

     // TODO(b/261521010): after removing the rule transition from dependency resolution, remove
     // this. It won't be possible afterwards because null configuration keys will only be used for
     // visibility dependencies.
     BuildConfigurationKey configurationKey = preRuleTransitionKey.getConfigurationKey();
     if ((configurationKey != null) != target.isConfigurable()) {
       // We somehow ended up in a target that requires a non-null configuration as a dependency of
       // one that requires a null configuration or the other way round. This is always an error, but
       // we need to analyze the dependencies of the latter target to realize that. Short-circuit the
       // evaluation to avoid doing useless work and running code with a null configuration that's
       // not prepared for it.
       sink.acceptTargetAndConfigurationError(
           TargetAndConfigurationError.of(new InconsistentNullConfigException()));
       return DONE;
     }

     // TODO(b/261521010): after removing the rule transition from dependency resolution, the logic
     // here changes.
     //
     // A null configuration key will only be used for visibility dependencies so when that's true, a
     // check that the target is a PackageGroup will be performed, throwing
     // InvalidVisibilityDependencyException on failure.
     if (configurationKey == null) {
       // The ConfiguredTargetKey cannot fan-in in this case.
       sink.acceptTargetAndConfiguration(
           new TargetAndConfiguration(target, /* configuration= */ null), preRuleTransitionKey);
       return DONE;
     }

     return new RuleTransitionConfigurationProducer();
   }

   /** Applies any requested rule transition before producing the final configuration. */
   private class RuleTransitionConfigurationProducer
       implements StateMachine,
           RuleTransitionApplier.ResultSink,
           ValueOrExceptionSink<InvalidConfigurationException> {
     // -------------------- Internal State --------------------
     private BuildConfigurationKey configurationKey;
     private ConfiguredTargetKey fullKey;

     @Override
     public StateMachine step(Tasks tasks, ExtendedEventHandler listener) {
       return new RuleTransitionApplier(
           preRuleTransitionKey.getConfigurationKey(),
           target.getAssociatedRule(),
           trimmingTransitionFactory,
           transitionCache,
           (RuleTransitionApplier.ResultSink) this,
           /* runAfter= */ this::processTransitionedKey);
     }

     @Override
     public void acceptRuleTransitionResult(BuildConfigurationKey result) {
       this.configurationKey = result;
     }

     @Override
     public void acceptRuleTransitionError(TransitionException e) {
       emitTransitionErrorMessage(e.getMessage());
     }

     @Override
     public void acceptRuleTransitionError(OptionsParsingException e) {
       emitTransitionErrorMessage(e.getMessage());
     }

     private StateMachine processTransitionedKey(Tasks tasks, ExtendedEventHandler listener) {
       if (configurationKey == null) {
         return DONE; // There was an error.
       }

       if (!configurationKey.equals(preRuleTransitionKey.getConfigurationKey())) {
         fullKey =
             ConfiguredTargetKey.builder()
                 .setDelegate(preRuleTransitionKey)
                 .setConfigurationKey(configurationKey)
                 .build();
         ActionLookupKey delegate = fullKey.toKey();
         if (!delegate.equals(preRuleTransitionKey)) {
           // Delegates to the key that already owns this configuration.
           delegateTo(tasks, delegate);
           return DONE;
         }
       } else {
         fullKey = preRuleTransitionKey;
       }

       // This key owns the configuration and the computation completes normally.
       tasks.lookUp(
           configurationKey,
           InvalidConfigurationException.class,
           (ValueOrExceptionSink<InvalidConfigurationException>) this);
       return DONE;
     }

     @Override
     public void acceptValueOrException(
         @Nullable SkyValue value, @Nullable InvalidConfigurationException error) {
       if (value != null) {
         sink.acceptTargetAndConfiguration(
             new TargetAndConfiguration(target, (BuildConfigurationValue) value), fullKey);
         return;
       }
       emitTransitionErrorMessage(error.getMessage());
     }

     private void emitTransitionErrorMessage(String message) {
       // The target must be a rule because these errors happen during the Rule transition.
       Rule rule = target.getAssociatedRule();
       emitError(message, rule.getLocation(), /* exitCode= */ null);
     }
   }

   private void delegateTo(Tasks tasks, ActionLookupKey delegate) {
     tasks.lookUp(delegate, (Consumer<SkyValue>) this);
   }

   @Override
   public void accept(SkyValue value) {
     sink.acceptTargetAndConfigurationDelegatedValue((ConfiguredTargetValue) value);
   }

   private void emitError(
       String message, @Nullable Location location, @Nullable DetailedExitCode exitCode) {
     sink.acceptTargetAndConfigurationError(
         TargetAndConfigurationError.of(
             new ConfiguredValueCreationException(
                 location,
                 message,
                 preRuleTransitionKey.getLabel(),
                 getConfigurationId(preRuleTransitionKey.getConfigurationKey()),
                 /* rootCauses= */ null,
                 exitCode)));
   }

   private static BuildEventId getConfigurationId(@Nullable BuildConfigurationKey configurationKey) {
     return configurationKey == null
         ? BuildEventIdUtil.nullConfigurationId()
         : BuildEventIdUtil.configurationId(configurationKey.getOptions().checksum());
   }
 }
	// Copyright 2023 The Bazel Authors. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	package com.google.devtools.build.lib.analysis.producers;

	import com.google.auto.value.AutoOneOf;
	import com.google.devtools.build.lib.actions.ActionLookupKey;
	import com.google.devtools.build.lib.analysis.ConfiguredTargetValue;
	import com.google.devtools.build.lib.analysis.InconsistentNullConfigException;
	import com.google.devtools.build.lib.analysis.InvalidVisibilityDependencyException;
	import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
	import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue;
	import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
	import com.google.devtools.build.lib.analysis.config.StarlarkTransitionCache;
	import com.google.devtools.build.lib.analysis.config.transitions.TransitionFactory;
	import com.google.devtools.build.lib.analysis.starlark.StarlarkTransition.TransitionException;
	import com.google.devtools.build.lib.buildeventstream.BuildEventIdUtil;
	import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildEventId;
	import com.google.devtools.build.lib.events.ExtendedEventHandler;
	import com.google.devtools.build.lib.packages.NoSuchPackageException;
	import com.google.devtools.build.lib.packages.NoSuchTargetException;
	import com.google.devtools.build.lib.packages.PackageGroup;
	import com.google.devtools.build.lib.packages.Rule;
	import com.google.devtools.build.lib.packages.RuleTransitionData;
	import com.google.devtools.build.lib.packages.Target;
	import com.google.devtools.build.lib.skyframe.BuildConfigurationKey;
	import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey;
	import com.google.devtools.build.lib.skyframe.ConfiguredValueCreationException;
	import com.google.devtools.build.lib.util.DetailedExitCode;
	import com.google.devtools.build.skyframe.SkyValue;
	import com.google.devtools.build.skyframe.state.StateMachine;
	import com.google.devtools.common.options.OptionsParsingException;
	import java.util.function.Consumer;
	import javax.annotation.Nullable;
	import net.starlark.java.syntax.Location;

	/**
	* Computes the target and configuration for a configured target key.
	*
	* <p>If the key has a configuration and the target is configurable, attempts to apply a rule side
	* transition. If the target is not configurable, directly transitions to the null configuration. If
	* the resulting configuration already has an owner, delegates to the owner instead of recomputing
	* the configured target.
	*
	* <p>If the key does not have a configuration, it was requested as a visibility dependency.
	* Verifies that the {@link Target} is a {@link PackageGroup}, throwing {@link
	* InvalidVisibilityDependencyException} if that's not the case.
	*/
	public final class TargetAndConfigurationProducer
	implements StateMachine, Consumer<SkyValue>, TargetProducer.ResultSink {
	/** Accepts results of this producer. */
	public interface ResultSink {
	void acceptTargetAndConfiguration(TargetAndConfiguration value, ConfiguredTargetKey fullKey);

	void acceptTargetAndConfigurationDelegatedValue(ConfiguredTargetValue value);

	void acceptTargetAndConfigurationError(TargetAndConfigurationError error);
	}

	/** Tagged union of possible errors. */
	@AutoOneOf(TargetAndConfigurationError.Kind.class)
	public abstract static class TargetAndConfigurationError {
	/** Tags the error type. */
	public enum Kind {
	CONFIGURED_VALUE_CREATION,
	INVALID_VISIBILITY_DEPENDENCY,
	INCONSISTENT_NULL_CONFIG
	}

	public abstract Kind kind();

	public abstract ConfiguredValueCreationException configuredValueCreation();

	public abstract InvalidVisibilityDependencyException invalidVisibilityDependency();

	public abstract InconsistentNullConfigException inconsistentNullConfig();

	private static TargetAndConfigurationError of(ConfiguredValueCreationException e) {
	return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
	.configuredValueCreation(e);
	}

	// TODO(b/261521010): enable this error once Rule transitions are removed from dependency
	// resolution.
	// private static TargetAndConfigurationError of(InvalidVisibilityDependencyException e) {
	// return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
	// .invalidVisibilityDependency(e);
	// }

	// TODO(b/261521010): delete this error once Rule transitions are removed from dependency
	// resolution.
	private static TargetAndConfigurationError of(InconsistentNullConfigException e) {
	return AutoOneOf_TargetAndConfigurationProducer_TargetAndConfigurationError
	.inconsistentNullConfig(e);
	}
	}

	// -------------------- Input --------------------
	private final ConfiguredTargetKey preRuleTransitionKey;
	@Nullable private final TransitionFactory<RuleTransitionData> trimmingTransitionFactory;
	private final StarlarkTransitionCache transitionCache;

	private final TransitiveDependencyState transitiveState;

	// -------------------- Output --------------------
	private final ResultSink sink;

	// -------------------- Internal State --------------------
	private Target target;

	public TargetAndConfigurationProducer(
	ConfiguredTargetKey preRuleTransitionKey,
	@Nullable TransitionFactory<RuleTransitionData> trimmingTransitionFactory,
	StarlarkTransitionCache transitionCache,
	TransitiveDependencyState transitiveState,
	ResultSink sink) {
	this.preRuleTransitionKey = preRuleTransitionKey;
	this.trimmingTransitionFactory = trimmingTransitionFactory;
	this.transitionCache = transitionCache;
	this.transitiveState = transitiveState;
	this.sink = sink;
	}

	@Override
	public StateMachine step(Tasks tasks, ExtendedEventHandler listener) {
	return new TargetProducer(
	preRuleTransitionKey.getLabel(),
	transitiveState,
	(TargetProducer.ResultSink) this,
	/* runAfter= */ this::determineConfiguration);
	}

	@Override
	public void acceptTarget(Target target) {
	this.target = target;
	}

	@Override
	public void acceptTargetError(NoSuchPackageException e) {
	emitError(e.getMessage(), /* location= */ null, e.getDetailedExitCode());
	}

	@Override
	public void acceptTargetError(NoSuchTargetException e, Location location) {
	emitError(e.getMessage(), location, e.getDetailedExitCode());
	}

	private StateMachine determineConfiguration(Tasks tasks, ExtendedEventHandler listener) {
	if (target == null) {
	return DONE; // There was an error.
	}

	// TODO(b/261521010): after removing the rule transition from dependency resolution, remove
	// this. It won't be possible afterwards because null configuration keys will only be used for
	// visibility dependencies.
	BuildConfigurationKey configurationKey = preRuleTransitionKey.getConfigurationKey();
	if ((configurationKey != null) != target.isConfigurable()) {
	// We somehow ended up in a target that requires a non-null configuration as a dependency of
	// one that requires a null configuration or the other way round. This is always an error, but
	// we need to analyze the dependencies of the latter target to realize that. Short-circuit the
	// evaluation to avoid doing useless work and running code with a null configuration that's
	// not prepared for it.
	sink.acceptTargetAndConfigurationError(
	TargetAndConfigurationError.of(new InconsistentNullConfigException()));
	return DONE;
	}

	// TODO(b/261521010): after removing the rule transition from dependency resolution, the logic
	// here changes.
	//
	// A null configuration key will only be used for visibility dependencies so when that's true, a
	// check that the target is a PackageGroup will be performed, throwing
	// InvalidVisibilityDependencyException on failure.
	if (configurationKey == null) {
	// The ConfiguredTargetKey cannot fan-in in this case.
	sink.acceptTargetAndConfiguration(
	new TargetAndConfiguration(target, /* configuration= */ null), preRuleTransitionKey);
	return DONE;
	}

	return new RuleTransitionConfigurationProducer();
	}

	/** Applies any requested rule transition before producing the final configuration. */
	private class RuleTransitionConfigurationProducer
	implements StateMachine,
	RuleTransitionApplier.ResultSink,
	ValueOrExceptionSink<InvalidConfigurationException> {
	// -------------------- Internal State --------------------
	private BuildConfigurationKey configurationKey;
	private ConfiguredTargetKey fullKey;

	@Override
	public StateMachine step(Tasks tasks, ExtendedEventHandler listener) {
	return new RuleTransitionApplier(
	preRuleTransitionKey.getConfigurationKey(),
	target.getAssociatedRule(),
	trimmingTransitionFactory,
	transitionCache,
	(RuleTransitionApplier.ResultSink) this,
	/* runAfter= */ this::processTransitionedKey);
	}

	@Override
	public void acceptRuleTransitionResult(BuildConfigurationKey result) {
	this.configurationKey = result;
	}

	@Override
	public void acceptRuleTransitionError(TransitionException e) {
	emitTransitionErrorMessage(e.getMessage());
	}

	@Override
	public void acceptRuleTransitionError(OptionsParsingException e) {
	emitTransitionErrorMessage(e.getMessage());
	}

	private StateMachine processTransitionedKey(Tasks tasks, ExtendedEventHandler listener) {
	if (configurationKey == null) {
	return DONE; // There was an error.
	}

	if (!configurationKey.equals(preRuleTransitionKey.getConfigurationKey())) {
	fullKey =
	ConfiguredTargetKey.builder()
	.setDelegate(preRuleTransitionKey)
	.setConfigurationKey(configurationKey)
	.build();
	ActionLookupKey delegate = fullKey.toKey();
	if (!delegate.equals(preRuleTransitionKey)) {
	// Delegates to the key that already owns this configuration.
	delegateTo(tasks, delegate);
	return DONE;
	}
	} else {
	fullKey = preRuleTransitionKey;
	}

	// This key owns the configuration and the computation completes normally.
	tasks.lookUp(
	configurationKey,
	InvalidConfigurationException.class,
	(ValueOrExceptionSink<InvalidConfigurationException>) this);
	return DONE;
	}

	@Override
	public void acceptValueOrException(
	@Nullable SkyValue value, @Nullable InvalidConfigurationException error) {
	if (value != null) {
	sink.acceptTargetAndConfiguration(
	new TargetAndConfiguration(target, (BuildConfigurationValue) value), fullKey);
	return;
	}
	emitTransitionErrorMessage(error.getMessage());
	}

	private void emitTransitionErrorMessage(String message) {
	// The target must be a rule because these errors happen during the Rule transition.
	Rule rule = target.getAssociatedRule();
	emitError(message, rule.getLocation(), /* exitCode= */ null);
	}
	}

	private void delegateTo(Tasks tasks, ActionLookupKey delegate) {
	tasks.lookUp(delegate, (Consumer<SkyValue>) this);
	}

	@Override
	public void accept(SkyValue value) {
	sink.acceptTargetAndConfigurationDelegatedValue((ConfiguredTargetValue) value);
	}

	private void emitError(
	String message, @Nullable Location location, @Nullable DetailedExitCode exitCode) {
	sink.acceptTargetAndConfigurationError(
	TargetAndConfigurationError.of(
	new ConfiguredValueCreationException(
	location,
	message,
	preRuleTransitionKey.getLabel(),
	getConfigurationId(preRuleTransitionKey.getConfigurationKey()),
	/* rootCauses= */ null,
	exitCode)));
	}

	private static BuildEventId getConfigurationId(@Nullable BuildConfigurationKey configurationKey) {
	return configurationKey == null
	? BuildEventIdUtil.nullConfigurationId()
	: BuildEventIdUtil.configurationId(configurationKey.getOptions().checksum());
	}
	}