diff --git a/.bazelrc.remote b/.bazelrc.remote
new file mode 100644
index 00000000000..f45d7a6fd2f
--- /dev/null
+++ b/.bazelrc.remote
@@ -0,0 +1,7 @@
+build --bes_results_url=https://app.buildbuddy.io/invocation/
+build --bes_backend=grpcs://cloud.buildbuddy.io
+# build --remote_cache=grpcs://cloud.buildbuddy.io
+
+# build --remote_download_minimal
+# build --remote_retries=0
+# build --remote_timeout=10
diff --git a/.bazelversion b/.bazelversion
new file mode 100644
index 00000000000..09b254e90c6
--- /dev/null
+++ b/.bazelversion
@@ -0,0 +1 @@
+6.0.0
diff --git a/.github/workflows/continuous-integration-workflow.yml b/.github/workflows/continuous-integration-workflow.yml
new file mode 100644
index 00000000000..b7ea78e2a21
--- /dev/null
+++ b/.github/workflows/continuous-integration-workflow.yml
@@ -0,0 +1,28 @@
+name: Run all tests
+on: [push]
+jobs:
+  build:
+    name: test with ${{ matrix.ij_product }}
+    runs-on: ubuntu-20.04
+    continue-on-error: ${{ matrix.experimental }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ij_product: ['intellij-2022.1', 'intellij-2022.2', 'intellij-2022.3']
+        experimental: [false]
+    steps:
+      - uses: actions/checkout@v2
+      - name: bazel cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.bazel-repository-cache
+          key: ${{ github.ref }}
+          restore-keys: refs/heads/master
+      - name: run bazel
+        continue-on-error: ${{ matrix.experimental }}
+        run: >
+          bazel --bazelrc=.bazelrc.remote test //:ijwb_ce_tests
+          --repository_cache=~/.bazel-repository-cache
+          --define=ij_product=${{ matrix.ij_product }}
+          --keep_going
+          --test_output=errors
diff --git a/WORKSPACE b/WORKSPACE
index af1686b012a..4f6db321c24 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -641,3 +641,29 @@ jvm_maven_import_external(
     licenses = ["notice"],  # Apache 2.0
     server_urls = ["https://repo1.maven.org/maven2"],
 )
+
+bazel_version = "31082327bdb64b7bf52dd55ae18d29e920e61025"
+
+bazel_repo_sha256 = "e8e1ac4bcab303f8f99c9b14ad3afbd059b84c516b7e76f6d9b89b8d5175594f"
+
+http_archive(
+    name = "bazel",
+    sha256 = bazel_repo_sha256,
+    strip_prefix = "bazel-" + bazel_version,
+    url = "https://github.com/bazelbuild/bazel/archive/%s.zip" % bazel_version,
+)
+
+http_archive(
+    name = "io_buildbuddy_buildbuddy_toolchain",
+    sha256 = "9055a3e6f45773cd61931eba7b7cf35d6477ab6ad8fb2f18bf9815271fc682fe",
+    strip_prefix = "buildbuddy-toolchain-52aa5d2cc6c9ba7ee4063de35987be7d1b75f8e2",
+    urls = ["https://github.com/buildbuddy-io/buildbuddy-toolchain/archive/52aa5d2cc6c9ba7ee4063de35987be7d1b75f8e2.tar.gz"],
+)
+
+load("@io_buildbuddy_buildbuddy_toolchain//:deps.bzl", "buildbuddy_deps")
+
+buildbuddy_deps()
+
+load("@io_buildbuddy_buildbuddy_toolchain//:rules.bzl", "buildbuddy")
+
+buildbuddy(name = "buildbuddy_toolchain")
diff --git a/aspect/fast_build_info.bzl b/aspect/fast_build_info.bzl
index db99e951c32..3dcba6fd2d0 100644
--- a/aspect/fast_build_info.bzl
+++ b/aspect/fast_build_info.bzl
@@ -23,6 +23,7 @@ def _fast_build_info_impl(target, ctx):
         "workspace_name": ctx.workspace_name,
         "label": stringify_label(target.label),
         "dependencies": [stringify_label(t.label) for t in dep_targets],
+        "build_file_path": ctx.build_file_path,
     }
 
     write_output = False
@@ -43,6 +44,9 @@ def _fast_build_info_impl(target, ctx):
     elif java_common.JavaToolchainInfo != platform_common.ToolchainInfo and \
          java_common.JavaToolchainInfo in target:
         toolchain = target[java_common.JavaToolchainInfo]
+    elif hasattr(ctx.rule.attr, "java_compile_toolchain") and ctx.rule.attr.java_compile_toolchain and \
+         java_common.JavaToolchainInfo in ctx.rule.attr.java_compile_toolchain:
+        toolchain = ctx.rule.attr.java_compile_toolchain[java_common.JavaToolchainInfo]
     else:
         toolchain = None
     if toolchain:
@@ -53,11 +57,17 @@ def _fast_build_info_impl(target, ctx):
         bootclasspath_jars = []
         if hasattr(toolchain, "bootclasspath"):
             bootclasspath_jars = [artifact_location(f) for f in toolchain.bootclasspath.to_list()]
+        java_runtime = struct()
+        if hasattr(toolchain, "java_runtime"):
+            java_runtime = struct_omit_none(
+                java_executable_exec_path = toolchain.java_runtime.java_executable_exec_path,
+            )
         info["java_toolchain_info"] = struct_omit_none(
             javac_jars = javac_jars,
             bootclasspath_jars = bootclasspath_jars,
             source_version = toolchain.source_version,
             target_version = toolchain.target_version,
+            java_runtime = java_runtime,
         )
     if JavaInfo in target:
         write_output = True
@@ -92,6 +102,13 @@ def _fast_build_info_impl(target, ctx):
         )
         info["android_info"] = android_info
 
+    if ProtoInfo in target:
+        write_output = True
+        proto_info = {
+            "sources": sources_from_target(ctx),
+        }
+        info["proto_info"] = struct_omit_none(**proto_info)
+
     if write_output:
         output_file = ctx.actions.declare_file(target.label.name + ".ide-fast-build-info.txt")
         ctx.actions.write(output_file, struct_omit_none(**info).to_proto())
diff --git a/aspect/intellij_info_impl.bzl b/aspect/intellij_info_impl.bzl
index 39b8e601178..43d6019273c 100644
--- a/aspect/intellij_info_impl.bzl
+++ b/aspect/intellij_info_impl.bzl
@@ -156,13 +156,8 @@ def library_artifact(java_output, rule_kind = None):
         return None
     src_jars = get_source_jars(java_output)
 
