Attempt to ignore unrecognized java options

Author: ChadKillingsworth

packages/google-closure-compiler/lib/node/index.js

@@ -30,7 +30,7 @@ export const javaPath = 'java';
 
 export default class Compiler {
   /**
-   * @param {Object<string,string>|Array<string>} args
+   * @param {Object<string,string|boolean>|Array<string>} args
    * @param {Array<String>=} extraCommandArgs
    */
   constructor(args, extraCommandArgs) {
@@ -65,7 +65,12 @@ export default class Compiler {
   /** @param {function(number, string, string)=} callback */
   run(callback) {
     if (this.JAR_PATH) {
-      this.commandArguments.unshift('--sun-misc-unsafe-memory-access=allow', '-jar', this.JAR_PATH);
+      this.commandArguments.unshift(
+          '-XX:+IgnoreUnrecognizedVMOptions',
+          '--sun-misc-unsafe-memory-access=allow',
+          '-jar',
+          this.JAR_PATH,
+      );
       if (this.extraCommandArgs) {
         this.commandArguments.unshift(...this.extraCommandArgs);
       }

packages/google-closure-compiler/test/node.js

@@ -39,17 +39,21 @@ describe('closure-compiler node bindings', () => {
 
   describe('java version', () => {
     let originalTimeout;
-    const compilerArgs = [
-      '-Xms2048m',
-      '--sun-misc-unsafe-memory-access=allow',
-      '-jar',
-      JAR_PATH,
+    const baseCompilerArgs = [
       '--one=true',
       '--two=two',
       '--three=one',
       '--three=two',
       '--three=three',
     ];
+    const expandedCompilerArgs = [
+      '-XX:+IgnoreUnrecognizedVMOptions',
+      '--sun-misc-unsafe-memory-access=allow',
+      '-jar',
+      JAR_PATH,
+    ].concat(baseCompilerArgs);
+    const extraCompilerArgs = ['-Xms2048m'];
+    const expandedPlusExtraArgs = extraCompilerArgs.concat(expandedCompilerArgs);
     beforeEach(() => {
       originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
       jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
@@ -76,29 +80,26 @@ describe('closure-compiler node bindings', () => {
       expect(hasRun).toBe(true);
     });
 
-    it('should normalize an options object to an arguments array', async () => {
+    it('should normalize an options object to an arguments array immediately', () => {
       const compiler = new Compiler({
         one: true,
         two: 'two',
         three: ['one', 'two', 'three']
       });
-      await new Promise((resolve) => compiler.run(resolve));
 
-      const expectedArray = compilerArgs.slice(1);
-      expect(compiler.commandArguments.length).toBe(expectedArray.length);
+      expect(compiler.commandArguments.length).toBe(baseCompilerArgs.length);
       compiler.commandArguments.forEach((item, index) => {
-        expect(expectedArray[index]).toBe(item);
+        expect(baseCompilerArgs[index]).toBe(item);
       });
     });
 
     it('should prepend the -jar argument and compiler path when configured by array', async () => {
-      const expectedArray = compilerArgs.slice(1);
-      const compiler = new Compiler(expectedArray.slice(3));
+      const compiler = new Compiler(baseCompilerArgs);
       await new Promise((resolve) => compiler.run(resolve));
 
-      expect(compiler.commandArguments.length).toBe(expectedArray.length);
+      expect(compiler.commandArguments.length).toBe(expandedCompilerArgs.length);
       compiler.commandArguments.forEach((item, index) => {
-        expect(expectedArray[index]).toBe(item);
+        expect(expandedCompilerArgs[index]).toBe(item);
       });
     });
 
@@ -109,23 +110,21 @@ describe('closure-compiler node bindings', () => {
           two: 'two',
           three: ['one', 'two', 'three'],
         };
-        const expectedArray = compilerArgs;
-        const compiler = new Compiler(args, compilerArgs.slice(0, 1));
+        const compiler = new Compiler(args, extraCompilerArgs);
         await new Promise((resolve) => compiler.run(resolve));
 
-        expect(compiler.commandArguments.length).toBe(expectedArray.length);
+        expect(compiler.commandArguments.length).toBe(expandedPlusExtraArgs.length);
         compiler.commandArguments.forEach(function (item, index) {
-          expect(expectedArray[index]).toBe(item);
+          expect(expandedPlusExtraArgs[index]).toBe(item);
         });
       });
 
       it('should include initial command arguments when configured by array', async () => {
-        const expectedArray = compilerArgs;
-        const compiler = new Compiler(expectedArray.slice(4), expectedArray.slice(0, 1));
+        const compiler = new Compiler(baseCompilerArgs, extraCompilerArgs);
         await new Promise((resolve) => compiler.run(resolve));
-        expect(compiler.commandArguments.length).toBe(expectedArray.length);
+        expect(compiler.commandArguments.length).toBe(expandedPlusExtraArgs.length);
         compiler.commandArguments.forEach(function (item, index) {
-          expect(expectedArray[index]).toBe(item);
+          expect(expandedPlusExtraArgs[index]).toBe(item);
         });
       });
     });