multiple resolc fixes and improvements (#151)

- Error out early on compiler invocations with invalid base path or include path flags.
- Do not error out if no files and no errors were produced. This aligns resolc closer to sloc.
- Add a CLI test with an involved fixture containing multiple contract remappings to properly testing the standard JSON path.
- Fixes input normalization in the Wasm version.



Co-authored-by: Cyrill Leutwiler <cyrill@parity.io>

crates/solidity/src/tests/cli-tests/src/helper.ts

@@ -1,29 +1,44 @@
 import * as shell from 'shelljs';
 import * as fs from 'fs';
+import { spawnSync } from 'child_process';
 
 interface CommandResult {
     output: string;
     exitCode: number;
 }
 
-export const executeCommand = (command: string): CommandResult  => {
-    const result  = shell.exec(command, {async: false});
+export const executeCommand = (command: string, stdin?: string): CommandResult => {
+    if (stdin) {
+        const process = spawnSync(command, [], {
+            input: stdin,
+            shell: true,
+            encoding: 'utf8',
+            maxBuffer: 30 * 1024 * 1024
+        });
+
+        return {
+            exitCode: process.status || 0,
+            output: (process.stdout || process.stderr || '').toString()
+        };
+    }
+
+    const result = shell.exec(command, { silent: true, async: false });
     return {
         exitCode: result.code,
-        output: result.stdout.trim() || result.stderr.trim(),
+        output: result.stdout || result.stderr || ''
     };
 };
 
-export const isFolderExist = (folder: string): boolean  => {
+export const isFolderExist = (folder: string): boolean => {
     return shell.test('-d', folder);
 };
 
-export const isFileExist = (pathToFileDir: string, fileName: string, fileExtension:string): boolean  => {     
-    return shell.ls(pathToFileDir).stdout.includes(fileName + fileExtension); 
+export const isFileExist = (pathToFileDir: string, fileName: string, fileExtension: string): boolean => {
+    return shell.ls(pathToFileDir).stdout.includes(fileName + fileExtension);
 };
 
-export const isFileEmpty = (file: string): boolean  => {
+export const isFileEmpty = (file: string): boolean => {
     if (fs.existsSync(file)) {
         return (fs.readFileSync(file).length === 0);
-    } 
+    }
 };

crates/solidity/src/tests/cli-tests/tests/common.test.ts

@@ -1,5 +1,7 @@
 import { executeCommand, isFolderExist, isFileExist, isFileEmpty } from "../src/helper";
 import { paths } from '../src/entities';
+import * as shell from 'shelljs';
+import * as path from 'path';
 
 
 //id1762
@@ -142,3 +144,48 @@ describe("Run resolc with source debug information, check LLVM debug-info", () =
         });
     }
 });
+
+
+
+describe("Standard JSON compilation with path options", () => {
+    const contractsDir = path.join(shell.tempdir(), 'contracts-test');
+    const inputFile = path.join(__dirname, '..', 'src/contracts/compiled/1.json');
+
+    beforeAll(() => {
+        shell.mkdir('-p', contractsDir);
+
+        const input = JSON.parse(shell.cat(inputFile).toString());
+
+        Object.entries(input.sources).forEach(([sourcePath, source]: [string, any]) => {
+            const filePath = path.join(contractsDir, sourcePath);
+            shell.mkdir('-p', path.dirname(filePath));
+            shell.ShellString(source.content).to(filePath);
+        });
+    });
+
+    afterAll(() => {
+        shell.rm('-rf', contractsDir);
+    });
+
+    describe("Output with all path options", () => {
+        let result: { exitCode: number; output: string };
+
+        beforeAll(() => {
+            const tempInputFile = path.join(contractsDir, 'temp-input.json');
+            shell.cp(inputFile, tempInputFile);
+            const inputContent = shell.cat(inputFile).toString();
+
+            const command = `resolc --standard-json --base-path "${contractsDir}" --include-path "${contractsDir}" --allow-paths "${contractsDir}"`;
+
+            result = executeCommand(command, inputContent);
+
+            shell.rm(tempInputFile);
+
+        });
+
+        it("Compiler run successful without emiting warnings", () => {
+            const parsedResults = JSON.parse(result.output)
+            expect(parsedResults.errors.filter((error: { type: string; }) => error.type != 'Warning')).toEqual([]);
+        });
+    });
+});