path: root/src/main/java/com/google/devtools/build/lib/ideinfo/AndroidStudioInfoAspect.java

// Copyright 2014 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.ideinfo;

import static com.google.common.collect.Iterables.transform;
import static com.google.devtools.build.lib.packages.Attribute.ConfigurationTransition.HOST;
import static com.google.devtools.build.lib.packages.Attribute.attr;
import static com.google.devtools.build.lib.packages.BuildType.LABEL;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.io.ByteSource;
import com.google.devtools.build.lib.actions.Action;
import com.google.devtools.build.lib.actions.ActionOwner;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.ParameterFile.ParameterFileType;
import com.google.devtools.build.lib.actions.Root;
import com.google.devtools.build.lib.analysis.AnalysisUtils;
import com.google.devtools.build.lib.analysis.ConfiguredAspect;
import com.google.devtools.build.lib.analysis.ConfiguredAspect.Builder;
import com.google.devtools.build.lib.analysis.ConfiguredAspectFactory;
import com.google.devtools.build.lib.analysis.ConfiguredTarget;
import com.google.devtools.build.lib.analysis.RuleConfiguredTarget.Mode;
import com.google.devtools.build.lib.analysis.RuleContext;
import com.google.devtools.build.lib.analysis.TransitiveInfoCollection;
import com.google.devtools.build.lib.analysis.actions.BinaryFileWriteAction;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
import com.google.devtools.build.lib.analysis.actions.SpawnAction;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.AndroidRuleIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.ArtifactLocation;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.CRuleIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.CToolchainIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.JavaRuleIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.JavaToolchainIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.LibraryArtifact;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.RuleIdeInfo;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.RuleIdeInfo.Kind;
import com.google.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo.TestInfo;
import com.google.devtools.build.lib.packages.AspectDefinition;
import com.google.devtools.build.lib.packages.AspectParameters;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.NativeAspectClass;
import com.google.devtools.build.lib.packages.NonconfigurableAttributeMapper;
import com.google.devtools.build.lib.packages.Package;
import com.google.devtools.build.lib.packages.Rule;
import com.google.devtools.build.lib.packages.TargetUtils;
import com.google.devtools.build.lib.rules.android.AndroidIdeInfoProvider;
import com.google.devtools.build.lib.rules.android.AndroidIdeInfoProvider.SourceDirectory;
import com.google.devtools.build.lib.rules.android.AndroidSdkProvider;
import com.google.devtools.build.lib.rules.cpp.CcLinkParamsProvider;
import com.google.devtools.build.lib.rules.cpp.CcToolchainProvider;
import com.google.devtools.build.lib.rules.cpp.CppCompilationContext;
import com.google.devtools.build.lib.rules.cpp.CppConfiguration;
import com.google.devtools.build.lib.rules.cpp.LinkerInput;
import com.google.devtools.build.lib.rules.java.JavaExportsProvider;
import com.google.devtools.build.lib.rules.java.JavaGenJarsProvider;
import com.google.devtools.build.lib.rules.java.JavaRuleOutputJarsProvider;
import com.google.devtools.build.lib.rules.java.JavaRuleOutputJarsProvider.OutputJar;
import com.google.devtools.build.lib.rules.java.JavaSourceInfoProvider;
import com.google.devtools.build.lib.rules.java.JavaToolchainProvider;
import com.google.devtools.build.lib.syntax.Type;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.protobuf.MessageLite;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.List;
import javax.annotation.Nullable;

/**
 * Generates ide-build information for Android Studio.
 */
public class AndroidStudioInfoAspect extends NativeAspectClass implements ConfiguredAspectFactory {
  public static final String NAME = "AndroidStudioInfoAspect";

  // Output groups.

  static final String IDE_INFO = "ide-info";
  static final String IDE_INFO_TEXT = "ide-info-text";
  static final String IDE_RESOLVE = "ide-resolve";
  static final String IDE_COMPILE = "ide-compile";

  private final String toolsRepository;
  private final AndroidStudioInfoSemantics androidStudioInfoSemantics;
  private final ImmutableList<PrerequisiteAttr> prerequisiteAttrs;

  public AndroidStudioInfoAspect(
      String toolsRepository,
      AndroidStudioInfoSemantics androidStudioInfoSemantics) {
    this.toolsRepository = toolsRepository;
    this.androidStudioInfoSemantics = androidStudioInfoSemantics;
    this.prerequisiteAttrs = buildPrerequisiteAttrs();
  }

  @Override
  public String getName() {
    return NAME;
  }

  /**
   * Attribute to propagate dependencies along.
   */
  public static class PrerequisiteAttr {
    public final String name;
    public final Type<?> type;
    public PrerequisiteAttr(String name, Type<?> type) {
      this.name = name;
      this.type = type;
    }
  }

