Begin work on tests

Author: guw

bundles/com.salesforce.bazel.eclipse.core/.classpath

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
 		<attributes>
 			<attribute name="module" value="true"/>
 		</attributes>

bundles/com.salesforce.bazel.eclipse.core/.settings/org.eclipse.jdt.core.prefs

@@ -1,9 +1,9 @@
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.methodParameters=generate
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.compliance=21
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -12,7 +12,7 @@ org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
 org.eclipse.jdt.core.compiler.release=enabled
-org.eclipse.jdt.core.compiler.source=17
+org.eclipse.jdt.core.compiler.source=21
 org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false
 org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
 org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line=true

bundles/com.salesforce.bazel.eclipse.core/META-INF/MANIFEST.MF

@@ -54,5 +54,5 @@ Require-Bundle: org.eclipse.core.jobs;bundle-version="3.12.0",
  org.eclipse.jdt.junit.core;bundle-version="3.11.0",
  org.eclipse.core.filesystem;bundle-version="1.9.500",
  org.eclipse.core.variables;bundle-version="3.6.0"
-Bundle-RequiredExecutionEnvironment: JavaSE-17
+Bundle-RequiredExecutionEnvironment: JavaSE-21
 Bundle-ActivationPolicy: lazy

bundles/com.salesforce.bazel.eclipse.core/plugin.xml

@@ -124,6 +124,10 @@
             class="com.salesforce.bazel.eclipse.core.model.discovery.BazelBuildfileTargetDiscovery"
             name="buildfiles">
       </targetDiscoveryStrategy>
+      <targetProvisioningStrategy
+            class="com.salesforce.bazel.eclipse.core.model.discovery.BuildfileDrivenProvisioningStrategy"
+            name="project-per-buildfile">
+      </targetProvisioningStrategy>
       <targetProvisioningStrategy
             class="com.salesforce.bazel.eclipse.core.model.discovery.BuildFileAndVisibilityDrivenProvisioningStrategy"
             name="build-file-and-visibility-driven">

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/BazelModel.java

@@ -13,6 +13,8 @@
  */
 package com.salesforce.bazel.eclipse.core.model;
 
+import static java.util.Objects.requireNonNull;
+
 import java.util.List;
 
 import org.eclipse.core.resources.IProject;
