From 1beb5db30eee5cda6b2a751677c55f9a1d020998 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Thu, 27 Jun 2024 17:16:19 +0000
Subject: [PATCH 01/11] Add import_depth to allow controlling transative
 dependency depth

---
 ...dVisibilityDrivenProvisioningStrategy.java | 22 +++---------
 .../discovery/JavaAspectsClasspathInfo.java   | 11 +++++-
 ...ProjectPerPackageProvisioningStrategy.java | 35 ++++++++++++++++++-
 .../ProjectPerTargetProvisioningStrategy.java | 26 +++++++++++++-
 .../projectview/BazelProjectFileReader.java   |  8 ++++-
 .../core/projectview/BazelProjectView.java    |  3 +-
 6 files changed, 82 insertions(+), 23 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
index bd251444..20542574 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
@@ -8,7 +8,6 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toCollection;
-import static java.util.stream.Collectors.toSet;
 import static org.eclipse.core.resources.IResource.DEPTH_ZERO;
 
 import java.util.ArrayList;
@@ -248,29 +247,17 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
 
                 // query for rdeps to find classpath exclusions
                 var projectTargets = activeTargetsPerProject.get(bazelProject);
-                var rdeps = workspace.getCommandExecutor()
-                        .runQueryWithoutLock(
-                            new BazelQueryForLabelsCommand(
-                                    workspaceRoot,
-                                    format(
-                                        "kind(java_library, rdeps(//..., %s))",
-                                        projectTargets.stream().map(BazelLabel::toString).collect(joining(" + "))),
-                                    true,
-                                    format(
-                                        "Querying for reverse dependencies of '%s' for classpath computation",
-                                        bazelProject.getName())))
-                        .stream()
-                        .map(BazelLabel::new)
-                        .collect(toSet());
 