  private ImmutableList<PrerequisiteAttr> buildPrerequisiteAttrs() {
    ImmutableList.Builder<PrerequisiteAttr> builder = ImmutableList.builder();
    builder.add(new PrerequisiteAttr("deps", BuildType.LABEL_LIST));
    builder.add(new PrerequisiteAttr("exports", BuildType.LABEL_LIST));
    // From android_test
    builder.add(new PrerequisiteAttr("binary_under_test", BuildType.LABEL));
    // from java_* rules
    builder.add(new PrerequisiteAttr(":java_toolchain", BuildType.LABEL));
    // from cc_* rules
    builder.add(new PrerequisiteAttr(":cc_toolchain", BuildType.LABEL));

    androidStudioInfoSemantics.augmentPrerequisiteAttrs(builder);

    return builder.build();
  }

  // File suffixes.
  public static final String ASWB_BUILD_SUFFIX = ".aswb-build";
  public static final String ASWB_BUILD_TEXT_SUFFIX = ".aswb-build.txt";
  public static final Function<Label, String> LABEL_TO_STRING = new Function<Label, String>() {
    @Nullable
    @Override
    public String apply(Label label) {
      return label.toString();
    }
  };

  @Override
  public AspectDefinition getDefinition(AspectParameters aspectParameters) {
    AspectDefinition.Builder builder = new AspectDefinition.Builder(NAME)
        .attributeAspect("runtime_deps", this)
        .attributeAspect("resources", this)
        .add(attr("$packageParser", LABEL).cfg(HOST).exec()
            .value(Label.parseAbsoluteUnchecked(
                toolsRepository + "//tools/android:PackageParser")))
        .add(attr("$jarFilter", LABEL).cfg(HOST).exec()
            .value(Label.parseAbsoluteUnchecked(
                toolsRepository + "//tools/android:JarFilter")));

    for (PrerequisiteAttr prerequisiteAttr : prerequisiteAttrs) {
      builder.attributeAspect(prerequisiteAttr.name, this);
    }

    return builder.build();
  }

  @Override
  public ConfiguredAspect create(
      ConfiguredTarget base, RuleContext ruleContext, AspectParameters parameters) {
    ConfiguredAspect.Builder builder = new Builder(NAME, ruleContext);

    AndroidStudioInfoFilesProvider.Builder providerBuilder =
        new AndroidStudioInfoFilesProvider.Builder();

    RuleIdeInfo.Kind ruleKind = getRuleKind(ruleContext.getRule(), base);

    DependenciesResult dependenciesResult = processDependencies(
        base, ruleContext, providerBuilder);

    AndroidStudioInfoFilesProvider provider = createIdeBuildArtifact(
        base,
        ruleContext,
        ruleKind,
        dependenciesResult,
        providerBuilder);

    builder
        .addOutputGroup(IDE_INFO, provider.getIdeInfoFiles())
        .addOutputGroup(IDE_INFO_TEXT, provider.getIdeInfoTextFiles())
        .addOutputGroup(IDE_RESOLVE, provider.getIdeResolveFiles())
        .addOutputGroup(IDE_COMPILE, provider.getIdeCompileFiles())
        .addProvider(provider);

    return builder.build();
  }

  private static class DependenciesResult {
    private DependenciesResult(Iterable<Label> deps,
        Iterable<Label> runtimeDeps, @Nullable Label resources) {
      this.deps = deps;
      this.runtimeDeps = runtimeDeps;
      this.resources = resources;
    }
    final Iterable<Label> deps;
    final Iterable<Label> runtimeDeps;
    @Nullable final Label resources;
  }