@@ -105,7 +107,9 @@ public IPath getLocation() {
      * @return the owning model manager
      */
     public BazelModelManager getModelManager() {
-        return modelManager;
+        return requireNonNull(
+            modelManager,
+            "not initialized properly; allowed only in unit tests, then mocking is required");
     }
 
     @Override

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/BaseProvisioningStrategy.java

@@ -1655,7 +1655,7 @@ private void linkSourceFilesWithoutCommonRoot(JavaSourceInfo sourceInfo, IFolder
         Set<IFile> linkedFiles = new HashSet<>();
         for (JavaSourceEntry fileEntry : files) {
             // peek at Java package to find proper "root"
-            var packagePath = fileEntry.getDetectedPackagePath();
+            var packagePath = fileEntry.hasDetectedPackagePath() ? fileEntry.getDetectedPackagePath() : IPath.EMPTY;
             var packageFolder = virtualSourceFolder.getFolder(packagePath);
             if (!packageFolder.exists()) {
                 createFolderAndParents(packageFolder, monitor.split(1));

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/analyzers/starlark/StarlarkAnalyzeInfo.java

@@ -26,12 +26,13 @@
 import net.starlark.java.eval.Sequence;
 import net.starlark.java.eval.Starlark;
 import net.starlark.java.eval.StarlarkInt;
+import net.starlark.java.eval.StarlarkValue;
 
 /**
  * A data type for returning information from the <code>analyze</code> function
  */
 @StarlarkBuiltin(name = "AnalyzeInfo", documented = false)
-public class StarlarkAnalyzeInfo {
+public class StarlarkAnalyzeInfo implements StarlarkValue {
 
     private List<String> convertToStringList(Sequence<?> exclude, String nameForErrorMessage) throws EvalException {
         List<String> stringList = new ArrayList<>();
@@ -54,12 +55,11 @@ private List<String> convertToStringList(Sequence<?> exclude, String nameForErro
                     @ParamType(type = Sequence.class, generic1 = String.class) }, defaultValue = "[]", named = true, documented = false),
             @Param(name = "exclude_directories", defaultValue = "1", named = true, documented = false),
             @Param(name = "allow_empty", defaultValue = "unbound", named = true, documented = false) })
-    StarlarkGlobInfo glob(Sequence<?> include, Sequence<?> exclude, StarlarkInt excludeDirectories, Object allowEmpty)
-            throws EvalException, InterruptedException {
+    StarlarkGlobInfo ProjectInfo(Sequence<?> include, Sequence<?> exclude, StarlarkInt excludeDirectories,
+            Object allowEmpty) throws EvalException, InterruptedException {
 
         var includeStringList = convertToStringList(include, "include");
         var excludeStringList = convertToStringList(exclude, "exclude");
         return new StarlarkGlobInfo(new GlobInfo(includeStringList, excludeStringList));
-
     }
 }

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/analyzers/starlark/StarlarkFunctionCallInfo.java

@@ -51,6 +51,7 @@ class StarlarkFunctionCallInfo implements StarlarkValue {
     private static final Logger LOG = LoggerFactory.getLogger(StarlarkFunctionCallInfo.class);
 
     private final FunctionCall functionCall;
+    private volatile Dict<String, Object> args;
 
     public StarlarkFunctionCallInfo(FunctionCall functionCall) {
         this.functionCall = functionCall;
@@ -84,7 +85,11 @@ private Dict<String, Object> evaluateArgs(StarlarkThread thread) {
 
     @StarlarkMethod(name = "args", structField = true, useStarlarkThread = true)
     public Dict<String, Object> getArgs(StarlarkThread thread) {
-        return evaluateArgs(thread);
+        var args = this.args;
+        if (args != null) {
+            return args;
+        }
+        return this.args = evaluateArgs(thread);
     }
 
     @StarlarkMethod(name = "resolved_function_name", structField = true)

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/analyzers/starlark/StarlarkMacroCallAnalyzer.java

@@ -64,22 +64,25 @@
  */
 public class StarlarkMacroCallAnalyzer implements MacroCallAnalyzer {
 
+    private static final String FUNCTION_INFO = "function_info";
+
     private static final StarlarkSemantics starlarkSemantics =
             StarlarkSemantics.builder().setBool(StarlarkSemantics.EXPERIMENTAL_ENABLE_STARLARK_SET, true).build();
 
-    private final IPath analyzeFile;
-    private final StarlarkFunction analyzeFunction;
-
-    public StarlarkMacroCallAnalyzer(BazelWorkspace bazelWorkspace, WorkspacePath bzlFile)
+    /**
+     * Parses the given input for an <code>'analyze'</code> function.
+     *
+     * @param input
+     *            the input to parse
+     * @param file
+     *            for error reporting only
+     * @return the parsed function (never <code>null</code>)
+     * @throws CoreException,
+     *             {@link OperationCanceledException}
+     */
+    /* for test only */
+    static StarlarkFunction parseInputAndGetAnalyzeFunction(ParserInput input, String file)
             throws CoreException, OperationCanceledException {
-        analyzeFile = bazelWorkspace.getLocation().append(bzlFile.relativePath());
-        ParserInput input;
-        try {
-            input = ParserInput.readFile(analyzeFile.toOSString());
-        } catch (IOException e) {
-            throw new CoreException(Status.error(format("Failed to read file '%s'", analyzeFile), e));
-        }
-
         try (var mu = Mutability.create("analyzer")) {
             ImmutableMap.Builder<String, Object> env = ImmutableMap.builder();
             //Starlark.addMethods(env, new CqueryDialectGlobals(), starlarkSemantics);
@@ -89,41 +92,68 @@ public StarlarkMacroCallAnalyzer(BazelWorkspace bazelWorkspace, WorkspacePath bz
             Starlark.execFile(input, FileOptions.DEFAULT, module, thread);
             var analyzeFn = module.getGlobal("analyze");
             if (analyzeFn == null) {
-                throw new CoreException(
-                        Status.error(format("File '%s' does not define 'analyze' function", analyzeFile)));
+                throw new CoreException(Status.error(format("File '%s' does not define 'analyze' function", file)));
             }
-            if (!(analyzeFn instanceof StarlarkFunction)) {
+            if (!(analyzeFn instanceof StarlarkFunction analyzeFunction)) {
                 throw new CoreException(
                         Status.error(
                             format(
                                 "File '%s' 'analyze' is not a function. Got '%s'.",
-                                analyzeFile,
+                                file,
                                 Starlark.type(analyzeFn))));
             }
-            analyzeFunction = (StarlarkFunction) analyzeFn;
-            if (analyzeFunction.getParameterNames().size() != 1) {
+            if (!analyzeFunction.getParameterNames().contains(FUNCTION_INFO)
+                    || (analyzeFunction.getParameterNames().size() != 1)) {
                 throw new CoreException(
-                        Status.error(format("File '%s' 'format' function must take exactly 1 argument", analyzeFile)));
+                        Status.error(
+                            format(
+                                "File '%s' 'analyze' function must take exactly 1 named argument 'function_info'",
+                                file)));
             }
+
+            return analyzeFunction;
         } catch (SyntaxError.Exception e) {
-            throw new CoreException(
-                    Status.error(format("Syntax error in file '%s': %s", analyzeFile, e.getMessage()), e));
+            throw new CoreException(Status.error(format("Syntax error in file '%s': %s", file, e.getMessage()), e));
         } catch (EvalException e) {
-            throw new CoreException(
-                    Status.error(format("Evaluation error in file '%s': %s", analyzeFile, e.getMessage()), e));
+            throw new CoreException(Status.error(format("Evaluation error in file '%s': %s", file, e.getMessage()), e));
         } catch (InterruptedException e) {
             throw new OperationCanceledException("Interrupted while executing Starlark");
         }
     }
 
+    private final IPath analyzeFile;
+
+    private final StarlarkFunction analyzeFunction;
+
+    public StarlarkMacroCallAnalyzer(BazelWorkspace bazelWorkspace, WorkspacePath bzlFile)
+            throws CoreException, OperationCanceledException {
+
+        analyzeFile = bazelWorkspace.getLocation().append(bzlFile.relativePath());
+
+        ParserInput input;
+        try {
+            input = ParserInput.readFile(analyzeFile.toOSString());
+        } catch (IOException e) {
+            throw new CoreException(Status.error(format("Failed to read file '%s'", analyzeFile), e));
+        }
+
+        analyzeFunction = parseInputAndGetAnalyzeFunction(input, analyzeFile.toOSString());
+    }
+
     @Override
     public boolean analyze(FunctionCall macroCall, JavaProjectInfo javaInfo) throws CoreException {
         try {
             var thread = StarlarkThread.createTransient(Mutability.create("analyze evaluation"), starlarkSemantics);
             thread.setMaxExecutionSteps(500_000L);
 
-            var kwargs = Map.<String, Object> of("macro_info", new StarlarkFunctionCallInfo(macroCall));
+            var kwargs = Map.<String, Object> of(FUNCTION_INFO, new StarlarkFunctionCallInfo(macroCall));
             var result = Starlark.call(thread, analyzeFunction, null, kwargs);
+            if (Starlark.isNullOrNone(result) || !Starlark.truth(result)) {
+                return false;
+            }
+            if (!(result instanceof StarlarkAnalyzeInfo)) {
+                throw Starlark.errorf("Return value is not of type AnalyzeInfo. Got '%s'", result);
+            }
         } catch (EvalException e) {
             throw new CoreException(
                     Status.error(

bundles/com.salesforce.bazel.eclipse.core/src/com/salesforce/bazel/eclipse/core/model/discovery/analyzers/starlark/StarlarkNativeModuleApiDummy.java

@@ -13,9 +13,6 @@
  */
 package com.salesforce.bazel.eclipse.core.model.discovery.analyzers.starlark;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import com.salesforce.bazel.eclipse.core.model.buildfile.GlobInfo;
 
 import net.starlark.java.annot.Param;
@@ -24,7 +21,6 @@
 import net.starlark.java.annot.StarlarkMethod;
 import net.starlark.java.eval.EvalException;
 import net.starlark.java.eval.Sequence;
-import net.starlark.java.eval.Starlark;
 import net.starlark.java.eval.StarlarkInt;
 
 /**
@@ -33,17 +29,6 @@
 @StarlarkBuiltin(name = "native", documented = false)
 public class StarlarkNativeModuleApiDummy {
 
-    private List<String> convertToStringList(Sequence<?> exclude, String nameForErrorMessage) throws EvalException {
-        List<String> stringList = new ArrayList<>();
-        for (Object value : exclude) {
-            if (!(value instanceof String s)) {
-                throw Starlark.errorf("Invalid 'glob' argument type in '%s': %s", nameForErrorMessage, value);
-            }
-            stringList.add(s);
-        }
-        return stringList;
-    }
-
     /**
      * Support for <code>glob</code> to turn into {@link StarlarkGlobInfo}.
      *
@@ -56,12 +41,8 @@ private List<String> convertToStringList(Sequence<?> exclude, String nameForErro
                     @ParamType(type = Sequence.class, generic1 = String.class) }, defaultValue = "[]", named = true, documented = false),
             @Param(name = "exclude_directories", defaultValue = "1", named = true, documented = false),
             @Param(name = "allow_empty", defaultValue = "unbound", named = true, documented = false) })
-    StarlarkGlobInfo glob(Sequence<?> include, Sequence<?> exclude, StarlarkInt excludeDirectories, Object allowEmpty)
-            throws EvalException, InterruptedException {
-
-        var includeStringList = convertToStringList(include, "include");
-        var excludeStringList = convertToStringList(exclude, "exclude");
-        return new StarlarkGlobInfo(new GlobInfo(includeStringList, excludeStringList));
-
+    StarlarkGlobInfo glob(Sequence<String> include, Sequence<String> exclude, StarlarkInt excludeDirectories,
+            Object allowEmpty) throws EvalException, InterruptedException {
+        return new StarlarkGlobInfo(new GlobInfo(include, exclude));
     }
 }