src/test/java/com/google/devtools/build/lib/analysis/OutputFileConfiguredTargetTest.java

// Copyright 2017 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;

import static com.google.common.truth.Truth.assertThat;

import com.google.devtools.build.lib.analysis.util.BuildViewTestBase;
import com.google.devtools.build.lib.skyframe.BuildConfigurationValue;
import com.google.devtools.build.lib.skyframe.SkyframeBuildView;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Tests for {@link OutputFileConfiguredTarget}.
 */
@RunWith(JUnit4.class)
public class OutputFileConfiguredTargetTest extends BuildViewTestBase {
  @Test
  public void generatingRuleIsCorrect() throws Exception {
    scratch.file("foo/BUILD",
        "genrule(",
        "    name='generating_rule', ",
        "    cmd = 'echo hi > $@',",
        "    srcs = [],",
        "    outs = ['generated.source'])");
    update("//foo:generating_rule");
    OutputFileConfiguredTarget generatedSource = (OutputFileConfiguredTarget)
        getConfiguredTarget("//foo:generated.source", getHostConfiguration());
    assertThat(generatedSource.getGeneratingRule())
        .isSameAs(getConfiguredTarget("//foo:generating_rule", getHostConfiguration()));
  }

  /**
   * This regression-tests the fix for a bug in which Bazel could crash with a NullPointerException
   * when two builds were invoked with different configurations because an output file ended up
   * unexpectedly having a null generating rule.
   *
   * <p>The reasons for this are subtle and complex. In short, the bug only happens when
   * --experimental_dynamic_configs=off and BuildConfiguration.equals provides value equality.
   *
   * <p>In that scenario, when we call {@code bazel build //foo:gen1 --copt a=b}, Bazel creates a
   * host configuration H1 for this build that attaches to {@code
   * //foo:host_generated_file_producer} (which is the generator of {@code host_src1.cc}).
   *
   * <p>When we then call {@code bazel build //foo:gen2 --copt a=c}, the options have changed so
   * Bazel clears all configurations and configured targets. This includes the host configuration,
   * even though - importantly - none of its options have changed. So Bazel uses a new host config
   * H2 that's value-equal to H1 (but not reference-equal) and assigns it to {@code host_src2.cc}.
   *
   * <p>Here's the problem: during configured target analysis, Bazel creates the configured target
   * <host_src2.cc, H2>, then requests from Skyframe the dependency with SkyKey
   * <host_generated_file_producer, H2>. But Skyframe uses an interner to reference-collapse
   * equivalent keys (SkyKey.SKY_KEY_INTERNER}). And that doesn't get cleared between builds. So
   * the actual SkyKey used is <host_generated_file_producer, H1>, which produces a ConfiguredTarget
   * with config=H1. This breaks {@link TargetContext#findDirectPrerequisite}, which output files
   * use to find their generating rules. That method looks for
   * {@code label.equals("host_generated_file_producer")} and {@code config == H2}, which finds
   * no match so returns a null reference.
   *
   * <p>When configs only use reference equality, the problem goes away because the interner can no
   * longer safely merge H1 and H2. An alternative fix might be to change
   * {@link TargetContext#findDirectPrerequisite} to check {@code config.equals(H2)} instead of
   * {@code config == H2}. But this isn't really safe because static configs embed references to
   * other configs in their transition table. So returning H1 when you expect H2 creates the
   * possibility of "leaking out" to the wrong configuration during a transition, even if H1 and H2
   * have the same exact build options.
   *
   * <p>All of these problems go away with dynamic configurations. This is for two reasons: 1)
   * dynamic configs don't embed transition tables, so "leaking out" is no longer possible. And
   * 2) a dynamic config is evaluated through Skyframe keyed on its BuildOptions, so semantic
   * equality implies reference equality anyway, 2 may change in the future, but if/when it does
   * this test should reliably fail so appropriate measures can be taken.
   */
  @Test
  public void regressionTestForStaticConfigsWithValueEquality() throws Exception {
    scratch.file("foo/BUILD",
        "genrule(",
        "    name = 'host_generated_file_producer',",
        "    srcs = [],",
        "    outs = [",
        "        'host_src1.cc',",
        "        'host_src2.cc',",
        "    ],",
        "    cmd = 'echo hi > $(location host_src1.cc); echo hi > $(location host_src2.cc)')",
        "",
        "cc_binary(",
        "    name = 'host_generated_file_consumer1',",
        "    srcs = ['host_src1.cc'])",
        "",
        "cc_binary(",
        "    name = 'host_generated_file_consumer2',",
        "    srcs = ['host_src2.cc'])",
        "",
        "genrule(",
        "    name = 'gen1',",
        "    srcs = [],",
        "    outs = ['gen1.out'],",
        "    cmd = 'echo hi > $@',",
        "    tools = [':host_generated_file_consumer1'])",
        "",
        "genrule(",
        "    name = 'gen2',",
        "    srcs = [],",
        "    outs = ['gen2.out'],",
        "    cmd = 'echo hi > $@',",
        "    tools = [':host_generated_file_consumer2'])"
    );
    useConfiguration("--copt", "a=b");
    update("//foo:gen1");
    useConfiguration("--copt", "a=c");
    update("//foo:gen2");
    OutputFileConfiguredTarget hostSrc2 = (OutputFileConfiguredTarget)
        getConfiguredTarget("//foo:host_src2.cc", getHostConfiguration());
    assertThat(hostSrc2.getGeneratingRule()).isNotNull();
  }