  private DependenciesResult processDependencies(
      ConfiguredTarget base, RuleContext ruleContext,
      AndroidStudioInfoFilesProvider.Builder providerBuilder) {

    // Calculate direct dependencies
    ImmutableList.Builder<TransitiveInfoCollection> directDepsBuilder = ImmutableList.builder();
    for (PrerequisiteAttr prerequisiteAttr : prerequisiteAttrs) {
      if (ruleContext.attributes().has(prerequisiteAttr.name, prerequisiteAttr.type)) {
        Mode mode = ruleContext.getAttributeMode(prerequisiteAttr.name);
        if (mode == Mode.TARGET || mode == Mode.SPLIT) {
          directDepsBuilder
              .addAll(ruleContext.getPrerequisites(prerequisiteAttr.name, Mode.TARGET));
        }
      }
    }
    List<TransitiveInfoCollection> directDeps = directDepsBuilder.build();

    // Add exports from direct dependencies
    NestedSetBuilder<Label> dependenciesBuilder = NestedSetBuilder.stableOrder();
    for (AndroidStudioInfoFilesProvider depProvider :
        AnalysisUtils.getProviders(directDeps, AndroidStudioInfoFilesProvider.class)) {
      dependenciesBuilder.addTransitive(depProvider.getExportedDeps());
    }
    for (TransitiveInfoCollection dep : directDeps) {
      dependenciesBuilder.add(dep.getLabel());
    }
    NestedSet<Label> dependencies = dependenciesBuilder.build();

    // Propagate my own exports
    JavaExportsProvider javaExportsProvider = base.getProvider(JavaExportsProvider.class);
    if (javaExportsProvider != null) {
      providerBuilder.exportedDepsBuilder()
          .addTransitive(javaExportsProvider.getTransitiveExports());
    }
    // android_library without sources exports all its deps
    if (ruleContext.getRule().getRuleClass().equals("android_library")) {
      JavaSourceInfoProvider sourceInfoProvider = base.getProvider(JavaSourceInfoProvider.class);
      boolean hasSources = sourceInfoProvider != null
          && !sourceInfoProvider.getSourceFiles().isEmpty();
      if (!hasSources) {
        for (TransitiveInfoCollection dep : directDeps) {
          providerBuilder.exportedDepsBuilder().add(dep.getLabel());
        }
      }
    }

    // runtime_deps
    List<? extends TransitiveInfoCollection> runtimeDeps = ImmutableList.of();
    NestedSetBuilder<Label> runtimeDepsBuilder = NestedSetBuilder.stableOrder();
    if (ruleContext.attributes().has("runtime_deps", BuildType.LABEL_LIST)) {
      runtimeDeps = ruleContext.getPrerequisites("runtime_deps", Mode.TARGET);
      for (TransitiveInfoCollection dep : runtimeDeps) {
        runtimeDepsBuilder.add(dep.getLabel());
      }
    }

    // resources
    @Nullable TransitiveInfoCollection resources =
        ruleContext.attributes().has("resources", BuildType.LABEL)
            ? ruleContext.getPrerequisite("resources", Mode.TARGET)
            : null;

    // Propagate providers from all prerequisites (deps + runtime_deps)
    ImmutableList.Builder<TransitiveInfoCollection> prerequisitesBuilder = ImmutableList.builder();
    prerequisitesBuilder.addAll(directDeps);
    prerequisitesBuilder.addAll(runtimeDeps);
    if (resources != null) {
      prerequisitesBuilder.add(resources);
    }

    List<TransitiveInfoCollection> prerequisites = prerequisitesBuilder.build();

    for (AndroidStudioInfoFilesProvider depProvider :
        AnalysisUtils.getProviders(prerequisites, AndroidStudioInfoFilesProvider.class)) {
      providerBuilder.ideInfoFilesBuilder().addTransitive(depProvider.getIdeInfoFiles());
      providerBuilder.ideInfoTextFilesBuilder().addTransitive(depProvider.getIdeInfoTextFiles());
      providerBuilder.ideResolveFilesBuilder().addTransitive(depProvider.getIdeResolveFiles());
      providerBuilder.ideCompileFilesBuilder().addTransitive(depProvider.getIdeCompileFiles());
    }


    return new DependenciesResult(
        dependencies,
        runtimeDepsBuilder.build(),
        resources != null ? resources.getLabel() : null);
  }