-    if rule_kind != None and rule_kind.startswith("scala"):
-        interface_jar = None
-    else:
-        interface_jar = artifact_location(java_output.ijar)
-
     return struct_omit_none(
-        interface_jar = interface_jar,
+        interface_jar = None,
         jar = artifact_location(java_output.class_jar),
         source_jar = artifact_location(src_jars[0]) if src_jars else None,
         source_jars = [artifact_location(f) for f in src_jars],
@@ -328,6 +323,24 @@ def _do_starlark_string_expansion(ctx, name, strings, extra_targets = []):
     return strings
 
 ##### Builders for individual parts of the aspect output
+def collect_proto_info(target, ctx, semantics, ide_info, ide_info_file, output_groups):
+    if not ProtoInfo in target:
+        return False
+
+    proto_info = target[ProtoInfo]
+    proto_output = depset([proto_info.direct_descriptor_set])
+
+    ide_info["proto_ide_info"] = struct_omit_none(
+        sources = sources_from_target(ctx),
+        source_root = proto_info.proto_source_root,
+        strip_import_prefix = ctx.rule.attr.strip_import_prefix,
+        import_prefix = ctx.rule.attr.import_prefix,
+    )
+
+    update_sync_output_groups(output_groups, "intellij-info-proto", depset([ide_info_file]))
+    update_sync_output_groups(output_groups, "intellij-compile-proto", proto_output)
+    update_sync_output_groups(output_groups, "intellij-resolve-proto", proto_output)
+    return True
 
 def collect_py_info(target, ctx, semantics, ide_info, ide_info_file, output_groups):
     """Updates Python-specific output groups, returns false if not a Python target."""
@@ -1123,6 +1136,7 @@ def intellij_info_aspect_impl(target, ctx, semantics):
     ide_info["test_info"] = build_test_info(ctx)
 
     handled = False
+    handled = collect_proto_info(target, ctx, semantics, ide_info, ide_info_file, output_groups) or handled
     handled = collect_py_info(target, ctx, semantics, ide_info, ide_info_file, output_groups) or handled
     handled = collect_cpp_info(target, ctx, semantics, ide_info, ide_info_file, output_groups) or handled
     handled = collect_c_toolchain_info(target, ctx, semantics, ide_info, ide_info_file, output_groups) or handled
diff --git a/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/BUILD b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/BUILD
new file mode 100644
index 00000000000..0b932ae4122
--- /dev/null
+++ b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/BUILD
@@ -0,0 +1,41 @@
+licenses(["notice"])  # Apache 2.0
+
+load(
+    "//aspect/testing/rules:intellij_aspect_test_fixture.bzl",
+    "intellij_aspect_test_fixture",
+)
+
+proto_library(
+    name = "a_proto",
+    srcs = ["a.proto"],
+    import_prefix = "test",
+    strip_import_prefix = "/" + package_name(),
+)
+
+proto_library(
+    name = "b_proto",
+    srcs = ["b.proto"],
+    deps = [":a_proto"],
+)
+
+intellij_aspect_test_fixture(
+    name = "fixture",
+    deps = [":b_proto"],
+)
+
+java_test(
+    name = "ProtoLibraryTest",
+    srcs = ["ProtoLibraryTest.java"],
+    data = [
+        ":fixture",
+    ],
+    deps = [
+        "//aspect/testing:BazelIntellijAspectTest",
+        "//aspect/testing:guava",
+        "//aspect/testing/rules:IntellijAspectTest",
+        "//aspect/testing/rules:intellij_aspect_test_fixture_java_proto",
+        "//intellij_platform_sdk:test_libs",
+        "//proto:intellij_ide_info_java_proto",
+        "@junit//jar",
+    ],
+)
diff --git a/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/ProtoLibraryTest.java b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/ProtoLibraryTest.java
new file mode 100644
index 00000000000..22984a8518b
--- /dev/null
+++ b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/ProtoLibraryTest.java
@@ -0,0 +1,72 @@
+/*
+ * 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.idea.blaze.aspect.proto.pl;
+
+import com.google.devtools.intellij.IntellijAspectTestFixtureOuterClass.IntellijAspectTestFixture;
+import com.google.devtools.intellij.ideinfo.IntellijIdeInfo.TargetIdeInfo;
+import com.google.idea.blaze.BazelIntellijAspectTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static com.google.common.truth.Truth.assertThat;
+
+/** Tests for proto_library. */
+@RunWith(JUnit4.class)
+public class ProtoLibraryTest extends BazelIntellijAspectTest {
+
+  @Test
+  public void testProtoLibrary() throws Exception {
+    IntellijAspectTestFixture fixture = loadTestFixture(":fixture");
+
+    TargetIdeInfo aProto = findTarget(fixture, ":a_proto");
+    assertThat(aProto).isNotNull();
+    assertThat(aProto.hasProtoIdeInfo()).isTrue();
+    assertThat(relativePathsForArtifacts(aProto.getProtoIdeInfo().getSourcesList()))
+        .containsExactly(testRelative("a.proto"));
+    assertThat(aProto.getProtoIdeInfo().getSourceRoot())
+        .isEqualTo(
+            "bazel-out/darwin-fastbuild/bin/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/_virtual_imports/a_proto");
+    assertThat(aProto.getProtoIdeInfo().getImportPrefix()).isEqualTo("test");
+    assertThat(aProto.getProtoIdeInfo().getStripImportPrefix())
+        .isEqualTo("/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl");
+
+    TargetIdeInfo bProto = findTarget(fixture, ":b_proto");
+    assertThat(bProto).isNotNull();
+    assertThat(bProto.hasProtoIdeInfo()).isTrue();
+    assertThat(relativePathsForArtifacts(bProto.getProtoIdeInfo().getSourcesList()))
+        .containsExactly(testRelative("b.proto"));
+    assertThat(bProto.getProtoIdeInfo().getSourceRoot()).isEqualTo(".");
+    assertThat(bProto.getProtoIdeInfo().getImportPrefix()).isEmpty();
+    assertThat(bProto.getProtoIdeInfo().getStripImportPrefix()).isEmpty();
+    assertThat(dependenciesForTarget(bProto)).contains(dep(aProto));
+
+    assertThat(getOutputGroupFiles(fixture, "intellij-info-proto"))
+        .containsExactly(
+            testRelative(intellijInfoFileName(aProto.getKey())),
+            testRelative(intellijInfoFileName(bProto.getKey())));
+
+    assertThat(getOutputGroupFiles(fixture, "intellij-compile-proto"))
+        .containsExactly(
+            testRelative("a_proto-descriptor-set.proto.bin"),
+            testRelative("b_proto-descriptor-set.proto.bin"));
+
+    assertThat(getOutputGroupFiles(fixture, "intellij-resolve-proto"))
+        .containsExactly(
+            testRelative("a_proto-descriptor-set.proto.bin"),
+            testRelative("b_proto-descriptor-set.proto.bin"));
+  }
+}
diff --git a/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/a.proto b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/a.proto
new file mode 100644
index 00000000000..972e1e98051
--- /dev/null
+++ b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/a.proto
@@ -0,0 +1,3 @@
+syntax = "proto2";
+package a;
+message A {}
diff --git a/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/b.proto b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/b.proto
new file mode 100644
index 00000000000..43e87d26fa4
--- /dev/null
+++ b/aspect/testing/tests/src/com/google/idea/blaze/aspect/proto/pl/b.proto
@@ -0,0 +1,4 @@
+syntax = "proto3";
+import "test/a.proto";
+package b;
+message B {a.A a = 1;}
diff --git a/base/src/META-INF/blaze-base.xml b/base/src/META-INF/blaze-base.xml
index fa9a7799bfb..ededbd3c010 100644
--- a/base/src/META-INF/blaze-base.xml
+++ b/base/src/META-INF/blaze-base.xml
@@ -226,6 +226,8 @@
                         serviceImplementation="com.google.idea.blaze.base.projectview.ProjectViewStorageManagerImpl"/>
     <projectService serviceInterface="com.google.idea.blaze.base.projectview.ProjectViewManager"
                     serviceImplementation="com.google.idea.blaze.base.projectview.ProjectViewManagerImpl"/>
+    <projectService serviceInterface="com.google.idea.blaze.base.prelude.PreludeManager"
+                    serviceImplementation="com.google.idea.blaze.base.prelude.PreludeManagerImpl"/>
     <applicationService serviceInterface="com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface"
                         serviceImplementation="com.google.idea.blaze.base.sync.aspects.BlazeIdeInterfaceAspectsImpl"/>
     <projectService serviceInterface="com.google.idea.blaze.base.toolwindow.TasksToolWindowService"
diff --git a/base/src/com/google/idea/blaze/base/actions/BuildFileUtils.java b/base/src/com/google/idea/blaze/base/actions/BuildFileUtils.java
index c9d8d9c27b2..9cf043e6e21 100644
--- a/base/src/com/google/idea/blaze/base/actions/BuildFileUtils.java
+++ b/base/src/com/google/idea/blaze/base/actions/BuildFileUtils.java
@@ -25,11 +25,13 @@
 import com.google.idea.blaze.base.lang.buildfile.search.BlazePackage;
 import com.google.idea.blaze.base.model.BlazeProjectData;
 import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.model.primitives.LanguageClass;
 import com.google.idea.blaze.base.model.primitives.WorkspacePath;
 import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
 import com.google.idea.blaze.base.targetmaps.SourceToTargetMap;
 import com.google.idea.common.experiments.BoolExperiment;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.io.FileUtilRt;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFileSystemItem;
@@ -37,6 +39,7 @@
 import java.io.File;
 import java.util.Arrays;
 import java.util.Set;
+import java.util.stream.Stream;
 import javax.annotation.Nullable;
 
 /** BUILD-file utility methods used by actions. */
@@ -74,9 +77,11 @@ static PsiElement findBuildTarget(Project project, BlazePackage parentPackage, F
     if (packagePath == null) {
       return null;
     }
+    final Stream<Label> targetLabels = SourceToTargetMap.getInstance(project)
+        .getTargetsToBuildForSourceFile(file).stream();
+
     Label label =
-        SourceToTargetMap.getInstance(project).getTargetsToBuildForSourceFile(file).stream()
-            .filter(l -> l.blazePackage().equals(packagePath))
+        filterCRelatedLabelsWhichBelongToOtherPackages(file,packagePath, targetLabels)
             .findFirst()
             .orElse(null);
     if (label == null) {
@@ -98,6 +103,28 @@ static PsiElement findBuildTarget(Project project, BlazePackage parentPackage, F
     return null;
   }
 
+  private static Stream<Label> filterCRelatedLabelsWhichBelongToOtherPackages(File file,
+      WorkspacePath packagePath, Stream<Label> targetLabels) {
+    /*
+      More info:
+      https://bazelbuild.slack.com/archives/CM8JQCANN/p1566481600003600
+      Filter was deliberately added to fix an issue with C++ headers.
+      The original bug was that opening the BUILD file for foo/bar.h caused it to open baz/qux/BUILD
+      because there’s a cc_library target in baz/qux that includes foo/bar.h in its headers.
+      The source-to-target look up queries the index for the target during the last sync which compiled the source file.
+      In this case, it was the cc_library target in baz/qux.
+      So the fix was to ensure that the BUILD file is always for the parent package (foo/bar).
+
+      This is limited to C only since this logic messes up supporting aggregate targets
+      https://github.com/bazelbuild/intellij/issues/475
+     */
+    LanguageClass fileLanguage = LanguageClass.fromExtension(
+        FileUtilRt.getExtension(file.getName()).toLowerCase());
+    return (fileLanguage == LanguageClass.C) ?
+            targetLabels.filter(l -> l.blazePackage().equals(packagePath)) :
+            targetLabels;
+  }
+
   /**
    * Returns the label of a macro with name prefixing the target name of a given label with a '_' or
    * '-' delimiter.
diff --git a/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java b/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
index be55ff87bb3..ec781fd1b91 100644
--- a/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
+++ b/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
@@ -190,6 +190,7 @@ default ImmutableList<FileNameMatcher> buildLanguageFileTypeMatchers() {
     possibleBuildFileNames().forEach(s -> list.add(new ExactFileNameMatcher(s)));
     possibleWorkspaceFileNames().forEach(s -> list.add(new ExactFileNameMatcher(s)));
     possibleFileExtensions().forEach(s -> list.add(new ExtensionFileNameMatcher(s)));
+    list.add(new ExactFileNameMatcher("prelude_bazel"));
     return list.build();
   }
 
diff --git a/base/src/com/google/idea/blaze/base/command/info/BazelBinaryNotFoundNotification.java b/base/src/com/google/idea/blaze/base/command/info/BazelBinaryNotFoundNotification.java
new file mode 100644
index 00000000000..9383820973e
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/command/info/BazelBinaryNotFoundNotification.java
@@ -0,0 +1,40 @@
+package com.google.idea.blaze.base.command.info;
+
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationAction;
+import com.intellij.notification.NotificationDisplayType;
+import com.intellij.notification.NotificationGroup;
+import com.intellij.notification.NotificationType;
+import com.intellij.notification.Notifications;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.options.ShowSettingsUtil;
+import org.jetbrains.annotations.NotNull;
+
+class BazelBinaryNotFoundNotification {
+  private static final NotificationGroup notificationGroup =
+      new NotificationGroup("Bazel binary not found", NotificationDisplayType.BALLOON, true);
+
+  static void show(String binaryPath) {
+    Notification notification = new Notification(
+        notificationGroup.getDisplayId(),
+        "Bazel binary not found",
+        "Cannot execute command '" + binaryPath
+            + "'. Please configure correct bazel binary location and try again.",
+        NotificationType.ERROR
+    );
+
+    notification.addAction(new NotificationAction("Bazel Settings") {
+      public void update(@NotNull AnActionEvent e) {
+        e.getPresentation().setEnabledAndVisible(e.getProject() != null);
+      }
+
+      public void actionPerformed(@NotNull AnActionEvent e, @NotNull Notification notification) {
+        if (e.getProject() == null) {
+          return;
+        }
+        ShowSettingsUtil.getInstance().showSettingsDialog(e.getProject(), "Bazel Settings");
+      }
+    });
+    Notifications.Bus.notify(notification);
+  }
+}
diff --git a/base/src/com/google/idea/blaze/base/command/info/BlazeInfoRunnerImpl.java b/base/src/com/google/idea/blaze/base/command/info/BlazeInfoRunnerImpl.java
index 3dbb8a0c29b..7bd740cfc5b 100644
--- a/base/src/com/google/idea/blaze/base/command/info/BlazeInfoRunnerImpl.java
+++ b/base/src/com/google/idea/blaze/base/command/info/BlazeInfoRunnerImpl.java
@@ -84,6 +84,13 @@ private static ByteArrayOutputStream runBlazeInfo(
       List<String> blazeFlags,
       BlazeContext context)
       throws BlazeInfoException {
+
+    boolean isExecutable = ExternalTask.builder().args("which", binaryPath).build().run() == 0;
+    if (!isExecutable) {
+      BazelBinaryNotFoundNotification.show(binaryPath);
+      throw new BlazeInfoException(-1, binaryPath + " cannot be executed");
+    }
+
     BlazeCommand.Builder builder = BlazeCommand.builder(binaryPath, BlazeCommandName.INFO);
     if (key != null) {
       builder.addBlazeFlags(key);
diff --git a/base/src/com/google/idea/blaze/base/ideinfo/ProtoIdeInfo.java b/base/src/com/google/idea/blaze/base/ideinfo/ProtoIdeInfo.java
new file mode 100644
index 00000000000..c39b9851137
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/ideinfo/ProtoIdeInfo.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.ideinfo;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.intellij.ideinfo.IntellijIdeInfo;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+/** Ide info specific to proto rules. */
+public final class ProtoIdeInfo implements ProtoWrapper<IntellijIdeInfo.ProtoIdeInfo> {
+  private final ImmutableList<ArtifactLocation> sources;
+  @Nullable private final String sourceRoot;
+  @Nullable private final String importPrefix;
+  @Nullable private final String stripImportPrefix;
+
+  private ProtoIdeInfo(
+      ImmutableList<ArtifactLocation> sources,
+      @Nullable String sourceRoot,
+      @Nullable String importPrefix,
+      @Nullable String stripImportPrefix) {
+    this.sources = sources;
+    this.sourceRoot = sourceRoot;
+    this.importPrefix = importPrefix;
+    this.stripImportPrefix = stripImportPrefix;
+  }
+
+  static ProtoIdeInfo fromProto(IntellijIdeInfo.ProtoIdeInfo proto) {
+    return new ProtoIdeInfo(
+        ProtoWrapper.map(proto.getSourcesList(), ArtifactLocation::fromProto),
+        Strings.emptyToNull(proto.getSourceRoot()),
+        Strings.emptyToNull(proto.getImportPrefix()),
+        Strings.emptyToNull(proto.getStripImportPrefix()));
+  }
+
+  @Override
+  public IntellijIdeInfo.ProtoIdeInfo toProto() {
+    IntellijIdeInfo.ProtoIdeInfo.Builder builder =
+        IntellijIdeInfo.ProtoIdeInfo.newBuilder().addAllSources(ProtoWrapper.mapToProtos(sources));
+    ProtoWrapper.setIfNotNull(builder::setSourceRoot, sourceRoot);
+    ProtoWrapper.setIfNotNull(builder::setImportPrefix, importPrefix);
+    ProtoWrapper.setIfNotNull(builder::setStripImportPrefix, stripImportPrefix);
+    return builder.build();
+  }
+
+  public ImmutableList<ArtifactLocation> getSources() {
+    return sources;
+  }
+
+  @Nullable
+  public String getSourceRoot() {
+    return sourceRoot;
+  }
+
+  @Nullable
+  public String getImportPrefix() {
+    return importPrefix;
+  }
+
+  @Nullable
+  public String getStripImportPrefix() {
+    return stripImportPrefix;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /** Builder for proto info */
+  public static class Builder {
+    @Nullable String sourceRoot;
+    @Nullable String importPrefix;
+    @Nullable String stripImportPrefix;
+
+    public Builder setSourceRoot(String sourceRoot) {
+      this.sourceRoot = sourceRoot;
+      return this;
+    }
+
+    public Builder setImportPrefix(String importPrefix) {
+      this.importPrefix = importPrefix;
+      return this;
+    }
+
+    public Builder setStripImportPrefix(String stripImportPrefix) {
+      this.stripImportPrefix = stripImportPrefix;
+      return this;
+    }
+
+    public ProtoIdeInfo build() {
+      return new ProtoIdeInfo(ImmutableList.of(), sourceRoot, importPrefix, stripImportPrefix);
+    }
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ProtoIdeInfo that = (ProtoIdeInfo) o;
+    return Objects.equals(sources, that.sources)
+        && Objects.equals(sourceRoot, that.sourceRoot)
+        && Objects.equals(importPrefix, that.importPrefix)
+        && Objects.equals(stripImportPrefix, that.stripImportPrefix);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(sources, sourceRoot, importPrefix, stripImportPrefix);
+  }
+}
diff --git a/base/src/com/google/idea/blaze/base/ideinfo/TargetIdeInfo.java b/base/src/com/google/idea/blaze/base/ideinfo/TargetIdeInfo.java
index 4972f8d49d2..12a597fbfed 100644
--- a/base/src/com/google/idea/blaze/base/ideinfo/TargetIdeInfo.java
+++ b/base/src/com/google/idea/blaze/base/ideinfo/TargetIdeInfo.java
@@ -54,6 +54,7 @@ public final class TargetIdeInfo implements ProtoWrapper<IntellijIdeInfo.TargetI
   @Nullable private final TestIdeInfo testIdeInfo;
   @Nullable private final JavaToolchainIdeInfo javaToolchainIdeInfo;
   @Nullable private final KotlinToolchainIdeInfo kotlinToolchainIdeInfo;
+  @Nullable private final ProtoIdeInfo protoIdeInfo;
   @Nullable private final Long syncTimeMillis;
 
   private TargetIdeInfo(
@@ -78,6 +79,7 @@ private TargetIdeInfo(
       @Nullable TestIdeInfo testIdeInfo,
       @Nullable JavaToolchainIdeInfo javaToolchainIdeInfo,
       @Nullable KotlinToolchainIdeInfo kotlinToolchainIdeInfo,
+      @Nullable ProtoIdeInfo protoIdeInfo,
       @Nullable Long syncTimeMillis) {
     this.key = key;
     this.kind = kind;
@@ -100,6 +102,7 @@ private TargetIdeInfo(
     this.testIdeInfo = testIdeInfo;
     this.javaToolchainIdeInfo = javaToolchainIdeInfo;
     this.kotlinToolchainIdeInfo = kotlinToolchainIdeInfo;
+    this.protoIdeInfo = protoIdeInfo;
     this.syncTimeMillis = syncTimeMillis;
   }
 
@@ -155,6 +158,11 @@ public static TargetIdeInfo fromProto(
       dartIdeInfo = DartIdeInfo.fromProto(proto.getDartIdeInfo());
       sourcesBuilder.addAll(dartIdeInfo.getSources());
     }
+    ProtoIdeInfo protoIdeInfo = null;
+    if (proto.hasProtoIdeInfo()) {
+      protoIdeInfo = ProtoIdeInfo.fromProto(proto.getProtoIdeInfo());
+      sourcesBuilder.addAll(protoIdeInfo.getSources());
+    }
     Long syncTime =
         syncTimeOverride != null
             ? Long.valueOf(syncTimeOverride.toEpochMilli())
@@ -195,6 +203,7 @@ public static TargetIdeInfo fromProto(
         proto.hasKtToolchainIdeInfo()
             ? KotlinToolchainIdeInfo.fromProto(proto.getKtToolchainIdeInfo())
             : null,
+        protoIdeInfo,
         syncTime);
   }
 
@@ -223,6 +232,7 @@ public IntellijIdeInfo.TargetIdeInfo toProto() {
     ProtoWrapper.unwrapAndSetIfNotNull(builder::setTestInfo, testIdeInfo);
     ProtoWrapper.unwrapAndSetIfNotNull(builder::setJavaToolchainIdeInfo, javaToolchainIdeInfo);
     ProtoWrapper.unwrapAndSetIfNotNull(builder::setKtToolchainIdeInfo, kotlinToolchainIdeInfo);
+    ProtoWrapper.unwrapAndSetIfNotNull(builder::setProtoIdeInfo, protoIdeInfo);
     ProtoWrapper.setIfNotNull(builder::setSyncTimeMillis, syncTimeMillis);
     return builder.build();
   }
@@ -258,6 +268,7 @@ public TargetIdeInfo updateSyncTime(Instant syncTime) {
         testIdeInfo,
         javaToolchainIdeInfo,
         kotlinToolchainIdeInfo,
+        protoIdeInfo,
         syncTimeMillis);
   }
 
@@ -361,6 +372,11 @@ public KotlinToolchainIdeInfo getKotlinToolchainIdeInfo() {
     return kotlinToolchainIdeInfo;
   }
 
+  @Nullable
+  public ProtoIdeInfo getProtoIdeInfo() {
+    return protoIdeInfo;
+  }
+
   @Nullable
   public Instant getSyncTime() {
     return syncTimeMillis != null ? Instant.ofEpochMilli(syncTimeMillis) : null;
@@ -419,6 +435,7 @@ public static class Builder {
     private TestIdeInfo testIdeInfo;
     private JavaToolchainIdeInfo javaToolchainIdeInfo;
     private KotlinToolchainIdeInfo kotlinToolchainIdeInfo;
+    private ProtoIdeInfo protoIdeInfo;
     private Long syncTime;
 
     @CanIgnoreReturnValue
@@ -549,6 +566,12 @@ public Builder setKotlinToolchainIdeInfo(KotlinToolchainIdeInfo.Builder toolchai
       return this;
     }
 
+    @CanIgnoreReturnValue
+    public Builder setProtoInfo(ProtoIdeInfo.Builder builder) {
+      protoIdeInfo = builder.build();
+      return this;
+    }
+
     @CanIgnoreReturnValue
     public Builder addTag(String s) {
       this.tags.add(s);
@@ -608,6 +631,7 @@ public TargetIdeInfo build() {
           testIdeInfo,
           javaToolchainIdeInfo,
           kotlinToolchainIdeInfo,
+          protoIdeInfo,
           syncTime);
     }
   }
@@ -642,6 +666,7 @@ public boolean equals(Object o) {
         && Objects.equals(testIdeInfo, that.testIdeInfo)
         && Objects.equals(javaToolchainIdeInfo, that.javaToolchainIdeInfo)
         && Objects.equals(kotlinToolchainIdeInfo, that.kotlinToolchainIdeInfo)
+        && Objects.equals(protoIdeInfo, that.protoIdeInfo)
         && Objects.equals(syncTimeMillis, that.syncTimeMillis);
   }
 
@@ -669,6 +694,7 @@ public int hashCode() {
         testIdeInfo,
         javaToolchainIdeInfo,
         kotlinToolchainIdeInfo,
+        protoIdeInfo,
         syncTimeMillis);
   }
 }
diff --git a/base/src/com/google/idea/blaze/base/lang/buildfile/search/ResolveUtil.java b/base/src/com/google/idea/blaze/base/lang/buildfile/search/ResolveUtil.java
index 62f6ec57026..39d78659d86 100644
--- a/base/src/com/google/idea/blaze/base/lang/buildfile/search/ResolveUtil.java
+++ b/base/src/com/google/idea/blaze/base/lang/buildfile/search/ResolveUtil.java
@@ -25,6 +25,7 @@
 import com.google.idea.blaze.base.lang.buildfile.psi.Parameter;
 import com.google.idea.blaze.base.lang.buildfile.psi.StatementList;
 import com.google.idea.blaze.base.lang.buildfile.psi.TargetExpression;
+import com.google.idea.blaze.base.prelude.PreludeManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiFileSystemItem;
@@ -43,7 +44,15 @@ public static void searchInScope(PsiElement originalElement, Processor<BuildElem
     while (!(element instanceof PsiFileSystemItem)) {
       PsiElement parent = element.getParent();
       if (parent instanceof BuildFile) {
-        if (!((BuildFile) parent).searchSymbolsInScope(processor, topLevelScope ? element : null)) {
+        BuildFile parentBuildFile = (BuildFile) parent;
+        PsiElement stopAtElement = topLevelScope ? element : null;
+        PreludeManager preludeManager = PreludeManager.getInstance(originalElement.getProject());
+        // if it is build file we should start looking from topmost level
+        if (parentBuildFile.getBlazeFileType() == BuildFile.BlazeFileType.BuildPackage
+            && !preludeManager.searchSymbolsInScope(processor, stopAtElement)) {
+          return;
+        }
+        if (!parentBuildFile.searchSymbolsInScope(processor, stopAtElement)) {
           return;
         }
       } else if (parent instanceof FunctionStatement) {
diff --git a/base/src/com/google/idea/blaze/base/prelude/PreludeFile.java b/base/src/com/google/idea/blaze/base/prelude/PreludeFile.java
new file mode 100644
index 00000000000..157da8f6e99
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/prelude/PreludeFile.java
@@ -0,0 +1,23 @@
+package com.google.idea.blaze.base.prelude;
+
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildElement;
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.util.Processor;
+
+import javax.annotation.Nullable;
+
+final public class PreludeFile {
+
+  private final BuildFile delegate;
+
+  PreludeFile(BuildFile delegate) {
+    this.delegate = delegate;
+  }
+
+  public boolean searchSymbolsInScope(Processor<BuildElement> processor,
+      @Nullable PsiElement stopAtElement) {
+    return delegate.searchSymbolsInScope(processor, stopAtElement);
+  }
+
+}
diff --git a/base/src/com/google/idea/blaze/base/prelude/PreludeManager.java b/base/src/com/google/idea/blaze/base/prelude/PreludeManager.java
new file mode 100644
index 00000000000..e392d7cfe86
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/prelude/PreludeManager.java
@@ -0,0 +1,20 @@
+package com.google.idea.blaze.base.prelude;
+
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildElement;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.util.Processor;
+
+import javax.annotation.Nullable;
+
+public abstract class PreludeManager {
+
+  public static PreludeManager getInstance(Project project) {
+    return ServiceManager.getService(project, PreludeManager.class);
+  }
+
+  public abstract boolean searchSymbolsInScope(Processor<BuildElement> processor,
+      @Nullable PsiElement stopAtElement);
+
+}
diff --git a/base/src/com/google/idea/blaze/base/prelude/PreludeManagerImpl.java b/base/src/com/google/idea/blaze/base/prelude/PreludeManagerImpl.java
new file mode 100644
index 00000000000..90e3cfc4e9e
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/prelude/PreludeManagerImpl.java
@@ -0,0 +1,90 @@
+package com.google.idea.blaze.base.prelude;
+
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildElement;
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildFile;
+import com.google.idea.blaze.base.lang.buildfile.references.BuildReferenceManager;
+import com.google.idea.blaze.base.model.primitives.WorkspacePath;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.vfs.newvfs.BulkFileListener;
+import com.intellij.openapi.vfs.newvfs.events.VFileEvent;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFileSystemItem;
+import com.intellij.util.ObjectUtils;
+import com.intellij.util.Processor;
+import com.intellij.util.messages.MessageBusConnection;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+final public class PreludeManagerImpl extends PreludeManager {
+
+  private static final String PRELUDE_FILE_NAME = "prelude_bazel";
+
+  private final Project project;
+  private PreludeFile preludeFile = null;
+  private final AtomicBoolean initialized = new AtomicBoolean(false);
+
+  public PreludeManagerImpl(Project project) {
+    this.project = project;
+  }
+
+  @Override
+  public boolean searchSymbolsInScope(Processor<BuildElement> processor,
+      @Nullable PsiElement stopAtElement) {
+    if (!initialized.getAndSet(true)) {
+      reloadPreludeFile();
+      subscribeToFileUpdates();
+    }
+
+    if (preludeFile != null) {
+      return preludeFile.searchSymbolsInScope(processor, stopAtElement);
+    } else {
+      return true;
+    }
+  }
+
+  private void subscribeToFileUpdates() {
+    MessageBusConnection connection = project.getMessageBus().connect();
+    connection.subscribe(VirtualFileManager.VFS_CHANGES, new BulkFileListener() {
+      @Override
+      public void after(@NotNull List<? extends VFileEvent> events) {
+        boolean preludeUpdated = events.stream().anyMatch(f -> {
+          VirtualFile updatedFile = f.getFile();
+          boolean isPreludeFile =
+              updatedFile != null && updatedFile.getName().endsWith(PRELUDE_FILE_NAME);
+          return isPreludeFile && f.isFromSave() || f.isFromRefresh();
+        });
+
+        if (preludeUpdated) {
+          reloadPreludeFile();
+        }
+      }
+    });
+  }
+
+  private void reloadPreludeFile() {
+    WorkspaceRoot projectRoot = WorkspaceRoot.fromProjectSafe(project);
+    if (projectRoot == null) {
+      return;
+    }
+
+    File preludeFileOnDisk = projectRoot
+        .fileForPath(new WorkspacePath("tools/build_rules/" + PRELUDE_FILE_NAME));
+    if (preludeFileOnDisk == null) {
+      return;
+    }
+
+    PsiFileSystemItem preludeFile = BuildReferenceManager.getInstance(project)
+        .resolveFile(preludeFileOnDisk);
+    if (preludeFile != null) {
+      this.preludeFile = new PreludeFile(ObjectUtils.tryCast(preludeFile, BuildFile.class));
+    }
+  }
+
+}
diff --git a/base/src/com/google/idea/blaze/base/projectview/section/sections/AutomaticallyDeriveTargetsSection.java b/base/src/com/google/idea/blaze/base/projectview/section/sections/AutomaticallyDeriveTargetsSection.java
index 7a1a80c1ad9..7d5983b2a44 100644
--- a/base/src/com/google/idea/blaze/base/projectview/section/sections/AutomaticallyDeriveTargetsSection.java
+++ b/base/src/com/google/idea/blaze/base/projectview/section/sections/AutomaticallyDeriveTargetsSection.java
@@ -85,7 +85,7 @@ public ProjectView addProjectViewDefaultValue(
                   TextBlock.of(
                       "# Automatically includes all relevant targets under the 'directories'"
                           + " above")))
-          .add(ScalarSection.builder(KEY).set(true))
+          .add(ScalarSection.builder(KEY).set(false))
           .add(TextBlockSection.of(TextBlock.newLine()))
           .build();
     }
diff --git a/base/src/com/google/idea/blaze/base/run/producers/BlazeBuildFileRunConfigurationProducer.java b/base/src/com/google/idea/blaze/base/run/producers/BlazeBuildFileRunConfigurationProducer.java
index d13586c3f47..6eada191608 100644
--- a/base/src/com/google/idea/blaze/base/run/producers/BlazeBuildFileRunConfigurationProducer.java
+++ b/base/src/com/google/idea/blaze/base/run/producers/BlazeBuildFileRunConfigurationProducer.java
@@ -149,6 +149,12 @@ static BuildTarget getBuildTarget(@Nullable FuncallExpression rule) {
     if (ruleType == null || label == null) {
       return null;
     }
+
+    if (ruleType.equals("specs2_unit_test") || ruleType.equals("specs2_ite2e_test")
+        || ruleType.equals("specs2_mixed_test")) {
+      label = Label.create(label + "_test_runner");
+    }
+
     return new BuildTarget(rule, Kind.guessRuleType(ruleType), label);
   }
 
diff --git a/base/src/com/google/idea/blaze/base/scope/output/StatusOutput.java b/base/src/com/google/idea/blaze/base/scope/output/StatusOutput.java
index 579b998fd10..0004f1182ed 100644
--- a/base/src/com/google/idea/blaze/base/scope/output/StatusOutput.java
+++ b/base/src/com/google/idea/blaze/base/scope/output/StatusOutput.java
@@ -36,4 +36,4 @@ public StatusOutput(@NotNull String status) {
   public String getStatus() {
     return status;
   }
-}
+}
\ No newline at end of file
diff --git a/base/src/com/google/idea/blaze/base/sync/libraries/LibraryModifier.java b/base/src/com/google/idea/blaze/base/sync/libraries/LibraryModifier.java
index 1597cb7dd40..7a04fe97db5 100644
--- a/base/src/com/google/idea/blaze/base/sync/libraries/LibraryModifier.java
+++ b/base/src/com/google/idea/blaze/base/sync/libraries/LibraryModifier.java
@@ -20,18 +20,29 @@
 import com.google.idea.blaze.base.model.LibraryFilesProvider;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.progress.DumbProgressIndicator;
 import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.Library.ModifiableModel;
+import com.intellij.openapi.roots.libraries.ui.RootDetector;
+import com.intellij.openapi.roots.ui.configuration.LibrarySourceRootDetectorUtil;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
+import com.intellij.openapi.vfs.JarFileSystem;
+import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.StandardFileSystems;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.util.io.URLUtil;
 import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
 
-/** Modifies {@link Library} content in {@link Library.ModifiableModel}. */
+/**
+ * Modifies {@link Library} content in {@link Library.ModifiableModel}.
+ */
 public class LibraryModifier {
+
   private static final Logger logger = Logger.getInstance(LibraryModifier.class);
   private final LibraryFilesProvider libraryFilesProvider;
   private final Library.ModifiableModel modifiableModel;
@@ -46,7 +57,9 @@ public Library.ModifiableModel getModifiableModel() {
     return modifiableModel;
   }
 
-  /** Writes the library content to its {@link Library.ModifiableModel}. */
+  /**
+   * Writes the library content to its {@link Library.ModifiableModel}.
+   */
   public void updateModifiableModel(BlazeProjectData blazeProjectData) {
     removeAllContents();
     for (File classFile : libraryFilesProvider.getClassFiles(blazeProjectData)) {
@@ -54,8 +67,42 @@ public void updateModifiableModel(BlazeProjectData blazeProjectData) {
     }
 
     for (File sourceFile : libraryFilesProvider.getSourceFiles(blazeProjectData)) {
-      addRoot(sourceFile, OrderRootType.SOURCES);
+      if (sourceFile != null && sourceFile.exists()) {
+        detectSourceRoots(sourceFile).forEach(root -> {
+          modifiableModel.addRoot(root, OrderRootType.SOURCES);
+        });
+      }
+    }
+  }
+
+  private List<VirtualFile> detectSourceRoots(File sourceJar) {
+    List<VirtualFile> roots = new ArrayList<>();
+
+    VirtualFile srcFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(sourceJar);
+    if (srcFile == null) {
+      return roots;
+    }
+
+    VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(srcFile);
+    if (jarRoot == null) {
+      return roots;
     }
+
+    List<RootDetector> detectors = LibrarySourceRootDetectorUtil.JAVA_SOURCE_ROOT_DETECTOR
+        .getExtensionList();
+
+    return detect(detectors, jarRoot);
+  }
+
+  private List<VirtualFile> detect(List<RootDetector> detectors, VirtualFile jarRoot) {
+    List<VirtualFile> roots = new ArrayList<>();
+
+    for (RootDetector detector : detectors) {
+      DumbProgressIndicator progressIndicator = new DumbProgressIndicator();
+      roots.addAll(detector.detectRoots(jarRoot, progressIndicator));
+    }
+
+    return roots;
   }
 
   private ModifiableModel getLibraryModifiableModel(
diff --git a/base/src/com/google/idea/blaze/base/toolwindow/ConsoleView.java b/base/src/com/google/idea/blaze/base/toolwindow/ConsoleView.java
index 13ad5d56d10..c9e79b02dcd 100644
--- a/base/src/com/google/idea/blaze/base/toolwindow/ConsoleView.java
+++ b/base/src/com/google/idea/blaze/base/toolwindow/ConsoleView.java
@@ -69,10 +69,10 @@ final class ConsoleView implements Disposable {
   private static long consoleIdCounter;
 
   private static final Class<?>[] IGNORED_CONSOLE_ACTION_TYPES = {
-    PreviousOccurenceToolbarAction.class, // common_typos_disable
-    NextOccurenceToolbarAction.class,
-    ClearConsoleAction.class,
-    PrintAction.class
+      PreviousOccurenceToolbarAction.class, // common_typos_disable
+      NextOccurenceToolbarAction.class,
+      ClearConsoleAction.class,
+      PrintAction.class
   };
 
   private final Project project;
@@ -359,4 +359,4 @@ public JComponent getContent() {
     }
     return content;
   }
-}
+}
\ No newline at end of file
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/lang/buildfile/completion/PreludeBasedCompletionTest.java b/base/tests/integrationtests/com/google/idea/blaze/base/lang/buildfile/completion/PreludeBasedCompletionTest.java
new file mode 100644
index 00000000000..c933844487d
--- /dev/null
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/lang/buildfile/completion/PreludeBasedCompletionTest.java
@@ -0,0 +1,85 @@
+package com.google.idea.blaze.base.lang.buildfile.completion;
+
+import com.google.idea.blaze.base.lang.buildfile.BuildFileIntegrationTestCase;
+import com.google.idea.blaze.base.lang.buildfile.psi.BuildFile;
+import com.google.idea.blaze.base.lang.buildfile.psi.FuncallExpression;
+import com.google.idea.blaze.base.lang.buildfile.psi.FunctionStatement;
+import com.google.idea.blaze.base.model.primitives.WorkspacePath;
+import com.intellij.openapi.editor.Editor;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(JUnit4.class)
+public class PreludeBasedCompletionTest extends BuildFileIntegrationTestCase {
+
+  private BuildFile buildDefs;
+
+  @Before
+  public void setup() {
+    buildDefs = createBuildFile(new WorkspacePath("java/com/google/build_defs.bzl"),
+        "def function(name, deps)\n def test_function(arg)");
+    createBuildFile(new WorkspacePath("java/com/google/build_rules.bzl"), "test_rule = rule()");
+    workspace.createFile(new WorkspacePath("tools/build_rules/prelude_bazel"),
+        "load(",
+        "\"//java/com/google:build_defs.bzl\",",
+        "\"function\"",
+        ")",
+        "load(",
+        "\"//java/com/google:build_rules.bzl\",",
+        "\"test_rule\"",
+        ")");
+  }
+
+  @Test
+  public void testLoadedFunctionsCompletion() throws Throwable {
+    BuildFile file = createBuildFile(new WorkspacePath("BUILD"), "funct");
+
+    Editor editor = editorTest.openFileInEditor(file.getVirtualFile());
+    editorTest.setCaretPosition(editor, 0, 4);
+
+    String[] completionItems = editorTest.getCompletionItemsAsStrings();
+    assertThat(completionItems).asList().containsExactly("function");
+  }
+
+  @Test
+  public void testLoadedRuleCompletion() throws Throwable {
+    BuildFile file = createBuildFile(new WorkspacePath("BUILD"), "test_");
+
+    Editor editor = editorTest.openFileInEditor(file.getVirtualFile());
+    editorTest.setCaretPosition(editor, 0, 4);
+
+    String[] completionItems = editorTest.getCompletionItemsAsStrings();
+    assertThat(completionItems).asList().containsExactly("test_rule");
+  }
+
+  @Test
+  public void testFunctionCompletionWhenFunctionIsNotLoaded() throws Throwable {
+    BuildFile file = createBuildFile(new WorkspacePath("BUILD"), "test_func");
+
+    Editor editor = editorTest.openFileInEditor(file.getVirtualFile());
+    editorTest.setCaretPosition(editor, 0, 9);
+
+    String[] completionItems = editorTest.getCompletionItemsAsStrings();
+    assertThat(completionItems).asList().isEmpty();
+  }
+
+  @Test
+  public void testReferenceToLoadedFunction() {
+    BuildFile file = createBuildFile(new WorkspacePath("BUILD"), "function()");
+
+    FunctionStatement function = buildDefs.firstChildOfClass(FunctionStatement.class);
+    FuncallExpression funcall = file.firstChildOfClass(FuncallExpression.class);
+
+    assertThat(funcall.getReferencedElement()).isEqualTo(function);
+  }
+
+  @Override
+  protected boolean isLightTestCase() {
+    return false;
+  }
+
+}
diff --git a/build_defs/stamp_plugin_xml.py b/build_defs/stamp_plugin_xml.py
index 55d190f30c3..5a460f64fc5 100755
--- a/build_defs/stamp_plugin_xml.py
+++ b/build_defs/stamp_plugin_xml.py
@@ -221,13 +221,7 @@ def main():
     idea_version_element = dom.createElement("idea-version")
     new_elements.append(idea_version_element)
 
-    if is_eap:
-      # IU211.6693.111 >> since_build=211.6693 and until_build=211.6693.*
-      build_version = _strip_build_number(
-          _strip_product_code(api_version))
-    else:
-      # IU211.6693.111 >> since_build=211 and until_build=211.*
-      build_version = _parse_major_version(api_version)
+    build_version = _parse_major_version(_strip_product_code(api_version))
 
     if args.stamp_since_build:
       if build_version in since_build_numbers.keys():
diff --git a/ijwb/src/META-INF/java-contents.xml b/ijwb/src/META-INF/java-contents.xml
index 6337348cd8a..7a03ab6addb 100644
--- a/ijwb/src/META-INF/java-contents.xml
+++ b/ijwb/src/META-INF/java-contents.xml
@@ -19,5 +19,6 @@
     <JavaSyncAugmenter implementation="com.google.idea.blaze.ijwb.android.BlazeAndroidLiteJavaSyncAugmenter"/>
     <SyncDataDeserializer implementation="com.google.idea.blaze.java.sync.model.BlazeJavaSyncData$Deserializer"/>
     <SyncDataDeserializer implementation="com.google.idea.blaze.java.sync.jdeps.JdepsState$Deserializer"/>
+    <FastBuildCompilerExtensionPoint implementation="com.google.idea.blaze.java.fastbuild.FastBuildJavaCompilerExtensionPoint"/>
   </extensions>
 </idea-plugin>
diff --git a/java/BUILD b/java/BUILD
index 126b47b75c6..8feb3f96321 100644
--- a/java/BUILD
+++ b/java/BUILD
@@ -114,24 +114,6 @@ intellij_plugin(
 intellij_unit_test_suite(
     name = "unit_tests",
     srcs = glob(["tests/unittests/**/*.java"]),
-    # Used for the compiler tests
-    data = [
-        ":auto_value_lib_deploy.jar",
-        ":auto_value_plugin_lib_deploy.jar",
-        ":fast_build_javac",
-        ":guava_lib_deploy.jar",
-        ":truth_lib_deploy.jar",
-    ],
-    jvm_flags = [
-        "-Dauto_value.jar=$(location :auto_value_lib_deploy.jar)",
-        "-Dauto_value_plugin.jar=$(location :auto_value_plugin_lib_deploy.jar)",
-        "-Dfast_build_javac.jar=$(location :fast_build_javac)",
-        "-Dguava.jar=$(location :guava_lib_deploy.jar)",
-        "-Dtruth.jar=$(location :truth_lib_deploy.jar)",
-        "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
-        "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
-        "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
-    ],
     test_package_root = "com.google.idea.blaze.java",
     deps = [
         ":java",
@@ -180,6 +162,24 @@ java_binary(
 intellij_integration_test_suite(
     name = "integration_tests",
     srcs = glob(["tests/integrationtests/**/*.java"]),
+    # Used for the compiler tests
+    data = [
+        ":auto_value_lib_deploy.jar",
+        ":auto_value_plugin_lib_deploy.jar",
+        ":fast_build_javac",
+        ":guava_lib_deploy.jar",
+        ":truth_lib_deploy.jar",
+    ],
+    jvm_flags = [
+        "-Dauto_value.jar=$(location :auto_value_lib_deploy.jar)",
+        "-Dauto_value_plugin.jar=$(location :auto_value_plugin_lib_deploy.jar)",
+        "-Dfast_build_javac.jar=$(location :fast_build_javac)",
+        "-Dguava.jar=$(location :guava_lib_deploy.jar)",
+        "-Dtruth.jar=$(location :truth_lib_deploy.jar)",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+    ],
     required_plugins = "com.google.idea.blaze.java",
     test_package_root = "com.google.idea.blaze.java",
     runtime_deps = [
diff --git a/java/src/META-INF/java-contents.xml b/java/src/META-INF/java-contents.xml
index 0433e124c47..61638fde66b 100644
--- a/java/src/META-INF/java-contents.xml
+++ b/java/src/META-INF/java-contents.xml
@@ -170,5 +170,7 @@
                     interface="com.google.idea.blaze.java.run.hotswap.HotSwapCommandBuilder"/>
     <extensionPoint qualifiedName="com.google.idea.blaze.blazeJavaDebuggingSetupHandler"
                     interface="com.google.idea.blaze.java.run.BlazeJavaDebuggingSetupHandler"/>
+    <extensionPoint qualifiedName="com.google.idea.blaze.FastBuildCompilerExtensionPoint"
+      interface="com.google.idea.blaze.java.fastbuild.FastBuildCompilerExtensionPoint"/>
   </extensionPoints>
 </idea-plugin>
diff --git a/java/src/com/google/idea/blaze/java/JavaBlazeRules.java b/java/src/com/google/idea/blaze/java/JavaBlazeRules.java
index 1641ce835fe..aef2831af84 100644
--- a/java/src/com/google/idea/blaze/java/JavaBlazeRules.java
+++ b/java/src/com/google/idea/blaze/java/JavaBlazeRules.java
@@ -33,6 +33,7 @@ public final class JavaBlazeRules implements Kind.Provider {
   public enum RuleTypes {
     JAVA_LIBRARY("java_library", LanguageClass.JAVA, RuleType.LIBRARY),
     JAVA_TEST("java_test", LanguageClass.JAVA, RuleType.TEST),
+    SCALA_JUNIT_TEST("scala_junit_test", LanguageClass.SCALA, RuleType.TEST),
     JAVA_BINARY("java_binary", LanguageClass.JAVA, RuleType.BINARY),
     JAVA_IMPORT("java_import", LanguageClass.JAVA, RuleType.UNKNOWN),
     JAVA_TOOLCHAIN("java_toolchain", LanguageClass.JAVA, RuleType.UNKNOWN),
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildAspectStrategy.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildAspectStrategy.java
index 7c241b28875..13c711ba2f6 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildAspectStrategy.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildAspectStrategy.java
@@ -69,7 +69,7 @@ final String getAspectOutputGroup() {
   final void addAspectAndOutputGroups(
       BlazeCommand.Builder blazeCommandBuilder, String... additionalOutputGroups) {
     String outputGroups =
-        Stream.concat(Arrays.stream(additionalOutputGroups), Stream.of(OUTPUT_GROUP))
+        Stream.concat(Arrays.stream(additionalOutputGroups).map(s -> "+"+s), Stream.of("+" + OUTPUT_GROUP))
             .collect(joining(","));
     blazeCommandBuilder
         .addBlazeFlags(getAspectFlags())
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildBlazeData.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildBlazeData.java
index 93f998a5714..22e491068f2 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildBlazeData.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildBlazeData.java
@@ -59,6 +59,10 @@ public abstract class FastBuildBlazeData {
 
   public abstract Optional<JavaToolchainInfo> javaToolchainInfo();
 
+  public abstract Optional<ProtoInfo> protoInfo();
+
+  public abstract String buildFilePath();
+
   public static Builder builder() {
     return new AutoValue_FastBuildBlazeData.Builder()
         .setDependencies(ImmutableList.of())
@@ -82,7 +86,11 @@ public abstract static class Builder {
 
     public abstract Builder setJavaToolchainInfo(JavaToolchainInfo javaToolchainInfo);
 
+    public abstract Builder setProtoInfo(ProtoInfo protoInfo);
+
     public abstract FastBuildBlazeData build();
+
+    public abstract Builder setBuildFilePath(String label);
   }
 
   static FastBuildBlazeData fromProto(FastBuildInfo.FastBuildBlazeData proto) {
@@ -93,7 +101,8 @@ static FastBuildBlazeData fromProto(FastBuildInfo.FastBuildBlazeData proto) {
             .setWorkspaceName(proto.getWorkspaceName())
             .setDependencies(
                 proto.getDependenciesList().stream().map(Label::fromProto).collect(toSet()))
-            .setData(convertDataToMap(proto.getDataList()));
+            .setData(convertDataToMap(proto.getDataList()))
+            .setBuildFilePath(proto.getBuildFilePath());
     if (proto.hasAndroidInfo()) {
       builder.setAndroidInfo(AndroidInfo.fromProto(proto.getAndroidInfo()));
     }
@@ -103,6 +112,9 @@ static FastBuildBlazeData fromProto(FastBuildInfo.FastBuildBlazeData proto) {
     if (proto.hasJavaToolchainInfo()) {
       builder.setJavaToolchainInfo(JavaToolchainInfo.fromProto(proto.getJavaToolchainInfo()));
     }
+    if (proto.hasProtoInfo()) {
+      builder.setProtoInfo(ProtoInfo.fromProto(proto.getProtoInfo()));
+    }
     return builder.build();
   }
 
@@ -215,7 +227,7 @@ public abstract Builder setAnnotationProcessorClasspath(
 
   /** Data about a java_toolchain rule. */
   @AutoValue
-  abstract static class JavaToolchainInfo {
+  public abstract static class JavaToolchainInfo {
     public abstract ImmutableList<ArtifactLocation> javacJars();
 
     public abstract ImmutableList<ArtifactLocation> bootClasspathJars();
@@ -224,13 +236,16 @@ abstract static class JavaToolchainInfo {
 
     public abstract String targetVersion();
 
+    public abstract Optional<JavaRuntime> javaRuntime();
+
     static JavaToolchainInfo create(
         ImmutableList<ArtifactLocation> javacJars,
         ImmutableList<ArtifactLocation> bootJars,
         String sourceVersion,
-        String targetVersion) {
+        String targetVersion,
+        JavaRuntime javaRuntime) {
       return new AutoValue_FastBuildBlazeData_JavaToolchainInfo(
-          javacJars, bootJars, sourceVersion, targetVersion);
+          javacJars, bootJars, sourceVersion, targetVersion, Optional.ofNullable(javaRuntime));
     }
 
     static JavaToolchainInfo fromProto(FastBuildInfo.JavaToolchainInfo javaToolchainInfo) {
@@ -242,11 +257,49 @@ static JavaToolchainInfo fromProto(FastBuildInfo.JavaToolchainInfo javaToolchain
           javaToolchainInfo.getBootclasspathJarsList().stream()
               .map(ArtifactLocation::fromProto)
               .collect(toImmutableList());
+      JavaRuntime javaRuntime = null;
+      if (javaToolchainInfo.hasJavaRuntime()) {
+        javaRuntime = JavaRuntime.fromProto(javaToolchainInfo.getJavaRuntime());
+      }
+
       return create(
           javacJars,
           bootJars,
           javaToolchainInfo.getSourceVersion(),
-          javaToolchainInfo.getTargetVersion());
+          javaToolchainInfo.getTargetVersion(), javaRuntime);
+    }
+  }
+  /** Data about a java_runtime rule. */
+  @AutoValue
+  public abstract static class JavaRuntime {
+    public abstract String javaExecutableExecPath();
+
+    static JavaRuntime create(
+        String javaExecutableExecPath) {
+      return new AutoValue_FastBuildBlazeData_JavaRuntime(javaExecutableExecPath);
+    }
+
+    static JavaRuntime fromProto(FastBuildInfo.JavaRuntimeInfo javaRuntime) {
+      return create(javaRuntime.getJavaExecutableExecPath());
+    }
+  }
+
+  /**
+   * Data about a proto_library rule.
+   */
+  @AutoValue
+  public abstract static class ProtoInfo {
+
+    public abstract Set<ArtifactLocation> sources();
+
+    static ProtoInfo create(Set<ArtifactLocation> sources) {
+      return new AutoValue_FastBuildBlazeData_ProtoInfo(sources);
+    }
+
+    static ProtoInfo fromProto(FastBuildInfo.ProtoInfo proto) {
+      Set<ArtifactLocation> sources =
+          proto.getSourcesList().stream().map(ArtifactLocation::fromProto).collect(toSet());
+      return create(sources);
     }
   }
 }
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesService.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesService.java
index 4a456821a3d..4700ac0d0dc 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesService.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesService.java
@@ -31,6 +31,7 @@
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
 import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
 import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
 import com.google.idea.blaze.java.fastbuild.FastBuildState.BuildOutput;
@@ -157,8 +158,12 @@ synchronized ChangedSources getAndResetChangedSources(Label label) {
     switch (data.state) {
       case WAITING_FOR_SOURCES:
       case COLLECTING:
+        if (!data.changedNonCompilableSources.isEmpty()) {
+          return ChangedSources.fullCompile();
+        }
         ChangedSources result = ChangedSources.withChangedSources(data.changedSources);
         data.changedSources = new HashSet<>();
+        data.changedNonCompilableSources = new HashSet<>();
         return result;
       case TOO_MANY_CHANGES:
         // Don't reset anything in data; it'll get reset when a new build starts and newBuild() is
@@ -177,7 +182,7 @@ synchronized void addFilesFromFailedCompilation(Label label, Set<File> files) {
     // TODO(b/145386688): Access should be guarded by enclosing instance
     // 'com.google.idea.blaze.java.fastbuild.FastBuildChangedFilesService' of 'data', which is not
     // accessible in this scope; instead found: 'this'
-    data.updateChangedSources(files);
+    data.updateChangedSources(files, ImmutableSet.of());
   }
 
   private synchronized void subscribe() {
@@ -231,25 +236,39 @@ public void after(List<? extends VFileEvent> events) {
                     return null;
                   }
 
-                  ImmutableSet<File> changedFiles =
+                  ImmutableSet<String> changedFilePaths =
                       events.stream()
                           // We don't want to compile deleted files
                           .filter(event -> !(event instanceof VFileDeleteEvent))
                           .map(VFileEvent::getPath)
-                          .filter(f -> f.endsWith(".java"))
+                          .collect(toImmutableSet());
+
+                  ImmutableSet<File> changedCompilableFiles =
+                      changedFilePaths.stream()
+                          .filter(f -> f.endsWith(".java") || f.endsWith(".scala"))
+                          .map(File::new)
+                          .collect(toImmutableSet());
+
+                  ImmutableSet<File> changedNonCompilableFiles =
+                      changedFilePaths.stream()
+                          .filter(f -> f.endsWith(".proto") || f.endsWith(".bazel"))
                           .map(File::new)
                           .collect(toImmutableSet());
 
-                  if (changedFiles.isEmpty()) {
-                    return null;
-                  }
                   // TODO(b/145386688): Access should be guarded by enclosing instance
                   // 'com.google.idea.blaze.java.fastbuild.FastBuildChangedFilesService' of 'data',
                   // which is not accessible in this scope
-                  labelData.values().forEach(data -> data.updateChangedSources(changedFiles));
+
+                  if (!changedCompilableFiles.isEmpty() || !changedNonCompilableFiles.isEmpty()) {
+                    labelData.values()
+                        .forEach(data -> data.updateChangedSources(changedCompilableFiles,
+                            changedNonCompilableFiles));
+                  }
+
                   return null;
                 }
               });
+
       Futures.addCallback(submit, new LogErrorCallback(), executor);
     }
 
@@ -285,31 +304,50 @@ private ImmutableSet<File> getSourceFiles(Label label, Map<Label, FastBuildBlaze
   private ImmutableSet<File> getSourceFilesRecursively(
       Label label, Map<Label, FastBuildBlazeData> blazeData) {
     FastBuildBlazeData data = blazeData.get(label);
-    if (data == null || !data.javaInfo().isPresent()) {
+    if (data == null || (!data.javaInfo().isPresent() && !data.protoInfo().isPresent())) {
       return ImmutableSet.of();
     }
     Set<File> sourceFiles = new HashSet<>();
     ArtifactLocationDecoder decoder =
         projectDataManager.getBlazeProjectData().getArtifactLocationDecoder();
+
+    String workSpaceRootPath = WorkspaceRoot.fromProject(project).directory().getAbsolutePath();
+
     SuccessorsFunction<FastBuildBlazeData> graph = l -> getDependencies(blazeData, l);
     Traverser.forGraph(graph)
         .breadthFirst(data)
         .forEach(
             d -> {
-              d.javaInfo().get().sources().stream()
-                  .map(decoder::decode)
-                  .filter(f -> f.getName().endsWith(".java"))
-                  .forEach(sourceFiles::add);
+              if (d.javaInfo().isPresent()) {
+                d.javaInfo().get().sources().stream()
+                    .map(decoder::decode)
+                    .filter(f -> f.getName().endsWith(".java") || f.getName().endsWith(".scala"))
+                    .forEach(sourceFiles::add);
+                addBuildFile(sourceFiles, workSpaceRootPath, d.buildFilePath());
+              } else if (d.protoInfo().isPresent()) {
+                d.protoInfo().get().sources().stream()
+                    .map(decoder::decode)
+                    .forEach(sourceFiles::add);
+                addBuildFile(sourceFiles, workSpaceRootPath, d.buildFilePath());
+              }
             });
     return ImmutableSet.copyOf(sourceFiles);
   }
 
+  private static void addBuildFile(Set<File> sourceFiles, String workSpaceRootPath,
+      String buildFilePath) {
+    File buildFile = new File(workSpaceRootPath, buildFilePath);
+    if (buildFile.exists()) {
+      sourceFiles.add(buildFile);
+    }
+  }
+
   private static ImmutableSet<FastBuildBlazeData> getDependencies(
       Map<Label, FastBuildBlazeData> map, FastBuildBlazeData labelData) {
     return labelData.dependencies().stream()
         .map(map::get)
         .filter(Objects::nonNull)
-        .filter(data -> data.javaInfo().isPresent())
+        .filter(data -> (data.javaInfo().isPresent() || data.protoInfo().isPresent()))
         .collect(toImmutableSet());
   }
 
@@ -320,9 +358,11 @@ private enum State {
   }
 
   private static class Data {
+
     // State only moves forward, never backward (WAITING_FOR_SOURCES->COLLECTING->TOO_MANY_CHANGES)
     State state = State.WAITING_FOR_SOURCES;
     Set<File> changedSources = new HashSet<>();
+    Set<File> changedNonCompilableSources = new HashSet<>();
     ImmutableSet<File> sources = null;
 
     static Data waitingForSources() {
@@ -334,22 +374,30 @@ void setSources(ImmutableSet<File> sources) {
       checkState(state.equals(State.WAITING_FOR_SOURCES));
       state = State.COLLECTING;
       this.sources = sources;
-      ImmutableSet<File> allModifiedFiles = ImmutableSet.copyOf(changedSources);
+      ImmutableSet<File> allCompilableModifiedFiles = ImmutableSet.copyOf(changedSources);
+      ImmutableSet<File> allNonCompilableModifiedFiles = ImmutableSet.copyOf(
+          changedNonCompilableSources);
       changedSources.clear();
-      updateChangedSources(allModifiedFiles);
+      changedNonCompilableSources.clear();
+      // Any files modified, before the sources were set, get checked against the sources once they're set
+      updateChangedSources(allCompilableModifiedFiles, allNonCompilableModifiedFiles);
     }
 
     @GuardedBy("FastBuildChangedFilesService.this")
-    void updateChangedSources(Set<File> changedFiles) {
+    void updateChangedSources(Set<File> changedCompilableFiles,
+        Set<File> changedNonCompilableFiles) {
 
-      if (state.equals(State.TOO_MANY_CHANGES)) {
+      // If a single non-compilable file is detected, a full compile is needed, no need to check files further
+      if (state.equals(State.TOO_MANY_CHANGES) || !changedNonCompilableSources.isEmpty()) {
         return;
       }
 
       if (state.equals(State.WAITING_FOR_SOURCES)) {
-        changedSources.addAll(changedFiles);
+        changedSources.addAll(changedCompilableFiles);
+        changedNonCompilableSources.addAll(changedNonCompilableFiles);
       } else if (state.equals(State.COLLECTING)) {
-        changedSources.addAll(intersection(changedFiles, sources));
+        changedSources.addAll(intersection(changedCompilableFiles, sources));
+        changedNonCompilableSources.addAll(intersection(changedNonCompilableFiles, sources));
       }
       if (changedSources.size() > MAX_FILES_TO_COLLECT) {
         changedSources = ImmutableSet.of();
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompiler.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompiler.java
index 06d5c38c86a..4ce50e928dc 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompiler.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompiler.java
@@ -19,21 +19,22 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.idea.blaze.base.scope.BlazeContext;
+
 import java.io.File;
 import java.util.Collection;
 import java.util.List;
 
-interface FastBuildCompiler {
+public interface FastBuildCompiler {
 
   void compile(BlazeContext context, CompileInstructions instructions) throws FastBuildException;
 
   @AutoValue
   abstract class CompileInstructions {
-    abstract ImmutableSet<File> filesToCompile();
+    public abstract ImmutableSet<File> filesToCompile();
 
-    abstract ImmutableList<File> classpath();
+    public abstract ImmutableList<File> classpath();
 
-    abstract File outputDirectory();
+    public abstract File outputDirectory();
 
     abstract ImmutableSet<String> annotationProcessorClassNames();
 
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerExtensionPoint.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerExtensionPoint.java
new file mode 100644
index 00000000000..bc281c26b63
--- /dev/null
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerExtensionPoint.java
@@ -0,0 +1,19 @@
+package com.google.idea.blaze.java.fastbuild;
+
+import com.intellij.openapi.extensions.ExtensionPointName;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+
+public interface FastBuildCompilerExtensionPoint {
+
+    ExtensionPointName<FastBuildCompilerExtensionPoint> EP_NAME =
+            ExtensionPointName.create("com.google.idea.blaze.FastBuildCompilerExtensionPoint");
+
+    FastBuildCompiler getCompiler(List<File> javacJars, List<File> bootClassPathJars, String sourceVersion, String targetVersion)
+        throws FastBuildException;
+
+    boolean canCreateCompilerFor(Set<File> filesToCompile);
+
+}
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactory.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactory.java
index ebc8d86f81c..d8fb818e130 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactory.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactory.java
@@ -18,7 +18,10 @@
 import com.google.idea.blaze.base.model.primitives.Label;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
+
+import java.io.File;
 import java.util.Map;
+import java.util.Set;
 
 interface FastBuildCompilerFactory {
 
@@ -26,6 +29,6 @@ static FastBuildCompilerFactory getInstance(Project project) {
     return ServiceManager.getService(project, FastBuildCompilerFactory.class);
   }
 
-  FastBuildCompiler getCompilerFor(Label label, Map<Label, FastBuildBlazeData> blazeData)
+  FastBuildCompiler getCompilerFor(Label label, Map<Label, FastBuildBlazeData> blazeData, Set<File> filesToCompile)
       throws FastBuildException;
 }
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImpl.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImpl.java
index 2224207268a..0c8363e96d6 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImpl.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImpl.java
@@ -16,16 +16,7 @@
 package com.google.idea.blaze.java.fastbuild;
 
 import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.toList;
 
-import com.google.common.base.Stopwatch;
-import com.google.common.collect.ImmutableList;
-import com.google.common.reflect.Reflection;
-import com.google.idea.blaze.base.logging.EventLoggingService;
-import com.google.idea.blaze.base.logging.EventLoggingService.Command;
-import com.google.idea.blaze.base.logging.NoopEventLoggingService;
 import com.google.idea.blaze.base.model.BlazeProjectData;
 import com.google.idea.blaze.base.model.primitives.Label;
 import com.google.idea.blaze.base.scope.BlazeContext;
@@ -35,73 +26,40 @@
 import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
 import com.google.idea.blaze.common.PrintOutput;
 import com.google.idea.blaze.java.fastbuild.FastBuildBlazeData.JavaToolchainInfo;
-import com.google.idea.blaze.java.fastbuild.FastBuildCompiler.CompileInstructions;
-import com.google.idea.blaze.java.fastbuild.FastBuildJavac.CompilerOutput;
-import com.google.idea.blaze.java.fastbuild.FastBuildJavac.DiagnosticLine;
-import com.google.idea.blaze.java.fastbuild.FastBuildLogDataScope.FastBuildLogOutput;
-import com.intellij.ide.plugins.IdeaPluginDescriptor;
-import com.intellij.ide.plugins.PluginManager;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.serviceContainer.NonInjectable;
 import java.io.File;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Collection;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Supplier;
-import javax.tools.Diagnostic;
-import javax.tools.Diagnostic.Kind;
 
 final class FastBuildCompilerFactoryImpl implements FastBuildCompilerFactory {
 
-  private static final Logger logger = Logger.getInstance(FastBuildCompilerFactoryImpl.class);
-
-  private static final String FAST_BUILD_JAVAC_CLASS =
-      "com.google.idea.blaze.java.fastbuild.FastBuildJavacImpl";
-  private static final Path FAST_BUILD_JAVAC_JAR = Paths.get("lib", "libfast_build_javac.jar");
-
   private final BlazeProjectDataManager projectDataManager;
-  private final Supplier<EventLoggingService> eventLoggerSupplier;
-  private final Supplier<File> fastBuildJavacJarSupplier;
 
   @NonInjectable
   private FastBuildCompilerFactoryImpl(
-      BlazeProjectDataManager projectDataManager,
-      Supplier<EventLoggingService> eventLoggerSupplier,
-      Supplier<File> fastBuildJavacJarSupplier) {
+      BlazeProjectDataManager projectDataManager) {
     this.projectDataManager = projectDataManager;
-    this.eventLoggerSupplier = eventLoggerSupplier;
-    this.fastBuildJavacJarSupplier = fastBuildJavacJarSupplier;
   }
 
   FastBuildCompilerFactoryImpl(Project project) {
     this(
-        BlazeProjectDataManager.getInstance(project),
-        EventLoggingService::getInstance,
-        FastBuildCompilerFactoryImpl::findFastBuildJavacJar);
+        BlazeProjectDataManager.getInstance(project)
+    );
   }
 
   static FastBuildCompilerFactoryImpl createForTest(
-      BlazeProjectDataManager projectDataManager, File fastBuildJavacJar) {
+      BlazeProjectDataManager projectDataManager) {
     return new FastBuildCompilerFactoryImpl(
-        projectDataManager, NoopEventLoggingService::new, () -> fastBuildJavacJar);
+        projectDataManager);
   }
 
   @Override
-  public FastBuildCompiler getCompilerFor(Label label, Map<Label, FastBuildBlazeData> blazeData)
+  public FastBuildCompiler getCompilerFor(Label label, Map<Label, FastBuildBlazeData> blazeData, Set<File> filesToCompile)
       throws FastBuildException {
-
     JavaToolchainInfo javaToolchain = getJavaToolchain(label, blazeData);
 
     BlazeProjectData projectData = projectDataManager.getBlazeProjectData();
@@ -110,15 +68,24 @@ public FastBuildCompiler getCompilerFor(Label label, Map<Label, FastBuildBlazeDa
         projectData.getArtifactLocationDecoder().decodeAll(javaToolchain.javacJars());
     List<File> bootJars =
         projectData.getArtifactLocationDecoder().decodeAll(javaToolchain.bootClasspathJars());
-    Javac javac = createCompiler(javacJars);
-    return new JavacRunner(
-        javac, bootJars, javaToolchain.sourceVersion(), javaToolchain.targetVersion());
+
+    final FastBuildCompilerExtensionPoint fastBuildCompilerExtensionPoint =
+        Arrays.stream(FastBuildCompilerExtensionPoint.EP_NAME.getExtensions())
+        .filter(ep -> ep.canCreateCompilerFor(filesToCompile))
+        .findFirst()
+        .orElseThrow(() -> new RuntimeException("Couldn't find a FastBuildCompiler for needed files " + filesToCompile));
+
+    return fastBuildCompilerExtensionPoint
+        .getCompiler(javacJars, bootJars, javaToolchain.sourceVersion(), javaToolchain.targetVersion());
   }
 
-  private JavaToolchainInfo getJavaToolchain(Label label, Map<Label, FastBuildBlazeData> blazeData)
+  public JavaToolchainInfo getJavaToolchain(Label label, Map<Label, FastBuildBlazeData> blazeData)
       throws FastBuildException {
     FastBuildBlazeData targetData = blazeData.get(label);
     Set<JavaToolchainInfo> javaToolchains = new HashSet<>();
+    if (targetData.javaToolchainInfo().isPresent()) {
+      javaToolchains.add(targetData.javaToolchainInfo().get());
+    }
     for (Label dependency : targetData.dependencies()) {
       FastBuildBlazeData depInfo = blazeData.get(dependency);
       if (depInfo != null && depInfo.javaToolchainInfo().isPresent()) {
@@ -136,247 +103,4 @@ private JavaToolchainInfo getJavaToolchain(Label label, Map<Label, FastBuildBlaz
     return javaToolchains.iterator().next();
   }
 
-  @FunctionalInterface
-  private interface Javac {
-    boolean compile(BlazeContext context, List<String> javacArgs, Collection<File> files)
-        throws FastBuildException;
-  }
-
-  private Javac createCompiler(List<File> javacJars) throws FastBuildException {
-    try {
-      Class<?> javacClass =
-          loadJavacClass(
-              FAST_BUILD_JAVAC_CLASS,
-              ImmutableList.<File>builder()
-                  .addAll(javacJars)
-                  .add(fastBuildJavacJarSupplier.get())
-                  .build());
-
-      Constructor<?> createMethod = javacClass.getConstructor();
-      Object javacInstance = createMethod.newInstance();
-
-      FastBuildJavac javaCompiler =
-          Reflection.newProxy(
-              FastBuildJavac.class, new MatchingMethodInvocationHandler(javacClass, javacInstance));
-      return (context, javacArgs, files) -> {
-        Stopwatch timer = Stopwatch.createStarted();
-        Object[] rawOutput = javaCompiler.compile(javacArgs, files);
-        CompilerOutput output = CompilerOutput.decode(rawOutput);
-        processDiagnostics(context, output);
-        boolean result = output.result;
-        Command command =
-            Command.builder()
-                .setExecutable("javac")
-                .setArguments(javacArgs)
-                .setExitCode(result ? 0 : 1)
-                .setSubcommandName("javac")
-                .setDuration(timer.elapsed())
-                .build();
-        eventLoggerSupplier.get().logCommand(getClass(), command);
-        return result;
-      };
-    } catch (MalformedURLException | ReflectiveOperationException e) {
-      throw new FastBuildIncrementalCompileException(e);
-    }
-  }
-
-  private static File findFastBuildJavacJar() {
-    IdeaPluginDescriptor blazePlugin =
-        PluginManager.getPlugin(
-            PluginManager.getPluginByClassName(FastBuildCompilerFactoryImpl.class.getName()));
-    return Paths.get(blazePlugin.getPath().getAbsolutePath())
-        .resolve(FAST_BUILD_JAVAC_JAR)
-        .toFile();
-  }
-
-  private Class<?> loadJavacClass(String javaCompilerClass, List<File> jars)
-      throws MalformedURLException, ClassNotFoundException {
-    URL[] urls = new URL[jars.size()];
-    for (int i = 0; i < jars.size(); ++i) {
-      urls[i] = jars.get(i).toURI().toURL();
-    }
-    URLClassLoader urlClassLoader = new URLClassLoader(urls, ClassLoader.getPlatformClassLoader());
-    return urlClassLoader.loadClass(javaCompilerClass);
-  }
-
-  private static class JavacRunner implements FastBuildCompiler {
-
-    private final Javac javac;
-    private final List<File> bootClassPathJars;
-    private final String sourceVersion;
-    private final String targetVersion;
-
-    private JavacRunner(
-        Javac javac, List<File> bootClassPathJars, String sourceVersion, String targetVersion) {
-      this.javac = javac;
-      this.bootClassPathJars = bootClassPathJars;
-      this.sourceVersion = sourceVersion;
-      this.targetVersion = targetVersion;
-    }
-
-    @Override
-    public void compile(BlazeContext context, CompileInstructions instructions)
-        throws FastBuildException {
-      ImmutableList.Builder<String> argsBuilder =
-          ImmutableList.<String>builder()
-              .add("-d")
-              .add(instructions.outputDirectory().getPath())
-              .add("-source")
-              .add(sourceVersion)
-              .add("-target")
-              .add(targetVersion)
-              .add("-cp")
-              .add(instructions.classpath().stream().map(File::getPath).collect(joining(":")))
-              .add("-g");
-      if (!bootClassPathJars.isEmpty()) {
-        argsBuilder
-            .add("-bootclasspath")
-            .add(bootClassPathJars.stream().map(File::getPath).collect(joining(":")));
-      }
-      if (instructions.annotationProcessorClassNames().isEmpty()) {
-        // Without this, it will find all the annotation processors in the classpath and run them.
-        // We only want to run them if the BUILD file asked for it.
-        argsBuilder.add("-proc:none");
-      } else {
-        argsBuilder
-            .add("-processor")
-            .add(String.join(",", instructions.annotationProcessorClassNames()));
-        if (!instructions.annotationProcessorClasspath().isEmpty()) {
-          argsBuilder
-              .add("-processorpath")
-              .add(
-                  instructions.annotationProcessorClasspath().stream()
-                      .map(File::getPath)
-                      .collect(joining(":")));
-        }
-      }
-      List<String> args = argsBuilder.build();
-      writeCompilationStartedMessage(context, instructions);
-
-      // don't log the full classpath
-      List<String> trimmedArgs =
-          args.stream()
-              .map(
-                  a ->
-                      StringUtil.shortenTextWithEllipsis(
-                          a, /* maxLength= */ 500, /* suffixLength= */ 0))
-              .collect(toImmutableList());
-      logger.info("Running javac with options: " + trimmedArgs);
-
-      Stopwatch timer = Stopwatch.createStarted();
-      boolean success = javac.compile(context, args, instructions.filesToCompile());
-      timer.stop();
-      writeCompilationFinishedMessage(context, instructions, success, timer);
-      if (!success) {
-        throw new FastBuildIncrementalCompileException();
-      }
-    }
-  }
-
-  private static void writeCompilationStartedMessage(
-      BlazeContext context, CompileInstructions instructions) {
-    if (instructions.annotationProcessorClassNames().isEmpty()) {
-      context.output(
-          new StatusOutput(
-              String.format(
-                  "Running javac on files %s", getSourceFileNames(instructions.filesToCompile()))));
-    } else {
-      context.output(
-          new StatusOutput(
-              String.format(
-                  "Running javac on %s with annotation processors %s",
-                  getSourceFileNames(instructions.filesToCompile()),
-                  getProcessorNames(instructions.annotationProcessorClassNames()))));
-    }
-  }
-
-  private static void writeCompilationFinishedMessage(
-      BlazeContext context, CompileInstructions instructions, boolean success, Stopwatch timer) {
-    context.output(new StatusOutput(String.format("Compilation finished in %s", timer)));
-
-    context.output(FastBuildLogOutput.keyValue("javac_success", Boolean.toString(success)));
-    context.output(
-        FastBuildLogOutput.keyValue(
-            "javac_source_file_count", Integer.toString(instructions.filesToCompile().size())));
-    context.output(
-        FastBuildLogOutput.keyValue(
-            "javac_source_files", instructions.filesToCompile().toString()));
-    context.output(
-        FastBuildLogOutput.keyValue(
-            "javac_annotation_processor_count",
-            Integer.toString(instructions.annotationProcessorClassNames().size())));
-    context.output(
-        FastBuildLogOutput.keyValue(
-            "javac_annotation_processors",
-            instructions.annotationProcessorClassNames().toString()));
-    context.output(FastBuildLogOutput.milliseconds("javac_time_ms", timer));
-  }
-
-  private static List<String> getSourceFileNames(Collection<File> sourceFiles) {
-    return sourceFiles.stream().map(File::getName).collect(toList());
-  }
-
-  private static List<String> getProcessorNames(Collection<String> classNames) {
-    return classNames.stream()
-        .map(
-            className -> {
-              int lastDot = className.lastIndexOf('.');
-              if (lastDot > -1 && lastDot < className.length() - 1) {
-                return className.substring(lastDot + 1);
-              } else {
-                return className;
-              }
-            })
-        .collect(toList());
-  }
-
-  private static class MatchingMethodInvocationHandler implements InvocationHandler {
-
-    private final Class<?> matchingClass;
-    private final Object matchingInstance;
-
-    private MatchingMethodInvocationHandler(Class<?> matchingClass, Object matchingInstance) {
-      this.matchingClass = matchingClass;
-      this.matchingInstance = matchingInstance;
-    }
-
-    @Override
-    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
-      // We have two different copies of matchingClass from different classloaders, so we can't use
-      // method directory. We have to look up the copy in the other classloader.
-      Method otherMethod = matchingClass.getMethod(method.getName(), method.getParameterTypes());
-      return otherMethod.invoke(matchingInstance, objects);
-    }
-  }
-
-  private static void processDiagnostics(BlazeContext context, CompilerOutput output) {
-    output.diagnostics.forEach(d -> processDiagostic(context, d));
-  }
-
-  private static void processDiagostic(BlazeContext context, DiagnosticLine line) {
-    IssueOutput.Builder output = IssueOutput.issue(toCategory(line.kind), line.message);
-    if (line.uri != null) {
-      output.inFile(new File(line.uri));
-    }
-    if (line.lineNumber != Diagnostic.NOPOS) {
-      output.onLine((int) line.lineNumber).inColumn((int) line.columnNumber);
-    }
-    context.output(output.build());
-    context.output(new PrintOutput(line.formattedMessage));
-  }
-
-  private static Category toCategory(Kind kind) {
-    switch (kind) {
-      case ERROR:
-        return Category.ERROR;
-      case MANDATORY_WARNING:
-      case WARNING:
-        return Category.WARNING;
-      case NOTE:
-        return Category.NOTE;
-      case OTHER:
-        return Category.INFORMATION;
-    }
-    throw new AssertionError("Unknown Kind " + kind);
-  }
 }
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildIncrementalCompilerImpl.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildIncrementalCompilerImpl.java
index 6d907da0fc1..883868d54ae 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildIncrementalCompilerImpl.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildIncrementalCompilerImpl.java
@@ -82,7 +82,7 @@ public ListenableFuture<BuildOutput> compile(
                 }
 
                 compilerFactory
-                    .getCompilerFor(label, buildOutput.blazeData())
+                    .getCompilerFor(label, buildOutput.blazeData(), changedSourceInfo.pathsToCompile)
                     .compile(context, instructions);
               } else {
                 context.output(new PrintOutput("No modified files to compile."));
@@ -151,7 +151,7 @@ private void recursivelyAddModifiedJavaSources(
     boolean addedSources = false;
     for (ArtifactLocation sourceArtifact : javaInfo.sources()) {
       File sourceFile = artifactLocationDecoder.decode(sourceArtifact);
-      if (sourceFile.getName().endsWith(".java")
+      if ((sourceFile.getName().endsWith(".java") || sourceFile.getName().endsWith(".scala"))
           && modifiedSinceBuild.contains(sourceFile)
           && sourceFile.exists()) {
         sourceFiles.add(sourceFile);
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildJavaCompilerExtensionPoint.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildJavaCompilerExtensionPoint.java
new file mode 100644
index 00000000000..cd2bf53e771
--- /dev/null
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildJavaCompilerExtensionPoint.java
@@ -0,0 +1,316 @@
+package com.google.idea.blaze.java.fastbuild;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.ImmutableList;
+import com.google.common.reflect.Reflection;
+import com.google.idea.blaze.base.logging.EventLoggingService;
+import com.google.idea.blaze.base.logging.EventLoggingService.Command;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.output.IssueOutput;
+import com.google.idea.blaze.base.scope.output.IssueOutput.Category;
+import com.google.idea.blaze.common.PrintOutput;
+import com.google.idea.blaze.base.scope.output.StatusOutput;
+import com.google.idea.blaze.java.fastbuild.FastBuildCompiler.CompileInstructions;
+import com.google.idea.blaze.java.fastbuild.FastBuildJavac.CompilerOutput;
+import com.google.idea.blaze.java.fastbuild.FastBuildJavac.DiagnosticLine;
+import com.google.idea.blaze.java.fastbuild.FastBuildLogDataScope.FastBuildLogOutput;
+import com.intellij.ide.plugins.IdeaPluginDescriptor;
+import com.intellij.ide.plugins.PluginManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.text.StringUtil;
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Supplier;
+import javax.tools.Diagnostic;
+import javax.tools.Diagnostic.Kind;
+
+public class FastBuildJavaCompilerExtensionPoint implements FastBuildCompilerExtensionPoint {
+
+  //Kept with previous class in case people have configured the logger, can consider removing
+  private static final Logger logger = Logger.getInstance(FastBuildCompilerFactoryImpl.class);
+
+  private static final String FAST_BUILD_JAVAC_CLASS =
+      "com.google.idea.blaze.java.fastbuild.FastBuildJavacImpl";
+  private static final Path FAST_BUILD_JAVAC_JAR = Paths.get("lib", "libfast_build_javac.jar");
+  private final Supplier<EventLoggingService> eventLoggerSupplier;
+  private final Supplier<File> fastBuildJavacJarSupplier;
+
+  public FastBuildJavaCompilerExtensionPoint(Supplier<EventLoggingService> eventLoggerSupplier, Supplier<File> fastBuildJavacJarSupplier) {
+    this.eventLoggerSupplier = eventLoggerSupplier;
+    this.fastBuildJavacJarSupplier = fastBuildJavacJarSupplier;
+  }
+  public FastBuildJavaCompilerExtensionPoint() {
+    this(
+        EventLoggingService::getInstance,
+        FastBuildJavaCompilerExtensionPoint::findFastBuildJavacJar);
+  }
+  public FastBuildCompiler getCompiler(List<File> javacJars, List<File> bootJars, String sourceVersion, String targetVersion)
+      throws FastBuildException {
+    Javac javac = createCompiler(javacJars);
+    return new JavacRunner(
+        javac, bootJars, sourceVersion, targetVersion);
+  }
+
+  @Override
+  public boolean canCreateCompilerFor(Set<File> filesToCompile) {
+    return filesToCompile.stream().allMatch(f -> f.getName().endsWith(".java"));
+  }
+
+  @FunctionalInterface
+  private interface Javac {
+    boolean compile(BlazeContext context, List<String> javacArgs, Collection<File> files)
+        throws FastBuildException;
+  }
+
+  private Javac createCompiler(List<File> javacJars) throws FastBuildException {
+    try {
+      Class<?> javacClass =
+          loadJavacClass(
+              FAST_BUILD_JAVAC_CLASS,
+              ImmutableList.<File>builder()
+                  .addAll(javacJars)
+                  .add(fastBuildJavacJarSupplier.get())
+                  .build());
+
+      Constructor<?> createMethod = javacClass.getConstructor();
+      Object javacInstance = createMethod.newInstance();
+
+      FastBuildJavac javaCompiler =
+          Reflection.newProxy(
+              FastBuildJavac.class, new MatchingMethodInvocationHandler(javacClass, javacInstance));
+      return (context, javacArgs, files) -> {
+        Stopwatch timer = Stopwatch.createStarted();
+        Object[] rawOutput = javaCompiler.compile(javacArgs, files);
+        CompilerOutput output = CompilerOutput.decode(rawOutput);
+        processDiagnostics(context, output);
+        boolean result = output.result;
+        Command command =
+            Command.builder()
+                .setExecutable("javac")
+                .setArguments(javacArgs)
+                .setExitCode(result ? 0 : 1)
+                .setSubcommandName("javac")
+                .setDuration(timer.elapsed())
+                .build();
+        eventLoggerSupplier.get().logCommand(getClass(), command);
+        return result;
+      };
+    } catch (MalformedURLException | ReflectiveOperationException e) {
+      throw new FastBuildIncrementalCompileException(e);
+    }
+  }
+
+  private static File findFastBuildJavacJar() {
+    IdeaPluginDescriptor blazePlugin =
+        PluginManager.getPlugin(
+            PluginManager.getPluginByClassName(FastBuildCompilerFactoryImpl.class.getName()));  //TODO
+    return Paths.get(blazePlugin.getPath().getAbsolutePath())
+        .resolve(FAST_BUILD_JAVAC_JAR)
+        .toFile();
+  }
+
+  private Class<?> loadJavacClass(String javaCompilerClass, List<File> jars)
+      throws MalformedURLException, ClassNotFoundException {
+    URL[] urls = new URL[jars.size()];
+    for (int i = 0; i < jars.size(); ++i) {
+      urls[i] = jars.get(i).toURI().toURL();
+    }
+    URLClassLoader urlClassLoader = new URLClassLoader(urls, ClassLoader.getPlatformClassLoader());
+    return urlClassLoader.loadClass(javaCompilerClass);
+  }
+
+  private static class JavacRunner implements FastBuildCompiler {
+
+    private final Javac javac;
+    private final List<File> bootClassPathJars;
+    private final String sourceVersion;
+    private final String targetVersion;
+
+    private JavacRunner(
+        Javac javac, List<File> bootClassPathJars, String sourceVersion, String targetVersion) {
+      this.javac = javac;
+      this.bootClassPathJars = bootClassPathJars;
+      this.sourceVersion = sourceVersion;
+      this.targetVersion = targetVersion;
+    }
+
+    @Override
+    public void compile(BlazeContext context, CompileInstructions instructions)
+        throws FastBuildException {
+      ImmutableList.Builder<String> argsBuilder =
+          ImmutableList.<String>builder()
+              .add("-d")
+              .add(instructions.outputDirectory().getPath())
+              .add("-source")
+              .add(sourceVersion)
+              .add("-target")
+              .add(targetVersion)
+              .add("-cp")
+              .add(instructions.classpath().stream().map(File::getPath).collect(joining(":")))
+              .add("-g");
+      if (!bootClassPathJars.isEmpty()) {
+        argsBuilder
+            .add("-bootclasspath")
+            .add(bootClassPathJars.stream().map(File::getPath).collect(joining(":")));
+      }
+      if (instructions.annotationProcessorClassNames().isEmpty()) {
+        // Without this, it will find all the annotation processors in the classpath and run them.
+        // We only want to run them if the BUILD file asked for it.
+        argsBuilder.add("-proc:none");
+      } else {
+        argsBuilder
+            .add("-processor")
+            .add(String.join(",", instructions.annotationProcessorClassNames()));
+        if (!instructions.annotationProcessorClasspath().isEmpty()) {
+          argsBuilder
+              .add("-processorpath")
+              .add(
+                  instructions.annotationProcessorClasspath().stream()
+                      .map(File::getPath)
+                      .collect(joining(":")));
+        }
+      }
+      List<String> args = argsBuilder.build();
+      writeCompilationStartedMessage(context, instructions);
+
+      // don't log the full classpath
+      List<String> trimmedArgs =
+          args.stream()
+              .map(
+                  a ->
+                      StringUtil.shortenTextWithEllipsis(
+                          a, /* maxLength= */ 500, /* suffixLength= */ 0))
+              .collect(toImmutableList());
+      logger.info("Running javac with options: " + trimmedArgs);
+
+      Stopwatch timer = Stopwatch.createStarted();
+      boolean success = javac.compile(context, args, instructions.filesToCompile());
+      timer.stop();
+      writeCompilationFinishedMessage(context, instructions, success, timer);
+      if (!success) {
+        throw new FastBuildIncrementalCompileException();
+      }
+    }
+  }
+
+  private static void writeCompilationStartedMessage(
+      BlazeContext context, CompileInstructions instructions) {
+    if (instructions.annotationProcessorClassNames().isEmpty()) {
+      context.output(
+          new StatusOutput(
+              String.format(
+                  "Running javac on files %s", getSourceFileNames(instructions.filesToCompile()))));
+    } else {
+      context.output(
+          new StatusOutput(
+              String.format(
+                  "Running javac on %s with annotation processors %s",
+                  getSourceFileNames(instructions.filesToCompile()),
+                  getProcessorNames(instructions.annotationProcessorClassNames()))));
+    }
+  }
+
+  private static void writeCompilationFinishedMessage(
+      BlazeContext context, CompileInstructions instructions, boolean success, Stopwatch timer) {
+    context.output(new StatusOutput(String.format("Compilation finished in %s", timer)));
+
+    context.output(FastBuildLogOutput.keyValue("javac_success", Boolean.toString(success)));
+    context.output(
+        FastBuildLogOutput.keyValue(
+            "javac_source_file_count", Integer.toString(instructions.filesToCompile().size())));
+    context.output(
+        FastBuildLogOutput.keyValue(
+            "javac_source_files", instructions.filesToCompile().toString()));
+    context.output(
+        FastBuildLogOutput.keyValue(
+            "javac_annotation_processor_count",
+            Integer.toString(instructions.annotationProcessorClassNames().size())));
+    context.output(
+        FastBuildLogOutput.keyValue(
+            "javac_annotation_processors",
+            instructions.annotationProcessorClassNames().toString()));
+    context.output(FastBuildLogOutput.milliseconds("javac_time_ms", timer));
+  }
+
+  private static List<String> getSourceFileNames(Collection<File> sourceFiles) {
+    return sourceFiles.stream().map(File::getName).collect(toList());
+  }
+
+  private static List<String> getProcessorNames(Collection<String> classNames) {
+    return classNames.stream()
+        .map(
+            className -> {
+              int lastDot = className.lastIndexOf('.');
+              if (lastDot > -1 && lastDot < className.length() - 1) {
+                return className.substring(lastDot + 1);
+              } else {
+                return className;
+              }
+            })
+        .collect(toList());
+  }
+
+  private static class MatchingMethodInvocationHandler implements InvocationHandler {
+
+    private final Class<?> matchingClass;
+    private final Object matchingInstance;
+
+    private MatchingMethodInvocationHandler(Class<?> matchingClass, Object matchingInstance) {
+      this.matchingClass = matchingClass;
+      this.matchingInstance = matchingInstance;
+    }
+
+    @Override
+    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
+      // We have two different copies of matchingClass from different classloaders, so we can't use
+      // method directory. We have to look up the copy in the other classloader.
+      Method otherMethod = matchingClass.getMethod(method.getName(), method.getParameterTypes());
+      return otherMethod.invoke(matchingInstance, objects);
+    }
+  }
+
+  private static void processDiagnostics(BlazeContext context, CompilerOutput output) {
+    output.diagnostics.forEach(d -> processDiagostic(context, d));
+  }
+
+  private static void processDiagostic(BlazeContext context, DiagnosticLine line) {
+    IssueOutput.Builder output = IssueOutput.issue(toCategory(line.kind), line.message);
+    if (line.uri != null) {
+      output.inFile(new File(line.uri));
+    }
+    if (line.lineNumber != Diagnostic.NOPOS) {
+      output.onLine((int) line.lineNumber).inColumn((int) line.columnNumber);
+    }
+    context.output(output.build());
+    context.output(new PrintOutput(line.formattedMessage));
+  }
+
+  private static Category toCategory(Kind kind) {
+    switch (kind) {
+      case ERROR:
+        return Category.ERROR;
+      case MANDATORY_WARNING:
+      case WARNING:
+        return Category.WARNING;
+      case NOTE:
+        return Category.NOTE;
+      case OTHER:
+        return Category.INFORMATION;
+    }
+    throw new AssertionError("Unknown Kind " + kind);
+  }
+}
diff --git a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildServiceImpl.java b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildServiceImpl.java
index 30e667215a7..8807e9b8a1f 100644
--- a/java/src/com/google/idea/blaze/java/fastbuild/FastBuildServiceImpl.java
+++ b/java/src/com/google/idea/blaze/java/fastbuild/FastBuildServiceImpl.java
@@ -81,7 +81,10 @@ final class FastBuildServiceImpl implements FastBuildService, ProjectComponent {
 
   private static final ImmutableSetMultimap<BuildSystemName, Kind> SUPPORTED_KINDS =
       ImmutableSetMultimap.<BuildSystemName, Kind>builder()
-          .putAll(BuildSystemName.Bazel, JavaBlazeRules.RuleTypes.JAVA_TEST.getKind())
+          .putAll(
+              BuildSystemName.Bazel,
+              JavaBlazeRules.RuleTypes.JAVA_TEST.getKind(),
+              JavaBlazeRules.RuleTypes.SCALA_JUNIT_TEST.getKind())
           .putAll(
               BuildSystemName.Blaze,
               AndroidBlazeRules.RuleTypes.ANDROID_ROBOLECTRIC_TEST.getKind(),
diff --git a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
index 96cc453bf79..d7be6d29ffa 100644
--- a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
+++ b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
@@ -71,8 +71,11 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import javax.annotation.Nullable;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * A Blaze run configuration set up with an executor, program runner, and other settings, ready to
@@ -80,6 +83,7 @@
  * when using a debug executor.
  */
 public final class BlazeJavaRunProfileState extends BlazeJavaDebuggableRunProfileState {
+
   private static final Logger logger = Logger.getInstance(BlazeJavaRunProfileState.class);
   private static final String JAVA_RUNFILES_ENV = "JAVA_RUNFILES=";
   private static final String TEST_DIAGNOSTICS_OUTPUT_DIR_ENV = "TEST_DIAGNOSTICS_OUTPUT_DIR=";
@@ -261,6 +265,9 @@ static BlazeCommand.Builder getBlazeCommandBuilder(
       if (isBinary) {
         command.addExeFlags(debugPortFlag(false, debugPort));
       } else {
+        List<String> debugFlags = getAdditionalBlazeDebugFlags();
+        command.addBlazeFlags(debugFlags);
+
         command.addBlazeFlags(BlazeFlags.JAVA_TEST_DEBUG);
         command.addBlazeFlags(debugPortFlag(true, debugPort));
       }
@@ -273,6 +280,17 @@ static BlazeCommand.Builder getBlazeCommandBuilder(
     return command;
   }
 
+  @NotNull
+  private static List<String> getAdditionalBlazeDebugFlags() {
+    // Allow adding additional flags when running in debug mode.
+    // For example, it allows to disable remote execution when debugging.
+    String additionalDebugFlags = System.getenv("INTELLIJ_BAZEL_JAVA_DEBUG_FLAGS");
+    if (additionalDebugFlags != null) {
+      return Arrays.asList(additionalDebugFlags.trim().split("\\s+"));
+    }
+    return Collections.emptyList();
+  }
+
   private ProcessHandler getScopedProcessHandler(
       Project project, ImmutableList<String> command, WorkspaceRoot workspaceRoot)
       throws ExecutionException {
diff --git a/java/src/com/google/idea/blaze/java/run/fastbuild/BazelFastBuildTestEnvironmentCreator.java b/java/src/com/google/idea/blaze/java/run/fastbuild/BazelFastBuildTestEnvironmentCreator.java
index 7a840265113..8a3da4d97e0 100644
--- a/java/src/com/google/idea/blaze/java/run/fastbuild/BazelFastBuildTestEnvironmentCreator.java
+++ b/java/src/com/google/idea/blaze/java/run/fastbuild/BazelFastBuildTestEnvironmentCreator.java
@@ -20,10 +20,11 @@
 import com.google.idea.blaze.base.settings.BuildSystemName;
 import com.intellij.openapi.project.Project;
 import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import javax.annotation.Nullable;
 
 final class BazelFastBuildTestEnvironmentCreator extends FastBuildTestEnvironmentCreator {
-
   // Bazel adds the Java launcher to the runfiles path when building a Java test target.
   private static final File STANDARD_JAVA_BINARY = new File("../local_jdk/bin/java");
 
@@ -39,11 +40,16 @@ String getTestRunner() {
 
   @Override
   File getJavaBinFromLauncher(
-      Project project, Label label, @Nullable Label javaLauncher, boolean swigdeps) {
-    if (javaLauncher == null) {
-      return STANDARD_JAVA_BINARY;
-    } else {
+      Project project, Label label, @Nullable Label javaLauncher, boolean swigdeps,
+      String javaExecutableExecPath, Path workingDir) {
+    if (javaLauncher != null) {
       return new File(getTestBinary(label) + "_nativedeps");
+    } else {
+      final Path p = workingDir.resolve(javaExecutableExecPath);
+      if (Files.exists(p))
+        return p.toFile();
+      else
+        return STANDARD_JAVA_BINARY;
     }
   }
 
diff --git a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildConfigurationRunner.java b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildConfigurationRunner.java
index de1a2bfd15a..d6a281e991d 100644
--- a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildConfigurationRunner.java
+++ b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildConfigurationRunner.java
@@ -67,21 +67,21 @@ public final class FastBuildConfigurationRunner implements BlazeCommandRunConfig
   private static final Logger logger = Logger.getInstance(FastBuildConfigurationRunner.class);
 
   static final Key<AtomicReference<FastBuildInfo>> BUILD_INFO_KEY =
-      Key.create("blaze.java.fastRun.buildInfo");
+          Key.create("blaze.java.fastRun.buildInfo");
   static final Key<AtomicReference<BlazeContext>> BLAZE_CONTEXT =
-      Key.create("blaze.java.fastRun.blazeContext");
+          Key.create("blaze.java.fastRun.blazeContext");
 
   /** Returns false if this isn't a 'blaze test' invocation. */
   static boolean canRun(RunProfile runProfile) {
     BlazeCommandRunConfiguration blazeCfg =
-        BlazeCommandRunConfigurationRunner.getBlazeConfig(runProfile);
+            BlazeCommandRunConfigurationRunner.getBlazeConfig(runProfile);
     if (blazeCfg == null) {
       return false;
     }
     return Objects.equals(blazeCfg.getHandler().getCommandName(), BlazeCommandName.TEST)
-        && FastBuildService.getInstance(blazeCfg.getProject())
+            && FastBuildService.getInstance(blazeCfg.getProject())
             .supportsFastBuilds(
-                Blaze.getBuildSystemName(blazeCfg.getProject()), blazeCfg.getTargetKind());
+                    Blaze.getBuildSystemName(blazeCfg.getProject()), blazeCfg.getTargetKind());
   }
 
   @Override
@@ -102,18 +102,18 @@ public boolean executeBeforeRunTask(ExecutionEnvironment env) {
     }
     Project project = env.getProject();
     BlazeCommandRunConfiguration configuration =
-        BlazeCommandRunConfigurationRunner.getBlazeConfig(env.getRunProfile());
+            BlazeCommandRunConfigurationRunner.getBlazeConfig(env.getRunProfile());
     BlazeCommandRunConfigurationCommonState handlerState =
-        (BlazeCommandRunConfigurationCommonState)
-            Objects.requireNonNull(configuration).getHandler().getState();
+            (BlazeCommandRunConfigurationCommonState)
+                    Objects.requireNonNull(configuration).getHandler().getState();
 
     checkState(configuration.getSingleTarget() != null);
     Label label = (Label) configuration.getSingleTarget();
 
     String binaryPath =
-        handlerState.getBlazeBinaryState().getBlazeBinary() != null
-            ? handlerState.getBlazeBinaryState().getBlazeBinary()
-            : Blaze.getBuildSystemProvider(project).getBinaryPath(project);
+            handlerState.getBlazeBinaryState().getBlazeBinary() != null
+                    ? handlerState.getBlazeBinaryState().getBlazeBinary()
+                    : Blaze.getBuildSystemProvider(project).getBinaryPath(project);
 
     SaveUtil.saveAllFiles();
     FastBuildService buildService = FastBuildService.getInstance(project);
@@ -122,29 +122,29 @@ public boolean executeBeforeRunTask(ExecutionEnvironment env) {
     FocusBehavior consolePopupBehavior = BlazeUserSettings.getInstance().getShowBlazeConsoleOnRun();
     FocusBehavior problemsViewFocus = BlazeUserSettings.getInstance().getShowProblemsViewOnRun();
     BlazeContext context =
-        BlazeContext.create()
-            .push(
-                new ToolWindowScope.Builder(
-                        project,
-                        new Task(project, "Fast Build " + label.targetName(), Task.Type.FAST_BUILD))
-                    .setPopupBehavior(consolePopupBehavior)
-                    .setIssueParsers(
-                        BlazeIssueParser.defaultIssueParsers(
-                            project,
-                            WorkspaceRoot.fromProject(project),
-                            ContextType.RunConfiguration))
-                    .build())
-            .push(new ProblemsViewScope(project, problemsViewFocus))
-            .push(new IdeaLogScope())
-            .push(new FastBuildLogDataScope());
+            BlazeContext.create()
+                    .push(
+                            new ToolWindowScope.Builder(
+                                    project,
+                                    new Task(project, "Fast Build " + label.targetName(), Task.Type.FAST_BUILD))
+                                    .setPopupBehavior(consolePopupBehavior)
+                                    .setIssueParsers(
+                                            BlazeIssueParser.defaultIssueParsers(
+                                                    project,
+                                                    WorkspaceRoot.fromProject(project),
+                                                    ContextType.RunConfiguration))
+                                    .build())
+                    .push(new ProblemsViewScope(project, problemsViewFocus))
+                    .push(new IdeaLogScope())
+                    .push(new FastBuildLogDataScope());
 
     try {
       buildFuture =
-          buildService.createBuild(
-              context,
-              label,
-              binaryPath,
-              handlerState.getBlazeFlagsState().getFlagsForExternalProcesses());
+              buildService.createBuild(
+                      context,
+                      label,
+                      binaryPath,
+                      handlerState.getBlazeFlagsState().getFlagsForExternalProcesses());
       FastBuildInfo fastBuildInfo = buildFuture.get();
       env.getCopyableUserData(BUILD_INFO_KEY).set(fastBuildInfo);
       env.getCopyableUserData(BLAZE_CONTEXT).set(context);
@@ -153,10 +153,10 @@ public boolean executeBeforeRunTask(ExecutionEnvironment env) {
       cancelBuildFuture(buildFuture);
     } catch (CancellationException e) {
       ExecutionUtil.handleExecutionError(
-          env.getProject(),
-          env.getExecutor().getToolWindowId(),
-          env.getRunProfile(),
-          new RunCanceledByUserException());
+              env.getProject(),
+              env.getExecutor().getToolWindowId(),
+              env.getRunProfile(),
+              new RunCanceledByUserException());
     } catch (FastBuildException e) {
       if (!(e instanceof BlazeBuildError)) {
         // no need to log blaze build errors; they're expected
@@ -167,12 +167,12 @@ public boolean executeBeforeRunTask(ExecutionEnvironment env) {
       logger.warn(e);
       if (e.getCause() instanceof FastBuildIncrementalCompileException) {
         handleJavacError(
-            env,
-            project,
-            label,
-            buildService,
-            (FastBuildIncrementalCompileException) e.getCause(),
-            context);
+                env,
+                project,
+                label,
+                buildService,
+                (FastBuildIncrementalCompileException) e.getCause(),
+                context);
       } else {
         ExecutionUtil.handleExecutionError(env, new ExecutionException(e.getCause()));
       }
@@ -189,37 +189,37 @@ private void cancelBuildFuture(Future<FastBuildInfo> buildFuture) {
   }
 
   private static void handleJavacError(
-      ExecutionEnvironment env,
-      Project project,
-      Label label,
-      FastBuildService buildService,
-      FastBuildIncrementalCompileException e,
-      BlazeContext context) {
+          ExecutionEnvironment env,
+          Project project,
+          Label label,
+          FastBuildService buildService,
+          FastBuildIncrementalCompileException e,
+          BlazeContext context) {
 
     context.output(IssueOutput.error(e.getMessage() + "\n").build());
 
     // TODO(b/240126599): Consider supporting outputting Hyperlinks to the Blaze console again.
     NotificationGroupManager.getInstance()
-        .getNotificationGroup("Fastbuild failed notification")
-        .createNotification(
-            "To run the tests again with a fresh "
-                + Blaze.getBuildSystemName(project)
-                + " build, click",
-            NotificationType.ERROR)
-        .addAction(
-            NotificationAction.createExpiring(
-                "here", (event, notification) -> rerunTests(env, label, buildService)))
-        .notify(project);
+            .getNotificationGroup("Fastbuild failed notification")
+            .createNotification(
+                    "To run the tests again with a fresh "
+                            + Blaze.getBuildSystemName(project)
+                            + " build, click",
+                    NotificationType.ERROR)
+            .addAction(
+                    NotificationAction.createExpiring(
+                            "here", (event, notification) -> rerunTests(env, label, buildService)))
+            .notify(project);
 
     ExecutionUtil.handleExecutionError(
-        env, new ExecutionException("See the Blaze Console for javac output", e.getCause()));
+            env, new ExecutionException("See the Blaze Console for javac output", e.getCause()));
   }
 
   private static void rerunTests(
-      ExecutionEnvironment env, Label label, FastBuildService buildService) {
+          ExecutionEnvironment env, Label label, FastBuildService buildService) {
     buildService.resetBuild(label);
     ExecutionUtil.restart(env);
     EventLoggingService.getInstance()
-        .logEvent(FastBuildConfigurationRunner.class, "rerun_tests_with_blaze_link_clicked");
+            .logEvent(FastBuildConfigurationRunner.class, "rerun_tests_with_blaze_link_clicked");
   }
-}
+}
\ No newline at end of file
diff --git a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinder.java b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinder.java
index 202ba2c5a38..21bc69f99ad 100644
--- a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinder.java
+++ b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinder.java
@@ -34,6 +34,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
+import javax.annotation.Nullable;
 
 final class FastBuildTestClassFinder {
 
@@ -47,7 +48,7 @@ static FastBuildTestClassFinder getInstance(Project project) {
     return ServiceManager.getService(project, FastBuildTestClassFinder.class);
   }
 
-  String getTestClass(Label label, JavaInfo targetJavaInfo) throws ExecutionException {
+  String getTestClass(Label label, JavaInfo targetJavaInfo, @Nullable String testFilter) throws ExecutionException {
     if (targetJavaInfo.testClass().isPresent()) {
       return targetJavaInfo.testClass().get();
     } else {
@@ -59,17 +60,26 @@ String getTestClass(Label label, JavaInfo targetJavaInfo) throws ExecutionExcept
       BlazeProjectData blazeProjectData =
           BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
 
-      Optional<String> testClass =
+      Optional<String> testClassFromSources =
           determineTestClassFromSources(psiManager, blazeProjectData, label, targetJavaInfo);
-      if (testClass.isPresent()) { // In Java9, we could chain these with Optional.or()
-        return testClass.get();
+      if (testClassFromSources.isPresent()) { // In Java9, we could chain these with Optional.or()
+        return testClassFromSources.get();
       }
-
-      return determineTestClassFromPackage(psiManager, blazeProjectData, label)
-          .orElseThrow(() -> new ExecutionException("Couldn't determine test class."));
+      final Optional<String> testClassFromPackage = determineTestClassFromPackage(psiManager, blazeProjectData, label);
+      if (testClassFromPackage.isPresent()) { // In Java9, we could chain these with Optional.or()
+        return testClassFromPackage.get();
+      }
+      if (testFilter != null && !testFilter.trim().isEmpty()) {
+        return getTestClassFromTestFilter(testFilter);
+      }
+      throw new ExecutionException("Couldn't determine test class.");
     }
   }
 
+  private String getTestClassFromTestFilter(String testFilter) {
+    return testFilter.substring(0, testFilter.indexOf('#'));
+  }
+
   // This is the first part of Bazel's JavaCommon.determinePrimaryClass()
   private static Optional<String> determineTestClassFromSources(
       PsiManager psiManager,
diff --git a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestEnvironmentCreator.java b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestEnvironmentCreator.java
index c4fd66d9120..fc8dba60d8e 100644
--- a/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestEnvironmentCreator.java
+++ b/java/src/com/google/idea/blaze/java/run/fastbuild/FastBuildTestEnvironmentCreator.java
@@ -66,7 +66,8 @@ static FastBuildTestEnvironmentCreator getInstance(BuildSystemName buildSystemNa
   abstract String getTestRunner();
 
   abstract File getJavaBinFromLauncher(
-      Project project, Label label, @Nullable Label javaLauncher, boolean swigdeps);
+      Project project, Label label, @Nullable Label javaLauncher, boolean swigdeps,
+      String javaExecutableExecPath, Path workingDir);
 
   GeneralCommandLine createCommandLine(
       Project project,
@@ -95,13 +96,14 @@ GeneralCommandLine createCommandLine(
 
     commandBuilder.setJavaBinary(
         getJavaBinFromLauncher(
-            project, target, getLauncher(fastBuildInfo).orElse(null), getSwigdeps(fastBuildInfo)));
+            project, target, getLauncher(fastBuildInfo).orElse(null), getSwigdeps(fastBuildInfo),
+            getJavaExecutableExecPath(fastBuildInfo), workingDir));
 
     fastBuildInfo.classpath().forEach(commandBuilder::addClasspathElement);
 
     commandBuilder.addSystemProperty(
         getTestClassProperty(),
-        FastBuildTestClassFinder.getInstance(project).getTestClass(target, targetJavaInfo));
+        FastBuildTestClassFinder.getInstance(project).getTestClass(target, targetJavaInfo, testFilter));
 
     commandBuilder.setMainClass(getTestRunner());
 
@@ -156,6 +158,16 @@ private Optional<Label> getLauncher(FastBuildInfo fastBuildInfo) {
     return javaInfo.launcher();
   }
 
+  private String getJavaExecutableExecPath(FastBuildInfo fastBuildInfo) {
+    Label label = fastBuildInfo.label();
+    FastBuildBlazeData targetData = fastBuildInfo.blazeData().get(label);
+    checkState(targetData != null, "Couldn't find data for target %s", label);
+    checkState(targetData.javaToolchainInfo().isPresent(), "Couldn't find Java toolchain info for target %s", label);
+    checkState(targetData.javaToolchainInfo().get().javaRuntime().isPresent(), "Couldn't find Java runtime info for target %s", label);
+    String javaExecutableExecPath = targetData.javaToolchainInfo().get().javaRuntime().get().javaExecutableExecPath();
+    return javaExecutableExecPath;
+  }
+
   private static boolean getSwigdeps(FastBuildInfo fastBuildInfo) {
     Label label = fastBuildInfo.label();
     FastBuildBlazeData targetData = fastBuildInfo.blazeData().get(label);
diff --git a/java/src/com/google/idea/blaze/java/run/fastbuild/LocationSubstitution.java b/java/src/com/google/idea/blaze/java/run/fastbuild/LocationSubstitution.java
index d44b40d6077..f6fdb381b6c 100644
--- a/java/src/com/google/idea/blaze/java/run/fastbuild/LocationSubstitution.java
+++ b/java/src/com/google/idea/blaze/java/run/fastbuild/LocationSubstitution.java
@@ -31,7 +31,7 @@ final class LocationSubstitution {
   //   \$\((locations?)\s+([^)]+)\s*\)
   // The first group is 'location' or 'locations'. The second group is the target.
   private static final Pattern LOCATION_PATTERN =
-      Pattern.compile("\\$\\((locations?)\\s+([^)]+)\\s*\\)");
+      Pattern.compile("\\$\\((locations?|rootpaths?)\\s+([^)]+)\\s*\\)");
 
   private LocationSubstitution() {}
 
diff --git a/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java b/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
index 4b4fb60c964..3b5b99d81c8 100644
--- a/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
+++ b/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
@@ -237,13 +237,7 @@ private static void updateJdk(
 
     Sdk sdk = Jdks.chooseOrCreateJavaSdk(currentSdk, javaLanguageLevel);
     if (sdk == null) {
-      String msg =
-          String.format(
-              "Unable to find a JDK %1$s installed.\n", javaLanguageLevel.getPresentableText());
-      msg +=
-          "After configuring a suitable JDK in the \"Project Structure\" dialog, "
-              + "sync the project again.";
-      IssueOutput.error(msg).submit(context);
+      JdkDetectionNotification.show(project, context, javaLanguageLevel);
       return;
     }
 
diff --git a/java/src/com/google/idea/blaze/java/sync/JdkDetectionNotification.java b/java/src/com/google/idea/blaze/java/sync/JdkDetectionNotification.java
new file mode 100644
index 00000000000..7d6dd7ef888
--- /dev/null
+++ b/java/src/com/google/idea/blaze/java/sync/JdkDetectionNotification.java
@@ -0,0 +1,65 @@
+package com.google.idea.blaze.java.sync;
+
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.output.IssueOutput;
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationAction;
+import com.intellij.notification.NotificationDisplayType;
+import com.intellij.notification.NotificationGroup;
+import com.intellij.notification.NotificationType;
+import com.intellij.notification.Notifications;
+import com.intellij.notification.NotificationsManager;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
+import com.intellij.pom.java.LanguageLevel;
+import org.jetbrains.annotations.NotNull;
+
+class JdkDetectionNotification {
+
+  private static final NotificationGroup notificationGroup =
+      new NotificationGroup("JDK Detection", NotificationDisplayType.BALLOON, true);
+
+  static void show(Project project, BlazeContext context, @NotNull LanguageLevel languageLevel) {
+
+    Notification[] notifications = NotificationsManager
+        .getNotificationsManager()
+        .getNotificationsOfType(Notification.class, project);
+
+    for (Notification notification : notifications) {
+      if (notification.getGroupId().equals(notificationGroup.getDisplayId())) {
+        return;
+      }
+    }
+
+    String title =
+        String.format("Unable to find a JDK %1$s installed.", languageLevel.getPresentableText());
+
+    String body =
+        "After configuring a suitable JDK in the \"Project Structure\" dialog, sync the project again.";
+
+    Notification notification =
+        new Notification(notificationGroup.getDisplayId(), title, body, NotificationType.ERROR);
+
+    notification.addAction(openProjectSettingsAction());
+    Notifications.Bus.notify(notification, project);
+
+    IssueOutput.error(title + "\n" + body).submit(context);
+  }
+
+  static private AnAction openProjectSettingsAction() {
+    return new NotificationAction("Project Settings") {
+      public void update(@NotNull AnActionEvent e) {
+        e.getPresentation().setEnabledAndVisible(e.getProject() != null);
+      }
+
+      public void actionPerformed(@NotNull AnActionEvent e, @NotNull Notification notification) {
+        if (e.getProject() == null) {
+          return;
+        }
+        ProjectSettingsService.getInstance(e.getProject()).openProjectSettings();
+      }
+    };
+  }
+}
diff --git a/java/src/com/google/idea/blaze/java/sync/importer/BlazeJavaWorkspaceImporter.java b/java/src/com/google/idea/blaze/java/sync/importer/BlazeJavaWorkspaceImporter.java
index 2fde9a79691..692974e7292 100644
--- a/java/src/com/google/idea/blaze/java/sync/importer/BlazeJavaWorkspaceImporter.java
+++ b/java/src/com/google/idea/blaze/java/sync/importer/BlazeJavaWorkspaceImporter.java
@@ -261,6 +261,8 @@ private void addTargetAsSource(
       workspaceBuilder.jdeps.addAll(
           jars.stream()
               .filter(jar -> !jar.contains("-kt-ijar.jar") && !jar.contains("-kt-src.jar"))
+              .map(jar -> jar.contains("/_ijar/") ? jar : jar.replace("-ijar.jar", ".jar"))
+              .map(jar -> jar.replace("-hjar.jar", ".jar"))
               .collect(toImmutableList()));
     }
 
diff --git a/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesServiceTest.java b/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesServiceTest.java
index 9256288e037..a9cf80d4bed 100644
--- a/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesServiceTest.java
+++ b/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildChangedFilesServiceTest.java
@@ -38,6 +38,7 @@
 import com.google.idea.blaze.base.settings.BuildSystemName;
 import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
 import com.google.idea.blaze.java.fastbuild.FastBuildBlazeData.JavaInfo;
+import com.google.idea.blaze.java.fastbuild.FastBuildBlazeData.ProtoInfo;
 import com.google.idea.blaze.java.fastbuild.FastBuildChangedFilesService.ChangedSources;
 import com.google.idea.blaze.java.fastbuild.FastBuildState.BuildOutput;
 import java.io.File;
@@ -227,7 +228,7 @@ public void graphOfLabels() {
             new File("deploy.jar"),
             ImmutableMap.of(
                 Label.create("//a:a"),
-                    sources("a.java").setDependencies(deps("//b:b", "//c:c")).build(),
+                sources("a.java").setDependencies(deps("//b:b", "//c:c")).build(),
                 Label.create("//b:b"), sources("b.java").setDependencies(deps("//d:d")).build(),
                 Label.create("//c:c"), sources("c.java").setDependencies(deps("//b:b")).build(),
                 Label.create("//d:d"), sources("d.java").build()),
@@ -348,6 +349,26 @@ public void addFilesFromFailedCompilation() {
         .containsExactly(new File("/foo/bar.txt"), new File("/what/fun.txt"));
   }
 
+  @Test
+  public void suggestsRecompilationWithNonCompilableSourceModified() {
+    BuildOutput buildOutput =
+        BuildOutput.create(
+            new File("deploy.jar"),
+            ImmutableMap.of(
+                Label.create("//java:all_files"),
+                protoSources("proto/com/google/HelloService.proto").build()),
+            BLAZE_INFO);
+    changedFilesService.newBuild(
+        Label.create("//java:all_files"), Futures.immediateFuture(buildOutput));
+
+    workspace.createFile(WorkspacePath.createIfValid("proto/com/google/HelloService.proto"));
+
+    ChangedSources changedSources =
+        changedFilesService.getAndResetChangedSources(Label.create("//java:all_files"));
+
+    assertThat(changedSources.needsFullCompile()).isTrue();
+  }
+
   private static com.google.idea.blaze.base.ideinfo.ArtifactLocation source(String relativePath) {
     return com.google.idea.blaze.base.ideinfo.ArtifactLocation.fromProto(
         protoSourceArtifact(relativePath));
@@ -358,16 +379,28 @@ private static ArtifactLocation protoSourceArtifact(String relativePath) {
   }
 
   private static FastBuildBlazeData.Builder sources(String... artifacts) {
-    Set<ArtifactLocation> sourceArtifacts =
-        Arrays.stream(artifacts)
-            .map(FastBuildChangedFilesServiceTest::protoSourceArtifact)
-            .collect(toSet());
     return FastBuildBlazeData.builder()
         .setLabel(Label.create("//ignore:ignore"))
         .setWorkspaceName("io_bazel")
         .setJavaInfo(
             JavaInfo.fromProto(
-                FastBuildInfo.JavaInfo.newBuilder().addAllSources(sourceArtifacts).build()));
+                FastBuildInfo.JavaInfo.newBuilder().addAllSources(sourceArtifacts(artifacts))
+                    .build()));
+  }
+
+  private static FastBuildBlazeData.Builder protoSources(String... artifacts) {
+    return FastBuildBlazeData.builder()
+        .setLabel(Label.create("//ignore:ignore"))
+        .setWorkspaceName("io_bazel")
+        .setProtoInfo(ProtoInfo.fromProto(
+            FastBuildInfo.ProtoInfo.newBuilder().addAllSources(sourceArtifacts(artifacts))
+                .build()));
+  }
+
+  private static Set<ArtifactLocation> sourceArtifacts(String... artifacts) {
+    return Arrays.stream(artifacts)
+        .map(FastBuildChangedFilesServiceTest::protoSourceArtifact)
+        .collect(toSet());
   }
 
   private static ImmutableList<Label> deps(String... deps) {
diff --git a/java/tests/unittests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java b/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java
similarity index 92%
rename from java/tests/unittests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java
rename to java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java
index 948687355b8..83c88cee287 100644
--- a/java/tests/unittests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java
+++ b/java/tests/integrationtests/com/google/idea/blaze/java/fastbuild/FastBuildCompilerFactoryImplTest.java
@@ -21,6 +21,8 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import com.google.idea.blaze.base.BlazeIntegrationTestCase;
+import com.google.idea.blaze.base.logging.NoopEventLoggingService;
 import com.google.idea.blaze.base.model.BlazeProjectData;
 import com.google.idea.blaze.base.model.MockBlazeProjectDataBuilder;
 import com.google.idea.blaze.base.model.MockBlazeProjectDataManager;
@@ -40,8 +42,10 @@
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -50,7 +54,7 @@
 
 /** Unit tests for {@link FastBuildCompilerFactoryImpl}. */
 @RunWith(JUnit4.class)
-public final class FastBuildCompilerFactoryImplTest {
+public final class FastBuildCompilerFactoryImplTest extends BlazeIntegrationTestCase {
 
   private static final String AUTO_VALUE_PROCESSOR =
       "com.google.auto.value.processor.AutoValueProcessor";
@@ -68,7 +72,8 @@ public final class FastBuildCompilerFactoryImplTest {
           /* javacJars= */ ImmutableList.of(),
           /* bootJars= */ ImmutableList.of(),
           /* sourceVersion= */ "8",
-          /* targetVersion= */ "8");
+          /* targetVersion= */ "8",
+          null);
   private static final JavaInfo JAVA_LIBRARY_WITHOUT_SOURCES = JavaInfo.builder().build();
 
   private FastBuildCompilerFactory compilerFactory;
@@ -83,14 +88,16 @@ public static void verifyJars() {
   }
 
   @Before
-  public void setUp() {
+  public void setUpForThisTestClass() {
     BlazeProjectData projectData =
         MockBlazeProjectDataBuilder.builder()
             .setArtifactLocationDecoder(new MockArtifactLocationDecoder())
             .build();
     BlazeProjectDataManager projectDataManager = new MockBlazeProjectDataManager(projectData);
-    compilerFactory =
-        FastBuildCompilerFactoryImpl.createForTest(projectDataManager, FAST_BUILD_JAVAC_JAR);
+    final FastBuildCompilerExtensionPoint fastBuildJavaCompilerExtensionPoint =
+        new FastBuildJavaCompilerExtensionPoint(NoopEventLoggingService::new, () -> FAST_BUILD_JAVAC_JAR);
+    super.registerExtension(FastBuildCompilerExtensionPoint.EP_NAME, fastBuildJavaCompilerExtensionPoint);
+    compilerFactory = FastBuildCompilerFactoryImpl.createForTest(projectDataManager);
   }
 
   @Test
@@ -115,7 +122,7 @@ public void testNoJavaToolchain() {
     blazeData.put(dependencyLabel, dependencyData);
 
     try {
-      compilerFactory.getCompilerFor(targetLabel, blazeData);
+      compilerFactory.getCompilerFor(targetLabel, blazeData, Collections.emptySet());
       fail("Should have thrown FastBuildException");
     } catch (FastBuildException e) {
       assertThat(e.getMessage()).contains("Couldn't find a Java toolchain");
@@ -152,14 +159,15 @@ public void testMultipleDifferentJavaToolchains() {
                     /* javacJars= */ ImmutableList.of(),
                     /* bootJars= */ ImmutableList.of(),
                     /* sourceVersion= */ "12345",
-                    /* targetVersion= */ "9876"))
+                    /* targetVersion= */ "9876",
+                    null))
             .build();
     blazeData.put(targetLabel, targetData);
     blazeData.put(jdkOneLabel, jdkOneData);
     blazeData.put(jdkTwoLabel, jdkTwoData);
 
     try {
-      compilerFactory.getCompilerFor(targetLabel, blazeData);
+      compilerFactory.getCompilerFor(targetLabel, blazeData, Collections.emptySet());
       fail("Should have thrown FastBuildException");
     } catch (FastBuildException e) {
       assertThat(e.getMessage()).contains("Found multiple Java toolchains");
@@ -198,7 +206,7 @@ public void testMultipleIdenticalJavaToolchains() throws FastBuildException {
     blazeData.put(jdkTwoLabel, jdkTwoData);
 
     // If this doesn't throw, the test passes.
-    compilerFactory.getCompilerFor(targetLabel, blazeData);
+    compilerFactory.getCompilerFor(targetLabel, blazeData, Collections.emptySet());
   }
 
   @Test
@@ -286,7 +294,8 @@ public void errorOnTooNewSource() throws IOException, FastBuildException {
                   /* javacJars= */ ImmutableList.of(),
                   /* bootJars= */ ImmutableList.of(),
                   /* sourceVersion= */ "7",
-                  /* targetVersion= */ "8"))
+                  /* targetVersion= */ "8",
+                  null))
           .compile(createBlazeContext(javacOutput), createCompileInstructions(java).build());
       fail("Should have thrown FastBuildIncrementalCompileException");
     } catch (FastBuildIncrementalCompileException e) {
@@ -378,7 +387,7 @@ private FastBuildCompiler getCompiler(JavaToolchainInfo javaToolchain) throws Fa
     blazeData.put(targetLabel, targetData);
     blazeData.put(jdkLabel, jdkData);
 
-    return compilerFactory.getCompilerFor(targetLabel, blazeData);
+    return compilerFactory.getCompilerFor(targetLabel, blazeData, Collections.emptySet());
   }
 
   private static BlazeContext createBlazeContext(Writer javacOutput) {
diff --git a/java/tests/integrationtests/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinderTest.java b/java/tests/integrationtests/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinderTest.java
index a0977104e2c..c162f63f356 100644
--- a/java/tests/integrationtests/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinderTest.java
+++ b/java/tests/integrationtests/com/google/idea/blaze/java/run/fastbuild/FastBuildTestClassFinderTest.java
@@ -60,7 +60,7 @@ public void getClassFromJavaInfo() throws ExecutionException {
 
     String testClass =
         FastBuildTestClassFinder.getInstance(getProject())
-            .getTestClass(Label.create("//javatests/com/google/devtools:AllTests"), javaInfo);
+            .getTestClass(Label.create("//javatests/com/google/devtools:AllTests"), javaInfo, null);
 
     assertThat(testClass).isEqualTo("my.fake.TestClass");
   }
@@ -94,7 +94,7 @@ public void getClassFromTargetSources() throws ExecutionException {
 
     String testClass =
         FastBuildTestClassFinder.getInstance(getProject())
-            .getTestClass(Label.create("//javatests:AllTests"), javaInfo);
+            .getTestClass(Label.create("//javatests:AllTests"), javaInfo, null);
 
     assertThat(testClass).isEqualTo("com.google.hello.AllTests");
   }
@@ -112,7 +112,7 @@ public void getClassFromFoundSources() throws ExecutionException {
 
     String testClass =
         FastBuildTestClassFinder.getInstance(getProject())
-            .getTestClass(Label.create("//javatests:AllTests"), javaInfo);
+            .getTestClass(Label.create("//javatests:AllTests"), javaInfo, null);
 
     assertThat(testClass).isEqualTo("com.google.hello.AllTests");
   }
diff --git a/java/tests/unittests/com/google/idea/blaze/java/run/fastbuild/LocationSubstitutionTest.java b/java/tests/unittests/com/google/idea/blaze/java/run/fastbuild/LocationSubstitutionTest.java
index a9aa7bd3642..a6a5d3eabbb 100644
--- a/java/tests/unittests/com/google/idea/blaze/java/run/fastbuild/LocationSubstitutionTest.java
+++ b/java/tests/unittests/com/google/idea/blaze/java/run/fastbuild/LocationSubstitutionTest.java
@@ -207,4 +207,34 @@ public void testNoArtifacts() {
       assertThat(e.getMessage()).contains(SOURCE_TARGET.toString());
     }
   }
+
+  @Test
+  public void testRootpathSubstitution() throws ExecutionException {
+    ImmutableMap<Label, ImmutableSet<ArtifactLocation>> data =
+        ImmutableMap.of(
+            Label.create("//test/location:location"),
+            ImmutableSet.of(
+                ArtifactLocation.builder().setRelativePath("test/location.txt").build()));
+
+    String result =
+        LocationSubstitution.replaceLocations(
+            "foo$(rootpath //test/location)bar", SOURCE_TARGET, data);
+
+    assertThat(result).isEqualTo("footest/location.txtbar");
+  }
+
+  @Test
+  public void testRootpathsWithSingleArtifact() throws ExecutionException {
+    ImmutableMap<Label, ImmutableSet<ArtifactLocation>> data =
+        ImmutableMap.of(
+            Label.create("//test/location:location"),
+            ImmutableSet.of(
+                ArtifactLocation.builder().setRelativePath("test/location.txt").build()));
+
+    String result =
+        LocationSubstitution.replaceLocations(
+            "foo$(rootpaths //test/location)bar", SOURCE_TARGET, data);
+
+    assertThat(result).isEqualTo("footest/location.txtbar");
+  }
 }
diff --git a/proto/fast_build_info.proto b/proto/fast_build_info.proto
index aece81d55f9..1a5fb6e225a 100644
--- a/proto/fast_build_info.proto
+++ b/proto/fast_build_info.proto
@@ -29,6 +29,8 @@ message FastBuildBlazeData {
   AndroidInfo android_info = 5;
   JavaInfo java_info = 6;
   JavaToolchainInfo java_toolchain_info = 7;
+  ProtoInfo proto_info = 8;
+  string build_file_path = 9;
 }
 
 message Data {
@@ -57,4 +59,13 @@ message JavaToolchainInfo {
   string target_version = 3;
   repeated ArtifactLocation javac_jars = 4;
   repeated ArtifactLocation bootclasspath_jars = 5;
+  JavaRuntimeInfo java_runtime = 6;
+}
+
+message JavaRuntimeInfo {
+  string java_executable_exec_path = 1;
+}
+
+message ProtoInfo {
+  repeated ArtifactLocation sources = 1;
 }
diff --git a/proto/intellij_ide_info.proto b/proto/intellij_ide_info.proto
index 797bb478e6c..f204dd3d972 100644
--- a/proto/intellij_ide_info.proto
+++ b/proto/intellij_ide_info.proto
@@ -206,6 +206,13 @@ message Dependency {
   DependencyType dependency_type = 2;
 }
 
+message ProtoIdeInfo {
+  repeated ArtifactLocation sources = 1;
+  string source_root = 2;
+  string import_prefix = 3;
+  string strip_import_prefix = 4;
+}
+
 message TargetIdeInfo {
   string kind_string = 1;
   TargetKey key = 2;
@@ -237,4 +244,5 @@ message TargetIdeInfo {
   TsIdeInfo ts_ide_info = 160;
   DartIdeInfo dart_ide_info = 170;
   KotlinToolchainIdeInfo kt_toolchain_ide_info = 180;
+  ProtoIdeInfo proto_ide_info = 190;
 }
diff --git a/scala/BUILD b/scala/BUILD
index c40852b0b74..bf28c3e8826 100644
--- a/scala/BUILD
+++ b/scala/BUILD
@@ -22,6 +22,8 @@ java_library(
     srcs = glob(["src/**/*.java"]),
     deps = [
         "//base",
+        "//common/experiments",
+        "//common/util:transactions",
         "//intellij_platform_sdk:jsr305",
         "//intellij_platform_sdk:plugin_api",
         "//java",
diff --git a/scala/src/META-INF/scala-contents.xml b/scala/src/META-INF/scala-contents.xml
index 7264ceb58b0..aa80bb97a60 100644
--- a/scala/src/META-INF/scala-contents.xml
+++ b/scala/src/META-INF/scala-contents.xml
@@ -28,6 +28,7 @@
         order="before JavaTestContextProvider"/>
     <BinaryContextProvider implementation="com.google.idea.blaze.scala.run.producers.ScalaBinaryContextProvider"/>
     <SyncStatusContributor implementation="com.google.idea.blaze.scala.sync.ScalaSyncStatusContributor"/>
+    <FastBuildCompilerExtensionPoint implementation="com.google.idea.blaze.scala.fastbuild.FastBuildScalaCompilerExtensionPoint"/>
   </extensions>
 
   <extensions defaultExtensionNs="com.intellij">
@@ -41,5 +42,7 @@
     <stepsBeforeRunProvider
         implementation="com.google.idea.blaze.scala.run.producers.GenerateDeployableJarTaskProvider"/>
     <postStartupActivity implementation="com.google.idea.blaze.scala.run.producers.NonBlazeProducerSuppressor"/>
+    <attachSourcesProvider implementation="com.google.idea.blaze.scala.libraries.BlazeScalaAttachSourceProvider"/>
+    <library.javaSourceRootDetector implementation="com.google.idea.blaze.scala.libraries.ScalaRootsDetector"/>
   </extensions>
 </idea-plugin>
diff --git a/scala/src/com/google/idea/blaze/scala/fastbuild/BloopProject.java b/scala/src/com/google/idea/blaze/scala/fastbuild/BloopProject.java
new file mode 100644
index 00000000000..d6e68b0905a
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/fastbuild/BloopProject.java
@@ -0,0 +1,144 @@
+package com.google.idea.blaze.scala.fastbuild;
+
+import com.intellij.openapi.diagnostic.Logger;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class BloopProject {
+
+  private static final Logger logger = Logger.getInstance(BloopProject.class);
+  private final static Path bloopConfigDir = Paths.get(System.getProperty("java.io.tmpdir"),
+      "ijwb_fast_test_config",".bloop");
+  private static final String DIR_NAME_SEPARATOR = "_";
+
+  static {
+    try {
+      Files.createDirectories(bloopConfigDir);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private final File destination;
+  private final Set<File> files;
+  private final List<File> classpath;
+  private final String name;
+
+  public BloopProject(File destination, Set<File> files, List<File> classpath) {
+    this.destination = destination;
+    this.files = files;
+    this.classpath = classpath;
+    this.name = randomString() + DIR_NAME_SEPARATOR + ZonedDateTime.now().toInstant().toEpochMilli();
+  }
+
+  public void outputToDisk() {
+    log();
+    String modifiedBloopConfig = bloopProject(name,
+        mkStringFromStreamOfFiles(files.stream()),
+        mkStringFromStreamOfFiles(classpath.stream()),
+        destination.getAbsolutePath());
+    try {
+      Files.write(Paths.get(bloopConfigDir + "/" + name + ".json"), modifiedBloopConfig.getBytes());
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private void log() {
+    logger.debugValues("Pre compilation " +
+            "changed files, " +
+            "uber jar, " +
+            "target, " +
+            "bloop project name, " +
+            "bloop config dir, ",
+        Arrays.asList(files,
+            classpath,
+            destination,
+            getName(),
+            getConfigDir())
+    );
+
+  }
+
+  public Path getConfigDir() {
+    return bloopConfigDir;
+  }
+  public Path getWorkspaceDir() {
+    return bloopConfigDir.getParent();
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  private static String mkStringFromStreamOfFiles(Stream<File> files) {
+    return files.map(f -> "\"" + f.toString() + "\"").collect(Collectors.joining(","));
+  }
+
+  private static String randomString() {
+    int leftLimit = 48; // numeral '0'
+    int rightLimit = 122; // letter 'z'
+    int targetStringLength = 10;
+    Random random = new Random();
+
+    String generatedString = random.ints(leftLimit, rightLimit + 1)
+        .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
+        .limit(targetStringLength)
+        .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+        .toString();
+    return generatedString;
+  }
+
+  private static String bloopProject(String name, String sources, String classpath, String out) {
+    return String.join(System.lineSeparator(),
+        "{",
+        "  \"version\" : \"1.0.0\",",
+        "  \"project\" : {",
+        "    \"name\" : \"" + name + "\",",
+        "    \"directory\" : \"/tmp\",",
+        "    \"sources\" : [" + sources + "],",
+        "    \"dependencies\" : [],",
+        "    \"classpath\" : [" + classpath + "],",
+        "    \"out\" : \"" + out + "\",",
+        "    \"classesDir\" : \"/tmp\",",
+        "    \"test\": {",
+        "      \"frameworks\": [",
+        "        {",
+        "          \"names\": [",
+        "            \"org.specs2.runner.Specs2Framework\",",
+        "            \"com.novocode.junit.JUnitFramework\"",
+        "          ]",
+        "        }",
+        "      ],",
+        "      \"options\": {",
+        "        \"excludes\": [],",
+        "        \"arguments\": [",
+        "          {",
+        "            \"args\": [",
+        "              \"--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED\",",
+        "              \"--add-opens=java.base/java.lang=ALL-UNNAMED\"",
+        "            ],",
+        "            \"framework\": {",
+        "              \"names\": [",
+        "                \"org.specs2.runner.Specs2Framework\",",
+        "                \"com.novocode.junit.JUnitFramework\"",
+        "              ]",
+        "            }",
+        "          }",
+        "        ]",
+        "      }",
+        "    }",
+        "  }",
+        "}");
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/fastbuild/BspFastCompile.java b/scala/src/com/google/idea/blaze/scala/fastbuild/BspFastCompile.java
new file mode 100644
index 00000000000..ee59600a544
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/fastbuild/BspFastCompile.java
@@ -0,0 +1,173 @@
+package com.google.idea.blaze.scala.fastbuild;
+
+import ch.epfl.scala.bsp4j.BuildServerCapabilities;
+import ch.epfl.scala.bsp4j.BuildTargetIdentifier;
+import ch.epfl.scala.bsp4j.CompileParams;
+import ch.epfl.scala.bsp4j.CompileResult;
+import ch.epfl.scala.bsp4j.DiagnosticSeverity;
+import ch.epfl.scala.bsp4j.Position;
+import ch.epfl.scala.bsp4j.PublishDiagnosticsParams;
+import ch.epfl.scala.bsp4j.StatusCode;
+import ch.epfl.scala.bsp4j.TaskFinishParams;
+import com.google.gson.JsonObject;
+import com.google.idea.blaze.base.io.VfsUtils;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.output.StatusOutput;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.DocumentUtil;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import org.jetbrains.bsp.protocol.BspCommunication;
+import org.jetbrains.bsp.protocol.BspNotifications.BspNotification;
+import org.jetbrains.bsp.protocol.BspNotifications.PublishDiagnostics;
+import org.jetbrains.bsp.protocol.BspNotifications.TaskFinish;
+import org.jetbrains.bsp.protocol.session.BspSession.BspServer;
+import org.jetbrains.bsp.settings.BspProjectSettings.BloopConfig$;
+import org.jetbrains.plugins.scala.build.BuildReporter;
+import org.jetbrains.plugins.scala.build.ConsoleReporter;
+import scala.Function1;
+import scala.Function2;
+import scala.runtime.BoxedUnit;
+
+public class BspFastCompile {
+
+  private static final String FILE_PROTOCOL_PREFIX = "file://";
+  private static final String CLIENT_DIR_FILE_PROTOCOL_PREFIX = "file://";
+  private final File destination;
+  private final BloopProject bloopProject;
+  private final BlockingQueue<TaskFinishParams> finishParams;
+  private static final Logger logger = Logger.getInstance(BspFastCompile.class);
+  private final BspCompileRunner bspCompileRunner;
+  private final BspNotificationsHandler bspNotificationsHandler;
+  private final BuildReporter reporter;
+
+  public BspFastCompile(File destination, BloopProject bloopProject,
+      BlazeContext context) {
+    this.destination = destination;
+    this.bloopProject = bloopProject;
+    finishParams = new LinkedBlockingQueue<>();
+    bspCompileRunner = new BspCompileRunner(bloopProject);
+    bspNotificationsHandler = new BspNotificationsHandler(finishParams, context);
+    reporter = new ConsoleReporter("Fast test");
+
+  }
+
+  void compileWithBsp() throws IOException, InterruptedException {
+    final BspCommunication bspCommunication =
+        BspCommunication.forWorkspace(bloopProject.getWorkspaceDir().toFile(),
+            BloopConfig$.MODULE$);
+    // for some reason the BspJop<CompileResult> doesn't return the actual data
+    // so we're using a queue to communicate back the results
+    bspCommunication.run(bspCompileRunner, bspNotificationsHandler, BspFastCompile::log, reporter);
+
+    TaskFinishParams taskFinishParams = finishParams.poll(3, TimeUnit.MINUTES);
+    if (taskFinishParams.getStatus() == StatusCode.OK) {
+      copyCompilationOutputs(taskFinishParams);
+    } else {
+      throw new RuntimeException("Bsp fast scala compilation");
+    }
+
+  }
+
+  private void copyCompilationOutputs(TaskFinishParams taskFinishParams) throws IOException {
+    JsonObject jsonObject = (JsonObject) taskFinishParams.getData();
+    String clientDir = jsonObject.get("clientDir").getAsString();
+    //clientDir starts with file protocol prefix which needs to be removed
+    Path clientDirPath = Paths.get(clientDir.substring(CLIENT_DIR_FILE_PROTOCOL_PREFIX.length()));
+    FileUtils.copyFolderRecursively(clientDirPath, destination.toPath());
+  }
+
+  private static class BspCompileRunner implements
+      Function2<BspServer, BuildServerCapabilities, CompletableFuture<CompileResult>> {
+
+    private final BloopProject bloopProject;
+
+    private BspCompileRunner(BloopProject bloopProject) {
+      this.bloopProject = bloopProject;
+    }
+
+    @Override
+    public CompletableFuture<CompileResult> apply(BspServer bspServer,
+        BuildServerCapabilities v2) {
+      return bspServer.buildTargetCompile(new CompileParams(
+          Collections.singletonList(new BuildTargetIdentifier(FILE_PROTOCOL_PREFIX + bloopProject
+              .getWorkspaceDir() + "?id=" + bloopProject.getName())))
+      );
+    }
+  }
+
+  private static class BspNotificationsHandler implements Function1<BspNotification, BoxedUnit> {
+
+    private final BlockingQueue<TaskFinishParams> finishParams;
+    private final BlazeContext context;
+
+    private BspNotificationsHandler(BlockingQueue<TaskFinishParams> finishParams,
+        BlazeContext context) {
+      this.finishParams = finishParams;
+      this.context = context;
+    }
+
+    @Override
+    public BoxedUnit apply(BspNotification bspNotification) {
+      switch (bspNotification.getClass().getSimpleName()) {
+        case "PublishDiagnostics": {
+          PublishDiagnosticsParams params = ((PublishDiagnostics) bspNotification).params();
+
+          final String fileLocationWithoutFileProtocolPrefix = params.getTextDocument().getUri()
+              .substring(FILE_PROTOCOL_PREFIX.length());
+          final File file = Paths.get(fileLocationWithoutFileProtocolPrefix).toFile();
+          final VirtualFile virtualFile = VfsUtils.resolveVirtualFile(file, false);
+          params.getDiagnostics().stream()
+              .filter(diagnostic -> diagnostic.getSeverity() == DiagnosticSeverity.ERROR)
+              .map(diagnostic -> {
+                final Position start = diagnostic.getRange().getStart();
+                final Document document = FileDocumentManager.getInstance().getDocument(
+                    Objects.requireNonNull(virtualFile));
+                final String lineWithError = Objects.requireNonNull(document)
+                    .getText(DocumentUtil.getLineTextRange(document, start.getLine()));
+                final StatusOutput lineWithErrorStatusOutput = new StatusOutput(lineWithError);
+                final StatusOutput locationStatusOutput = new StatusOutput(
+                    fileLocationWithoutFileProtocolPrefix + ":" + (start.getLine() + 1) + ":" + (
+                        start.getCharacter() + 1) + System.lineSeparator());
+                final StatusOutput messageStatusOutput = new StatusOutput(diagnostic.getMessage());
+                return Arrays.asList(lineWithErrorStatusOutput, locationStatusOutput, messageStatusOutput);
+              }).forEach(statusOutputs -> statusOutputs.forEach(context::output));
+          break;
+        }
+        case "TaskFinish": {
+          TaskFinishParams params = ((TaskFinish) bspNotification).params();
+          finishParams.add(params);
+          break;
+        }
+        default: {
+      /*
+        LogMessage
+        ShowMessage
+        TaskStart
+        TaskProgress
+        DidChangeBuildTarget
+       */
+        }
+      }
+      return BoxedUnit.UNIT;
+    }
+
+  }
+
+  private static BoxedUnit log(String message) {
+    logger.debug(message);
+    return BoxedUnit.UNIT;
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/fastbuild/FastBuildScalaCompilerExtensionPoint.java b/scala/src/com/google/idea/blaze/scala/fastbuild/FastBuildScalaCompilerExtensionPoint.java
new file mode 100644
index 00000000000..6487aa8ef0f
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/fastbuild/FastBuildScalaCompilerExtensionPoint.java
@@ -0,0 +1,41 @@
+package com.google.idea.blaze.scala.fastbuild;
+
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.java.fastbuild.FastBuildCompiler;
+import com.google.idea.blaze.java.fastbuild.FastBuildCompilerExtensionPoint;
+import com.google.idea.blaze.java.fastbuild.FastBuildException;
+import com.google.idea.blaze.java.fastbuild.FastBuildIncrementalCompileException;
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+
+
+public class FastBuildScalaCompilerExtensionPoint implements FastBuildCompilerExtensionPoint {
+
+    @Override
+    public FastBuildCompiler getCompiler(List<File> javacJars, List<File> bootClassPathJars, String sourceVersion, String targetVersion) {
+            return new ScalacBsp();
+    }
+
+    @Override
+    public boolean canCreateCompilerFor(Set<File> filesToCompile) {
+        return !filesToCompile.isEmpty() && filesToCompile.stream().allMatch(f -> f.getName().endsWith(".scala") || f.getName().endsWith(".java"));
+    }
+
+    static class ScalacBsp implements FastBuildCompiler {
+        @Override
+        public void compile(BlazeContext context, CompileInstructions instructions)
+            throws FastBuildException {
+            try {
+                final BloopProject bloopProject = new BloopProject(instructions.outputDirectory(), instructions.filesToCompile(), instructions.classpath());
+                bloopProject.outputToDisk();
+                final BspFastCompile bspFastCompile = new BspFastCompile(instructions.outputDirectory(), bloopProject, context);
+                bspFastCompile.compileWithBsp();
+            } catch (Exception e) {
+                throw new FastBuildIncrementalCompileException(e);
+            }
+        }
+    }
+
+
+}
diff --git a/scala/src/com/google/idea/blaze/scala/fastbuild/FileUtils.java b/scala/src/com/google/idea/blaze/scala/fastbuild/FileUtils.java
new file mode 100644
index 00000000000..414a327dd22
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/fastbuild/FileUtils.java
@@ -0,0 +1,37 @@
+package com.google.idea.blaze.scala.fastbuild;
+
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+
+import com.intellij.openapi.diagnostic.Logger;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Collections;
+
+public class FileUtils {
+  private static final Logger logger = Logger.getInstance(FileUtils.class);
+
+  public static void copyFolderRecursively(Path source, Path target)
+      throws IOException {
+    Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
+      @Override
+      public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
+          throws IOException {
+        logger.debugValues("visiting dir ", Collections.singletonList(dir));
+        Files.createDirectories(target.resolve(source.relativize(dir)));
+        return FileVisitResult.CONTINUE;
+      }
+
+      @Override
+      public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+          throws IOException {
+        logger.debugValues("visiting file ", Collections.singletonList(file));
+        Files.copy(file, target.resolve(source.relativize(file)), REPLACE_EXISTING);
+        return FileVisitResult.CONTINUE;
+      }
+    });
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/fastbuild/ScalaFastCompilationException.java b/scala/src/com/google/idea/blaze/scala/fastbuild/ScalaFastCompilationException.java
new file mode 100644
index 00000000000..1c172100964
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/fastbuild/ScalaFastCompilationException.java
@@ -0,0 +1,13 @@
+package com.google.idea.blaze.scala.fastbuild;
+
+public class ScalaFastCompilationException extends RuntimeException {
+
+  public ScalaFastCompilationException(String message) {
+    super(message);
+  }
+
+  public ScalaFastCompilationException(Exception e) {
+    super(e);
+  }
+
+}
diff --git a/scala/src/com/google/idea/blaze/scala/libraries/BlazeScalaAttachSourceProvider.java b/scala/src/com/google/idea/blaze/scala/libraries/BlazeScalaAttachSourceProvider.java
new file mode 100644
index 00000000000..93e49f5714b
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/libraries/BlazeScalaAttachSourceProvider.java
@@ -0,0 +1,179 @@
+package com.google.idea.blaze.scala.libraries;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
+import com.google.idea.blaze.base.model.BlazeLibrary;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.LibraryKey;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.libraries.LibraryEditor;
+import com.google.idea.blaze.java.libraries.AttachedSourceJarManager;
+import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
+import com.google.idea.blaze.scala.sync.model.BlazeScalaSyncData;
+import com.google.idea.common.experiments.BoolExperiment;
+import com.google.idea.common.util.Transactions;
+import com.google.idea.sdkcompat.general.BaseSdkCompat;
+import com.google.idea.sdkcompat.java.AttachSourcesProviderAdapter;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.TransactionGuard;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.LibraryOrderEntry;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.ui.Messages;
+import com.intellij.openapi.util.ActionCallback;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
+import java.util.Collection;
+import java.util.List;
+import javax.annotation.Nullable;
+
+public class BlazeScalaAttachSourceProvider extends AttachSourcesProviderAdapter {
+
+  private static final BoolExperiment attachAutomatically =
+      new BoolExperiment("blaze.attach.source.jars.automatically.3", true);
+
+  @Override
+  public Collection<AttachSourcesAction> getAdapterActions(
+      List<? extends LibraryOrderEntry> orderEntries, final PsiFile psiFile) {
+    Project project = psiFile.getProject();
+    BlazeProjectData blazeProjectData =
+        BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+    if (blazeProjectData == null) {
+      return ImmutableList.of();
+    }
+
+    List<BlazeLibrary> librariesToAttachSourceTo = Lists.newArrayList();
+    for (LibraryOrderEntry orderEntry : orderEntries) {
+      Library library = orderEntry.getLibrary();
+      if (library == null) {
+        continue;
+      }
+      String name = library.getName();
+      if (name == null) {
+        continue;
+      }
+      LibraryKey libraryKey = LibraryKey.fromIntelliJLibraryName(name);
+      if (AttachedSourceJarManager.getInstance(project).hasSourceJarAttached(libraryKey)) {
+        continue;
+      }
+      BlazeJarLibrary blazeLibrary =
+          findLibraryFromIntellijLibrary(project, blazeProjectData, library);
+      if (blazeLibrary == null) {
+        continue;
+      }
+      LibraryArtifact libraryArtifact = blazeLibrary.libraryArtifact;
+      if (libraryArtifact.getSourceJars().isEmpty()) {
+        continue;
+      }
+      librariesToAttachSourceTo.add(blazeLibrary);
+    }
+
+    if (librariesToAttachSourceTo.isEmpty()) {
+      return ImmutableList.of();
+    }
+
+    // Hack: When sources are requested and we have them, we attach them automatically in the
+    // background.
+    if (attachAutomatically.getValue()) {
+      TransactionGuard.getInstance()
+          .submitTransactionLater(
+              project,
+              () -> {
+                attachSources(project, blazeProjectData, librariesToAttachSourceTo);
+              });
+      return ImmutableList.of();
+    }
+
+    return ImmutableList.of(
+        new AttachSourcesActionAdapter() {
+          @Override
+          public String getName() {
+            return "Attach Blaze Source Jars";
+          }
+
+          @Override
+          public String getBusyText() {
+            return "Attaching source jars...";
+          }
+
+          @Override
+          public ActionCallback adapterPerform(
+              List<? extends LibraryOrderEntry> orderEntriesContainingFile) {
+            ActionCallback callback =
+                new ActionCallback().doWhenDone(() -> navigateToSource(psiFile));
+            Transactions.submitTransaction(
+                project,
+                () -> {
+                  attachSources(project, blazeProjectData, librariesToAttachSourceTo);
+                  callback.setDone();
+                });
+            return callback;
+          }
+        });
+  }
+
+  private static void navigateToSource(PsiFile psiFile) {
+    ApplicationManager.getApplication()
+        .invokeLater(
+            () -> {
+              PsiFile psi = refreshPsiFile(psiFile);
+              if (psi != null && psi.canNavigate()) {
+                psi.navigate(false);
+              }
+            });
+  }
+
+  /**
+   * The previous {@link PsiFile} can be invalidated when source jars are attached.
+   */
+  @Nullable
+  private static PsiFile refreshPsiFile(PsiFile psiFile) {
+    return PsiManager.getInstance(psiFile.getProject())
+        .findFile(psiFile.getViewProvider().getVirtualFile());
+  }
+
+  private static void attachSources(
+      Project project,
+      BlazeProjectData blazeProjectData,
+      Collection<BlazeLibrary> librariesToAttachSourceTo) {
+    ApplicationManager.getApplication()
+        .runWriteAction(
+            () -> {
+              IdeModifiableModelsProvider modelsProvider =
+                  BaseSdkCompat.createModifiableModelsProvider(project);
+              for (BlazeLibrary blazeLibrary : librariesToAttachSourceTo) {
+                // Make sure we don't do it twice
+                if (AttachedSourceJarManager.getInstance(project)
+                    .hasSourceJarAttached(blazeLibrary.key)) {
+                  continue;
+                }
+                AttachedSourceJarManager.getInstance(project)
+                    .setHasSourceJarAttached(blazeLibrary.key, true);
+                LibraryEditor.updateLibrary(
+                    project,
+                    blazeProjectData,
+                    modelsProvider,
+                    blazeLibrary);
+              }
+              modelsProvider.commit();
+            });
+  }
+
+  @Nullable
+  private BlazeJarLibrary findLibraryFromIntellijLibrary(
+      Project project, BlazeProjectData blazeProjectData, Library library) {
+    String libName = library.getName();
+    if (libName == null) {
+      return null;
+    }
+    LibraryKey libraryKey = LibraryKey.fromIntelliJLibraryName(libName);
+    BlazeScalaSyncData syncData = blazeProjectData.getSyncState().get(BlazeScalaSyncData.class);
+    if (syncData == null) {
+      Messages.showErrorDialog(project, "Project isn't synced. Please resync project.", "Error");
+      return null;
+    }
+    return syncData.getImportResult().libraries.get(libraryKey);
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/libraries/ScalaRootsDetector.java b/scala/src/com/google/idea/blaze/scala/libraries/ScalaRootsDetector.java
new file mode 100644
index 00000000000..1b48b46d36c
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/libraries/ScalaRootsDetector.java
@@ -0,0 +1,23 @@
+package com.google.idea.blaze.scala.libraries;
+
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.libraries.ui.RootDetector;
+import com.intellij.openapi.vfs.VirtualFile;
+import java.util.Collection;
+import org.jetbrains.annotations.NotNull;
+
+public class ScalaRootsDetector extends RootDetector {
+
+  protected ScalaRootsDetector() {
+    super(OrderRootType.SOURCES, false, "sources");
+  }
+
+  @NotNull
+  @Override
+  public Collection<VirtualFile> detectRoots(
+      @NotNull VirtualFile rootCandidate, @NotNull ProgressIndicator progressIndicator
+  ) {
+    return ScalaVfsSourceRootDetectionUtil.suggestRoots(rootCandidate, progressIndicator);
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/libraries/ScalaVfsSourceRootDetectionUtil.java b/scala/src/com/google/idea/blaze/scala/libraries/ScalaVfsSourceRootDetectionUtil.java
new file mode 100644
index 00000000000..7485e0a5691
--- /dev/null
+++ b/scala/src/com/google/idea/blaze/scala/libraries/ScalaVfsSourceRootDetectionUtil.java
@@ -0,0 +1,105 @@
+package com.google.idea.blaze.scala.libraries;
+
+import com.intellij.ide.util.projectWizard.importSources.JavaSourceRootDetectionUtil;
+import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.util.SystemInfo;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileVisitor;
+import com.intellij.util.containers.ContainerUtil;
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.scala.ScalaFileType;
+
+/*
+  Note: copy from IntelliJ source with a change to support ScalaFileType
+ */
+public class ScalaVfsSourceRootDetectionUtil {
+
+  private ScalaVfsSourceRootDetectionUtil() {
+  }
+
+  @NotNull
+  public static List<VirtualFile> suggestRoots(
+      @NotNull VirtualFile dir, @NotNull final ProgressIndicator progressIndicator
+  ) {
+    if (!dir.isDirectory()) {
+      return ContainerUtil.emptyList();
+    }
+
+    final FileTypeManager typeManager = FileTypeManager.getInstance();
+    final ArrayList<VirtualFile> foundDirectories = new ArrayList<>();
+    try {
+      VfsUtilCore.visitChildrenRecursively(dir, new VirtualFileVisitor() {
+        @NotNull
+        @Override
+        public Result visitFileEx(@NotNull VirtualFile file) {
+          progressIndicator.checkCanceled();
+
+          if (file.isDirectory()) {
+            if (typeManager.isFileIgnored(file) || StringUtil
+                .startsWithIgnoreCase(file.getName(), "testData")) {
+              return SKIP_CHILDREN;
+            }
+          } else {
+            FileType type = typeManager.getFileTypeByFileName(file.getNameSequence());
+
+            // Change: instead of JAVA, looks for ScalaFileType
+            if (ScalaFileType.INSTANCE == type) {
+              VirtualFile root = suggestRootForJavaFile(file);
+              if (root != null) {
+                foundDirectories.add(root);
+                return skipTo(root);
+              }
+            }
+          }
+
+          return CONTINUE;
+        }
+      });
+    } catch (ProcessCanceledException ignore) {
+    }
+
+    return foundDirectories;
+  }
+
+  @Nullable
+  private static VirtualFile suggestRootForJavaFile(VirtualFile javaFile) {
+    if (javaFile.isDirectory()) {
+      return null;
+    }
+
+    CharSequence chars = LoadTextUtil.loadText(javaFile);
+
+    String packageName = JavaSourceRootDetectionUtil.getPackageName(chars);
+    if (packageName != null) {
+      VirtualFile root = javaFile.getParent();
+      int index = packageName.length();
+      while (index > 0) {
+        int index1 = packageName.lastIndexOf('.', index - 1);
+        String token = packageName.substring(index1 + 1, index);
+        String dirName = root.getName();
+        final boolean equalsToToken = SystemInfo.isFileSystemCaseSensitive ? dirName.equals(token)
+            : dirName.equalsIgnoreCase(token);
+        if (!equalsToToken) {
+          return null;
+        }
+        root = root.getParent();
+        if (root == null) {
+          return null;
+        }
+        index = index1;
+      }
+      return root;
+    }
+
+    return null;
+  }
+}
diff --git a/scala/src/com/google/idea/blaze/scala/run/producers/GenerateDeployableJarTaskProvider.java b/scala/src/com/google/idea/blaze/scala/run/producers/GenerateDeployableJarTaskProvider.java
index b6147e592d4..1053698b02f 100644
--- a/scala/src/com/google/idea/blaze/scala/run/producers/GenerateDeployableJarTaskProvider.java
+++ b/scala/src/com/google/idea/blaze/scala/run/producers/GenerateDeployableJarTaskProvider.java
@@ -253,6 +253,7 @@ protected BuildResult execute(BlazeContext context) {
                                 context,
                                 invocationContext))
                         .addBlazeFlags(buildResultHelper.getBuildFlags())
+                        .addBlazeFlags("--remote_upload_local_results=false")
                         .build();
                 int exitCode =
                     ExternalTask.builder(workspaceRoot)