+                var targets = projectTargets.stream().map(BazelLabel::toString).collect(joining(" + "));
                 // get all accessible targets based on visibility
                 Set<BazelLabel> allVisibleTargets = workspace.getCommandExecutor()
                         .runQueryWithoutLock(
                             new BazelQueryForLabelsCommand(
                                     workspaceRoot,
                                     format(
-                                        "kind(java_library, visible(%s, //...))",
-                                        projectTargets.stream().map(BazelLabel::toString).collect(joining(" + "))),
+                                        "kind(java_library, visible(%s, //...)) except kind(java_library, rdeps(//..., %s))",
+                                        targets,
+                                        targets),
                                     true,
                                     format(
                                         "Querying for Java targets visibile to '%s' for classpath computation",
@@ -295,7 +282,6 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
 
                 // get the remaining list of visible deps based on workspace dependency graph
                 var visibleDeps = new ArrayList<>(allVisibleTargets);
-                visibleDeps.removeAll(rdeps); // exclude reverse deps
                 visibleDeps.removeAll(projectTargets); // exclude project targets (avoid dependencies on itself)
 
                 // compute the classpath
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index f9c53759..e42877f8 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -66,6 +66,7 @@
 import com.salesforce.bazel.eclipse.core.model.discovery.classpath.AccessRule;
 import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 import com.salesforce.bazel.sdk.command.BazelBuildWithIntelliJAspectsCommand;
+import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
  * Holds information for computing Java classpath configuration of a target or a package.
@@ -132,10 +133,13 @@ static boolean isJavaProtoTarget(TargetIdeInfo target) {
 
     /** set of exports (insertion order is not relevant) */
     final Set<Label> exports = new HashSet<>();
+    final Set<BazelLabel> availableDependencies;
 
-    public JavaAspectsClasspathInfo(JavaAspectsInfo aspectsInfo, BazelWorkspace bazelWorkspace) throws CoreException {
+    public JavaAspectsClasspathInfo(JavaAspectsInfo aspectsInfo, BazelWorkspace bazelWorkspace,
+            Set<BazelLabel> availableDependencies) throws CoreException {
         super(bazelWorkspace);
         this.aspectsInfo = aspectsInfo;
+        this.availableDependencies = availableDependencies;
     }
 
     private void addDirectDependency(Dependency directDependency) {
@@ -363,6 +367,10 @@ public Collection<ClasspathEntry> compute() throws CoreException {
 
         // Collect jars referenced by runtime deps
         for (TargetKey targetKey : runtimeDeps) {
+            if ((availableDependencies.size() > 0)
+                    && !availableDependencies.contains(new BazelLabel(targetKey.getLabel().toString()))) {
+                continue;
+            }
             var entries = resolveDependency(targetKey);
             for (ClasspathEntry entry : entries) {
                 // runtime dependencies are only visible to tests
@@ -514,6 +522,7 @@ protected Collection<ClasspathEntry> resolveDependency(TargetKey targetKey) thro
         var exported = exports.contains(targetKey.getLabel());
         var result = new LinkedHashSet<ClasspathEntry>();
         for (BlazeJarLibrary library : jars) {
+
             var jarEntry = resolveJar(library.libraryArtifact);
             if (jarEntry == null) {
                 if (LOG.isDebugEnabled()) {
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
index 5a418163..6e0c2d58 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
@@ -7,6 +7,7 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -48,6 +49,7 @@
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects.OutputGroup;
 import com.salesforce.bazel.sdk.command.BazelBuildWithIntelliJAspectsCommand;
+import com.salesforce.bazel.sdk.command.BazelQueryForLabelsCommand;
 import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
@@ -80,6 +82,34 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
         try {
             var monitor =
                     TracingSubMonitor.convert(progress, "Computing Bazel project classpaths", 1 + bazelProjects.size());
+
+            var importDepth = workspace.getBazelProjectView().importDepth();
+            Set<BazelLabel> availableDependencies = Set.of();
+            if (importDepth > 0) {
+                List<BazelTarget> targets = new ArrayList<>();
+                for (BazelProject project : bazelProjects) {
+                    monitor.checkCanceled();
+                    targets.addAll(project.getBazelTargets());
+                }
+                var targetLabels =
+                        targets.stream().map(BazelTarget::getLabel).map(BazelLabel::toString).collect(joining(" + "));
+                availableDependencies = workspace.getCommandExecutor()
+                        .runQueryWithoutLock(
+                            new BazelQueryForLabelsCommand(
+                                    workspace.getLocation().toPath(),
+                                    format(
+                                        "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
+                                        targetLabels,
+                                        importDepth,
+                                        targetLabels,
+                                        importDepth),
+                                    true,
+                                    format("Querying for depdendencies for projects: %s", targetLabels)))
+                        .stream()
+                        .map(BazelLabel::new)
+                        .collect(toSet());
+            }
+
             monitor.subTask("Collecting shards...");
 
             Map<BazelProject, Collection<BazelTarget>> activeTargetsPerProject = new HashMap<>();
@@ -137,6 +167,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
             var currentShardCount = 0;
             for (Map<BazelProject, Collection<BazelTarget>> shard : shardsToBuild) {
                 currentShardCount++;
+
                 var targetsToBuild = shard.values()
                         .stream()
                         .flatMap(Collection::stream)
@@ -181,7 +212,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                     subMonitor.checkCanceled();
 
                     // build index of classpath info
-                    var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace);
+                    var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies);
                     var buildPathProblems = new ArrayList<IStatus>();
 
                     // add the targets
@@ -235,6 +266,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
             }
 
             return classpathsByProject;
+
         } finally {
             if (progress != null) {
                 progress.done();
@@ -438,6 +470,7 @@ yield requireNonNull(additionalJavaLikeRules, "additional java like rules not in
                         .contains(ruleName);
             }
         };
+
     }
 
     private void logSourceFilesWithoutCommonRoot(BazelProject project, JavaSourceInfo sourceInfo, boolean isTestSources)
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
index 5dce5ac5..d2094927 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
@@ -2,7 +2,9 @@
 
 import static java.lang.String.format;
 import static java.nio.file.Files.isRegularFile;
+import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 import static org.eclipse.core.runtime.SubMonitor.SUPPRESS_ALL_LABELS;
 
 import java.util.ArrayList;
@@ -32,6 +34,7 @@
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects.OutputGroup;
 import com.salesforce.bazel.sdk.command.BazelBuildWithIntelliJAspectsCommand;
+import com.salesforce.bazel.sdk.command.BazelQueryForLabelsCommand;
 import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
@@ -78,6 +81,27 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
 
             var workspaceRoot = workspace.getLocation().toPath();
 
+            var importDepth = workspace.getBazelProjectView().importDepth();
+            Set<BazelLabel> availableDependencies = Set.of();
+            if (importDepth > 0) {
+                var targetLabels = targetsToBuild.stream().map(BazelLabel::toString).collect(joining(" + "));
+                availableDependencies = workspace.getCommandExecutor()
+                        .runQueryWithoutLock(
+                            new BazelQueryForLabelsCommand(
+                                    workspace.getLocation().toPath(),
+                                    format(
+                                        "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
+                                        targetLabels,
+                                        importDepth,
+                                        targetLabels,
+                                        importDepth),
+                                    true,
+                                    format("Querying for depdendencies for projects: %s", targetLabels)))
+                        .stream()
+                        .map(BazelLabel::new)
+                        .collect(toSet());
+            }
+
             // run the aspect to compute all required information
             var aspects = workspace.getParent().getModelManager().getIntellijAspects();
             var languages = Set.of(LanguageClass.JAVA);
@@ -114,7 +138,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                 monitor.checkCanceled();
 
                 // build index of classpath info
-                var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace);
+                var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies);
 
                 // remove old marker
                 deleteClasspathContainerProblems(bazelProject);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
index a4ac2e90..04579c91 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
@@ -77,6 +77,7 @@ public void close() {
         final LinkedHashSet<String> externalJarsFilters = new LinkedHashSet<>();
         int targetShardSize = 500;
         boolean shardSync = true;
+        int importDepth = 0;
 
         public BazelProjectView build() throws IllegalStateException {
             // check mandatory parameters
@@ -147,7 +148,8 @@ public BazelProjectView build() throws IllegalStateException {
                     discoverAllExternalAndWorkspaceJars,
                     new GlobSetMatcher(externalJarsFilters),
                     shardSync,
-                    targetShardSize);
+                    targetShardSize,
+                    importDepth);
         }
 
         public ImportHandle startImporting(Path bazelProjectViewFile) throws IOException {
@@ -404,6 +406,10 @@ private void parseProjectFile(Path bazelProjectFile, BazelProjectViewBuilder bui
                         // ignore deprecated
                         break;
                     }
+                    case "import_depth": {
+                        builder.importDepth = parseSectionBodyAsInt(rawSection, builder.importDepth);
+                        break;
+                    }
                     default:
                         LOG.warn("Unexpected section '{}' while reading '{}'", rawSection.getName(), bazelProjectFile);
                         break;
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
index 153bcd95..0fac61d1 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
@@ -51,7 +51,8 @@ public record BazelProjectView(
         boolean discoverAllExternalAndWorkspaceJars,
         GlobSetMatcher externalJarsDiscoveryFilter,
         boolean shardSync,
-        int targetShardSize) {
+        int targetShardSize,
+        int importDepth) {
 
     public BazelProjectView {
         directoriesToImport = unmodifiableCollection(directoriesToImport);

From b2a04cebe508055063f8aa40dc7dd138f7f20ccd Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Fri, 28 Jun 2024 21:24:48 +0000
Subject: [PATCH 02/11] Some refactoring

---
 .../discovery/BaseProvisioningStrategy.java   | 34 +++++++++++++++++
 .../discovery/JavaAspectsClasspathInfo.java   | 26 ++++++++++---
 ...ProjectPerPackageProvisioningStrategy.java | 38 +++++--------------
 .../ProjectPerTargetProvisioningStrategy.java | 24 +-----------
 4 files changed, 66 insertions(+), 56 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index 7583d5d7..caac7e13 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -16,6 +16,7 @@
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 import static org.eclipse.core.runtime.Platform.PI_RUNTIME;
 import static org.eclipse.core.runtime.Platform.PREF_LINE_SEPARATOR;
 import static org.eclipse.jdt.core.IClasspathAttribute.ADD_EXPORTS;
@@ -97,6 +98,7 @@
 import com.salesforce.bazel.eclipse.core.model.discovery.projects.LabelEntry;
 import com.salesforce.bazel.eclipse.core.util.trace.TracingSubMonitor;
 import com.salesforce.bazel.sdk.command.BazelCQueryWithStarlarkExpressionCommand;
+import com.salesforce.bazel.sdk.command.BazelQueryForLabelsCommand;
 import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
@@ -564,6 +566,38 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
         }
     }
 
+    /**
+     * Calculates the java_library and java_imports for the provided targets, limited by the depth
+     *
+     * @param workspace
+     *            the bazel workspace
+     * @param targetsToBuild
+     *            a list of targets as part of the build to query their dependencies
+     * @param dependencyDepth
+     *            the depth in the dependency graph to traverse and include in the result
+     * @return a set of java_library and java_imports
+     * @throws CoreException
+     */
+    protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
+            List<BazelLabel> targetsToBuild, int dependencyDepth) throws CoreException {
+        var targetLabels = targetsToBuild.stream().map(BazelLabel::toString).collect(joining(" + "));
+        return workspace.getCommandExecutor()
+                .runQueryWithoutLock(
+                    new BazelQueryForLabelsCommand(
+                            workspace.getLocation().toPath(),
+                            format(
+                                "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
+                                targetLabels,
+                                dependencyDepth,
+                                targetLabels,
+                                dependencyDepth),
+                            true,
+                            format("Querying for depdendencies for projects: %s", targetLabels)))
+                .stream()
+                .map(BazelLabel::new)
+                .collect(toSet());
+    }
+
     /**
      * Collects base Java information for a given project and the targets it represents.
      * <p>
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index e42877f8..fd0c6561 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -133,13 +133,18 @@ static boolean isJavaProtoTarget(TargetIdeInfo target) {
 
     /** set of exports (insertion order is not relevant) */
     final Set<Label> exports = new HashSet<>();
-    final Set<BazelLabel> availableDependencies;
+
+    /**
+     * Set of dependencies available to the whole project, to be used to filter out runtime dependencies that are not
+     * part of this set. Allows creating a partial classpath to improve performance on large projects.
+     */
+    final Set<BazelLabel> runtimeDependencyIncludes;
 
     public JavaAspectsClasspathInfo(JavaAspectsInfo aspectsInfo, BazelWorkspace bazelWorkspace,
-            Set<BazelLabel> availableDependencies) throws CoreException {
+            Set<BazelLabel> runtimeDependencyIncludes) throws CoreException {
         super(bazelWorkspace);
         this.aspectsInfo = aspectsInfo;
-        this.availableDependencies = availableDependencies;
+        this.runtimeDependencyIncludes = runtimeDependencyIncludes;
     }
 
     private void addDirectDependency(Dependency directDependency) {
@@ -367,8 +372,7 @@ public Collection<ClasspathEntry> compute() throws CoreException {
 
         // Collect jars referenced by runtime deps
         for (TargetKey targetKey : runtimeDeps) {
-            if ((availableDependencies.size() > 0)
-                    && !availableDependencies.contains(new BazelLabel(targetKey.getLabel().toString()))) {
+            if (!runtimeDependencyAvailable(targetKey)) {
                 continue;
             }
             var entries = resolveDependency(targetKey);
@@ -636,4 +640,16 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
         return resolveProject(targetKey.getLabel());
     }
 
+    /**
+     * Allows filtering runtime dependencies based on the availability of the dependency in runtimeDependencyIncludes
+     * when it includes elements
+     *
+     * @param targetKey
+     *            the dependency to check
+     * @return true if runtimeDependencyAvailable is empty or it includes the dependency
+     */
+    private boolean runtimeDependencyAvailable(TargetKey targetKey) {
+        return runtimeDependencyIncludes.isEmpty() || runtimeDependencyIncludes.contains(targetKey.getLabel());
+    }
+
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
index 6e0c2d58..3213b67c 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
@@ -7,7 +7,6 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toSet;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -49,7 +48,6 @@
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects.OutputGroup;
 import com.salesforce.bazel.sdk.command.BazelBuildWithIntelliJAspectsCommand;
-import com.salesforce.bazel.sdk.command.BazelQueryForLabelsCommand;
 import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
@@ -83,33 +81,6 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
             var monitor =
                     TracingSubMonitor.convert(progress, "Computing Bazel project classpaths", 1 + bazelProjects.size());
 
-            var importDepth = workspace.getBazelProjectView().importDepth();
-            Set<BazelLabel> availableDependencies = Set.of();
-            if (importDepth > 0) {
-                List<BazelTarget> targets = new ArrayList<>();
-                for (BazelProject project : bazelProjects) {
-                    monitor.checkCanceled();
-                    targets.addAll(project.getBazelTargets());
-                }
-                var targetLabels =
-                        targets.stream().map(BazelTarget::getLabel).map(BazelLabel::toString).collect(joining(" + "));
-                availableDependencies = workspace.getCommandExecutor()
-                        .runQueryWithoutLock(
-                            new BazelQueryForLabelsCommand(
-                                    workspace.getLocation().toPath(),
-                                    format(
-                                        "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
-                                        targetLabels,
-                                        importDepth,
-                                        targetLabels,
-                                        importDepth),
-                                    true,
-                                    format("Querying for depdendencies for projects: %s", targetLabels)))
-                        .stream()
-                        .map(BazelLabel::new)
-                        .collect(toSet());
-            }
-
             monitor.subTask("Collecting shards...");
 
             Map<BazelProject, Collection<BazelTarget>> activeTargetsPerProject = new HashMap<>();
@@ -140,6 +111,15 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                 activeTargetsPerProject.put(bazelProject, projectTargetsToBuild);
             }
 
+            var importDepth = workspace.getBazelProjectView().importDepth();
+            var targets = activeTargetsPerProject.values()
+                    .stream()
+                    .flatMap(Collection::stream)
+                    .map(BazelTarget::getLabel)
+                    .collect(toList());
+            var availableDependencies = importDepth > 0
+                    ? calculateWorkspaceDependencies(workspace, targets, importDepth) : Set.<BazelLabel> of();
+
             // collect classpaths by project
             Map<BazelProject, Collection<ClasspathEntry>> classpathsByProject = new HashMap<>();
 
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
index d2094927..bbf0d9fb 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
@@ -2,9 +2,7 @@
 
 import static java.lang.String.format;
 import static java.nio.file.Files.isRegularFile;
-import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toSet;
 import static org.eclipse.core.runtime.SubMonitor.SUPPRESS_ALL_LABELS;
 
 import java.util.ArrayList;
@@ -34,7 +32,6 @@
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects.OutputGroup;
 import com.salesforce.bazel.sdk.command.BazelBuildWithIntelliJAspectsCommand;
-import com.salesforce.bazel.sdk.command.BazelQueryForLabelsCommand;
 import com.salesforce.bazel.sdk.model.BazelLabel;
 
 /**
@@ -82,25 +79,8 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
             var workspaceRoot = workspace.getLocation().toPath();
 
             var importDepth = workspace.getBazelProjectView().importDepth();
-            Set<BazelLabel> availableDependencies = Set.of();
-            if (importDepth > 0) {
-                var targetLabels = targetsToBuild.stream().map(BazelLabel::toString).collect(joining(" + "));
-                availableDependencies = workspace.getCommandExecutor()
-                        .runQueryWithoutLock(
-                            new BazelQueryForLabelsCommand(
-                                    workspace.getLocation().toPath(),
-                                    format(
-                                        "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
-                                        targetLabels,
-                                        importDepth,
-                                        targetLabels,
-                                        importDepth),
-                                    true,
-                                    format("Querying for depdendencies for projects: %s", targetLabels)))
-                        .stream()
-                        .map(BazelLabel::new)
-                        .collect(toSet());
-            }
+            var availableDependencies = importDepth > 0
+                    ? calculateWorkspaceDependencies(workspace, targetsToBuild, importDepth) : Set.<BazelLabel> of();
 
             // run the aspect to compute all required information
             var aspects = workspace.getParent().getModelManager().getIntellijAspects();

From 7e4701efec72a81ee1d89df4d89bb5a8cc987d69 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Mon, 1 Jul 2024 21:56:25 +0000
Subject: [PATCH 03/11] Store unloaded dependencies for use in runtime

---
 .../classpath/BazelClasspathContainer.java    | 28 +++++++++++++++++--
 ...azelClasspathContainerRuntimeResolver.java | 14 +++++++---
 .../BazelClasspathContainerSaveHelper.java    | 24 ++++++++++------
 .../core/classpath/BazelClasspathManager.java | 22 +++++++++------
 .../core/classpath/ClasspathHolder.java       | 26 +++++++++++++++++
 .../core/edits/AddDependenciesJob.java        |  8 +++++-
 ...dVisibilityDrivenProvisioningStrategy.java |  8 ++++--
 .../discovery/JavaAspectsClasspathInfo.java   | 23 +++++++++++----
 ...ProjectPerPackageProvisioningStrategy.java | 16 ++++++++---
 .../ProjectPerTargetProvisioningStrategy.java | 10 ++++---
 .../discovery/TargetProvisioningStrategy.java |  4 +--
 .../discovery/WorkspaceClasspathStrategy.java | 10 ++++---
 12 files changed, 147 insertions(+), 46 deletions(-)
 create mode 100644 bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
index 9d8469d3..4f24ddc2 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
@@ -36,6 +36,8 @@
 package com.salesforce.bazel.eclipse.core.classpath;
 
 import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.jdt.core.IClasspathContainer;
@@ -49,14 +51,16 @@
  */
 public class BazelClasspathContainer implements IClasspathContainer, Serializable {
 
-    private static final long serialVersionUID = 390898179243551621L;
+    private static final long serialVersionUID = 390898179243551622L;
 
     private final IPath path;
     private final IClasspathEntry[] classpath;
+    private final IClasspathEntry[] unloadedClasspath;
 
-    public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath) {
+    public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] unloadedClasspath) {
         this.path = path;
         this.classpath = classpath;
+        this.unloadedClasspath = unloadedClasspath;
     }
 
     @Override
@@ -69,6 +73,22 @@ public String getDescription() {
         return "Bazel Dependencies";
     }
 
+    public IClasspathEntry[] getFullClasspath() {
+        if (unloadedClasspath.length == 0) {
+            return classpath;
+        }
+        List<IClasspathEntry> entries = new ArrayList<>(unloadedClasspath.length);
+        var index = 0;
+        for (IClasspathEntry entry : unloadedClasspath) {
+            if (entry == null) {
+                entries.add(classpath[index++]);
+            } else {
+                entries.add(entry);
+            }
+        }
+        return entries.toArray(new IClasspathEntry[entries.size()]);
+    }
+
     @Override
     public int getKind() {
         return IClasspathContainer.K_APPLICATION;
@@ -78,4 +98,8 @@ public int getKind() {
     public IPath getPath() {
         return path;
     }
+
+    public IClasspathEntry[] getUnloadedEntries() {
+        return unloadedClasspath;
+    }
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
index 8395d39d..cddfe3ec 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
@@ -129,12 +129,18 @@ private void populateWithSavedContainer(IJavaProject project, Collection<IRuntim
         var bazelContainer = getClasspathManager().getSavedContainer(project.getProject());
         if (bazelContainer != null) {
             var workspaceRoot = project.getResource().getWorkspace().getRoot();
-            var entries = bazelContainer.getClasspathEntries();
+            var entries = bazelContainer.getFullClasspath();
+            //            var entries = bazelContainer.getClasspathEntries();
             for (IClasspathEntry e : entries) {
                 switch (e.getEntryKind()) {
                     case IClasspathEntry.CPE_PROJECT: {
                         // projects need to be resolved properly so we have all the output folders and exported jars on the classpath
                         var sourceProject = workspaceRoot.getProject(e.getPath().segment(0));
+                        //TODO why is recursion happening / why is the project dependeing on itsel?
+                        if (sourceProject.equals(project.getProject())) {
+                            resolvedClasspath.add(new RuntimeClasspathEntry(e));
+                            continue;
+                        }
                         populateWithResolvedProject(resolvedClasspath, sourceProject);
                         break;
                     }
@@ -152,6 +158,8 @@ private void populateWithSavedContainer(IJavaProject project, Collection<IRuntim
                                         e)));
                 }
             }
+
+            //            resolvedClasspath.addAll(Arrays.stream(bazelContainer.getUnloadedEntries()).map(IRuntimeClasspathEntry::new).collect(toList()));
         }
     }
 
@@ -181,9 +189,7 @@ public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEn
             // however it is convenient with source code lookups for missing dependencies
             var bazelProjects = bazelProject.getBazelWorkspace().getBazelProjects();
             for (BazelProject sourceProject : bazelProjects) {
-                if (!sourceProject.isWorkspaceProject()) {
-                    populateWithResolvedProject(result, sourceProject.getProject());
-                }
+                populateWithResolvedProject(result, sourceProject.getProject());
             }
         }
 
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
index 04eb895d..a7fd77ab 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
@@ -26,7 +26,6 @@
 import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.core.IAccessRule;
 import org.eclipse.jdt.core.IClasspathAttribute;
-import org.eclipse.jdt.core.IClasspathContainer;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.JavaCore;
 
@@ -103,8 +102,13 @@ static final class LibraryEntryReplace implements Serializable {
         }
 
         IClasspathEntry getEntry() {
-            return JavaCore.newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, //
-                accessRules, extraAttributes, exported);
+            return JavaCore.newLibraryEntry(
+                path,
+                sourceAttachmentPath,
+                sourceAttachmentRootPath, //
+                accessRules,
+                extraAttributes,
+                exported);
         }
     }
 
@@ -150,12 +154,16 @@ static final class ProjectEntryReplace implements Serializable {
         }
 
         IClasspathEntry getEntry() {
-            return JavaCore.newProjectEntry(path, accessRules, //
-                combineAccessRules, extraAttributes, exported);
+            return JavaCore.newProjectEntry(
+                path,
+                accessRules, //
+                combineAccessRules,
+                extraAttributes,
+                exported);
         }
     }
 
-    public IClasspathContainer readContainer(InputStream input) throws IOException, ClassNotFoundException {
+    public BazelClasspathContainer readContainer(InputStream input) throws IOException, ClassNotFoundException {
         ObjectInputStream is = new ObjectInputStream(new BufferedInputStream(input)) {
             {
                 enableResolveObject(true);
@@ -181,10 +189,10 @@ protected Object resolveObject(Object o) throws IOException {
                 return super.resolveObject(o);
             }
         };
-        return (IClasspathContainer) is.readObject();
+        return (BazelClasspathContainer) is.readObject();
     }
 
-    public void writeContainer(IClasspathContainer container, OutputStream output) throws IOException {
+    public void writeContainer(BazelClasspathContainer container, OutputStream output) throws IOException {
         ObjectOutputStream os = new ObjectOutputStream(new BufferedOutputStream(output)) {
             {
                 enableReplaceObject(true);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
index cb9a2ed2..37f983d3 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
@@ -178,7 +178,7 @@ String getJavadocLocation(IClasspathEntry entry) {
      * @return a saved classpath container for the specified project (may be <code>null</code>)
      * @throws CoreException
      */
-    public IClasspathContainer getSavedContainer(IProject project) throws CoreException {
+    public BazelClasspathContainer getSavedContainer(IProject project) throws CoreException {
         var containerStateFile = getContainerStateFile(project);
         if (!containerStateFile.exists()) {
             return null;
@@ -239,8 +239,8 @@ TargetProvisioningStrategy getTargetProvisioningStrategy(BazelWorkspace bazelWor
      * @param monitor
      * @throws CoreException
      */
-    public void patchClasspathContainer(BazelProject bazelProject, List<ClasspathEntry> classpath,
-            IProgressMonitor progress) throws CoreException {
+    public void patchClasspathContainer(BazelProject bazelProject, ClasspathHolder classpath, IProgressMonitor progress)
+            throws CoreException {
         var monitor = SubMonitor.convert(progress);
         try {
             monitor.beginTask("Patchig classpath: " + bazelProject.getName(), 2);
@@ -300,8 +300,10 @@ public void persistAttachedSourcesAndJavadoc(IJavaProject project, IClasspathCon
                 bazelProject.getBazelWorkspace(),
                 DEFAULT_CLASSPATH,
                 monitor.split(1, SUPPRESS_ALL_LABELS));
-            entries =
-                    configureClasspathWithSourceAttachments(classpaths.get(bazelProject), null /* no props */, monitor);
+            entries = configureClasspathWithSourceAttachments(
+                classpaths.get(bazelProject).loaded(),
+                null /* no props */,
+                monitor);
             for (IClasspathEntry entry : entries) {
                 if (IClasspathEntry.CPE_LIBRARY == entry.getEntryKind()) {
                     var path = entry.getPath().toPortableString();
@@ -338,7 +340,7 @@ public void persistAttachedSourcesAndJavadoc(IJavaProject project, IClasspathCon
         }
     }
 
-    void saveAndSetContainer(IJavaProject javaProject, Collection<ClasspathEntry> classpath, IProgressMonitor monitor)
+    void saveAndSetContainer(IJavaProject javaProject, ClasspathHolder classpath, IProgressMonitor monitor)
             throws CoreException, JavaModelException {
         var containerEntry = getBazelContainerEntry(javaProject);
         var path = containerEntry != null ? containerEntry.getPath()
@@ -347,7 +349,11 @@ void saveAndSetContainer(IJavaProject javaProject, Collection<ClasspathEntry> cl
         var sourceAttachmentProperties = getSourceAttachmentProperties(javaProject.getProject());
         var container = new BazelClasspathContainer(
                 path,
-                configureClasspathWithSourceAttachments(classpath, sourceAttachmentProperties, monitor.slice(1)));
+                configureClasspathWithSourceAttachments(
+                    classpath.loaded(),
+                    sourceAttachmentProperties,
+                    monitor.slice(1)),
+                classpath.unloaded().stream().map(ClasspathEntry::build).toArray(IClasspathEntry[]::new));
 
         JavaCore.setClasspathContainer(
             container.getPath(),
@@ -359,7 +365,7 @@ void saveAndSetContainer(IJavaProject javaProject, Collection<ClasspathEntry> cl
         saveContainerState(javaProject.getProject(), container);
     }
 
-    private void saveContainerState(IProject project, IClasspathContainer container) throws CoreException {
+    private void saveContainerState(IProject project, BazelClasspathContainer container) throws CoreException {
         var containerStateFile = getContainerStateFile(project);
         try (var is = new FileOutputStream(containerStateFile)) {
             new BazelClasspathContainerSaveHelper().writeContainer(container, is);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
new file mode 100644
index 00000000..44c273ea
--- /dev/null
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
@@ -0,0 +1,26 @@
+/*-
+ * Copyright (c) 2024 Salesforce and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *      Salesforce - adapted from M2E, JDT or other Eclipse project
+ */
+package com.salesforce.bazel.eclipse.core.classpath;
+
+import java.util.Collection;
+
+import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
+
+/**
+ * Represents a targets classpath as two parts, loaded being the classpath entries that are loaded into the project
+ * model, and unloaded being classpaths that are part of the target, but are not to be loaded in the project model
+ */
+public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<ClasspathEntry> unloaded) {
+
+}
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
index e16a2dfa..754d9c83 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
@@ -6,6 +6,7 @@
 import static java.util.stream.Collectors.toList;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Stream;
@@ -21,6 +22,7 @@
 import org.eclipse.core.runtime.jobs.Job;
 
 import com.google.idea.blaze.base.model.primitives.Label;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.classpath.InitializeOrRefreshClasspathJob;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
@@ -147,7 +149,11 @@ public IStatus runInWorkspace(final IProgressMonitor monitor) throws CoreExcepti
                 }
 
                 if (modified) {
-                    classpathManager.patchClasspathContainer(bazelProject, classpath, monitor);
+                    var unloaded = Arrays.stream(container.getUnloadedEntries())
+                            .map(ClasspathEntry::fromExisting)
+                            .collect(toList());
+                    classpathManager
+                            .patchClasspathContainer(bazelProject, new ClasspathHolder(classpath, unloaded), monitor);
                 }
                 return Status.OK_STATUS;
             }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
index 20542574..c9338e45 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BuildFileAndVisibilityDrivenProvisioningStrategy.java
@@ -12,6 +12,7 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -36,6 +37,7 @@
 import com.google.idea.blaze.base.model.primitives.WildcardTargetPattern;
 import com.google.idea.blaze.base.model.primitives.WorkspacePath;
 import com.salesforce.bazel.eclipse.core.classpath.BazelClasspathScope;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelPackage;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
@@ -193,7 +195,7 @@ public boolean isAllowedDependencyPath(BazelPackage fromPackage, BazelPackage to
             new TargetDiscoveryAndProvisioningExtensionLookup();
 
     @Override
-    public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collection<BazelProject> bazelProjects,
+    public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProject> bazelProjects,
             BazelWorkspace workspace, BazelClasspathScope scope, IProgressMonitor progress) throws CoreException {
         LOG.debug("Computing classpath for projects: {}", bazelProjects);
         try {
@@ -237,7 +239,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
             // use the hints to avoid circular dependencies between projects in Eclipse
             var circularDependenciesHelper = new CircularDependenciesHelper(workspace.getBazelProjectView().targets());
 
-            Map<BazelProject, Collection<ClasspathEntry>> classpathsByProject = new HashMap<>();
+            Map<BazelProject, ClasspathHolder> classpathsByProject = new HashMap<>();
             for (BazelProject bazelProject : bazelProjects) {
                 monitor.subTask("Analyzing: " + bazelProject);
                 monitor.checkCanceled();
@@ -365,7 +367,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                     }
                 }
 
-                classpathsByProject.put(bazelProject, classpath);
+                classpathsByProject.put(bazelProject, new ClasspathHolder(classpath, Collections.emptyList()));
                 monitor.worked(1);
             }
 
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index fd0c6561..7c383fa4 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -60,6 +60,7 @@
 import com.google.idea.blaze.java.JavaBlazeRules;
 import com.google.idea.blaze.java.sync.importer.ExecutionPathHelper;
 import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
@@ -306,7 +307,7 @@ public IStatus addTarget(BazelTarget bazelTarget) throws CoreException {
      * @return the computed classpath
      * @throws CoreException
      */
-    public Collection<ClasspathEntry> compute() throws CoreException {
+    public ClasspathHolder compute() throws CoreException {
         // the code below is copied and adapted from BlazeJavaWorkspaceImporter
 
         // Preserve classpath order. Add leaf level dependencies first and work the way up. This
@@ -370,12 +371,14 @@ public Collection<ClasspathEntry> compute() throws CoreException {
             }
         }
 
+        Map<IPath, ClasspathEntry> unloadedEntries = new LinkedHashMap<>();
+
+        var hasUnloadedEntries = false;
         // Collect jars referenced by runtime deps
         for (TargetKey targetKey : runtimeDeps) {
-            if (!runtimeDependencyAvailable(targetKey)) {
-                continue;
-            }
             var entries = resolveDependency(targetKey);
+            var runtimeDependencyAvailable = runtimeDependencyAvailable(targetKey);
+
             for (ClasspathEntry entry : entries) {
                 // runtime dependencies are only visible to tests
                 entry.getExtraAttributes().put(IClasspathAttribute.TEST, Boolean.toString(true));
@@ -385,11 +388,19 @@ public Collection<ClasspathEntry> compute() throws CoreException {
                             new AccessRule(
                                     PATTERN_EVERYTHING,
                                     IAccessRule.K_DISCOURAGED | IAccessRule.IGNORE_IF_BETTER));
-                result.putIfAbsent(entry.getPath(), entry);
+                if (runtimeDependencyAvailable) {
+                    result.putIfAbsent(entry.getPath(), entry);
+                    unloadedEntries.putIfAbsent(entry.getPath(), null);
+                } else {
+                    unloadedEntries.putIfAbsent(entry.getPath(), entry);
+                    hasUnloadedEntries = true;
+                }
             }
         }
 
-        return result.values();
+        return new ClasspathHolder(
+                result.values(),
+                hasUnloadedEntries ? unloadedEntries.values() : Collections.emptyList());
     }
 
     private BazelWorkspace findExternalWorkspace(Label label) throws CoreException {
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
index 3213b67c..a6695002 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
@@ -35,6 +35,7 @@
 import com.google.common.collect.Interners;
 import com.google.idea.blaze.base.model.primitives.LanguageClass;
 import com.salesforce.bazel.eclipse.core.classpath.BazelClasspathScope;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelPackage;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
@@ -71,10 +72,12 @@ public class ProjectPerPackageProvisioningStrategy extends BaseProvisioningStrat
     public static final String STRATEGY_NAME = "project-per-package";
 
     private static Logger LOG = LoggerFactory.getLogger(ProjectPerPackageProvisioningStrategy.class);
+    public static final Map<BazelProject, Collection<ClasspathEntry>> TEST = new HashMap<>();
+
     private final Set<String> additionalJavaLikeRules = new HashSet<>();
 
     @Override
-    public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collection<BazelProject> bazelProjects,
+    public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProject> bazelProjects,
             BazelWorkspace workspace, BazelClasspathScope scope, IProgressMonitor progress) throws CoreException {
         LOG.debug("Computing classpath for projects: {}", bazelProjects);
         try {
@@ -121,7 +124,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                     ? calculateWorkspaceDependencies(workspace, targets, importDepth) : Set.<BazelLabel> of();
 
             // collect classpaths by project
-            Map<BazelProject, Collection<ClasspathEntry>> classpathsByProject = new HashMap<>();
+            Map<BazelProject, ClasspathHolder> classpathsByProject = new HashMap<>();
 
             var workspaceRoot = workspace.getLocation().toPath();
 
@@ -207,7 +210,12 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                     }
 
                     // compute the classpath
-                    var classpath = classpathInfo.compute();
+                    var targetClasspath = classpathInfo.compute();
+                    var classpath = targetClasspath.loaded();
+
+                    if (!targetClasspath.unloaded().isEmpty()) {
+                        TEST.put(bazelProject, targetClasspath.unloaded());
+                    }
 
                     // remove old marker
                     deleteClasspathContainerProblems(bazelProject);
@@ -240,7 +248,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                         entry -> (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
                                 && entry.getPath().equals(bazelProject.getProject().getFullPath()));
 
-                    classpathsByProject.put(bazelProject, classpath);
+                    classpathsByProject.put(bazelProject, new ClasspathHolder(classpath, targetClasspath.unloaded()));
                     subMonitor.worked(1);
                 }
             }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
index bbf0d9fb..7b375e89 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
@@ -23,6 +23,7 @@
 
 import com.google.idea.blaze.base.model.primitives.LanguageClass;
 import com.salesforce.bazel.eclipse.core.classpath.BazelClasspathScope;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
@@ -55,7 +56,7 @@ public class ProjectPerTargetProvisioningStrategy extends BaseProvisioningStrate
     public static final String STRATEGY_NAME = "project-per-target";
 
     @Override
-    public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collection<BazelProject> bazelProjects,
+    public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProject> bazelProjects,
             BazelWorkspace workspace, BazelClasspathScope scope, IProgressMonitor progress) throws CoreException {
         LOG.debug("Computing classpath for projects: {}", bazelProjects);
         try {
@@ -111,7 +112,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                         monitor.split(1, SUPPRESS_ALL_LABELS));
 
             // populate map from result
-            Map<BazelProject, Collection<ClasspathEntry>> classpathsByProject = new HashMap<>();
+            Map<BazelProject, ClasspathHolder> classpathsByProject = new HashMap<>();
             var aspectsInfo = new JavaAspectsInfo(result, workspace);
             for (BazelProject bazelProject : bazelProjects) {
                 monitor.subTask(bazelProject.getName());
@@ -130,7 +131,8 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                 }
 
                 // compute the classpath
-                var classpath = classpathInfo.compute();
+                var targetClasspath = classpathInfo.compute();
+                var classpath = targetClasspath.loaded();
 
                 // check for non existing jars
                 for (ClasspathEntry entry : classpath) {
@@ -155,7 +157,7 @@ public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collectio
                     entry -> (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
                             && entry.getPath().equals(bazelProject.getProject().getFullPath()));
 
-                classpathsByProject.put(bazelProject, classpath);
+                classpathsByProject.put(bazelProject, new ClasspathHolder(classpath, targetClasspath.unloaded()));
                 monitor.worked(1);
             }
 
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/TargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/TargetProvisioningStrategy.java
index 32bed133..b591adb6 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/TargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/TargetProvisioningStrategy.java
@@ -12,11 +12,11 @@
 import org.eclipse.jdt.core.IClasspathEntry;
 
 import com.salesforce.bazel.eclipse.core.classpath.BazelClasspathScope;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
 import com.salesforce.bazel.eclipse.core.model.SynchronizeProjectViewJob;
-import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 
 /**
  * The target discovery strategy is responsible for provisioning targets into Eclipse as Eclipse projects.
@@ -78,7 +78,7 @@ public interface TargetProvisioningStrategy {
      * @throws CoreException
      *             in case of problems computing the classpath
      */
-    Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collection<BazelProject> bazelProjects,
+    Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProject> bazelProjects,
             BazelWorkspace workspace, BazelClasspathScope scope, IProgressMonitor monitor) throws CoreException;
 
     /**
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/WorkspaceClasspathStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/WorkspaceClasspathStrategy.java
index cecae4d1..769e21b5 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/WorkspaceClasspathStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/WorkspaceClasspathStrategy.java
@@ -8,6 +8,7 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.SortedSet;
@@ -19,6 +20,7 @@
 import org.eclipse.core.runtime.SubMonitor;
 
 import com.salesforce.bazel.eclipse.core.classpath.BazelClasspathScope;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
@@ -57,7 +59,7 @@ public class WorkspaceClasspathStrategy extends BaseProvisioningStrategy {
      * @return the computed classpath
      * @throws CoreException
      */
-    public Collection<ClasspathEntry> computeClasspath(BazelProject workspaceProject, BazelWorkspace bazelWorkspace,
+    public ClasspathHolder computeClasspath(BazelProject workspaceProject, BazelWorkspace bazelWorkspace,
             BazelClasspathScope scope, IProgressMonitor progress) throws CoreException {
         try {
             var monitor = SubMonitor.convert(progress);
@@ -84,7 +86,7 @@ public Collection<ClasspathEntry> computeClasspath(BazelProject workspaceProject
 
             if (!bazelWorkspace.getBazelProjectView().discoverAllExternalAndWorkspaceJars()) {
                 // abort early when discovery is disabled
-                return result;
+                return new ClasspathHolder(result, Collections.emptyList());
             }
 
             var externalLibrariesDiscovery = new ExternalLibrariesDiscovery(bazelWorkspace);
@@ -121,14 +123,14 @@ public Collection<ClasspathEntry> computeClasspath(BazelProject workspaceProject
                         "Some source jars are missing. Bazel does not build them by default. Consider runing 'bazel build  --output_groups=+_source_jars //...' to build any missing source jar."));
             }
 
-            return result;
+            return new ClasspathHolder(result, Collections.emptyList());
         } finally {
             progress.done();
         }
     }
 
     @Override
-    public Map<BazelProject, Collection<ClasspathEntry>> computeClasspaths(Collection<BazelProject> bazelProjects,
+    public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProject> bazelProjects,
             BazelWorkspace workspace, BazelClasspathScope scope, IProgressMonitor monitor) throws CoreException {
         if (bazelProjects.size() != 1) {
             throw new IllegalArgumentException("This strategy must only be used for the BazelWorkspace project!");

From 7eb1b4ecc2dc21738fd5c0606cf5b85fb27a0f94 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Tue, 2 Jul 2024 20:00:56 +0000
Subject: [PATCH 04/11] Refactor

---
 ...azelClasspathContainerRuntimeResolver.java | 12 +--
 .../discovery/BaseProvisioningStrategy.java   | 96 +++++++++----------
 .../discovery/JavaAspectsClasspathInfo.java   | 49 +++++++++-
 ...ProjectPerPackageProvisioningStrategy.java | 40 +-------
 .../ProjectPerTargetProvisioningStrategy.java | 34 +------
 5 files changed, 104 insertions(+), 127 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
index cddfe3ec..2fcce786 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerRuntimeResolver.java
@@ -130,17 +130,11 @@ private void populateWithSavedContainer(IJavaProject project, Collection<IRuntim
         if (bazelContainer != null) {
             var workspaceRoot = project.getResource().getWorkspace().getRoot();
             var entries = bazelContainer.getFullClasspath();
-            //            var entries = bazelContainer.getClasspathEntries();
             for (IClasspathEntry e : entries) {
                 switch (e.getEntryKind()) {
                     case IClasspathEntry.CPE_PROJECT: {
                         // projects need to be resolved properly so we have all the output folders and exported jars on the classpath
                         var sourceProject = workspaceRoot.getProject(e.getPath().segment(0));
-                        //TODO why is recursion happening / why is the project dependeing on itsel?
-                        if (sourceProject.equals(project.getProject())) {
-                            resolvedClasspath.add(new RuntimeClasspathEntry(e));
-                            continue;
-                        }
                         populateWithResolvedProject(resolvedClasspath, sourceProject);
                         break;
                     }
@@ -158,8 +152,6 @@ private void populateWithSavedContainer(IJavaProject project, Collection<IRuntim
                                         e)));
                 }
             }
-
-            //            resolvedClasspath.addAll(Arrays.stream(bazelContainer.getUnloadedEntries()).map(IRuntimeClasspathEntry::new).collect(toList()));
         }
     }
 
@@ -189,7 +181,9 @@ public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEn
             // however it is convenient with source code lookups for missing dependencies
             var bazelProjects = bazelProject.getBazelWorkspace().getBazelProjects();
             for (BazelProject sourceProject : bazelProjects) {
-                populateWithResolvedProject(result, sourceProject.getProject());
+                if (!sourceProject.isWorkspaceProject()) {
+                    populateWithResolvedProject(result, sourceProject.getProject());
+                }
             }
         }
 
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index caac7e13..50ab04f9 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -125,14 +125,61 @@ public abstract class BaseProvisioningStrategy implements TargetProvisioningStra
 
     private static Logger LOG = LoggerFactory.getLogger(BaseProvisioningStrategy.class);
 
-    private BazelProjectFileSystemMapper fileSystemMapper;
+    /**
+     * Creates a problem marker of type {@link BazelCoreSharedContstants#CLASSPATH_CONTAINER_PROBLEM_MARKER} for the
+     * given status.
+     *
+     * @param project
+     *            the project to create the marker at (must not be <code>null</code>)
+     * @param status
+     *            the status to create the marker for (must not be <code>null</code>)
+     * @return the created marker (never <code>null</code>)
+     * @throws CoreException
+     */
+    static IMarker createClasspathContainerProblem(BazelProject project, IStatus status) throws CoreException {
+        return createMarker(project.getProject(), CLASSPATH_CONTAINER_PROBLEM_MARKER, status);
+    }
+
+    static IMarker createMarker(IResource resource, String type, IStatus status) throws CoreException {
+        var message = status.getMessage();
+        if (status.isMultiStatus()) {
+            var children = status.getChildren();
+            if ((children != null) && (children.length > 0)) {
+                message = children[0].getMessage();
+            }
+        }
+        if ((message == null) && (status.getException() != null)) {
+            message = status.getException().getMessage();
+        }
+
+        if (message.length() >= 21000) {
+            // marker content is limited in length
+            message = message.substring(0, 20997).concat("...");
+        }
+
+        Map<String, Object> markerAttributes = new HashMap<>();
+        markerAttributes.put(IMarker.MESSAGE, message);
+        markerAttributes.put(IMarker.SOURCE_ID, "Bazel Project Provisioning");
 
+        if (status.matches(IStatus.ERROR)) {
+            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_ERROR));
+        } else if (status.matches(IStatus.WARNING)) {
+            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_WARNING));
+        } else if (status.matches(IStatus.INFO)) {
+            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_INFO));
+        }
+
+        return resource.createMarker(type, markerAttributes);
+    }
+
+    private BazelProjectFileSystemMapper fileSystemMapper;
     /**
      * Eclipse VM representing the currecurrent_java_toolchain
      */
     protected IVMInstall javaToolchainVm;
 
     protected String javaToolchainSourceVersion;
+
     protected String javaToolchainTargetVersion;
 
     /**
@@ -820,21 +867,6 @@ protected IMarker createBuildPathProblem(BazelProject project, IStatus status) t
         return createMarker(project.getProject(), BUILDPATH_PROBLEM_MARKER, status);
     }
 
-    /**
-     * Creates a problem marker of type {@link BazelCoreSharedContstants#CLASSPATH_CONTAINER_PROBLEM_MARKER} for the
-     * given status.
-     *
-     * @param project
-     *            the project to create the marker at (must not be <code>null</code>)
-     * @param status
-     *            the status to create the marker for (must not be <code>null</code>)
-     * @return the created marker (never <code>null</code>)
-     * @throws CoreException
-     */
-    protected IMarker createClasspathContainerProblem(BazelProject project, IStatus status) throws CoreException {
-        return createMarker(project.getProject(), CLASSPATH_CONTAINER_PROBLEM_MARKER, status);
-    }
-
     /**
      * Creates a folder hierarchy and marks them as derived (because they are generated and should not go into SCM)
      *
@@ -865,38 +897,6 @@ protected final void createFolderAndParents(final IContainer folder, IProgressMo
         }
     }
 
-    protected IMarker createMarker(IResource resource, String type, IStatus status) throws CoreException {
-        var message = status.getMessage();
-        if (status.isMultiStatus()) {
-            var children = status.getChildren();
-            if ((children != null) && (children.length > 0)) {
-                message = children[0].getMessage();
-            }
-        }
-        if ((message == null) && (status.getException() != null)) {
-            message = status.getException().getMessage();
-        }
-
-        if (message.length() >= 21000) {
-            // marker content is limited in length
-            message = message.substring(0, 20997).concat("...");
-        }
-
-        Map<String, Object> markerAttributes = new HashMap<>();
-        markerAttributes.put(IMarker.MESSAGE, message);
-        markerAttributes.put(IMarker.SOURCE_ID, "Bazel Project Provisioning");
-
-        if (status.matches(IStatus.ERROR)) {
-            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_ERROR));
-        } else if (status.matches(IStatus.WARNING)) {
-            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_WARNING));
-        } else if (status.matches(IStatus.INFO)) {
-            markerAttributes.put(IMarker.SEVERITY, Integer.valueOf(IMarker.SEVERITY_INFO));
-        }
-
-        return resource.createMarker(type, markerAttributes);
-    }
-
     /**
      * Creates an Eclipse project representing the specified owner.
      * <p>
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index 7c383fa4..24f63d1b 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -16,6 +16,7 @@
 
 import static java.lang.String.format;
 import static java.nio.file.Files.exists;
+import static java.nio.file.Files.isRegularFile;
 import static java.util.stream.Collectors.toList;
 import static org.eclipse.core.runtime.IPath.forPosix;
 import static org.eclipse.core.runtime.IPath.fromPath;
@@ -42,6 +43,7 @@
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jdt.core.IAccessRule;
 import org.eclipse.jdt.core.IClasspathAttribute;
+import org.eclipse.jdt.core.IClasspathEntry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -135,6 +137,9 @@ static boolean isJavaProtoTarget(TargetIdeInfo target) {
     /** set of exports (insertion order is not relevant) */
     final Set<Label> exports = new HashSet<>();
 
+    /** bazel project for this aspect */
+    final BazelProject bazelProject;
+
     /**
      * Set of dependencies available to the whole project, to be used to filter out runtime dependencies that are not
      * part of this set. Allows creating a partial classpath to improve performance on large projects.
@@ -142,10 +147,11 @@ static boolean isJavaProtoTarget(TargetIdeInfo target) {
     final Set<BazelLabel> runtimeDependencyIncludes;
 
     public JavaAspectsClasspathInfo(JavaAspectsInfo aspectsInfo, BazelWorkspace bazelWorkspace,
-            Set<BazelLabel> runtimeDependencyIncludes) throws CoreException {
+            Set<BazelLabel> runtimeDependencyIncludes, BazelProject bazelProject) throws CoreException {
         super(bazelWorkspace);
         this.aspectsInfo = aspectsInfo;
         this.runtimeDependencyIncludes = runtimeDependencyIncludes;
+        this.bazelProject = bazelProject;
     }
 
     private void addDirectDependency(Dependency directDependency) {
@@ -332,6 +338,9 @@ public ClasspathHolder compute() throws CoreException {
             }
             var entry = resolveLibrary(library);
             if (entry != null) {
+                if (!entryAvailable(entry)) {
+                    continue;
+                }
                 if (jdepsDependency.dependencyKind == Kind.IMPLICIT) {
                     entry.getAccessRules()
                             .add(
@@ -359,6 +368,9 @@ public ClasspathHolder compute() throws CoreException {
                 }
                 continue;
             }
+            if (!entryAvailable(jarEntry)) {
+                continue;
+            }
             jarEntry.setExported(true); // source jars should be exported
             result.putIfAbsent(jarEntry.getPath(), jarEntry);
         }
@@ -367,7 +379,9 @@ public ClasspathHolder compute() throws CoreException {
         for (TargetKey targetKey : directDeps) {
             var entries = resolveDependency(targetKey);
             for (ClasspathEntry entry : entries) {
-                result.putIfAbsent(entry.getPath(), entry);
+                if (entryAvailable(entry)) {
+                    result.putIfAbsent(entry.getPath(), entry);
+                }
             }
         }
 
@@ -380,6 +394,9 @@ public ClasspathHolder compute() throws CoreException {
             var runtimeDependencyAvailable = runtimeDependencyAvailable(targetKey);
 
             for (ClasspathEntry entry : entries) {
+                if (!entryAvailable(entry)) {
+                    continue;
+                }
                 // runtime dependencies are only visible to tests
                 entry.getExtraAttributes().put(IClasspathAttribute.TEST, Boolean.toString(true));
                 // runtime dependencies are never accessible
@@ -403,6 +420,29 @@ public ClasspathHolder compute() throws CoreException {
                 hasUnloadedEntries ? unloadedEntries.values() : Collections.emptyList());
     }
 
+    /**
+     * Validates the classpath entry is valid and returns true if the entry should be included
+     *
+     * @param entry
+     *            the classpath entry to validate and check
+     * @return false if the entry should not be included in the classpath
+     * @throws CoreException
+     *             if validation fails
+     */
+    private boolean entryAvailable(ClasspathEntry entry) throws CoreException {
+        if ((entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) && !isRegularFile(entry.getPath().toPath())) {
+            BaseProvisioningStrategy.createClasspathContainerProblem(
+                bazelProject,
+                Status.error(
+                    format("Library '%s' is missing. Please consider running 'bazel fetch'", entry.getPath())));
+        }
+
+        // remove references to the project represented by the package
+        // (this can happen because we have tests and none tests in the same package, also the runtime CP self-reference)
+        return (entry.getEntryKind() != IClasspathEntry.CPE_PROJECT)
+                || !entry.getPath().equals(bazelProject.getProject().getFullPath());
+    }
+
     private BazelWorkspace findExternalWorkspace(Label label) throws CoreException {
         var externalWorkspaceName = label.externalWorkspaceName();
         if (externalWorkspaceName.startsWith("@")) {
@@ -652,7 +692,7 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
     }
 
     /**
-     * Allows filtering runtime dependencies based on the availability of the dependency in runtimeDependencyIncludes
+     * Allows filtering runtime dependencies based on the availability of the dependency in runtimseDependencyIncludes
      * when it includes elements
      *
      * @param targetKey
@@ -660,7 +700,8 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
      * @return true if runtimeDependencyAvailable is empty or it includes the dependency
      */
     private boolean runtimeDependencyAvailable(TargetKey targetKey) {
-        return runtimeDependencyIncludes.isEmpty() || runtimeDependencyIncludes.contains(targetKey.getLabel());
+        return runtimeDependencyIncludes.isEmpty()
+                || runtimeDependencyIncludes.contains(new BazelLabel(targetKey.getLabel().toString()));
     }
 
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
index a6695002..d74a2671 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
@@ -1,7 +1,6 @@
 package com.salesforce.bazel.eclipse.core.model.discovery;
 
 import static java.lang.String.format;
-import static java.nio.file.Files.isRegularFile;
 import static java.util.Objects.requireNonNull;
 import static java.util.function.Predicate.not;
 import static java.util.stream.Collectors.groupingBy;
@@ -27,7 +26,6 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
-import org.eclipse.jdt.core.IClasspathEntry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -41,7 +39,6 @@
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspaceBlazeInfo;
-import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 import com.salesforce.bazel.eclipse.core.model.discovery.projects.JavaProjectInfo;
 import com.salesforce.bazel.eclipse.core.model.discovery.projects.JavaSourceEntry;
 import com.salesforce.bazel.eclipse.core.model.discovery.projects.JavaSourceInfo;
@@ -72,7 +69,6 @@ public class ProjectPerPackageProvisioningStrategy extends BaseProvisioningStrat
     public static final String STRATEGY_NAME = "project-per-package";
 
     private static Logger LOG = LoggerFactory.getLogger(ProjectPerPackageProvisioningStrategy.class);
-    public static final Map<BazelProject, Collection<ClasspathEntry>> TEST = new HashMap<>();
 
     private final Set<String> additionalJavaLikeRules = new HashSet<>();
 
@@ -195,7 +191,8 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                     subMonitor.checkCanceled();
 
                     // build index of classpath info
-                    var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies);
+                    var classpathInfo =
+                            new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies, bazelProject);
                     var buildPathProblems = new ArrayList<IStatus>();
 
                     // add the targets
@@ -210,12 +207,7 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                     }
 
                     // compute the classpath
-                    var targetClasspath = classpathInfo.compute();
-                    var classpath = targetClasspath.loaded();
-
-                    if (!targetClasspath.unloaded().isEmpty()) {
-                        TEST.put(bazelProject, targetClasspath.unloaded());
-                    }
+                    var classpath = classpathInfo.compute();
 
                     // remove old marker
                     deleteClasspathContainerProblems(bazelProject);
@@ -225,36 +217,12 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                         createClasspathContainerProblem(bazelProject, problem);
                     }
 
-                    // check for non existing jars
-                    for (ClasspathEntry entry : classpath) {
-                        if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY) {
-                            continue;
-                        }
-
-                        if (!isRegularFile(entry.getPath().toPath())) {
-                            createClasspathContainerProblem(
-                                bazelProject,
-                                Status.error(
-                                    format(
-                                        "Library '%s' is missing. Please consider running 'bazel fetch'",
-                                        entry.getPath())));
-                            break;
-                        }
-                    }
-
-                    // remove references to the project represented by the package
-                    // (this can happen because we have tests and none tests in the same package, also the runtime CP self-reference)
-                    classpath.removeIf(
-                        entry -> (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
-                                && entry.getPath().equals(bazelProject.getProject().getFullPath()));
-
-                    classpathsByProject.put(bazelProject, new ClasspathHolder(classpath, targetClasspath.unloaded()));
+                    classpathsByProject.put(bazelProject, classpath);
                     subMonitor.worked(1);
                 }
             }
 
             return classpathsByProject;
-
         } finally {
             if (progress != null) {
                 progress.done();
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
index 7b375e89..ef04b891 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
@@ -1,7 +1,6 @@
 package com.salesforce.bazel.eclipse.core.model.discovery;
 
 import static java.lang.String.format;
-import static java.nio.file.Files.isRegularFile;
 import static java.util.stream.Collectors.toList;
 import static org.eclipse.core.runtime.SubMonitor.SUPPRESS_ALL_LABELS;
 
@@ -17,7 +16,6 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.SubMonitor;
-import org.eclipse.jdt.core.IClasspathEntry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -28,7 +26,6 @@
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspaceBlazeInfo;
-import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 import com.salesforce.bazel.eclipse.core.util.trace.TracingSubMonitor;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects;
 import com.salesforce.bazel.sdk.aspects.intellij.IntellijAspects.OutputGroup;
@@ -119,7 +116,8 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                 monitor.checkCanceled();
 
                 // build index of classpath info
-                var classpathInfo = new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies);
+                var classpathInfo =
+                        new JavaAspectsClasspathInfo(aspectsInfo, workspace, availableDependencies, bazelProject);
 
                 // remove old marker
                 deleteClasspathContainerProblems(bazelProject);
@@ -131,33 +129,9 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                 }
 
                 // compute the classpath
-                var targetClasspath = classpathInfo.compute();
-                var classpath = targetClasspath.loaded();
-
-                // check for non existing jars
-                for (ClasspathEntry entry : classpath) {
-                    if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY) {
-                        continue;
-                    }
-
-                    if (!isRegularFile(entry.getPath().toPath())) {
-                        createClasspathContainerProblem(
-                            bazelProject,
-                            Status.error(
-                                format(
-                                    "Library '%s' is missing. Please consider running 'bazel fetch'",
-                                    entry.getPath())));
-                        break;
-                    }
-                }
-
-                // remove references to the project
-                // (the runtime classpath will contain a reference to the project)
-                classpath.removeIf(
-                    entry -> (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
-                            && entry.getPath().equals(bazelProject.getProject().getFullPath()));
+                var classpath = classpathInfo.compute();
 
-                classpathsByProject.put(bazelProject, new ClasspathHolder(classpath, targetClasspath.unloaded()));
+                classpathsByProject.put(bazelProject, classpath);
                 monitor.worked(1);
             }
 

From 5e55f348f964240bbfa6ac179cce9c2b6f53e961 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Wed, 3 Jul 2024 02:43:17 +0000
Subject: [PATCH 05/11] Ensure loaded and unloaded are correct

---
 .../classpath/BazelClasspathContainer.java    | 10 +++-
 .../core/classpath/BazelClasspathManager.java |  5 +-
 .../core/classpath/ClasspathHolder.java       | 57 ++++++++++++++++++-
 .../core/edits/AddDependenciesJob.java        |  5 +-
 .../discovery/JavaAspectsClasspathInfo.java   | 33 +++--------
 5 files changed, 81 insertions(+), 29 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
index 4f24ddc2..8d1e84df 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
@@ -55,7 +55,7 @@ public class BazelClasspathContainer implements IClasspathContainer, Serializabl
 
     private final IPath path;
     private final IClasspathEntry[] classpath;
-    private final IClasspathEntry[] unloadedClasspath;
+    private final IClasspathEntry[/*Nullable*/] unloadedClasspath;
 
     public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] unloadedClasspath) {
         this.path = path;
@@ -86,6 +86,9 @@ public IClasspathEntry[] getFullClasspath() {
                 entries.add(entry);
             }
         }
+        for (var i = index; i < classpath.length; i++) {
+            entries.add(classpath[i]);
+        }
         return entries.toArray(new IClasspathEntry[entries.size()]);
     }
 
@@ -99,6 +102,11 @@ public IPath getPath() {
         return path;
     }
 
+    /**
+     * A array of nullable unloaded classpath entries.
+     *
+     * @return
+     */
     public IClasspathEntry[] getUnloadedEntries() {
         return unloadedClasspath;
     }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
index 37f983d3..1075afcf 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
@@ -347,13 +347,16 @@ void saveAndSetContainer(IJavaProject javaProject, ClasspathHolder classpath, IP
                 : new Path(BazelCoreSharedContstants.CLASSPATH_CONTAINER_ID);
 
         var sourceAttachmentProperties = getSourceAttachmentProperties(javaProject.getProject());
+        var unloadedClasspath =
+                classpath.unloaded().stream().map(ce -> ce.isPresent() ? ce.get().build() : null).collect(toList());
+
         var container = new BazelClasspathContainer(
                 path,
                 configureClasspathWithSourceAttachments(
                     classpath.loaded(),
                     sourceAttachmentProperties,
                     monitor.slice(1)),
-                classpath.unloaded().stream().map(ClasspathEntry::build).toArray(IClasspathEntry[]::new));
+                unloadedClasspath.toArray(new IClasspathEntry[unloadedClasspath.size()]));
 
         JavaCore.setClasspathContainer(
             container.getPath(),
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
index 44c273ea..ff57e5a1 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
@@ -14,13 +14,66 @@
 package com.salesforce.bazel.eclipse.core.classpath;
 
 import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.eclipse.core.runtime.IPath;
 
 import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 
 /**
  * Represents a targets classpath as two parts, loaded being the classpath entries that are loaded into the project
- * model, and unloaded being classpaths that are part of the target, but are not to be loaded in the project model
+ * model, and unloaded being classpaths that are part of the target, but are not to be loaded in the project model.
+ *
+ * Note: Unloaded contains null values to keep the order between loaded and unloaded
  */
-public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<ClasspathEntry> unloaded) {
+public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<Optional<ClasspathEntry>> unloaded) {
+
+    public static class ClasspathHolderBuilder {
+        // Preserve classpath order. Add leaf level dependencies first and work the way up. This
+        // prevents conflicts when a JAR repackages it's dependencies. In such a case we prefer to
+        // resolve symbols from the original JAR rather than the repackaged version.
+        // Using accessOrdered LinkedHashMap because jars that are present in `workspaceBuilder.jdeps`
+        // and in `workspaceBuilder.directDeps`, we want to treat it as a directDep
+        private final Map<IPath, ClasspathEntry> loadedEntries =
+                new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
+        private final Map<IPath, Optional<ClasspathEntry>> unloadedEntries =
+                new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
+        private boolean hasUnloadedEntries = false;
+
+        private final boolean partialClasspathEnabled;
+
+        public ClasspathHolderBuilder(boolean partialClasspathEnabled) {
+            this.partialClasspathEnabled = partialClasspathEnabled;
+        }
+
+        public ClasspathHolder build() {
+            return new ClasspathHolder(
+                    loadedEntries.values(),
+                    hasUnloadedEntries ? unloadedEntries.values() : Collections.emptyList());
+        }
+
+        public void put(IPath path, ClasspathEntry entry) {
+            loadedEntries.put(path, entry);
+            if (partialClasspathEnabled) {
+                unloadedEntries.put(path, Optional.empty());
+            }
+        }
+
+        public void putIfAbsent(IPath path, ClasspathEntry entry) {
+            loadedEntries.putIfAbsent(path, entry);
+            if (partialClasspathEnabled) {
+                unloadedEntries.put(path, Optional.empty());
+            }
+        }
 
+        public void putUnloadedIfAbsent(IPath path, ClasspathEntry entry) {
+            if (!loadedEntries.containsKey(path)) {
+                unloadedEntries.putIfAbsent(path, Optional.of(entry));
+                hasUnloadedEntries = true;
+            }
+        }
+    }
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
index 754d9c83..33de4c2a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
@@ -9,6 +9,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.eclipse.core.resources.IResourceRuleFactory;
@@ -150,7 +151,9 @@ public IStatus runInWorkspace(final IProgressMonitor monitor) throws CoreExcepti
 
                 if (modified) {
                     var unloaded = Arrays.stream(container.getUnloadedEntries())
-                            .map(ClasspathEntry::fromExisting)
+                            .map(
+                                ce -> ce != null ? Optional.of(ClasspathEntry.fromExisting(ce))
+                                        : Optional.<ClasspathEntry> empty())
                             .collect(toList());
                     classpathManager
                             .patchClasspathContainer(bazelProject, new ClasspathHolder(classpath, unloaded), monitor);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index 24f63d1b..2a49bf0a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -28,16 +28,13 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Status;
@@ -63,6 +60,7 @@
 import com.google.idea.blaze.java.sync.importer.ExecutionPathHelper;
 import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
 import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder;
+import com.salesforce.bazel.eclipse.core.classpath.ClasspathHolder.ClasspathHolderBuilder;
 import com.salesforce.bazel.eclipse.core.model.BazelProject;
 import com.salesforce.bazel.eclipse.core.model.BazelTarget;
 import com.salesforce.bazel.eclipse.core.model.BazelWorkspace;
@@ -316,13 +314,7 @@ public IStatus addTarget(BazelTarget bazelTarget) throws CoreException {
     public ClasspathHolder compute() throws CoreException {
         // the code below is copied and adapted from BlazeJavaWorkspaceImporter
 
-        // Preserve classpath order. Add leaf level dependencies first and work the way up. This
-        // prevents conflicts when a JAR repackages it's dependencies. In such a case we prefer to
-        // resolve symbols from the original JAR rather than the repackaged version.
-        // Using accessOrdered LinkedHashMap because jars that are present in `workspaceBuilder.jdeps`
-        // and in `workspaceBuilder.directDeps`, we want to treat it as a directDep
-        Map<IPath, ClasspathEntry> result =
-                new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
+        var classpathBuilder = new ClasspathHolderBuilder(!runtimeDependencyIncludes.isEmpty());
 
         // Collect jars from jdep references
         for (JdepsDependency jdepsDependency : jdepsCompileJars) {
@@ -349,10 +341,10 @@ public ClasspathHolder compute() throws CoreException {
                                         IAccessRule.K_DISCOURAGED | IAccessRule.IGNORE_IF_BETTER));
 
                     // there might be an explicit entry, which we will never want to override!
-                    result.putIfAbsent(entry.getPath(), entry);
+                    classpathBuilder.putIfAbsent(entry.getPath(), entry);
                 } else {
                     entry.getAccessRules().add(new AccessRule(PATTERN_EVERYTHING, IAccessRule.K_ACCESSIBLE));
-                    result.put(entry.getPath(), entry);
+                    classpathBuilder.put(entry.getPath(), entry);
                 }
             } else if (LOG.isDebugEnabled()) {
                 LOG.warn("Unable to resolve compile jar: {}", jdepsDependency);
@@ -372,7 +364,7 @@ public ClasspathHolder compute() throws CoreException {
                 continue;
             }
             jarEntry.setExported(true); // source jars should be exported
-            result.putIfAbsent(jarEntry.getPath(), jarEntry);
+            classpathBuilder.putIfAbsent(jarEntry.getPath(), jarEntry);
         }
 
         // Collect jars referenced by direct deps
@@ -380,14 +372,11 @@ public ClasspathHolder compute() throws CoreException {
             var entries = resolveDependency(targetKey);
             for (ClasspathEntry entry : entries) {
                 if (entryAvailable(entry)) {
-                    result.putIfAbsent(entry.getPath(), entry);
+                    classpathBuilder.putIfAbsent(entry.getPath(), entry);
                 }
             }
         }
 
-        Map<IPath, ClasspathEntry> unloadedEntries = new LinkedHashMap<>();
-
-        var hasUnloadedEntries = false;
         // Collect jars referenced by runtime deps
         for (TargetKey targetKey : runtimeDeps) {
             var entries = resolveDependency(targetKey);
@@ -406,18 +395,14 @@ public ClasspathHolder compute() throws CoreException {
                                     PATTERN_EVERYTHING,
                                     IAccessRule.K_DISCOURAGED | IAccessRule.IGNORE_IF_BETTER));
                 if (runtimeDependencyAvailable) {
-                    result.putIfAbsent(entry.getPath(), entry);
-                    unloadedEntries.putIfAbsent(entry.getPath(), null);
+                    classpathBuilder.putIfAbsent(entry.getPath(), entry);
                 } else {
-                    unloadedEntries.putIfAbsent(entry.getPath(), entry);
-                    hasUnloadedEntries = true;
+                    classpathBuilder.putUnloadedIfAbsent(entry.getPath(), entry);
                 }
             }
         }
 
-        return new ClasspathHolder(
-                result.values(),
-                hasUnloadedEntries ? unloadedEntries.values() : Collections.emptyList());
+        return classpathBuilder.build();
     }
 
     /**

From 95d88a874ccdaa922ac55e99100c8e26b75f5a09 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Wed, 3 Jul 2024 16:21:17 +0000
Subject: [PATCH 06/11] Allow import depth of 0

---
 .../discovery/BaseProvisioningStrategy.java   | 12 +++-
 .../discovery/JavaAspectsClasspathInfo.java   | 63 ++++++++++---------
 ...ProjectPerPackageProvisioningStrategy.java |  4 +-
 .../ProjectPerTargetProvisioningStrategy.java |  4 +-
 .../projectview/BazelProjectFileReader.java   |  2 +-
 docs/common/projectviews.md                   |  9 +++
 6 files changed, 54 insertions(+), 40 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index 50ab04f9..ed836929 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -31,6 +31,7 @@
 import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -622,11 +623,18 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
      *            a list of targets as part of the build to query their dependencies
      * @param dependencyDepth
      *            the depth in the dependency graph to traverse and include in the result
-     * @return a set of java_library and java_imports
+     * @return a set of java_library and java_imports, or null, if partial classpath is disabled
      * @throws CoreException
      */
     protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
-            List<BazelLabel> targetsToBuild, int dependencyDepth) throws CoreException {
+            List<BazelLabel> targetsToBuild) throws CoreException {
+        var dependencyDepth = workspace.getBazelProjectView().importDepth();
+        if (dependencyDepth < 0) {
+            return null;
+        }
+        if (dependencyDepth == 0) {
+            return Collections.emptySet();
+        }
         var targetLabels = targetsToBuild.stream().map(BazelLabel::toString).collect(joining(" + "));
         return workspace.getCommandExecutor()
                 .runQueryWithoutLock(
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index 2a49bf0a..5f2162df 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -140,9 +140,10 @@ static boolean isJavaProtoTarget(TargetIdeInfo target) {
 
     /**
      * Set of dependencies available to the whole project, to be used to filter out runtime dependencies that are not
-     * part of this set. Allows creating a partial classpath to improve performance on large projects.
+     * part of this set. Allows creating a partial classpath to improve performance on large projects. Null indicates
+     * full classpath to be used
      */
-    final Set<BazelLabel> runtimeDependencyIncludes;
+    final /*Nullable*/ Set<BazelLabel> runtimeDependencyIncludes;
 
     public JavaAspectsClasspathInfo(JavaAspectsInfo aspectsInfo, BazelWorkspace bazelWorkspace,
             Set<BazelLabel> runtimeDependencyIncludes, BazelProject bazelProject) throws CoreException {
@@ -314,7 +315,7 @@ public IStatus addTarget(BazelTarget bazelTarget) throws CoreException {
     public ClasspathHolder compute() throws CoreException {
         // the code below is copied and adapted from BlazeJavaWorkspaceImporter
 
-        var classpathBuilder = new ClasspathHolderBuilder(!runtimeDependencyIncludes.isEmpty());
+        var classpathBuilder = new ClasspathHolderBuilder(runtimeDependencyIncludes != null);
 
         // Collect jars from jdep references
         for (JdepsDependency jdepsDependency : jdepsCompileJars) {
@@ -330,7 +331,7 @@ public ClasspathHolder compute() throws CoreException {
             }
             var entry = resolveLibrary(library);
             if (entry != null) {
-                if (!entryAvailable(entry)) {
+                if (!validateEntry(entry)) {
                     continue;
                 }
                 if (jdepsDependency.dependencyKind == Kind.IMPLICIT) {
@@ -360,7 +361,7 @@ public ClasspathHolder compute() throws CoreException {
                 }
                 continue;
             }
-            if (!entryAvailable(jarEntry)) {
+            if (!validateEntry(jarEntry)) {
                 continue;
             }
             jarEntry.setExported(true); // source jars should be exported
@@ -371,7 +372,7 @@ public ClasspathHolder compute() throws CoreException {
         for (TargetKey targetKey : directDeps) {
             var entries = resolveDependency(targetKey);
             for (ClasspathEntry entry : entries) {
-                if (entryAvailable(entry)) {
+                if (validateEntry(entry)) {
                     classpathBuilder.putIfAbsent(entry.getPath(), entry);
                 }
             }
@@ -383,7 +384,7 @@ public ClasspathHolder compute() throws CoreException {
             var runtimeDependencyAvailable = runtimeDependencyAvailable(targetKey);
 
             for (ClasspathEntry entry : entries) {
-                if (!entryAvailable(entry)) {
+                if (!validateEntry(entry)) {
                     continue;
                 }
                 // runtime dependencies are only visible to tests
@@ -405,29 +406,6 @@ public ClasspathHolder compute() throws CoreException {
         return classpathBuilder.build();
     }
 
-    /**
-     * Validates the classpath entry is valid and returns true if the entry should be included
-     *
-     * @param entry
-     *            the classpath entry to validate and check
-     * @return false if the entry should not be included in the classpath
-     * @throws CoreException
-     *             if validation fails
-     */
-    private boolean entryAvailable(ClasspathEntry entry) throws CoreException {
-        if ((entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) && !isRegularFile(entry.getPath().toPath())) {
-            BaseProvisioningStrategy.createClasspathContainerProblem(
-                bazelProject,
-                Status.error(
-                    format("Library '%s' is missing. Please consider running 'bazel fetch'", entry.getPath())));
-        }
-
-        // remove references to the project represented by the package
-        // (this can happen because we have tests and none tests in the same package, also the runtime CP self-reference)
-        return (entry.getEntryKind() != IClasspathEntry.CPE_PROJECT)
-                || !entry.getPath().equals(bazelProject.getProject().getFullPath());
-    }
-
     private BazelWorkspace findExternalWorkspace(Label label) throws CoreException {
         var externalWorkspaceName = label.externalWorkspaceName();
         if (externalWorkspaceName.startsWith("@")) {
@@ -685,8 +663,31 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
      * @return true if runtimeDependencyAvailable is empty or it includes the dependency
      */
     private boolean runtimeDependencyAvailable(TargetKey targetKey) {
-        return runtimeDependencyIncludes.isEmpty()
+        return (runtimeDependencyIncludes == null)
                 || runtimeDependencyIncludes.contains(new BazelLabel(targetKey.getLabel().toString()));
     }
 
+    /**
+     * Validates the classpath entry is valid and returns true if the entry should be included
+     *
+     * @param entry
+     *            the classpath entry to validate and check
+     * @return false if the entry should not be included in the classpath
+     * @throws CoreException
+     *             if validation fails
+     */
+    private boolean validateEntry(ClasspathEntry entry) throws CoreException {
+        if ((entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) && !isRegularFile(entry.getPath().toPath())) {
+            BaseProvisioningStrategy.createClasspathContainerProblem(
+                bazelProject,
+                Status.error(
+                    format("Library '%s' is missing. Please consider running 'bazel fetch'", entry.getPath())));
+        }
+
+        // remove references to the project represented by the package
+        // (this can happen because we have tests and none tests in the same package, also the runtime CP self-reference)
+        return (entry.getEntryKind() != IClasspathEntry.CPE_PROJECT)
+                || !entry.getPath().equals(bazelProject.getProject().getFullPath());
+    }
+
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
index d74a2671..0c024ca4 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerPackageProvisioningStrategy.java
@@ -110,14 +110,12 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
                 activeTargetsPerProject.put(bazelProject, projectTargetsToBuild);
             }
 
-            var importDepth = workspace.getBazelProjectView().importDepth();
             var targets = activeTargetsPerProject.values()
                     .stream()
                     .flatMap(Collection::stream)
                     .map(BazelTarget::getLabel)
                     .collect(toList());
-            var availableDependencies = importDepth > 0
-                    ? calculateWorkspaceDependencies(workspace, targets, importDepth) : Set.<BazelLabel> of();
+            var availableDependencies = calculateWorkspaceDependencies(workspace, targets);
 
             // collect classpaths by project
             Map<BazelProject, ClasspathHolder> classpathsByProject = new HashMap<>();
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
index ef04b891..99b4213a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/ProjectPerTargetProvisioningStrategy.java
@@ -76,9 +76,7 @@ public Map<BazelProject, ClasspathHolder> computeClasspaths(Collection<BazelProj
 
             var workspaceRoot = workspace.getLocation().toPath();
 
-            var importDepth = workspace.getBazelProjectView().importDepth();
-            var availableDependencies = importDepth > 0
-                    ? calculateWorkspaceDependencies(workspace, targetsToBuild, importDepth) : Set.<BazelLabel> of();
+            var availableDependencies = calculateWorkspaceDependencies(workspace, targetsToBuild);
 
             // run the aspect to compute all required information
             var aspects = workspace.getParent().getModelManager().getIntellijAspects();
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
index 04579c91..96827c4a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
@@ -77,7 +77,7 @@ public void close() {
         final LinkedHashSet<String> externalJarsFilters = new LinkedHashSet<>();
         int targetShardSize = 500;
         boolean shardSync = true;
-        int importDepth = 0;
+        int importDepth = -1;
 
         public BazelProjectView build() throws IllegalStateException {
             // check mandatory parameters
diff --git a/docs/common/projectviews.md b/docs/common/projectviews.md
index ae7d4caf..f9809939 100644
--- a/docs/common/projectviews.md
+++ b/docs/common/projectviews.md
@@ -219,6 +219,15 @@ This attribute also support exclusions if they begin with `-`.
 If the glob matches a package which is provisioned with the `project-per-package` strategy, all source folders in the project will be marked as containing test sources.
 
 
+### `import_depth`
+
+A integer indicating the depth of source targets dependencies pulled in to the project model during sync (default is `-1`, which pulls in all transitive dependencies in the graph).
+
+Providing a value greater or equal to 0 will filter transitive dependencies and provide a partial classpath to the project model.
+
+Note: While all required compile-time dependencies are added regardless, there may be edge cases with the Eclipse compiler
+which may result in compile errors.
+
 ## Unsupported Features / Limitations
 
 All deprecated items are not supported.

From bbd6c321426d0632554f1c5d6ac47e9b76440ca3 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Mon, 8 Jul 2024 17:02:14 +0000
Subject: [PATCH 07/11] Refactor importDepth to runtimeImportDepth

---
 .../core/model/discovery/BaseProvisioningStrategy.java    | 2 +-
 .../eclipse/core/projectview/BazelProjectFileReader.java  | 8 ++++----
 .../bazel/eclipse/core/projectview/BazelProjectView.java  | 2 +-
 docs/common/projectviews.md                               | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index ed836929..775ab1ea 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -628,7 +628,7 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
      */
     protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
             List<BazelLabel> targetsToBuild) throws CoreException {
-        var dependencyDepth = workspace.getBazelProjectView().importDepth();
+        var dependencyDepth = workspace.getBazelProjectView().runtimeImportDepth();
         if (dependencyDepth < 0) {
             return null;
         }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
index 96827c4a..49223fb9 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
@@ -77,7 +77,7 @@ public void close() {
         final LinkedHashSet<String> externalJarsFilters = new LinkedHashSet<>();
         int targetShardSize = 500;
         boolean shardSync = true;
-        int importDepth = -1;
+        int runtimeImportDepth = -1;
 
         public BazelProjectView build() throws IllegalStateException {
             // check mandatory parameters
@@ -149,7 +149,7 @@ public BazelProjectView build() throws IllegalStateException {
                     new GlobSetMatcher(externalJarsFilters),
                     shardSync,
                     targetShardSize,
-                    importDepth);
+                    runtimeImportDepth);
         }
 
         public ImportHandle startImporting(Path bazelProjectViewFile) throws IOException {
@@ -406,8 +406,8 @@ private void parseProjectFile(Path bazelProjectFile, BazelProjectViewBuilder bui
                         // ignore deprecated
                         break;
                     }
-                    case "import_depth": {
-                        builder.importDepth = parseSectionBodyAsInt(rawSection, builder.importDepth);
+                    case "runtime_import_depth": {
+                        builder.runtimeImportDepth = parseSectionBodyAsInt(rawSection, builder.runtimeImportDepth);
                         break;
                     }
                     default:
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
index 0fac61d1..ace64bf9 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
@@ -52,7 +52,7 @@ public record BazelProjectView(
         GlobSetMatcher externalJarsDiscoveryFilter,
         boolean shardSync,
         int targetShardSize,
-        int importDepth) {
+        int runtimeImportDepth) {
 
     public BazelProjectView {
         directoriesToImport = unmodifiableCollection(directoriesToImport);
diff --git a/docs/common/projectviews.md b/docs/common/projectviews.md
index f9809939..a021fe16 100644
--- a/docs/common/projectviews.md
+++ b/docs/common/projectviews.md
@@ -219,9 +219,9 @@ This attribute also support exclusions if they begin with `-`.
 If the glob matches a package which is provisioned with the `project-per-package` strategy, all source folders in the project will be marked as containing test sources.
 
 
-### `import_depth`
+### `runtime_import_depth`
 
-A integer indicating the depth of source targets dependencies pulled in to the project model during sync (default is `-1`, which pulls in all transitive dependencies in the graph).
+A integer indicating the depth of source targets runtime dependencies pulled in to the project model during sync (default is `-1`, which pulls in all transitive dependencies in the graph).
 
 Providing a value greater or equal to 0 will filter transitive dependencies and provide a partial classpath to the project model.
 

From d2f127c2715978236463065632b3607918c5d8f8 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Mon, 15 Jul 2024 17:50:22 +0000
Subject: [PATCH 08/11] Rename import depth flag

---
 .../core/model/discovery/BaseProvisioningStrategy.java | 10 +++++-----
 .../core/projectview/BazelProjectFileReader.java       |  8 ++++----
 .../eclipse/core/projectview/BazelProjectView.java     |  2 +-
 docs/common/projectviews.md                            |  6 +++---
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index 775ab1ea..5bdd81ae 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -628,11 +628,11 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
      */
     protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
             List<BazelLabel> targetsToBuild) throws CoreException {
-        var dependencyDepth = workspace.getBazelProjectView().runtimeImportDepth();
-        if (dependencyDepth < 0) {
+        var classpathDepth = workspace.getBazelProjectView().classpathDepth();
+        if (classpathDepth <= 0) {
             return null;
         }
-        if (dependencyDepth == 0) {
+        if (classpathDepth == 1) {
             return Collections.emptySet();
         }
         var targetLabels = targetsToBuild.stream().map(BazelLabel::toString).collect(joining(" + "));
@@ -643,9 +643,9 @@ protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace wo
                             format(
                                 "kind(java_library, deps(%s, %d)) + kind(java_import, deps(%s, %d))",
                                 targetLabels,
-                                dependencyDepth,
+                                classpathDepth,
                                 targetLabels,
-                                dependencyDepth),
+                                classpathDepth),
                             true,
                             format("Querying for depdendencies for projects: %s", targetLabels)))
                 .stream()
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
index 49223fb9..4eef6b4f 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
@@ -77,7 +77,7 @@ public void close() {
         final LinkedHashSet<String> externalJarsFilters = new LinkedHashSet<>();
         int targetShardSize = 500;
         boolean shardSync = true;
-        int runtimeImportDepth = -1;
+        int classpathDepth = 0;
 
         public BazelProjectView build() throws IllegalStateException {
             // check mandatory parameters
@@ -149,7 +149,7 @@ public BazelProjectView build() throws IllegalStateException {
                     new GlobSetMatcher(externalJarsFilters),
                     shardSync,
                     targetShardSize,
-                    runtimeImportDepth);
+                    classpathDepth);
         }
 
         public ImportHandle startImporting(Path bazelProjectViewFile) throws IOException {
@@ -406,8 +406,8 @@ private void parseProjectFile(Path bazelProjectFile, BazelProjectViewBuilder bui
                         // ignore deprecated
                         break;
                     }
-                    case "runtime_import_depth": {
-                        builder.runtimeImportDepth = parseSectionBodyAsInt(rawSection, builder.runtimeImportDepth);
+                    case "classpath_depth": {
+                        builder.classpathDepth = parseSectionBodyAsInt(rawSection, builder.classpathDepth);
                         break;
                     }
                     default:
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
index ace64bf9..0f523c3b 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
@@ -52,7 +52,7 @@ public record BazelProjectView(
         GlobSetMatcher externalJarsDiscoveryFilter,
         boolean shardSync,
         int targetShardSize,
-        int runtimeImportDepth) {
+        int classpathDepth) {
 
     public BazelProjectView {
         directoriesToImport = unmodifiableCollection(directoriesToImport);
diff --git a/docs/common/projectviews.md b/docs/common/projectviews.md
index a021fe16..9fb33205 100644
--- a/docs/common/projectviews.md
+++ b/docs/common/projectviews.md
@@ -219,11 +219,11 @@ This attribute also support exclusions if they begin with `-`.
 If the glob matches a package which is provisioned with the `project-per-package` strategy, all source folders in the project will be marked as containing test sources.
 
 
-### `runtime_import_depth`
+### `classpath_depth`
 
-A integer indicating the depth of source targets runtime dependencies pulled in to the project model during sync (default is `-1`, which pulls in all transitive dependencies in the graph).
+A integer indicating the depth of source targets runtime dependencies pulled in to the project model during sync (default is `0`, which pulls in all transitive dependencies in the graph).
 
-Providing a value greater or equal to 0 will filter transitive dependencies and provide a partial classpath to the project model.
+Providing a value greater then 0 will filter transitive dependencies and provide a partial classpath to the project model.
 
 Note: While all required compile-time dependencies are added regardless, there may be edge cases with the Eclipse compiler
 which may result in compile errors.

From 4426bfd3eb78d1488e8e4b572c6241b28598298a Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Tue, 16 Jul 2024 17:57:02 +0000
Subject: [PATCH 09/11] Don't maintain order and move flag inside settings

---
 .../classpath/BazelClasspathContainer.java    | 23 +++++--------------
 .../core/classpath/BazelClasspathManager.java |  3 +--
 .../core/classpath/ClasspathHolder.java       | 13 +++--------
 .../core/edits/AddDependenciesJob.java        |  5 +---
 .../discovery/BaseProvisioningStrategy.java   | 17 ++++++++++++--
 .../projectview/BazelProjectFileReader.java   |  8 +------
 .../core/projectview/BazelProjectView.java    |  3 +--
 docs/common/projectviews.md                   | 12 +++-------
 8 files changed, 31 insertions(+), 53 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
index 8d1e84df..ac58d48a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
@@ -36,8 +36,7 @@
 package com.salesforce.bazel.eclipse.core.classpath;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Arrays;
 
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.jdt.core.IClasspathContainer;
@@ -55,7 +54,7 @@ public class BazelClasspathContainer implements IClasspathContainer, Serializabl
 
     private final IPath path;
     private final IClasspathEntry[] classpath;
-    private final IClasspathEntry[/*Nullable*/] unloadedClasspath;
+    private final IClasspathEntry[] unloadedClasspath;
 
     public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] unloadedClasspath) {
         this.path = path;
@@ -77,19 +76,9 @@ public IClasspathEntry[] getFullClasspath() {
         if (unloadedClasspath.length == 0) {
             return classpath;
         }
-        List<IClasspathEntry> entries = new ArrayList<>(unloadedClasspath.length);
-        var index = 0;
-        for (IClasspathEntry entry : unloadedClasspath) {
-            if (entry == null) {
-                entries.add(classpath[index++]);
-            } else {
-                entries.add(entry);
-            }
-        }
-        for (var i = index; i < classpath.length; i++) {
-            entries.add(classpath[i]);
-        }
-        return entries.toArray(new IClasspathEntry[entries.size()]);
+        var fullClasspath = Arrays.copyOf(classpath, classpath.length + unloadedClasspath.length);
+        System.arraycopy(unloadedClasspath, 0, fullClasspath, classpath.length, unloadedClasspath.length);
+        return fullClasspath;
     }
 
     @Override
@@ -103,7 +92,7 @@ public IPath getPath() {
     }
 
     /**
-     * A array of nullable unloaded classpath entries.
+     * A array of unloaded classpath entries.
      *
      * @return
      */
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
index 1075afcf..64a295d3 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
@@ -347,8 +347,7 @@ void saveAndSetContainer(IJavaProject javaProject, ClasspathHolder classpath, IP
                 : new Path(BazelCoreSharedContstants.CLASSPATH_CONTAINER_ID);
 
         var sourceAttachmentProperties = getSourceAttachmentProperties(javaProject.getProject());
-        var unloadedClasspath =
-                classpath.unloaded().stream().map(ce -> ce.isPresent() ? ce.get().build() : null).collect(toList());
+        var unloadedClasspath = classpath.unloaded().stream().map(ClasspathEntry::build).collect(toList());
 
         var container = new BazelClasspathContainer(
                 path,
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
index ff57e5a1..04b03291 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
@@ -17,7 +17,6 @@
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Optional;
 
 import org.eclipse.core.runtime.IPath;
 
@@ -29,7 +28,7 @@
  *
  * Note: Unloaded contains null values to keep the order between loaded and unloaded
  */
-public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<Optional<ClasspathEntry>> unloaded) {
+public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<ClasspathEntry> unloaded) {
 
     public static class ClasspathHolderBuilder {
         // Preserve classpath order. Add leaf level dependencies first and work the way up. This
@@ -39,7 +38,7 @@ public static class ClasspathHolderBuilder {
         // and in `workspaceBuilder.directDeps`, we want to treat it as a directDep
         private final Map<IPath, ClasspathEntry> loadedEntries =
                 new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
-        private final Map<IPath, Optional<ClasspathEntry>> unloadedEntries =
+        private final Map<IPath, ClasspathEntry> unloadedEntries =
                 new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
         private boolean hasUnloadedEntries = false;
 
@@ -57,21 +56,15 @@ public ClasspathHolder build() {
 
         public void put(IPath path, ClasspathEntry entry) {
             loadedEntries.put(path, entry);
-            if (partialClasspathEnabled) {
-                unloadedEntries.put(path, Optional.empty());
-            }
         }
 
         public void putIfAbsent(IPath path, ClasspathEntry entry) {
             loadedEntries.putIfAbsent(path, entry);
-            if (partialClasspathEnabled) {
-                unloadedEntries.put(path, Optional.empty());
-            }
         }
 
         public void putUnloadedIfAbsent(IPath path, ClasspathEntry entry) {
             if (!loadedEntries.containsKey(path)) {
-                unloadedEntries.putIfAbsent(path, Optional.of(entry));
+                unloadedEntries.putIfAbsent(path, entry);
                 hasUnloadedEntries = true;
             }
         }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
index 33de4c2a..754d9c83 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
@@ -9,7 +9,6 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
-import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.eclipse.core.resources.IResourceRuleFactory;
@@ -151,9 +150,7 @@ public IStatus runInWorkspace(final IProgressMonitor monitor) throws CoreExcepti
 
                 if (modified) {
                     var unloaded = Arrays.stream(container.getUnloadedEntries())
-                            .map(
-                                ce -> ce != null ? Optional.of(ClasspathEntry.fromExisting(ce))
-                                        : Optional.<ClasspathEntry> empty())
+                            .map(ClasspathEntry::fromExisting)
                             .collect(toList());
                     classpathManager
                             .patchClasspathContainer(bazelProject, new ClasspathHolder(classpath, unloaded), monitor);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index 5bdd81ae..3f70ba89 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -112,6 +112,7 @@ public abstract class BaseProvisioningStrategy implements TargetProvisioningStra
     private static final String JRE_SYSTEM_LIBRARY = "jre_system_library";
     private static final String JRE_SYSTEM_LIBRARY_RUNTIME = "current_java_runtime";
     private static final String JRE_SYSTEM_LIBRARY_EE = "execution_environment";
+    private static final String CLASSPATH_DEPTH = "classpath_depth";
 
     private static final String JAVAC_OPT_ADD_OPENS = "--add-opens";
     private static final String JAVAC_OPT_ADD_EXPORTS = "--add-exports";
@@ -184,7 +185,7 @@ static IMarker createMarker(IResource resource, String type, IStatus status) thr
     protected String javaToolchainTargetVersion;
 
     /**
-     * Eclipse VM representing current_java_runtime
+     * Eclipse VM representing current_jaclasspath_depthva_runtime
      */
     protected IVMInstall javaRuntimeVm;
 
@@ -628,7 +629,19 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
      */
     protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
             List<BazelLabel> targetsToBuild) throws CoreException {
-        var classpathDepth = workspace.getBazelProjectView().classpathDepth();
+        var classpathDepthStr =
+                workspace.getBazelProjectView().targetProvisioningSettings().getOrDefault(CLASSPATH_DEPTH, "0");
+        var classpathDepth = 0;
+        try {
+            classpathDepth = Integer.parseInt(classpathDepthStr);
+        } catch (NumberFormatException e) {
+            LOG.warn(
+                "Invalid integer for target provisioning setting {} (falling back to default 0): {}",
+                CLASSPATH_DEPTH,
+                e.getMessage(),
+                e);
+        }
+
         if (classpathDepth <= 0) {
             return null;
         }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
index 4eef6b4f..a4ac2e90 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectFileReader.java
@@ -77,7 +77,6 @@ public void close() {
         final LinkedHashSet<String> externalJarsFilters = new LinkedHashSet<>();
         int targetShardSize = 500;
         boolean shardSync = true;
-        int classpathDepth = 0;
 
         public BazelProjectView build() throws IllegalStateException {
             // check mandatory parameters
@@ -148,8 +147,7 @@ public BazelProjectView build() throws IllegalStateException {
                     discoverAllExternalAndWorkspaceJars,
                     new GlobSetMatcher(externalJarsFilters),
                     shardSync,
-                    targetShardSize,
-                    classpathDepth);
+                    targetShardSize);
         }
 
         public ImportHandle startImporting(Path bazelProjectViewFile) throws IOException {
@@ -406,10 +404,6 @@ private void parseProjectFile(Path bazelProjectFile, BazelProjectViewBuilder bui
                         // ignore deprecated
                         break;
                     }
-                    case "classpath_depth": {
-                        builder.classpathDepth = parseSectionBodyAsInt(rawSection, builder.classpathDepth);
-                        break;
-                    }
                     default:
                         LOG.warn("Unexpected section '{}' while reading '{}'", rawSection.getName(), bazelProjectFile);
                         break;
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
index 0f523c3b..153bcd95 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/projectview/BazelProjectView.java
@@ -51,8 +51,7 @@ public record BazelProjectView(
         boolean discoverAllExternalAndWorkspaceJars,
         GlobSetMatcher externalJarsDiscoveryFilter,
         boolean shardSync,
-        int targetShardSize,
-        int classpathDepth) {
+        int targetShardSize) {
 
     public BazelProjectView {
         directoriesToImport = unmodifiableCollection(directoriesToImport);
diff --git a/docs/common/projectviews.md b/docs/common/projectviews.md
index 9fb33205..53639796 100644
--- a/docs/common/projectviews.md
+++ b/docs/common/projectviews.md
@@ -154,6 +154,9 @@ The syntax of each entry is `key=value`, where `key` and `value` are expected st
 * `jre_system_library` (possible values: `current_java_runtime` and `execution_environment`, configures the JRE System Library classpath container to use either the Bazel workspace's Java runtime or an execution environment id)
 * `project_name_separator_char` (used by `project-per-package` to replace `/` in package path for project name)
 * `java_like_rules` (used by `project-per-package`, comma separated list of additional java like rules to analyze when collecting targets for each package)
+* `classpath_depth` A integer indicating the depth of source targets runtime dependencies pulled in to the project model during sync (default is `0`, which pulls in all transitive dependencies in the graph).
+	* Providing a value greater then 0 will filter transitive dependencies and provide a partial classpath to the project model.
+	* Note: While all required compile-time dependencies are added regardless, there may be edge cases with the Eclipse compiler which may result in compile errors.
 
 ### `project_mappings`
 
@@ -219,15 +222,6 @@ This attribute also support exclusions if they begin with `-`.
 If the glob matches a package which is provisioned with the `project-per-package` strategy, all source folders in the project will be marked as containing test sources.
 
 
-### `classpath_depth`
-
-A integer indicating the depth of source targets runtime dependencies pulled in to the project model during sync (default is `0`, which pulls in all transitive dependencies in the graph).
-
-Providing a value greater then 0 will filter transitive dependencies and provide a partial classpath to the project model.
-
-Note: While all required compile-time dependencies are added regardless, there may be edge cases with the Eclipse compiler
-which may result in compile errors.
-
 ## Unsupported Features / Limitations
 
 All deprecated items are not supported.

From e32a36f67c5704a08dba793019a1d9487082ee00 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brianmay27@gmail.com>
Date: Thu, 18 Jul 2024 08:47:18 -0700
Subject: [PATCH 10/11] Apply suggestions from code review

Co-authored-by: Gunnar Wagenknecht <gunnar@wagenknecht.org>
---
 .../bazel/eclipse/core/classpath/BazelClasspathContainer.java | 4 ++--
 .../core/classpath/BazelClasspathContainerSaveHelper.java     | 4 ++--
 .../core/model/discovery/JavaAspectsClasspathInfo.java        | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
index ac58d48a..2345b901 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
@@ -58,8 +58,8 @@ public class BazelClasspathContainer implements IClasspathContainer, Serializabl
 
     public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] unloadedClasspath) {
         this.path = path;
-        this.classpath = classpath;
-        this.unloadedClasspath = unloadedClasspath;
+        this.classpath = requireNotNull(classpath);
+        this.unloadedClasspath = requireNotNull(unloadedClasspath);
     }
 
     @Override
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
index a7fd77ab..c5d36076 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainerSaveHelper.java
@@ -105,7 +105,7 @@ IClasspathEntry getEntry() {
             return JavaCore.newLibraryEntry(
                 path,
                 sourceAttachmentPath,
-                sourceAttachmentRootPath, //
+                sourceAttachmentRootPath,
                 accessRules,
                 extraAttributes,
                 exported);
@@ -156,7 +156,7 @@ static final class ProjectEntryReplace implements Serializable {
         IClasspathEntry getEntry() {
             return JavaCore.newProjectEntry(
                 path,
-                accessRules, //
+                accessRules,
                 combineAccessRules,
                 extraAttributes,
                 exported);
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index 5f2162df..5aa57035 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -662,7 +662,7 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
      *            the dependency to check
      * @return true if runtimeDependencyAvailable is empty or it includes the dependency
      */
-    private boolean runtimeDependencyAvailable(TargetKey targetKey) {
+    private boolean includeRuntimeDependencyAsCompileDependency(TargetKey targetKey) {
         return (runtimeDependencyIncludes == null)
                 || runtimeDependencyIncludes.contains(new BazelLabel(targetKey.getLabel().toString()));
     }

From a9c87e600111c1cc13223b26a2ed8a056b567e35 Mon Sep 17 00:00:00 2001
From: Brian McNamara <brian.mcnamara@salesforce.com>
Date: Thu, 18 Jul 2024 16:05:43 +0000
Subject: [PATCH 11/11] Review comments

---
 .../classpath/BazelClasspathContainer.java    | 22 +++++++-------
 .../core/classpath/BazelClasspathManager.java |  8 ++---
 .../core/classpath/ClasspathHolder.java       | 25 ++++++++--------
 .../core/edits/AddDependenciesJob.java        |  4 +--
 .../discovery/BaseProvisioningStrategy.java   | 29 +++++++++++--------
 .../discovery/JavaAspectsClasspathInfo.java   | 29 ++++++++++---------
 6 files changed, 62 insertions(+), 55 deletions(-)

diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
index 2345b901..b983bde5 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathContainer.java
@@ -35,6 +35,8 @@
  */
 package com.salesforce.bazel.eclipse.core.classpath;
 
+import static java.util.Objects.requireNonNull;
+
 import java.io.Serializable;
 import java.util.Arrays;
 
@@ -54,12 +56,12 @@ public class BazelClasspathContainer implements IClasspathContainer, Serializabl
 
     private final IPath path;
     private final IClasspathEntry[] classpath;
-    private final IClasspathEntry[] unloadedClasspath;
+    private final IClasspathEntry[] transitiveClasspath;
 
-    public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] unloadedClasspath) {
+    public BazelClasspathContainer(IPath path, IClasspathEntry[] classpath, IClasspathEntry[] transitiveClasspath) {
         this.path = path;
-        this.classpath = requireNotNull(classpath);
-        this.unloadedClasspath = requireNotNull(unloadedClasspath);
+        this.classpath = requireNonNull(classpath);
+        this.transitiveClasspath = requireNonNull(transitiveClasspath);
     }
 
     @Override
@@ -73,11 +75,11 @@ public String getDescription() {
     }
 
     public IClasspathEntry[] getFullClasspath() {
-        if (unloadedClasspath.length == 0) {
+        if (transitiveClasspath.length == 0) {
             return classpath;
         }
-        var fullClasspath = Arrays.copyOf(classpath, classpath.length + unloadedClasspath.length);
-        System.arraycopy(unloadedClasspath, 0, fullClasspath, classpath.length, unloadedClasspath.length);
+        var fullClasspath = Arrays.copyOf(classpath, classpath.length + transitiveClasspath.length);
+        System.arraycopy(transitiveClasspath, 0, fullClasspath, classpath.length, transitiveClasspath.length);
         return fullClasspath;
     }
 
@@ -92,11 +94,11 @@ public IPath getPath() {
     }
 
     /**
-     * A array of unloaded classpath entries.
+     * A array of transitive classpath entries.
      *
      * @return
      */
-    public IClasspathEntry[] getUnloadedEntries() {
-        return unloadedClasspath;
+    public IClasspathEntry[] getTransitiveEntries() {
+        return transitiveClasspath;
     }
 }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
index 64a295d3..aa3c0e7d 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/BazelClasspathManager.java
@@ -301,7 +301,7 @@ public void persistAttachedSourcesAndJavadoc(IJavaProject project, IClasspathCon
                 DEFAULT_CLASSPATH,
                 monitor.split(1, SUPPRESS_ALL_LABELS));
             entries = configureClasspathWithSourceAttachments(
-                classpaths.get(bazelProject).loaded(),
+                classpaths.get(bazelProject).compile(),
                 null /* no props */,
                 monitor);
             for (IClasspathEntry entry : entries) {
@@ -347,15 +347,15 @@ void saveAndSetContainer(IJavaProject javaProject, ClasspathHolder classpath, IP
                 : new Path(BazelCoreSharedContstants.CLASSPATH_CONTAINER_ID);
 
         var sourceAttachmentProperties = getSourceAttachmentProperties(javaProject.getProject());
-        var unloadedClasspath = classpath.unloaded().stream().map(ClasspathEntry::build).collect(toList());
+        var transativeClasspath = classpath.transitive().stream().map(ClasspathEntry::build).collect(toList());
 
         var container = new BazelClasspathContainer(
                 path,
                 configureClasspathWithSourceAttachments(
-                    classpath.loaded(),
+                    classpath.compile(),
                     sourceAttachmentProperties,
                     monitor.slice(1)),
-                unloadedClasspath.toArray(new IClasspathEntry[unloadedClasspath.size()]));
+                transativeClasspath.toArray(new IClasspathEntry[transativeClasspath.size()]));
 
         JavaCore.setClasspathContainer(
             container.getPath(),
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
index 04b03291..61cadf94 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/classpath/ClasspathHolder.java
@@ -23,12 +23,11 @@
 import com.salesforce.bazel.eclipse.core.model.discovery.classpath.ClasspathEntry;
 
 /**
- * Represents a targets classpath as two parts, loaded being the classpath entries that are loaded into the project
- * model, and unloaded being classpaths that are part of the target, but are not to be loaded in the project model.
- *
- * Note: Unloaded contains null values to keep the order between loaded and unloaded
+ * Represents a targets classpath as two parts, compile being the classpath entries that are loaded into the project
+ * model, and transtative as classpaths that are part of the targets runtime, but are not to be loaded in the project
+ * model.
  */
-public record ClasspathHolder(Collection<ClasspathEntry> loaded, Collection<ClasspathEntry> unloaded) {
+public record ClasspathHolder(Collection<ClasspathEntry> compile, Collection<ClasspathEntry> transitive) {
 
     public static class ClasspathHolderBuilder {
         // Preserve classpath order. Add leaf level dependencies first and work the way up. This
@@ -36,9 +35,9 @@ public static class ClasspathHolderBuilder {
         // resolve symbols from the original JAR rather than the repackaged version.
         // Using accessOrdered LinkedHashMap because jars that are present in `workspaceBuilder.jdeps`
         // and in `workspaceBuilder.directDeps`, we want to treat it as a directDep
-        private final Map<IPath, ClasspathEntry> loadedEntries =
+        private final Map<IPath, ClasspathEntry> compileEntries =
                 new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
-        private final Map<IPath, ClasspathEntry> unloadedEntries =
+        private final Map<IPath, ClasspathEntry> transitiveEntries =
                 new LinkedHashMap<>(/* initialCapacity= */ 32, /* loadFactor= */ 0.75f, /* accessOrder= */ true);
         private boolean hasUnloadedEntries = false;
 
@@ -50,21 +49,21 @@ public ClasspathHolderBuilder(boolean partialClasspathEnabled) {
 
         public ClasspathHolder build() {
             return new ClasspathHolder(
-                    loadedEntries.values(),
-                    hasUnloadedEntries ? unloadedEntries.values() : Collections.emptyList());
+                    compileEntries.values(),
+                    hasUnloadedEntries ? transitiveEntries.values() : Collections.emptyList());
         }
 
         public void put(IPath path, ClasspathEntry entry) {
-            loadedEntries.put(path, entry);
+            compileEntries.put(path, entry);
         }
 
         public void putIfAbsent(IPath path, ClasspathEntry entry) {
-            loadedEntries.putIfAbsent(path, entry);
+            compileEntries.putIfAbsent(path, entry);
         }
 
         public void putUnloadedIfAbsent(IPath path, ClasspathEntry entry) {
-            if (!loadedEntries.containsKey(path)) {
-                unloadedEntries.putIfAbsent(path, entry);
+            if (!compileEntries.containsKey(path)) {
+                transitiveEntries.putIfAbsent(path, entry);
                 hasUnloadedEntries = true;
             }
         }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
index 754d9c83..598adc1d 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/edits/AddDependenciesJob.java
@@ -149,11 +149,11 @@ public IStatus runInWorkspace(final IProgressMonitor monitor) throws CoreExcepti
                 }
 
                 if (modified) {
-                    var unloaded = Arrays.stream(container.getUnloadedEntries())
+                    var transitive = Arrays.stream(container.getTransitiveEntries())
                             .map(ClasspathEntry::fromExisting)
                             .collect(toList());
                     classpathManager
-                            .patchClasspathContainer(bazelProject, new ClasspathHolder(classpath, unloaded), monitor);
+                            .patchClasspathContainer(bazelProject, new ClasspathHolder(classpath, transitive), monitor);
                 }
                 return Status.OK_STATUS;
             }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
index 3f70ba89..93d0d423 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java
@@ -629,19 +629,8 @@ protected void analyzeProjectInfo(BazelProject project, JavaProjectInfo javaInfo
      */
     protected final Set<BazelLabel> calculateWorkspaceDependencies(BazelWorkspace workspace,
             List<BazelLabel> targetsToBuild) throws CoreException {
-        var classpathDepthStr =
-                workspace.getBazelProjectView().targetProvisioningSettings().getOrDefault(CLASSPATH_DEPTH, "0");
-        var classpathDepth = 0;
-        try {
-            classpathDepth = Integer.parseInt(classpathDepthStr);
-        } catch (NumberFormatException e) {
-            LOG.warn(
-                "Invalid integer for target provisioning setting {} (falling back to default 0): {}",
-                CLASSPATH_DEPTH,
-                e.getMessage(),
-                e);
-        }
 
+        var classpathDepth = getClasspathDepthValue(workspace);
         if (classpathDepth <= 0) {
             return null;
         }
@@ -1250,6 +1239,22 @@ private void garbageCollectFolderContent(IFolder folder, Set<IResource> membersT
         }
     }
 
+    private final int getClasspathDepthValue(BazelWorkspace workspace) throws CoreException {
+        var classpathDepthStr =
+                workspace.getBazelProjectView().targetProvisioningSettings().getOrDefault(CLASSPATH_DEPTH, "0");
+        var classpathDepth = 0;
+        try {
+            classpathDepth = Integer.parseInt(classpathDepthStr);
+        } catch (NumberFormatException e) {
+            LOG.warn(
+                "Invalid integer for target provisioning setting {} (falling back to default 0): {}",
+                CLASSPATH_DEPTH,
+                e.getMessage(),
+                e);
+        }
+        return classpathDepth;
+    }
+
     protected IWorkspace getEclipseWorkspace() {
         return ResourcesPlugin.getWorkspace();
     }
diff --git a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
index 5aa57035..77c6bf5a 100644
--- a/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
+++ b/bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/JavaAspectsClasspathInfo.java
@@ -381,7 +381,7 @@ public ClasspathHolder compute() throws CoreException {
         // Collect jars referenced by runtime deps
         for (TargetKey targetKey : runtimeDeps) {
             var entries = resolveDependency(targetKey);
-            var runtimeDependencyAvailable = runtimeDependencyAvailable(targetKey);
+            var runtimeDependencyAvailable = includeRuntimeDependencyAsCompileDependency(targetKey);
 
             for (ClasspathEntry entry : entries) {
                 if (!validateEntry(entry)) {
@@ -478,6 +478,19 @@ IWorkspaceRoot getEclipseWorkspaceRoot() {
         return ResourcesPlugin.getWorkspace().getRoot();
     }
 
+    /**
+     * Allows filtering runtime dependencies based on the availability of the dependency in runtimseDependencyIncludes
+     * when it includes elements
+     *
+     * @param targetKey
+     *            the dependency to check
+     * @return true if runtimeDependencyAvailable is empty or it includes the dependency
+     */
+    private boolean includeRuntimeDependencyAsCompileDependency(TargetKey targetKey) {
+        return (runtimeDependencyIncludes == null)
+                || runtimeDependencyIncludes.contains(new BazelLabel(targetKey.getLabel().toString()));
+    }
+
     private List<JdepsDependency> loadJdeps(TargetIdeInfo targetIdeInfo) throws CoreException {
         // load jdeps file
         var jdepsFile = resolveJdepsOutput(targetIdeInfo);
@@ -654,19 +667,6 @@ protected ClasspathEntry resolveProject(TargetKey targetKey) throws CoreExceptio
         return resolveProject(targetKey.getLabel());
     }
 
-    /**
-     * Allows filtering runtime dependencies based on the availability of the dependency in runtimseDependencyIncludes
-     * when it includes elements
-     *
-     * @param targetKey
-     *            the dependency to check
-     * @return true if runtimeDependencyAvailable is empty or it includes the dependency
-     */
-    private boolean includeRuntimeDependencyAsCompileDependency(TargetKey targetKey) {
-        return (runtimeDependencyIncludes == null)
-                || runtimeDependencyIncludes.contains(new BazelLabel(targetKey.getLabel().toString()));
-    }
-
     /**
      * Validates the classpath entry is valid and returns true if the entry should be included
      *
@@ -682,6 +682,7 @@ private boolean validateEntry(ClasspathEntry entry) throws CoreException {
                 bazelProject,
                 Status.error(
                     format("Library '%s' is missing. Please consider running 'bazel fetch'", entry.getPath())));
+            return false;
         }
 
         // remove references to the project represented by the package