  private AndroidStudioInfoFilesProvider createIdeBuildArtifact(
      ConfiguredTarget base,
      RuleContext ruleContext,
      Kind ruleKind,
      DependenciesResult dependenciesResult,
      AndroidStudioInfoFilesProvider.Builder providerBuilder) {

    Artifact ideInfoFile = derivedArtifact(base, ruleContext, ASWB_BUILD_SUFFIX);
    Artifact ideInfoTextFile = derivedArtifact(base, ruleContext, ASWB_BUILD_TEXT_SUFFIX);
    providerBuilder.ideInfoFilesBuilder().add(ideInfoFile);
    providerBuilder.ideInfoTextFilesBuilder().add(ideInfoTextFile);
    NestedSetBuilder<Artifact> ideResolveArtifacts = providerBuilder.ideResolveFilesBuilder();
    NestedSetBuilder<Artifact> ideCompileArtifacts = providerBuilder.ideCompileFilesBuilder();

    RuleIdeInfo.Builder outputBuilder = RuleIdeInfo.newBuilder();

    outputBuilder.setLabel(base.getLabel().toString());

    outputBuilder.setBuildFileArtifactLocation(
        makeArtifactLocation(ruleContext.getRule().getPackage()));

    if (ruleKind != Kind.UNRECOGNIZED) {
      outputBuilder.setKind(ruleKind);
    }
    outputBuilder.setKindString(ruleContext.getRule().getRuleClass());

    // Java rules
    JavaRuleOutputJarsProvider outputJarsProvider =
        base.getProvider(JavaRuleOutputJarsProvider.class);
    if (outputJarsProvider != null && !androidStudioInfoSemantics.suppressJavaRuleInfo(base)) {
      JavaRuleIdeInfo javaRuleIdeInfo = makeJavaRuleIdeInfo(base, ruleContext,
          outputJarsProvider, providerBuilder);
      outputBuilder.setJavaRuleIdeInfo(javaRuleIdeInfo);
    }

    // C rules
    if (isCppRule(base)) {
      CppCompilationContext cppCompilationContext = base.getProvider(CppCompilationContext.class);
      if (cppCompilationContext != null) {
        CRuleIdeInfo cRuleIdeInfo = makeCRuleIdeInfo(base, ruleContext,
            cppCompilationContext, ideResolveArtifacts, ideCompileArtifacts);
        outputBuilder.setCRuleIdeInfo(cRuleIdeInfo);
      }
    }

    // CCToolchain rule
    CcToolchainProvider ccToolchainProvider = base.getProvider(CcToolchainProvider.class);
    if (ccToolchainProvider != null) {
      CppConfiguration cppConfiguration = ccToolchainProvider.getCppConfiguration();
      if (cppConfiguration != null) {
        CToolchainIdeInfo cToolchainIdeInfo = makeCToolchainIdeInfo(ruleContext, cppConfiguration);
        if (cToolchainIdeInfo != null) {
          outputBuilder.setCToolchainIdeInfo(cToolchainIdeInfo);
        }
      }
    }

    // Android rules
    AndroidIdeInfoProvider androidIdeInfoProvider = base.getProvider(AndroidIdeInfoProvider.class);
    if (androidIdeInfoProvider != null) {
      outputBuilder.setAndroidRuleIdeInfo(makeAndroidRuleIdeInfo(
          androidIdeInfoProvider, dependenciesResult, ideResolveArtifacts));
    }

    // Test rules
    if (TargetUtils.isTestRule(base.getTarget())) {
      TestInfo.Builder builder = TestInfo.newBuilder();
      String attr = NonconfigurableAttributeMapper.of(base.getTarget().getAssociatedRule())
          .get("size", Type.STRING);
      if (attr != null) {
        builder.setSize(attr);
      }
      outputBuilder.setTestInfo(builder);
    }

    // Java toolchain rule
    JavaToolchainProvider javaToolchainProvider = base.getProvider(JavaToolchainProvider.class);
    if (javaToolchainProvider != null) {
      outputBuilder.setJavaToolchainIdeInfo(JavaToolchainIdeInfo.newBuilder()
          .setSourceVersion(javaToolchainProvider.getSourceVersion())
          .setTargetVersion(javaToolchainProvider.getTargetVersion()));
    }

    androidStudioInfoSemantics.augmentRuleInfo(
        outputBuilder, base, ruleContext, ideResolveArtifacts);

    AndroidStudioInfoFilesProvider provider = providerBuilder.build();

    outputBuilder.addAllDependencies(transform(dependenciesResult.deps, LABEL_TO_STRING));
    outputBuilder.addAllRuntimeDeps(transform(dependenciesResult.runtimeDeps, LABEL_TO_STRING));
    outputBuilder.addAllTags(base.getTarget().getAssociatedRule().getRuleTags());

    final RuleIdeInfo ruleIdeInfo = outputBuilder.build();

    ruleContext.registerAction(
        makeProtoWriteAction(ruleContext.getActionOwner(), ruleIdeInfo, ideInfoFile));
    ruleContext.registerAction(
        makeProtoTextWriteAction(ruleContext.getActionOwner(), ruleIdeInfo, ideInfoTextFile));

    return provider;
  }

  private boolean isCppRule(ConfiguredTarget base) {
    String ruleClass = base.getTarget().getAssociatedRule().getRuleClass();
    switch (ruleClass) {
      case "cc_library":
      case "cc_binary":
      case "cc_test":
      case "cc_inc_library:":
        return true;
      default:
        // Fall through
    }
    return androidStudioInfoSemantics.checkForAdditionalCppRules(ruleClass);
  }

  private static Action[] makePackageManifestAction(
      RuleContext ruleContext,
      Artifact packageManifest,
      Collection<Artifact> sourceFiles) {

    return new SpawnAction.Builder()
        .addInputs(sourceFiles)
        .addOutput(packageManifest)
        .setExecutable(ruleContext.getExecutablePrerequisite("$packageParser", Mode.HOST))
        .setCommandLine(CustomCommandLine.builder()
            .addExecPath("--output_manifest", packageManifest)
            .addJoinStrings("--sources", ":", toSerializedArtifactLocations(sourceFiles))
            .build())
        .useParameterFile(ParameterFileType.SHELL_QUOTED)
        .setProgressMessage("Parsing java package strings for " + ruleContext.getRule())
        .setMnemonic("JavaPackageManifest")
        .build(ruleContext);
  }

  private static Iterable<String> toSerializedArtifactLocations(Iterable<Artifact> artifacts) {
    return Iterables.transform(
        Iterables.filter(artifacts, Artifact.MIDDLEMAN_FILTER),
        PACKAGE_PARSER_SERIALIZER);
  }

  private static final Function<Artifact, String> PACKAGE_PARSER_SERIALIZER =
      new Function<Artifact, String>() {
        @Override
        public String apply(Artifact artifact) {
          Root root = artifact.getRoot();
          return Joiner.on(",").join(
              root.getExecPath().toString(),
              artifact.getRootRelativePath().toString()
          );
        }
      };