  /**
   * Dynamic configurations maintain a host configuration cache that stores configurations
   * instantiated outside of Skyframe. We shouldn't, in general, instantiate configurations
   * outside of {@link BuildConfigurationValue}. But in this specific case Bazel performance
   * suffers through the Skyframe interface and maintaining a local cache is much faster.
   * See {@link SkyframeBuildView} for details.
   *
   * <p>One consequence of this is that requesting a config that would be a Skyframe cache hit
   * can still produce a distinct instance. Meaning you can get cases where {@code
   * config1.equals(config2) && config1 != config2}.
   *
   * <p>This test checks for such a case: perform three consecutive Bazel builds. The first builds
   * with default options, producing top-level host config H1 and configured target
   * <host_generated_file_producer, H1>. The second builds with {@code --host_copt=a=b},
   * producing host config H2 (and clearing the top-level host config cache since the host config
   * changed). The third builds back with default options. This once again clears the host config
   * cache, since the host config changed again. So that cache creates a new config H3 where
   * H3.equals(H1) and instantiates new configured target <host_src3.cc, H3>. It then requests
   * dependency <host_generated_file_producer, H3> from Skyframe, but the Skyframe SkyKey interner
   * reduces this to the previously seen <host_generated_file_producer, H1> and returns that
   * instead.
   *
   * <p>This produces the expected scenario where the output file's config is value-equal but not
   * reference-equal to its generating rule's config.
   */
  @Test
  public void dynamicConfigsWithHostConfigSwitch() throws Exception {
    scratch.file("foo/BUILD",
        "genrule(",
        "    name = 'host_generated_file_producer',",
        "    srcs = [],",
        "    outs = [",
        "        'host_src1.cc',",
        "        'host_src2.cc',",
        "        'host_src3.cc',",
        "    ],",
        "    cmd = 'echo hi > $(location host_src1.cc); echo hi > $(location host_src2.cc); "
            + "echo hi > $(location host_src3.cc)')",
        "",
        "cc_binary(name = 'host_generated_file_consumer1', srcs = ['host_src1.cc'])",
        "cc_binary(name = 'host_generated_file_consumer2', srcs = ['host_src2.cc'])",
        "cc_binary(name = 'host_generated_file_consumer3', srcs = ['host_src3.cc'])",
        "",
        "genrule(name = 'gen1', srcs = [], outs = ['gen1.out'], cmd = 'echo hi > $@',",
        "    tools = [':host_generated_file_consumer1'])",
        "genrule(name = 'gen2', srcs = [], outs = ['gen2.out'], cmd = 'echo hi > $@',",
        "    tools = [':host_generated_file_consumer2'])",
        "genrule(name = 'gen3', srcs = [], outs = ['gen3.out'], cmd = 'echo hi > $@',",
        "    tools = [':host_generated_file_consumer3'])");

    String dynamicConfigsMode = "--experimental_dynamic_configs=notrim";
    useConfiguration(dynamicConfigsMode);
    update("//foo:gen1");
    useConfiguration(dynamicConfigsMode, "--host_copt", "a=b");
    update("//foo:gen2");
    useConfiguration(dynamicConfigsMode);
    update("//foo:gen3");

    OutputFileConfiguredTarget hostSrc3 = (OutputFileConfiguredTarget)
        getConfiguredTarget("//foo:host_src3.cc", getHostConfiguration());
    TransitiveInfoCollection hostGeneratedFileConsumer3 = hostSrc3.getGeneratingRule();
    assertThat(hostSrc3.getConfiguration())
        .isEqualTo(hostGeneratedFileConsumer3.getConfiguration());
    // TODO(gregce): enable below for Bazel tests, which for some reason realize the same instance
//    assertThat(hostSrc3.getConfiguration())
//        .isNotSameAs(hostGeneratedFileConsumer3.getConfiguration());
  }
}