Fix out-of-tree builds

out-of-tree builds allow multiple configurations to be built
simultaneously from one source tree. Each build configuration exists in
a separate builddir, and the srcdir contains no configuration, object
files or build artifacts. The builddir need not be a subdirectory of
srcdir, and typically it is on another filesystem than the sources.

In an autotools project which uses automake, the Makefiles are object
files, ie they are generated specifically for a particular
configuration, therefore they reside in the builddir.

When building an autotools project out-of-tree, the workspace is the
srcdir, and does not contain a Makefile. instead, the Makefile is in
$makeDirectory which is the builddir.

This commit cleans up the detection of makefile location that is done in
the extension so that the correct makefile is found, even if it lives
out-of-tree/out-of-workspace, has a name other than Makefile/makefile,
an whether or not a file named Makefile also exists in the srcdir.

The activationEvent is changed to "*" because when building out of
tree, there are no makefiles in the workspace. "*" is the better
activation because it means activate whenever the user enabled the
extension; don't second guess. OTOH, the extension does nothing
if a makefile is not found and not configured, so it's safe to
have it activated on workspaces without makefiles, because of the
cleaned-up detection/configuration of makefiles.

Author: drok

package.json

@@ -37,44 +37,7 @@
         "Other"
     ],
     "activationEvents": [
-        "onCommand:makefile.setBuildConfiguration",
-        "onCommand:makefile.getConfiguration",
-        "onCommand:makefile.setBuildTarget",
-        "onCommand:makefile.getBuildTarget",
-        "onCommand:makefile.buildTarget",
-        "onCommand:makefile.buildCleanTarget",
-        "onCommand:makefile.buildAll",
-        "onCommand:makefile.buildCleanAll",
-        "onCommand:makefile.setLaunchConfiguration",
-        "onCommand:makefile.launchDebug",
-        "onCommand:makefile.launchRun",
-        "onCommand:makefile.launchTargetPath",
-        "onCommand:makefile.getLaunchTargetPath",
-        "onCommand:makefile.launchTargetFileName",
-        "onCommand:makefile.getLaunchTargetFileName",
-        "onCommand:makefile.getLaunchTargetDirectory",
-        "onCommand:makefile.getLaunchTargetArgs",
-        "onCommand:makefile.getLaunchTargetArgsConcat",
-        "onCommand:makefile.makeBaseDirectory",
-        "onCommand:makefile.configure",
-        "onCommand:makefile.cleanConfigure",
-        "onCommand:makefile.preConfigure",
-        "onCommand:makefile.postConfigure",
-        "onCommand:makefile.outline.setBuildConfiguration",
-        "onCommand:makefile.outline.setBuildTarget",
-        "onCommand:makefile.outline.buildTarget",
-        "onCommand:makefile.outline.buildCleanTarget",
-        "onCommand:makefile.outline.setLaunchConfiguration",
-        "onCommand:makefile.outline.launchDebug",
-        "onCommand:makefile.outline.launchRun",
-        "onCommand:makefile.outline.configure",
-        "onCommand:makefile.outline.cleanConfigure",
-        "onCommand:makefile.outline.preConfigure",
-        "onCommand:makefile.outline.postConfigure",
-        "onCommand:makefile.resetState",
-        "workspaceContains:**/makefile",
-        "workspaceContains:**/Makefile",
-        "workspaceContains:**/GNUmakefile"
+        "*"
     ],
     "main": "./out/src/extension.js",
     "contributes": {

src/configuration.ts

@@ -699,39 +699,82 @@ export async function getCommandForConfiguration(configuration: string | undefin
         configurationMakeCommand += ".exe";
     }
 
+    // Add the working directory path via the -C switch.
+    // makefile.configurations.makeDirectory overwrites makefile.makeDirectory.
+    let makeDirectoryUsed: string | undefined = makefileConfiguration?.makeDirectory ? util.resolvePathToRoot(makefileConfiguration?.makeDirectory) : makeDirectory;
+    if (makeDirectoryUsed) {
+        configurationMakeArgs.push("-C");
+        configurationMakeArgs.push(`${makeDirectoryUsed}`);
+        configurationMakefile = makeDirectoryUsed;
+    }
+
     // Add the makefile path via the -f make switch.
+    // The make file is in makeDirectory or in the workspace directory,
+    // and is named "Makefile" or "makefile".
     // makefile.configurations.makefilePath overwrites makefile.makefilePath.
-    configurationMakefile = makefileConfiguration?.makefilePath ? util.resolvePathToRoot(makefileConfiguration?.makefilePath) : makefilePath;
-    if (configurationMakefile) {
-        // check if the makefile path is a directory. If so, try adding `Makefile` or `makefile`
-        if (util.checkDirectoryExistsSync(configurationMakefile)) {
-            let makeFileTest: string = path.join(configurationMakefile, "Makefile");
-            if (!util.checkFileExistsSync(makeFileTest)) {
-                makeFileTest = path.join(configurationMakefile, "makefile");
+    let makeFileTest: string | undefined;
+    // filename of makefile relative to makeDirectory
+    let relativeMakefile: string | undefined;
+    let makefileExists : boolean = false;
+    if (makeDirectoryUsed) {
+        // check if the makefile path is a directory. If so, try adding
+        // the configuration makefilePath, then the makefilePath, then `Makefile` or `makefile`
+        if (util.checkDirectoryExistsSync(makeDirectoryUsed)) {
+            if (makefileConfiguration?.makefilePath) {
+                makeFileTest = path.join(makeDirectoryUsed, makefileConfiguration?.makefilePath);
+                relativeMakefile = makefileConfiguration?.makefilePath;
+                makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+                if (!makefileExists) {
+                    makeFileTest = makefilePath;
+                    relativeMakefile = util.resolvePathToRoot(makeFileTest);
+                    makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+                }
             }
-
-            // if we found the makefile in the directory, set the `configurationMakefile` to the found file path.
-            if (util.checkFileExistsSync(makeFileTest)) {
-                configurationMakefile = makeFileTest;
+            if (!makefileExists) {
+                makeFileTest = path.join(makeDirectoryUsed, makefilePath);
+                relativeMakefile = makefilePath;
+                makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+                if (!makefileExists) {
+                    if (makefilePath != "Makefile") {
+                        relativeMakefile = "Makefile";
+                        makeFileTest = path.join(makeDirectoryUsed, relativeMakefile);
+                        makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+                    }
+                    if (!makefileExists) {
+                        relativeMakefile = "makefile";
+                        makeFileTest = path.join(makeDirectoryUsed, relativeMakefile);
+                        makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+                    }
+                }
             }
         }
+    }
+    if (!makefileExists) {
+        if (!makeDirectoryUsed && makefileConfiguration?.makefilePath) {
+            relativeMakefile = makefileConfiguration?.makefilePath;
+            makeFileTest = makefileConfiguration?.makefilePath;
+            makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+        }
+    }
+    if (!makefileExists) {
+        makeFileTest = makefilePath;
+        relativeMakefile = makefilePath;
+        makefileExists = util.checkFileExistsSync(util.resolvePathToRoot(makeFileTest));
+    }
 
+    // if we found the makefile in the directory, set the `configurationMakefile` to the found file path.
+    if (makefileExists) {
+        configurationMakefile = relativeMakefile;
         configurationMakeArgs.push("-f");
-        configurationMakeArgs.push(`${configurationMakefile}`);
+        configurationMakeArgs.push(`${relativeMakefile}`);
+        setMakefilePath(relativeMakefile);
+        setConfigurationMakefile(makeFileTest);
         // Need to rethink this (GitHub 59).
         // Some repos don't work when we automatically add -C, others don't work when we don't.
         // configurationMakeArgs.push("-C");
         // configurationMakeArgs.push(path.parse(configurationMakefile).dir);
     }
 
-    // Add the working directory path via the -C switch.
-    // makefile.configurations.makeDirectory overwrites makefile.makeDirectory.
-    let makeDirectoryUsed: string | undefined = makefileConfiguration?.makeDirectory ? util.resolvePathToRoot(makefileConfiguration?.makeDirectory) : makeDirectory;
-    if (makeDirectoryUsed) {
-        configurationMakeArgs.push("-C");
-        configurationMakeArgs.push(`${makeDirectoryUsed}`);
-    }
-
     // Make sure we append "makefile.configurations[].makeArgs" last, in case the developer wants to overwrite any arguments that the extension
     // deduces from the settings. Additionally, for -f/-C, resolve path to root.
     if (makefileConfiguration?.makeArgs) {
@@ -755,22 +798,6 @@ export async function getCommandForConfiguration(configuration: string | undefin
         logger.message(`Deduced command '${configurationMakeCommand} ${configurationMakeArgs.join(" ")}' for configuration "${configuration}"`);
     }
 
-    // Check for makefile path on disk: we search first for any makefile specified via the makefilePath setting,
-    // then via the makeDirectory setting and then in the root of the workspace. On linux/mac, it often is 'Makefile', so verify that we default to the right filename.
-    if (!configurationMakefile) {
-       if (makeDirectoryUsed) {
-          configurationMakefile = util.resolvePathToRoot(path.join(makeDirectoryUsed, "Makefile"));
-          if (!util.checkFileExistsSync(configurationMakefile)) {
-             configurationMakefile = util.resolvePathToRoot(path.join(makeDirectoryUsed, "makefile"));
-          }
-       } else {
-          configurationMakefile = util.resolvePathToRoot("./Makefile");
-          if (!util.checkFileExistsSync(configurationMakefile)) {
-             configurationMakefile = util.resolvePathToRoot("./makefile");
-          }
-       }
-    }
-
  // Validation and warnings about properly defining the makefile and make tool.
     // These are not needed if the current configuration reads from a build log instead of dry-run output.
     let buildLog: string | undefined = getConfigurationBuildLog();
@@ -808,7 +835,7 @@ export async function getCommandForConfiguration(configuration: string | undefin
             }
         }
 
-        if (!util.checkFileExistsSync(util.resolvePathToRoot(configurationMakefile))) {
+        if (!makefileExists) {
             logger.message("The makefile entry point was not found. " +
                 "Make sure it exists at the location defined by makefile.makefilePath, makefile.configurations[].makefilePath, " +
                 "makefile.makeDirectory, makefile.configurations[].makeDirectory" +