Move to clap 3.0

Use OsStr for filenames, so that they don't have to be valid utf8.

Signed-off-by: Sean Young <sean@mess.org>

Cargo.toml

@@ -19,7 +19,7 @@ num-bigint = "0.4"
 num-traits = "0.2"
 num-derive = "0.3"
 parity-wasm = "0.42"
-clap = "2.33"
+clap = "3.0"
 lazy_static = "1.4"
 hex = "0.4"
 tiny-keccak = { version = "2.0", features = ["keccak"] }

src/bin/languageserver/mod.rs

@@ -57,7 +57,7 @@ impl SolangServer {
 
             let os_str = path.file_name().unwrap();
 
-            let mut ns = parse_and_resolve(os_str.to_str().unwrap(), &mut resolver, self.target);
+            let mut ns = parse_and_resolve(os_str, &mut resolver, self.target);
 
             // codegen all the contracts; some additional errors/warnings will be detected here
             codegen(&mut ns, &Default::default());

src/bin/solang.rs

@@ -3,7 +3,7 @@ use itertools::Itertools;
 use num_traits::cast::ToPrimitive;
 use serde::Serialize;
 use std::collections::HashMap;
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::fs::{create_dir_all, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
@@ -46,14 +46,15 @@ fn main() {
         .author(env!("CARGO_PKG_AUTHORS"))
         .about(env!("CARGO_PKG_DESCRIPTION"))
         .arg(
-            Arg::with_name("INPUT")
+            Arg::new("INPUT")
                 .help("Solidity input files")
                 .required(true)
                 .conflicts_with("LANGUAGESERVER")
-                .multiple(true),
+                .allow_invalid_utf8(true)
+                .multiple_values(true),
         )
         .arg(
-            Arg::with_name("EMIT")
+            Arg::new("EMIT")
                 .help("Emit compiler state at early stage")
                 .long("emit")
                 .takes_value(true)
@@ -62,15 +63,15 @@ fn main() {
                 ]),
         )
         .arg(
-            Arg::with_name("OPT")
+            Arg::new("OPT")
                 .help("Set llvm optimizer level")
-                .short("O")
+                .short('O')
                 .takes_value(true)
                 .possible_values(&["none", "less", "default", "aggressive"])
                 .default_value("default"),
         )
         .arg(
-            Arg::with_name("TARGET")
+            Arg::new("TARGET")
                 .help("Target to build for")
                 .long("target")
                 .takes_value(true)
@@ -78,100 +79,99 @@ fn main() {
                 .required(true),
         )
         .arg(
-            Arg::with_name("ADDRESS_LENGTH")
+            Arg::new("ADDRESS_LENGTH")
                 .help("Address length on Substrate")
                 .long("address-length")
                 .takes_value(true)
                 .default_value("32"),
         )
         .arg(
-            Arg::with_name("VALUE_LENGTH")
+            Arg::new("VALUE_LENGTH")
                 .help("Value length on Substrate")
                 .long("value-length")
                 .takes_value(true)
                 .default_value("16"),
         )
         .arg(
-            Arg::with_name("STD-JSON")
+            Arg::new("STD-JSON")
                 .help("mimic solidity json output on stdout")
                 .conflicts_with_all(&["VERBOSE", "OUTPUT", "EMIT"])
                 .long("standard-json"),
         )
         .arg(
-            Arg::with_name("VERBOSE")
+            Arg::new("VERBOSE")
                 .help("show debug messages")
-                .short("v")
+                .short('v')
                 .long("verbose"),
         )
         .arg(
-            Arg::with_name("OUTPUT")
+            Arg::new("OUTPUT")
                 .help("output directory")
-                .short("o")
+                .short('o')
                 .long("output")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name("IMPORTPATH")
+            Arg::new("IMPORTPATH")
                 .help("Directory to search for solidity files")
-                .short("I")
+                .short('I')
                 .long("importpath")
                 .takes_value(true)
-                .multiple(true)
-                .require_delimiter(true),
+                .allow_invalid_utf8(true)
+                .multiple_occurrences(true),
         )
         .arg(
-            Arg::with_name("IMPORTMAP")
+            Arg::new("IMPORTMAP")
                 .help("Map directory to search for solidity files [format: map=path]")
-                .short("m")
+                .short('m')
                 .long("importmap")
                 .takes_value(true)
-                .multiple(true)
-                .require_delimiter(true),
+                .multiple_occurrences(true),
         )
         .arg(
-            Arg::with_name("CONSTANTFOLDING")
+            Arg::new("CONSTANTFOLDING")
                 .help("Disable constant folding codegen optimization")
                 .long("no-constant-folding")
                 .display_order(1),
         )
         .arg(
-            Arg::with_name("STRENGTHREDUCE")
+            Arg::new("STRENGTHREDUCE")
                 .help("Disable strength reduce codegen optimization")
                 .long("no-strength-reduce")
                 .display_order(2),
         )
         .arg(
-            Arg::with_name("DEADSTORAGE")
+            Arg::new("DEADSTORAGE")
                 .help("Disable dead storage codegen optimization")
                 .long("no-dead-storage")
                 .display_order(3),
         )
         .arg(
-            Arg::with_name("VECTORTOSLICE")
+            Arg::new("VECTORTOSLICE")
                 .help("Disable vector to slice codegen optimization")
                 .long("no-vector-to-slice")
                 .display_order(4),
         )
         .arg(
-            Arg::with_name("COMMONSUBEXPRESSIONELIMINATION")
+            Arg::new("COMMONSUBEXPRESSIONELIMINATION")
                 .help("Disable common subexpression elimination")
                 .long("no-cse")
                 .display_order(5),
         )
         .arg(
-            Arg::with_name("MATHOVERFLOW")
+            Arg::new("MATHOVERFLOW")
                 .help("Enable math overflow checking")
                 .long("math-overflow")
                 .display_order(6),
         )
         .arg(
-            Arg::with_name("LANGUAGESERVER")
+            Arg::new("LANGUAGESERVER")
                 .help("Start language server on stdin/stdout")
                 .conflicts_with_all(&["STD-JSON", "OUTPUT", "EMIT", "OPT", "INPUT"])
                 .long("language-server"),
         )
         .arg(
-            Arg::with_name("DOC")
+            Arg::new("DOC")
                 .help("Generate documention for contracts using doc comments")
                 .long("doc"),
         )
@@ -243,7 +243,7 @@ fn main() {
 
     let mut resolver = FileResolver::new();
 
-    for filename in matches.values_of("INPUT").unwrap() {
+    for filename in matches.values_of_os("INPUT").unwrap() {
         if let Ok(path) = PathBuf::from(filename).canonicalize() {
             let _ = resolver.add_import_path(path.parent().unwrap().to_path_buf());
         }
@@ -254,10 +254,10 @@ fn main() {
         std::process::exit(1);
     }
 
-    if let Some(paths) = matches.values_of("IMPORTPATH") {
+    if let Some(paths) = matches.values_of_os("IMPORTPATH") {
         for path in paths {
             if let Err(e) = resolver.add_import_path(PathBuf::from(path)) {
-                eprintln!("error: import path ‘{}’: {}", path, e);
+                eprintln!("error: import path ‘{}’: {}", path.to_string_lossy(), e);
                 std::process::exit(1);
             }
         }
@@ -282,13 +282,13 @@ fn main() {
         let mut success = true;
         let mut files = Vec::new();
 
-        for filename in matches.values_of("INPUT").unwrap() {
+        for filename in matches.values_of_os("INPUT").unwrap() {
             let ns = solang::parse_and_resolve(filename, &mut resolver, target);
 
             diagnostics::print_messages(&resolver, &ns, verbose);
 
             if ns.contracts.is_empty() {
-                eprintln!("{}: error: no contracts found", filename);
+                eprintln!("{}: error: no contracts found", filename.to_string_lossy());
                 success = false;
             } else if diagnostics::any_errors(&ns.diagnostics) {
                 success = false;
@@ -316,7 +316,7 @@ fn main() {
             strength_reduce: !matches.is_present("STRENGTHREDUCE"),
             vector_to_slice: !matches.is_present("VECTORTOSLICE"),
             math_overflow_check,
-            common_subexpression_elimination: !matches.is_present("COMMONEXPRESSIONELIMINATION"),
+            common_subexpression_elimination: !matches.is_present("COMMONSUBEXPRESSIONELIMINATION"),
             opt_level,
         };
 
@@ -324,7 +324,7 @@ fn main() {
 
         let mut errors = false;
 
-        for filename in matches.values_of("INPUT").unwrap() {
+        for filename in matches.values_of_os("INPUT").unwrap() {
             match process_file(filename, &mut resolver, target, &matches, &mut json, &opt) {
                 Ok(ns) => namespaces.push(ns),
                 Err(_) => {
@@ -424,7 +424,7 @@ fn output_file(matches: &ArgMatches, stem: &str, ext: &str) -> PathBuf {
 }
 
 fn process_file(
-    filename: &str,
+    filename: &OsStr,
     resolver: &mut FileResolver,
     target: solang::Target,
     matches: &ArgMatches,
@@ -473,7 +473,7 @@ fn process_file(
     }
 
     if let Some("ast") = matches.value_of("EMIT") {
-        println!("{}", ns.print(filename));
+        println!("{}", ns.print(&filename.to_string_lossy()));
         return Ok(ns);
     }
 
@@ -520,11 +520,12 @@ fn process_file(
         }
 
         let context = inkwell::context::Context::create();
+        let filename_string = filename.to_string_lossy();
 
         let binary = resolved_contract.emit(
             &ns,
             &context,
-            filename,
+            &filename_string,
             opt.opt_level.into(),
             opt.math_overflow_check,
         );
@@ -575,7 +576,8 @@ fn process_file(
         }
     }
 
-    json.contracts.insert(filename.to_owned(), json_contracts);
+    json.contracts
+        .insert(filename.to_string_lossy().to_string(), json_contracts);
 
     Ok(ns)
 }

src/file_resolver.rs

@@ -1,7 +1,7 @@
 use crate::parser::pt::Loc;
 use crate::sema::ast;
 use std::collections::HashMap;
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io;
 use std::io::{prelude::*, Error, ErrorKind};
@@ -125,7 +125,7 @@ impl FileResolver {
     pub fn resolve_file(
         &mut self,
         parent: Option<&ResolvedFile>,
-        filename: &str,
+        filename: &OsStr,
     ) -> Result<ResolvedFile, String> {
         let path = PathBuf::from(filename);
 
@@ -227,7 +227,7 @@ impl FileResolver {
             }
         }
 
-        Err(format!("file not found ‘{}’", filename))
+        Err(format!("file not found ‘{}’", filename.to_string_lossy()))
     }
 
     /// Get line and the target symbol's offset from loc

src/lib.rs

@@ -15,7 +15,7 @@ pub mod sema;
 use file_resolver::FileResolver;
 use sema::ast;
 use sema::diagnostics;
-use std::fmt;
+use std::{ffi::OsStr, fmt};
 
 /// The target chain you want to compile Solidity for.
 #[derive(Clone, Copy)]
@@ -108,7 +108,7 @@ impl Target {
 /// The ctx is the inkwell llvm context.
 #[cfg(feature = "llvm")]
 pub fn compile(
-    filename: &str,
+    filename: &OsStr,
     resolver: &mut FileResolver,
     opt_level: inkwell::OptimizationLevel,
     target: Target,
@@ -164,7 +164,7 @@ pub fn compile_many<'a>(
 ///
 /// Note that multiple contracts can be specified in on solidity source file.
 pub fn parse_and_resolve(
-    filename: &str,
+    filename: &OsStr,
     resolver: &mut FileResolver,
     target: Target,
 ) -> ast::Namespace {

src/sema/mod.rs

@@ -4,7 +4,7 @@ use ast::{Diagnostic, Mutability};
 use num_bigint::BigInt;
 use num_traits::Signed;
 use num_traits::Zero;
-use std::collections::HashMap;
+use std::{collections::HashMap, ffi::OsStr};
 
 mod address;
 pub mod ast;
@@ -176,7 +176,7 @@ fn resolve_import(
         pt::Import::Rename(f, _) => f,
     };
 
-    let import_file_no = match resolver.resolve_file(parent, &filename.string) {
+    let import_file_no = match resolver.resolve_file(parent, OsStr::new(&filename.string)) {
         Err(message) => {
             ns.diagnostics
                 .push(ast::Diagnostic::error(filename.loc, message));

tests/contract.rs

@@ -1,5 +1,6 @@
 use solang::{file_resolver::FileResolver, parse_and_resolve, Target};
 use std::{
+    ffi::OsStr,
     fs::{read_dir, File},
     io::{self, Read},
     path::PathBuf,
@@ -55,7 +56,7 @@ fn parse_file(path: PathBuf, target: Target) -> io::Result<()> {
     // The files may have had their end of lines mangled on Windows
     cache.set_file_contents(&filename, source.replace("\r\n", "\n"));
 
-    let ns = parse_and_resolve(&filename, &mut cache, target);
+    let ns = parse_and_resolve(OsStr::new(&filename), &mut cache, target);
 
     let mut path = path;
 

tests/ewasm.rs

@@ -5,6 +5,7 @@ use rand::Rng;
 use ripemd::Ripemd160;
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
+use std::ffi::OsStr;
 use std::fmt;
 use tiny_keccak::{Hasher, Keccak};
 use wasmi::memory_units::Pages;
@@ -800,7 +801,7 @@ fn build_solidity(src: &str) -> TestRuntime {
     cache.set_file_contents("test.sol", src.to_string());
 
     let (res, ns) = compile(
-        "test.sol",
+        OsStr::new("test.sol"),
         &mut cache,
         inkwell::OptimizationLevel::Default,
         Target::Ewasm,

tests/solana.rs

@@ -26,13 +26,16 @@ use solang::{
     sema::diagnostics,
     Target,
 };
-use std::alloc::Layout;
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::io::Write;
-use std::mem::{align_of, size_of};
-use std::rc::Rc;
+use std::{
+    alloc::Layout,
+    cell::RefCell,
+    collections::HashMap,
+    convert::TryInto,
+    ffi::OsStr,
+    io::Write,
+    mem::{align_of, size_of},
+    rc::Rc,
+};
 use tiny_keccak::{Hasher, Keccak};
 
 mod solana_tests;
@@ -116,7 +119,7 @@ fn build_solidity(src: &str) -> VirtualMachine {
 
     cache.set_file_contents("test.sol", src.to_string());
 
-    let mut ns = solang::parse_and_resolve("test.sol", &mut cache, Target::Solana);
+    let mut ns = solang::parse_and_resolve(OsStr::new("test.sol"), &mut cache, Target::Solana);
 
     // codegen all the contracts; some additional errors/warnings will be detected here
     codegen(&mut ns, &Options::default());

tests/solana_tests/simple.rs

@@ -1,5 +1,6 @@
 use crate::build_solidity;
 use solang::{file_resolver::FileResolver, Target};
+use std::ffi::OsStr;
 
 #[test]
 fn simple() {
@@ -274,7 +275,7 @@ contract line {
 
     cache.set_file_contents("test.sol", src);
 
-    let ns = solang::parse_and_resolve("test.sol", &mut cache, Target::Solana);
+    let ns = solang::parse_and_resolve(OsStr::new("test.sol"), &mut cache, Target::Solana);
 
     solang::sema::diagnostics::print_messages(&cache, &ns, false);
 

tests/substrate.rs

@@ -3,8 +3,7 @@ use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 use rand::Rng;
 use sha2::{Digest, Sha256};
-use std::collections::HashMap;
-use std::fmt;
+use std::{collections::HashMap, ffi::OsStr, fmt};
 use tiny_keccak::{Hasher, Keccak};
 use wasmi::memory_units::Pages;
 use wasmi::*;
@@ -1184,7 +1183,7 @@ pub fn build_solidity(src: &'static str) -> TestRuntime {
     cache.set_file_contents("test.sol", src.to_string());
 
     let (res, ns) = compile(
-        "test.sol",
+        OsStr::new("test.sol"),
         &mut cache,
         inkwell::OptimizationLevel::Default,
         Target::default_substrate(),
@@ -1221,7 +1220,7 @@ pub fn build_solidity_with_overflow_check(src: &'static str) -> TestRuntime {
     cache.set_file_contents("test.sol", src.to_string());
 
     let (res, ns) = compile(
-        "test.sol",
+        OsStr::new("test.sol"),
         &mut cache,
         inkwell::OptimizationLevel::Default,
         Target::default_substrate(),

tests/substrate_tests/events.rs

@@ -2,6 +2,7 @@ use crate::{build_solidity, no_errors};
 use parity_scale_codec::Encode;
 use parity_scale_codec_derive::Decode;
 use solang::{file_resolver::FileResolver, Target};
+use std::ffi::OsStr;
 
 #[test]
 fn emit() {
@@ -85,7 +86,8 @@ fn event_imported() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -115,7 +117,8 @@ fn event_imported() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -145,7 +148,8 @@ fn event_imported() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -173,7 +177,8 @@ fn event_imported() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 }

tests/substrate_tests/imports.rs

@@ -1,6 +1,7 @@
 use crate::{first_error, no_errors};
 use solang::file_resolver::FileResolver;
 use solang::Target;
+use std::ffi::OsStr;
 
 #[test]
 fn enum_import() {
@@ -26,7 +27,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -52,7 +54,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -78,7 +81,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -100,7 +104,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     assert_eq!(
         first_error(ns.diagnostics),
@@ -118,7 +123,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     assert_eq!(
         first_error(ns.diagnostics),
@@ -135,7 +141,8 @@ fn enum_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     assert_eq!(
         first_error(ns.diagnostics),
@@ -167,7 +174,8 @@ fn struct_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -193,7 +201,8 @@ fn struct_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     assert_eq!(first_error(ns.diagnostics), "type ‘struct_a’ not found");
 }
@@ -230,7 +239,8 @@ fn contract_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -273,7 +283,8 @@ fn contract_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -316,7 +327,8 @@ fn contract_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 }
@@ -339,7 +351,11 @@ fn circular_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("self.sol", &mut cache, Target::default_substrate());
+    let ns = solang::parse_and_resolve(
+        OsStr::new("self.sol"),
+        &mut cache,
+        Target::default_substrate(),
+    );
 
     no_errors(ns.diagnostics);
 
@@ -380,7 +396,8 @@ fn circular_import() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 }
@@ -414,7 +431,8 @@ fn import_symbol() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -449,7 +467,8 @@ fn import_symbol() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -484,7 +503,8 @@ fn import_symbol() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -529,7 +549,8 @@ fn import_symbol() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 }
@@ -579,7 +600,8 @@ fn enum_import_chain() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 
@@ -626,7 +648,8 @@ fn enum_import_chain() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     assert_eq!(
         first_error(ns.diagnostics),
@@ -675,7 +698,8 @@ fn import_base_dir() {
         .to_string(),
     );
 
-    let ns = solang::parse_and_resolve("a.sol", &mut cache, Target::default_substrate());
+    let ns =
+        solang::parse_and_resolve(OsStr::new("a.sol"), &mut cache, Target::default_substrate());
 
     no_errors(ns.diagnostics);
 }

tests/substrate_tests/inheritance.rs

@@ -3,6 +3,7 @@ use parity_scale_codec::Encode;
 use parity_scale_codec_derive::Decode;
 use solang::file_resolver::FileResolver;
 use solang::Target;
+use std::ffi::OsStr;
 
 #[test]
 fn test_abstract() {
@@ -29,7 +30,7 @@ fn test_abstract() {
     );
 
     let (contracts, ns) = solang::compile(
-        "a.sol",
+        OsStr::new("a.sol"),
         &mut cache,
         inkwell::OptimizationLevel::Default,
         Target::default_substrate(),
@@ -67,7 +68,7 @@ fn test_abstract() {
     );
 
     let (contracts, ns) = solang::compile(
-        "a.sol",
+        OsStr::new("a.sol"),
         &mut cache,
         inkwell::OptimizationLevel::Default,
         Target::default_substrate(),

tests/undefined_variable_detection.rs

@@ -3,11 +3,12 @@ use solang::file_resolver::FileResolver;
 use solang::sema::ast::Diagnostic;
 use solang::sema::ast::{Level, Namespace};
 use solang::{parse_and_resolve, Target};
+use std::ffi::OsStr;
 
 fn parse_and_codegen(src: &'static str) -> Namespace {
     let mut cache = FileResolver::new();
     cache.set_file_contents("test.sol", src.to_string());
-    let mut ns = parse_and_resolve("test.sol", &mut cache, Target::Ewasm);
+    let mut ns = parse_and_resolve(OsStr::new("test.sol"), &mut cache, Target::Ewasm);
 
     let opt = Options {
         dead_storage: false,

tests/unused_variable_detection.rs

@@ -3,12 +3,13 @@ use solang::file_resolver::FileResolver;
 use solang::sema::ast;
 use solang::sema::ast::{Diagnostic, Level};
 use solang::{parse_and_resolve, Target};
+use std::ffi::OsStr;
 
 fn parse(src: &'static str) -> ast::Namespace {
     let mut cache = FileResolver::new();
     cache.set_file_contents("test.sol", src.to_string());
 
-    parse_and_resolve("test.sol", &mut cache, Target::Ewasm)
+    parse_and_resolve(OsStr::new("test.sol"), &mut cache, Target::Ewasm)
 }
 
 fn parse_two_files(src1: &'static str, src2: &'static str) -> ast::Namespace {
@@ -16,7 +17,7 @@ fn parse_two_files(src1: &'static str, src2: &'static str) -> ast::Namespace {
     cache.set_file_contents("test.sol", src1.to_string());
     cache.set_file_contents("test2.sol", src2.to_string());
 
-    parse_and_resolve("test.sol", &mut cache, Target::Ewasm)
+    parse_and_resolve(OsStr::new("test.sol"), &mut cache, Target::Ewasm)
 }
 
 fn count_warnings(diagnostics: &[Diagnostic]) -> usize {