Add baseOptions to compiler props

Added as a way to help with compiler-explorer#1899

Author: AbrilRBS

lib/compiler-finder.js

@@ -156,16 +156,26 @@ class CompilerFinder {
         }
 
         const ceToolsPath = props("ceToolsPath", "./");
+
         const supportsBinary = !!props("supportsBinary", true);
         const supportsExecute = supportsBinary && !!props("supportsExecute", true);
         const supportsLibraryCodeFilter = !!props("supportsLibraryCodeFilter", true);
+
         const group = props("group", "");
+
         const demanglerProp = props("demangler", "");
         const demangler = demanglerProp ? path.normalize(demanglerProp.replace("${ceToolsPath}", ceToolsPath)) : "";
+
         const isSemVer = props("isSemVer", false);
         const baseName = props("baseName", null);
         const semverVer = props("semver", "");
+
         const name = props("name", compilerName);
+
+        const baseOptions = props("baseOptions", "");
+        const options = props("options", "");
+        let actualOptions = _.compact([baseOptions, options]).join(' ');
+
         const envVars = (() => {
             const envVarsString = props("envVars", "");
             if (envVarsString === "") {
@@ -185,7 +195,7 @@ class CompilerFinder {
             exe: exe,
             name: isSemVer && baseName ? `${baseName} ${semverVer}` : name,
             alias: _.filter(props("alias", "").split(":"), (a) => a !== ""),
-            options: props("options"),
+            options: actualOptions,
             versionFlag: props("versionFlag"),
             versionRe: props("versionRe"),
             compilerType: props("compilerType", ""),

test/compiler-finder-tests.js

@@ -40,23 +40,81 @@ const props = {
     compilers: "goodCompiler:&badCompiler"
 };
 
+const noOptionsAtAll = {
+    compilers: "goodCompiler"
+};
+
+const noBaseOptions = {
+    compilers: "goodCompiler",
+    options: "bar"
+};
+
+const onlyBaseOptions = {
+    compilers: "goodCompiler",
+    baseOptions: "foo"
+};
+
+const bothOptions = {
+    compilers: "goodCompiler",
+    baseOptions: "foo",
+    options: "bar"
+};
+
 describe('Compiler-finder', function () {
     let compilerProps;
 
+    let noOptionsAtAllProps;
+    let noBaseOptionsProps;
+    let onlyBaseOptionsProps;
+    let bothOptionsProps;
+
+    let optionsHandler;
+
     before(() => {
         compilerProps = new properties.CompilerProps(languages, properties.fakeProps(props));
-    });
 
-    it('should not hang for undefined groups (Bug #860)', () => {
-        const optionsHandler = {
+        noOptionsAtAllProps = new properties.CompilerProps(languages, properties.fakeProps(noOptionsAtAll));
+        noBaseOptionsProps = new properties.CompilerProps(languages, properties.fakeProps(noBaseOptions));
+        onlyBaseOptionsProps = new properties.CompilerProps(languages, properties.fakeProps(onlyBaseOptions));
+        bothOptionsProps = new properties.CompilerProps(languages, properties.fakeProps(bothOptions));
+
+        optionsHandler = {
             get: () => {
                 return {
                     libs: {},
                     tools: {}
                 };
             }
         };
+    });
+
+    it('should not hang for undefined groups (Bug #860)', () => {
+
         const finder = new CompilerFinder({}, compilerProps, properties.fakeProps({}), {}, optionsHandler);
         return finder.getCompilers().should.eventually.have.lengthOf(2);
-    })
+    });
+
+    it('should behave properly if no options are provided at all', async () => {
+        const finder = new CompilerFinder({}, noOptionsAtAllProps, properties.fakeProps({}), {}, optionsHandler);
+        const compilers = await finder.getCompilers();
+        compilers[0].options.should.equal('');
+    });
+
+    it('should behave properly if no base options are provided', async () => {
+        const finder = new CompilerFinder({}, noBaseOptionsProps, properties.fakeProps({}), {}, optionsHandler);
+        const compilers = await finder.getCompilers();
+        compilers[0].options.should.equal('bar');
+    });
+
+    it('should behave properly if only base options are provided', async () => {
+        const finder = new CompilerFinder({}, onlyBaseOptionsProps, properties.fakeProps({}), {}, optionsHandler);
+        const compilers = await finder.getCompilers();
+        compilers[0].options.should.equal('foo');
+    });
+
+    it('should behave properly if both options are provided', async () => {
+        const finder = new CompilerFinder({}, bothOptionsProps, properties.fakeProps({}), {}, optionsHandler);
+        const compilers = await finder.getCompilers();
+        compilers[0].options.should.equal('foo bar');
+    });
 });