  private static Action[] makeFilteredJarAction(
      RuleContext ruleContext,
      List<Artifact> jars,
      Artifact generatedPackageManifest,
      Artifact output) {

    return new SpawnAction.Builder()
        .addInputs(jars)
        .addInput(generatedPackageManifest)
        .addOutput(output)
        .setExecutable(ruleContext.getExecutablePrerequisite("$jarFilter", Mode.HOST))
        .setCommandLine(CustomCommandLine.builder()
            .addExecPaths("--jars", jars)
            .addExecPath("--manifest", generatedPackageManifest)
            .addExecPath("--output", output)
            .build())
        .useParameterFile(ParameterFileType.SHELL_QUOTED)
        .setProgressMessage("Filtering generated code for " + ruleContext.getRule())
        .setMnemonic("JarFilter")
        .build(ruleContext);
  }

  private static Artifact derivedArtifact(ConfiguredTarget base, RuleContext ruleContext,
      String suffix) {
    BuildConfiguration configuration = ruleContext.getConfiguration();
    assert configuration != null;
    Root binDirectory = configuration.getBinDirectory(
        ruleContext.getRule().getRepository());

    PathFragment derivedFilePath =
        getOutputFilePath(base, ruleContext, suffix);

    return ruleContext.getAnalysisEnvironment().getDerivedArtifact(
        derivedFilePath, binDirectory);
  }

  private static AndroidRuleIdeInfo makeAndroidRuleIdeInfo(
      AndroidIdeInfoProvider androidIdeInfoProvider,
      DependenciesResult dependenciesResult,
      NestedSetBuilder<Artifact> ideResolveArtifacts) {
    AndroidRuleIdeInfo.Builder builder = AndroidRuleIdeInfo.newBuilder();
    if (androidIdeInfoProvider.getSignedApk() != null) {
      builder.setApk(makeArtifactLocation(androidIdeInfoProvider.getSignedApk()));
    }

    Artifact manifest = androidIdeInfoProvider.getManifest();
    if (manifest != null) {
      builder.setManifest(makeArtifactLocation(manifest));
      addResolveArtifact(ideResolveArtifacts, manifest);
    }

    for (Artifact artifact : androidIdeInfoProvider.getApksUnderTest()) {
      builder.addDependencyApk(makeArtifactLocation(artifact));
    }
    for (SourceDirectory resourceDir : androidIdeInfoProvider.getResourceDirs()) {
      ArtifactLocation artifactLocation = makeArtifactLocation(resourceDir);
      builder.addResources(artifactLocation);
    }

    if (androidIdeInfoProvider.getJavaPackage() != null) {
      builder.setJavaPackage(androidIdeInfoProvider.getJavaPackage());
    }

    String idlImportRoot = androidIdeInfoProvider.getIdlImportRoot();
    if (idlImportRoot != null) {
      builder.setIdlImportRoot(idlImportRoot);
    }
    boolean hasIdlSources = !androidIdeInfoProvider.getIdlSrcs().isEmpty();
    builder.setHasIdlSources(hasIdlSources);
    if (hasIdlSources) {
      LibraryArtifact idlLibraryArtifact = makeLibraryArtifact(ideResolveArtifacts,
          androidIdeInfoProvider.getIdlClassJar(), null, androidIdeInfoProvider.getIdlSourceJar());
      if (idlLibraryArtifact != null) {
        builder.setIdlJar(idlLibraryArtifact);
      }
    }

    builder.setGenerateResourceClass(androidIdeInfoProvider.definesAndroidResources());

    if (dependenciesResult.resources != null) {
      builder.setLegacyResources(dependenciesResult.resources.toString());
    }

    OutputJar resourceJar = androidIdeInfoProvider.getResourceJar();
    if (resourceJar != null) {
      LibraryArtifact resourceLibraryArtifact = makeLibraryArtifact(ideResolveArtifacts,
          resourceJar.getClassJar(), resourceJar.getIJar(), resourceJar.getSrcJar());
      if (resourceLibraryArtifact != null) {
        builder.setResourceJar(resourceLibraryArtifact);
      }
    }

    return builder.build();
  }

  private static BinaryFileWriteAction makeProtoWriteAction(
      ActionOwner actionOwner, final MessageLite message, Artifact artifact) {
    return new BinaryFileWriteAction(
        actionOwner,
        artifact,
        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            return message.toByteString().newInput();
          }
        },
        /*makeExecutable =*/ false);
  }

  private static BinaryFileWriteAction makeProtoTextWriteAction(
      ActionOwner actionOwner, final MessageLite message, Artifact artifact) {
    return new BinaryFileWriteAction(
        actionOwner,
        artifact,
        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            return new ByteArrayInputStream(message.toString().getBytes(StandardCharsets.UTF_8));
          }
        },
        /*makeExecutable =*/ false);
  }

  public static ArtifactLocation makeArtifactLocation(Artifact artifact) {
    return makeArtifactLocation(artifact.getRoot(), artifact.getRootRelativePath());
  }

  private static ArtifactLocation makeArtifactLocation(Package pkg) {
    Root root = Root.asSourceRoot(pkg.getSourceRoot(),
        pkg.getPackageIdentifier().getRepository().isMain());
    PathFragment relativePath = pkg.getBuildFile().getPath().relativeTo(root.getPath());
    return makeArtifactLocation(root, relativePath);
  }

  private static ArtifactLocation makeArtifactLocation(Root root, PathFragment relativePath) {
    return ArtifactLocation.newBuilder()
        .setRootExecutionPathFragment(root.getExecPath().toString())
        .setRelativePath(relativePath.toString())
        .setIsSource(root.isSourceRoot())
        .build();
  }

  private static ArtifactLocation makeArtifactLocation(SourceDirectory resourceDir) {
    return ArtifactLocation.newBuilder()
        .setRootExecutionPathFragment(resourceDir.getRootExecutionPathFragment().toString())
        .setRelativePath(resourceDir.getRelativePath().toString())
        .setIsSource(resourceDir.isSource())
        .build();
  }

  private JavaRuleIdeInfo makeJavaRuleIdeInfo(
      ConfiguredTarget base,
      RuleContext ruleContext,
      JavaRuleOutputJarsProvider outputJarsProvider,
      AndroidStudioInfoFilesProvider.Builder providerBuilder) {
    NestedSetBuilder<Artifact> ideResolveArtifacts = providerBuilder.ideResolveFilesBuilder();
    JavaRuleIdeInfo.Builder builder = JavaRuleIdeInfo.newBuilder();

    List<Artifact> javaSources = Lists.newArrayList();
    List<Artifact> generatedJavaSources = Lists.newArrayList();
    getJavaSourcesForPackageManifest(ruleContext, javaSources, generatedJavaSources);

    if (!javaSources.isEmpty()) {
      Artifact packageManifest = derivedArtifact(base, ruleContext, ".manifest");
      providerBuilder.ideInfoFilesBuilder().add(packageManifest);
      ruleContext.registerAction(makePackageManifestAction(
          ruleContext, packageManifest, javaSources));
      builder.setPackageManifest(makeArtifactLocation(packageManifest));
    }

    if (!javaSources.isEmpty() && !generatedJavaSources.isEmpty()) {
      Artifact generatedPackageManifest = derivedArtifact(
          base, ruleContext, "-filtered-gen.manifest");
      ruleContext.registerAction(makePackageManifestAction(ruleContext,
          generatedPackageManifest, generatedJavaSources));
      Artifact filteredGenJar = derivedArtifact(base, ruleContext, "-filtered-gen.jar");
      List<Artifact> jars = Lists.newArrayList();
      for (OutputJar outputJar : outputJarsProvider.getOutputJars()) {
        Artifact jar = outputJar.getIJar();
        if (jar == null) {
          jar = outputJar.getClassJar();
        }
        if (jar == null) {
          continue;
        }
        jars.add(jar);
      }
      ruleContext.registerAction(makeFilteredJarAction(ruleContext,
          jars, generatedPackageManifest, filteredGenJar));
      ideResolveArtifacts.add(filteredGenJar);
      builder.setFilteredGenJar(makeLibraryArtifact(
          ideResolveArtifacts, filteredGenJar, null, null));
    }

    collectJarsFromOutputJarsProvider(builder, ideResolveArtifacts, outputJarsProvider);

    Artifact jdeps = outputJarsProvider.getJdeps();
    if (jdeps != null) {
      builder.setJdeps(makeArtifactLocation(jdeps));
    }

    JavaGenJarsProvider genJarsProvider =
        base.getProvider(JavaGenJarsProvider.class);
    if (genJarsProvider != null) {
      collectGenJars(builder, ideResolveArtifacts, genJarsProvider);
    }

    Collection<Artifact> sourceFiles = getSources(ruleContext);

    for (Artifact sourceFile : sourceFiles) {
      builder.addSources(makeArtifactLocation(sourceFile));
    }

    return builder.build();
  }

  private CRuleIdeInfo makeCRuleIdeInfo(
      ConfiguredTarget base,
      RuleContext ruleContext,
      CppCompilationContext cppCompilationContext,
      NestedSetBuilder<Artifact> ideResolveArtifacts,
      NestedSetBuilder<Artifact> ideCompileArtifacts) {
    CRuleIdeInfo.Builder builder = CRuleIdeInfo.newBuilder();

    Collection<Artifact> sourceFiles = getSources(ruleContext);
    for (Artifact sourceFile : sourceFiles) {
      builder.addSource(makeArtifactLocation(sourceFile));
    }

    ideResolveArtifacts.addTransitive(cppCompilationContext.getDeclaredIncludeSrcs());

    builder.addAllRuleInclude(getIncludes(ruleContext));
    builder.addAllRuleDefine(getDefines(ruleContext));
    builder.addAllRuleCopt(getCopts(ruleContext));

    // Get information about from the transitive closure
    ImmutableList<PathFragment> transitiveIncludeDirectories =
        cppCompilationContext.getIncludeDirs();
    for (PathFragment pathFragment : transitiveIncludeDirectories) {
      builder.addTransitiveIncludeDirectory(pathFragment.getSafePathString());
    }
    ImmutableList<PathFragment> transitiveQuoteIncludeDirectories =
        cppCompilationContext.getQuoteIncludeDirs();
    for (PathFragment pathFragment : transitiveQuoteIncludeDirectories) {
      builder.addTransitiveQuoteIncludeDirectory(pathFragment.getSafePathString());
    }
    ImmutableList<String> transitiveDefines = cppCompilationContext.getDefines();
    for (String transitiveDefine : transitiveDefines) {
      builder.addTransitiveDefine(transitiveDefine);
    }
    ImmutableList<PathFragment> transitiveSystemIncludeDirectories =
        cppCompilationContext.getSystemIncludeDirs();
    for (PathFragment pathFragment : transitiveSystemIncludeDirectories) {
      builder.addTransitiveSystemIncludeDirectory(pathFragment.getSafePathString());
    }

    // Add libs to ide-compile
    CcLinkParamsProvider ccLinkParams = base.getProvider(CcLinkParamsProvider.class);
    if (ccLinkParams != null) {
      for (LinkerInput lib : ccLinkParams.getCcLinkParams(true, false).getLibraries()) {
        ideCompileArtifacts.add(lib.getArtifact());
      }
    }

    androidStudioInfoSemantics.augmentCppRuleInfo(
        builder, base, ruleContext, cppCompilationContext, ideResolveArtifacts);

    return builder.build();
  }

  private static CToolchainIdeInfo makeCToolchainIdeInfo(
      RuleContext ruleContext, CppConfiguration cppConfiguration) {
    CToolchainIdeInfo.Builder builder = CToolchainIdeInfo.newBuilder();
    ImmutableSet<String> features = ruleContext.getFeatures();
    builder.setTargetName(cppConfiguration.getTargetGnuSystemName());

    builder.addAllBaseCompilerOption(cppConfiguration.getCompilerOptions(features));
    builder.addAllCOption(cppConfiguration.getCOptions());
    builder.addAllCppOption(cppConfiguration.getCxxOptions(features));
    builder.addAllLinkOption(cppConfiguration.getLinkOptions());

    // This includes options such as system includes from toolchains.
    builder.addAllUnfilteredCompilerOption(
        cppConfiguration.getUnfilteredCompilerOptions(features));

    builder.setPreprocessorExecutable(
        cppConfiguration.getCpreprocessorExecutable().getSafePathString());
    builder.setCppExecutable(cppConfiguration.getCppExecutable().getSafePathString());

    List<PathFragment> builtInIncludeDirectories = cppConfiguration
        .getBuiltInIncludeDirectories();
    for (PathFragment builtInIncludeDirectory : builtInIncludeDirectories) {
      builder.addBuiltInIncludeDirectory(builtInIncludeDirectory.getSafePathString());
    }
    return builder.build();
  }

  private static void collectJarsFromOutputJarsProvider(
      JavaRuleIdeInfo.Builder builder,
      NestedSetBuilder<Artifact> ideResolveArtifacts,
      JavaRuleOutputJarsProvider outputJarsProvider) {
    for (OutputJar outputJar : outputJarsProvider.getOutputJars()) {
      LibraryArtifact libraryArtifact = makeLibraryArtifact(ideResolveArtifacts,
          outputJar.getClassJar(), outputJar.getIJar(), outputJar.getSrcJar());

      if (libraryArtifact != null) {
        builder.addJars(libraryArtifact);
      }
    }
  }

  @Nullable
  private static LibraryArtifact makeLibraryArtifact(
      NestedSetBuilder<Artifact> ideResolveArtifacts,
      @Nullable Artifact classJar,
      @Nullable Artifact iJar,
      @Nullable Artifact sourceJar
      ) {
    // We don't want to add anything that doesn't have a class jar
    if (classJar == null) {
      return null;
    }
    LibraryArtifact.Builder jarsBuilder = LibraryArtifact.newBuilder();
    jarsBuilder.setJar(makeArtifactLocation(classJar));
    addResolveArtifact(ideResolveArtifacts, classJar);

    if (iJar != null) {
      jarsBuilder.setInterfaceJar(makeArtifactLocation(iJar));
      addResolveArtifact(ideResolveArtifacts, iJar);
    }
    if (sourceJar != null) {
      jarsBuilder.setSourceJar(makeArtifactLocation(sourceJar));
      addResolveArtifact(ideResolveArtifacts, sourceJar);
    }

    return jarsBuilder.build();
  }

  private static void collectGenJars(
      JavaRuleIdeInfo.Builder builder,
      NestedSetBuilder<Artifact> ideResolveArtifacts,
      JavaGenJarsProvider genJarsProvider) {
    LibraryArtifact.Builder genjarsBuilder = LibraryArtifact.newBuilder();

    if (genJarsProvider.usesAnnotationProcessing()) {
      Artifact genClassJar = genJarsProvider.getGenClassJar();
      if (genClassJar != null) {
        genjarsBuilder.setJar(makeArtifactLocation(genClassJar));
        addResolveArtifact(ideResolveArtifacts, genClassJar);
      }
      Artifact gensrcJar = genJarsProvider.getGenSourceJar();
      if (gensrcJar != null) {
        genjarsBuilder.setSourceJar(makeArtifactLocation(gensrcJar));
        addResolveArtifact(ideResolveArtifacts, gensrcJar);
      }
      if (genjarsBuilder.hasJar()) {
        builder.addGeneratedJars(genjarsBuilder.build());
      }
    }
  }

  private static void getJavaSourcesForPackageManifest(RuleContext ruleContext,
      List<Artifact> javaSources, List<Artifact> generatedSources) {
    Collection<Artifact> srcs = getSources(ruleContext);
    for (Artifact src : srcs) {
      if (src.getRootRelativePathString().endsWith(".java")) {
        if (src.isSourceArtifact()) {
          javaSources.add(src);
        } else {
          generatedSources.add(src);
        }
      }
    }
  }

  private static Collection<Artifact> getSources(RuleContext ruleContext) {
    return getTargetListAttribute(ruleContext, "srcs");
  }

  private static Collection<String> getIncludes(RuleContext ruleContext) {
    return getStringListAttribute(ruleContext, "includes");
  }

  private static Collection<String> getDefines(RuleContext ruleContext) {
    return getStringListAttribute(ruleContext, "defines");
  }

  private static Collection<String> getCopts(RuleContext ruleContext) {
    return getStringListAttribute(ruleContext, "copts");
  }

  private static Collection<Artifact> getTargetListAttribute(RuleContext ruleContext,
      String attributeName) {
    return (ruleContext.attributes().has(attributeName, BuildType.LABEL_LIST)
        && ruleContext.getAttributeMode(attributeName) == Mode.TARGET)
        ? ruleContext.getPrerequisiteArtifacts(attributeName, Mode.TARGET).list()
        : ImmutableList.<Artifact>of();
  }

  private static Collection<String> getStringListAttribute(RuleContext ruleContext,
      String attributeName) {
    return ruleContext.attributes().has(attributeName, Type.STRING_LIST)
        ? ruleContext.attributes().get(attributeName, Type.STRING_LIST)
        : ImmutableList.<String>of();
  }

  private static PathFragment getOutputFilePath(ConfiguredTarget base, RuleContext ruleContext,
      String suffix) {
    PathFragment packagePathFragment =
        ruleContext.getLabel().getPackageIdentifier().getSourceRoot();
    String name = base.getLabel().getName();
    return new PathFragment(packagePathFragment, new PathFragment(name + suffix));
  }


  private static void addResolveArtifact(NestedSetBuilder<Artifact> ideResolveArtifacts,
      Artifact artifact) {
    if (!artifact.isSourceArtifact()) {
      ideResolveArtifacts.add(artifact);
    }
  }

  @Deprecated
  private RuleIdeInfo.Kind getRuleKind(Rule rule, ConfiguredTarget base) {
    switch (rule.getRuleClassObject().getName()) {
      case "java_library":
        return Kind.JAVA_LIBRARY;
      case "java_import":
        return Kind.JAVA_IMPORT;
      case "java_test":
        return Kind.JAVA_TEST;
      case "java_binary":
        return Kind.JAVA_BINARY;
      case "android_library":
        return Kind.ANDROID_LIBRARY;
      case "android_binary":
        return Kind.ANDROID_BINARY;
      case "android_test":
        return Kind.ANDROID_TEST;
      case "android_robolectric_test":
        return Kind.ANDROID_ROBOELECTRIC_TEST;
      case "proto_library":
        return Kind.PROTO_LIBRARY;
      case "java_plugin":
        return Kind.JAVA_PLUGIN;
      case "android_resources":
        return Kind.ANDROID_RESOURCES;
      case "cc_library":
        return Kind.CC_LIBRARY;
      case "cc_binary":
        return Kind.CC_BINARY;
      case "cc_test":
        return Kind.CC_TEST;
      case "cc_inc_library":
        return Kind.CC_INC_LIBRARY;
      case "cc_toolchain":
        return Kind.CC_TOOLCHAIN;
      case "java_wrap_cc":
        return Kind.JAVA_WRAP_CC;
      default:
      {
        if (base.getProvider(AndroidSdkProvider.class) != null) {
          return RuleIdeInfo.Kind.ANDROID_SDK;
        } else {
          return RuleIdeInfo.Kind.UNRECOGNIZED;
        }
      }
    }
  }
}