Consistent use of single quotes

We have ‘x’, `x`, and ‘x‘. Always use 'x'.

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

solang-parser/src/lexer.rs

@@ -371,10 +371,10 @@ impl fmt::Display for LexicalError {
             }
             LexicalError::MissingNumber(..) => write!(f, "missing number"),
             LexicalError::InvalidCharacterInHexLiteral(_, ch) => {
-                write!(f, "invalid character ‘{}’ in hex literal string", ch)
+                write!(f, "invalid character '{}' in hex literal string", ch)
             }
-            LexicalError::UnrecognisedToken(_, t) => write!(f, "unrecognised token ‘{}’", t),
-            LexicalError::ExpectedFrom(_, t) => write!(f, "‘{}’ found where ‘from’ expected", t),
+            LexicalError::UnrecognisedToken(_, t) => write!(f, "unrecognised token '{}'", t),
+            LexicalError::ExpectedFrom(_, t) => write!(f, "'{}' found where 'from' expected", t),
             LexicalError::MissingExponent(..) => write!(f, "missing number"),
             LexicalError::DoublePoints(..) => write!(f, "found two dots in number"),
             LexicalError::UnrecognisedDecimal(..) => {

solang-parser/src/lib.rs

@@ -41,7 +41,7 @@ pub fn parse(
             } => Diagnostic::parser_error(
                 pt::Loc::File(file_no, l, r),
                 format!(
-                    "unrecognised token `{}', expected {}",
+                    "unrecognised token '{}', expected {}",
                     token,
                     expected.join(", ")
                 ),
@@ -49,7 +49,7 @@ pub fn parse(
             ParseError::User { error } => Diagnostic::parser_error(error.loc(), error.to_string()),
             ParseError::ExtraToken { token } => Diagnostic::parser_error(
                 pt::Loc::File(file_no, token.0, token.2),
-                format!("extra token `{}' encountered", token.0),
+                format!("extra token '{}' encountered", token.0),
             ),
             ParseError::UnrecognizedEOF { location, expected } => Diagnostic::parser_error(
                 pt::Loc::File(file_no, location, location),

src/bin/doc/mod.rs

@@ -476,7 +476,7 @@ Values: {{field}}
 
     if verbose {
         println!(
-            "debug: writing documentation to ‘{}’",
+            "debug: writing documentation to '{}'",
             filename.to_string_lossy()
         );
     }

src/bin/languageserver/mod.rs

@@ -58,7 +58,7 @@ impl SolangServer {
                 for path in paths {
                     if let Err(e) = resolver.add_import_path(PathBuf::from(path)) {
                         diags.push(Diagnostic {
-                            message: format!("import path ‘{}’: {}", path.to_string_lossy(), e),
+                            message: format!("import path '{}': {}", path.to_string_lossy(), e),
                             severity: Some(DiagnosticSeverity::ERROR),
                             ..Default::default()
                         });
@@ -73,14 +73,14 @@ impl SolangServer {
                             resolver.add_import_map(OsString::from(map), PathBuf::from(path))
                         {
                             diags.push(Diagnostic {
-                                message: format!("error: import path ‘{}’: {}", path, e),
+                                message: format!("error: import path '{}': {}", path, e),
                                 severity: Some(DiagnosticSeverity::ERROR),
                                 ..Default::default()
                             });
                         }
                     } else {
                         diags.push(Diagnostic {
-                            message: format!("error: import map ‘{}’: contains no ‘=’", p),
+                            message: format!("error: import map '{}': contains no '='", p),
                             severity: Some(DiagnosticSeverity::ERROR),
                             ..Default::default()
                         });

src/bin/solang.rs

@@ -180,7 +180,7 @@ fn main() {
     let address_length = match address_length.parse() {
         Ok(len) if (4..1024).contains(&len) => len,
         _ => {
-            eprintln!("error: address length ‘{}’ is not valid", address_length);
+            eprintln!("error: address length '{}' is not valid", address_length);
             std::process::exit(1);
         }
     };
@@ -190,7 +190,7 @@ fn main() {
     let value_length = match value_length.parse() {
         Ok(len) if (4..1024).contains(&len) => len,
         _ => {
-            eprintln!("error: value length ‘{}’ is not valid", value_length);
+            eprintln!("error: value length '{}' is not valid", value_length);
             std::process::exit(1);
         }
     };
@@ -207,7 +207,7 @@ fn main() {
 
     if !target.is_substrate() && matches.occurrences_of("ADDRESS_LENGTH") > 0 {
         eprintln!(
-            "error: address length cannot be modified for target ‘{}’",
+            "error: address length cannot be modified for target '{}'",
             target
         );
         std::process::exit(1);
@@ -215,7 +215,7 @@ fn main() {
 
     if !target.is_substrate() && matches.occurrences_of("VALUE_LENGTH") > 0 {
         eprintln!(
-            "error: value length cannot be modified for target ‘{}’",
+            "error: value length cannot be modified for target '{}'",
             target
         );
         std::process::exit(1);
@@ -255,7 +255,7 @@ fn main() {
     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.to_string_lossy(), e);
+                eprintln!("error: import path '{}': {}", path.to_string_lossy(), e);
                 std::process::exit(1);
             }
         }
@@ -265,11 +265,11 @@ fn main() {
         for p in maps {
             if let Some((map, path)) = p.split_once('=') {
                 if let Err(e) = resolver.add_import_map(OsString::from(map), PathBuf::from(path)) {
-                    eprintln!("error: import path ‘{}’: {}", path, e);
+                    eprintln!("error: import path '{}': {}", path, e);
                     std::process::exit(1);
                 }
             } else {
-                eprintln!("error: import map ‘{}’: contains no ‘=’", p);
+                eprintln!("error: import map '{}': contains no '='", p);
                 std::process::exit(1);
             }
         }
@@ -733,7 +733,7 @@ fn create_file(path: &Path) -> File {
     if let Some(parent) = path.parent() {
         if let Err(err) = create_dir_all(parent) {
             eprintln!(
-                "error: cannot create output directory ‘{}’: {}",
+                "error: cannot create output directory '{}': {}",
                 parent.display(),
                 err
             );
@@ -744,7 +744,7 @@ fn create_file(path: &Path) -> File {
     match File::create(path) {
         Ok(file) => file,
         Err(err) => {
-            eprintln!("error: cannot create file ‘{}’: {}", path.display(), err,);
+            eprintln!("error: cannot create file '{}': {}", path.display(), err,);
             std::process::exit(1);
         }
     }

src/file_resolver.rs

@@ -62,7 +62,7 @@ impl FileResolver {
         {
             Err(Error::new(
                 ErrorKind::Other,
-                format!("duplicate mapping for ‘{}’", map.to_string_lossy()),
+                format!("duplicate mapping for '{}'", map.to_string_lossy()),
             ))
         } else {
             self.import_paths.push((Some(map), path.canonicalize()?));
@@ -97,7 +97,7 @@ impl FileResolver {
         let mut f = match File::open(&path) {
             Err(err_info) => {
                 return Err(format!(
-                    "cannot open file ‘{}’: {}",
+                    "cannot open file '{}': {}",
                     path.display(),
                     err_info
                 ));
@@ -107,7 +107,7 @@ impl FileResolver {
 
         let mut contents = String::new();
         if let Err(e) = f.read_to_string(&mut contents) {
-            return Err(format!("failed to read file ‘{}’: {}", path.display(), e));
+            return Err(format!("failed to read file '{}': {}", path.display(), e));
         }
 
         let pos = self.files.len();
@@ -230,7 +230,7 @@ impl FileResolver {
             }
         }
 
-        Err(format!("file not found ‘{}’", filename.to_string_lossy()))
+        Err(format!("file not found '{}'", filename.to_string_lossy()))
     }
 
     /// Get line and the target symbol's offset from loc

src/sema/builtin.rs

@@ -823,7 +823,7 @@ pub fn builtin_var(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     String::from(
-                        "use the function ‘tx.gasprice(gas)’ in stead, as ‘tx.gasprice’ may round down to zero. See https://solang.readthedocs.io/en/latest/language.html#gasprice",
+                        "use the function 'tx.gasprice(gas)' in stead, as 'tx.gasprice' may round down to zero. See https://solang.readthedocs.io/en/latest/language.html#gasprice",
                     ),
                 ));
             }
@@ -896,7 +896,7 @@ pub fn resolve_call(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "cannot call function ‘{}’ in constant expression",
+                    "cannot call function '{}' in constant expression",
                     func.name
                 ),
             ));
@@ -907,7 +907,7 @@ pub fn resolve_call(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "builtin function ‘{}’ expects {} arguments, {} provided",
+                    "builtin function '{}' expects {} arguments, {} provided",
                     func.name,
                     func.args.len(),
                     args.len()
@@ -955,7 +955,7 @@ pub fn resolve_call(
                         diagnostics.push(Diagnostic::warning(
                             *loc,
                             String::from(
-                                "the function call ‘tx.gasprice(1)’ may round down to zero. See https://solang.readthedocs.io/en/latest/language.html#gasprice",
+                                "the function call 'tx.gasprice(1)' may round down to zero. See https://solang.readthedocs.io/en/latest/language.html#gasprice",
                             ),
                         ));
                     }
@@ -1059,7 +1059,7 @@ pub fn resolve_namespace_call(
                         if let Some(storage) = &param.storage {
                             diagnostics.push(Diagnostic::error(
                                 storage.loc(),
-                                format!("storage modifier ‘{}’ not allowed", storage),
+                                format!("storage modifier '{}' not allowed", storage),
                             ));
                             broken = true;
                         }
@@ -1067,7 +1067,7 @@ pub fn resolve_namespace_call(
                         if let Some(name) = &param.name {
                             diagnostics.push(Diagnostic::error(
                                 name.loc,
-                                format!("unexpected identifier ‘{}’ in type", name.name),
+                                format!("unexpected identifier '{}' in type", name.name),
                             ));
                             broken = true;
                         }
@@ -1144,7 +1144,7 @@ pub fn resolve_namespace_call(
             } else {
                 diagnostics.push(Diagnostic::error(
                     *loc,
-                    "function requires one ‘bytes4’ selector argument".to_string(),
+                    "function requires one 'bytes4' selector argument".to_string(),
                 ));
 
                 return Err(());
@@ -1212,7 +1212,7 @@ pub fn resolve_namespace_call(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "first argument should be function, got ‘{}’",
+                                "first argument should be function, got '{}'",
                                 ty.to_string(ns)
                             ),
                         ));
@@ -1248,7 +1248,7 @@ pub fn resolve_namespace_call(
             } else {
                 diagnostics.push(Diagnostic::error(
                     *loc,
-                    "function requires one ‘string’ signature argument".to_string(),
+                    "function requires one 'string' signature argument".to_string(),
                 ));
 
                 return Err(());
@@ -1310,7 +1310,7 @@ pub fn resolve_method_call(
             diagnostics.push(Diagnostic::error(
                 id.loc,
                 format!(
-                    "cannot call function ‘{}’ in constant expression",
+                    "cannot call function '{}' in constant expression",
                     func.name
                 ),
             ));
@@ -1321,7 +1321,7 @@ pub fn resolve_method_call(
             diagnostics.push(Diagnostic::error(
                 id.loc,
                 format!(
-                    "builtin function ‘{}’ expects {} arguments, {} provided",
+                    "builtin function '{}' expects {} arguments, {} provided",
                     func.name,
                     func.args.len(),
                     args.len()

src/sema/contracts.rs

@@ -115,7 +115,7 @@ pub fn resolve_base_contracts(
                 ns.diagnostics.push(ast::Diagnostic::error(
                     base.loc,
                     format!(
-                        "library ‘{}’ cannot have a base contract",
+                        "library '{}' cannot have a base contract",
                         ns.contracts[*contract_no].name
                     ),
                 ));
@@ -128,7 +128,7 @@ pub fn resolve_base_contracts(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             name.loc,
                             format!(
-                                "contract ‘{}’ cannot have itself as a base contract",
+                                "contract '{}' cannot have itself as a base contract",
                                 name.name
                             ),
                         ));
@@ -140,7 +140,7 @@ pub fn resolve_base_contracts(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             name.loc,
                             format!(
-                                "contract ‘{}’ duplicate base ‘{}’",
+                                "contract '{}' duplicate base '{}'",
                                 ns.contracts[*contract_no].name, name.name
                             ),
                         ));
@@ -148,7 +148,7 @@ pub fn resolve_base_contracts(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             name.loc,
                             format!(
-                                "base ‘{}’ from contract ‘{}’ is cyclic",
+                                "base '{}' from contract '{}' is cyclic",
                                 name.name, ns.contracts[*contract_no].name
                             ),
                         ));
@@ -158,7 +158,7 @@ pub fn resolve_base_contracts(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             name.loc,
                             format!(
-                                "interface ‘{}’ cannot have {} ‘{}’ as a base",
+                                "interface '{}' cannot have {} '{}' as a base",
                                 ns.contracts[*contract_no].name, ns.contracts[no].ty, name.name
                             ),
                         ));
@@ -168,7 +168,7 @@ pub fn resolve_base_contracts(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             name.loc,
                             format!(
-                                "library ‘{}’ cannot be used as base contract for {} ‘{}’",
+                                "library '{}' cannot be used as base contract for {} '{}'",
                                 name.name, contract.ty, contract.name,
                             ),
                         ));
@@ -186,7 +186,7 @@ pub fn resolve_base_contracts(
                 None => {
                     ns.diagnostics.push(ast::Diagnostic::error(
                         name.loc,
-                        format!("contract ‘{}’ not found", name.name),
+                        format!("contract '{}' not found", name.name),
                     ));
                 }
             }
@@ -318,9 +318,9 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             sym.loc(),
-                            format!("already defined ‘{}’", name),
+                            format!("already defined '{}'", name),
                             prev.loc(),
-                            format!("previous definition of ‘{}’", name),
+                            format!("previous definition of '{}'", name),
                         ));
                     }
                 }
@@ -353,7 +353,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                             Some(ast::Note {
                                 pos: func.loc,
                                 message: format!(
-                                    "function ‘{}’ is not specified ‘virtual’",
+                                    "function '{}' is not specified 'virtual'",
                                     func.name
                                 ),
                             })
@@ -365,7 +365,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     ns.diagnostics.push(ast::Diagnostic::error_with_notes(
                         cur.loc,
                         format!(
-                            "function ‘{}’ overrides functions which are not ‘virtual’",
+                            "function '{}' overrides functions which are not 'virtual'",
                             cur.name
                         ),
                         non_virtual,
@@ -383,7 +383,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         ns.diagnostics.push(ast::Diagnostic::error(
                             *loc,
                             format!(
-                                "function ‘{}’ should specify override list ‘override({})’",
+                                "function '{}' should specify override list 'override({})'",
                                 cur.name, source_override
                             ),
                         ));
@@ -403,7 +403,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                             ns.diagnostics.push(ast::Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "function ‘{}’ missing overrides ‘{}’, specify ‘override({})’",
+                                    "function '{}' missing overrides '{}', specify 'override({})'",
                                     cur.name,
                                     missing.join(","),
                                     source_override
@@ -421,7 +421,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                             ns.diagnostics.push(ast::Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "function ‘{}’ includes extraneous overrides ‘{}’, specify ‘override({})’",
+                                    "function '{}' includes extraneous overrides '{}', specify 'override({})'",
                                     cur.name,
                                     extra.join(","),
                                     source_override
@@ -439,7 +439,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         {
                             ns.diagnostics.push(ast::Diagnostic::error_with_note(
                                 cur.loc,
-                                format!("mutability ‘{}’ of function ‘{}’ is not compatible with mutability ‘{}’", cur.mutability, cur.name, func.mutability),
+                                format!("mutability '{}' of function '{}' is not compatible with mutability '{}'", cur.mutability, cur.name, func.mutability),
                                 func.loc,
                                 String::from("location of base function")
                             ));
@@ -448,7 +448,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         if !compatible_visibility(&cur.visibility, &func.visibility) {
                             ns.diagnostics.push(ast::Diagnostic::error_with_note(
                                 cur.loc,
-                                format!("visibility ‘{}’ of function ‘{}’ is not compatible with visibility ‘{}’", cur.visibility, cur.name, func.visibility),
+                                format!("visibility '{}' of function '{}' is not compatible with visibility '{}'", cur.visibility, cur.name, func.visibility),
                                 func.loc,
                                 String::from("location of base function")
                             ));
@@ -465,7 +465,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     if !ns.contracts[base_contract_no].is_interface() {
                         ns.diagnostics.push(ast::Diagnostic::error(
                             cur.loc,
-                            format!("function ‘{}’ should specify ‘override’", cur.name),
+                            format!("function '{}' should specify 'override'", cur.name),
                         ));
                     }
 
@@ -477,7 +477,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
-                            format!("mutability ‘{}’ of function ‘{}’ is not compatible with mutability ‘{}’", cur.mutability, cur.name, func.mutability),
+                            format!("mutability '{}' of function '{}' is not compatible with mutability '{}'", cur.mutability, cur.name, func.mutability),
                             func.loc,
                             String::from("location of base function")
                         ));
@@ -486,7 +486,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     if !compatible_visibility(&cur.visibility, &func.visibility) {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
-                            format!("visibility ‘{}’ of function ‘{}’ is not compatible with visibility ‘{}’", cur.visibility, cur.name, func.visibility),
+                            format!("visibility '{}' of function '{}' is not compatible with visibility '{}'", cur.visibility, cur.name, func.visibility),
                             func.loc,
                             String::from("location of base function")
                         ));
@@ -497,7 +497,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     ns.diagnostics.push(ast::Diagnostic::error(
                         cur.loc,
                         format!(
-                            "function ‘{}’ should specify override list ‘override({})’",
+                            "function '{}' should specify override list 'override({})'",
                             cur.name, source_override
                         ),
                     ));
@@ -517,7 +517,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                 if previous_defs.is_empty() && cur.is_override.is_some() {
                     ns.diagnostics.push(ast::Diagnostic::error(
                         cur.loc,
-                        format!("function ‘{}’ does not override anything", cur.name),
+                        format!("function '{}' does not override anything", cur.name),
                     ));
                     continue;
                 }
@@ -539,11 +539,11 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
                             format!(
-                                "function ‘{}’ overrides function in same contract",
+                                "function '{}' overrides function in same contract",
                                 cur.name
                             ),
                             func_prev.loc,
-                            format!("previous definition of ‘{}’", func_prev.name),
+                            format!("previous definition of '{}'", func_prev.name),
                         ));
 
                         continue;
@@ -552,9 +552,9 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     if func_prev.ty != cur.ty {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
-                            format!("{} ‘{}’ overrides {}", cur.ty, cur.name, func_prev.ty,),
+                            format!("{} '{}' overrides {}", cur.ty, cur.name, func_prev.ty,),
                             func_prev.loc,
-                            format!("previous definition of ‘{}’", func_prev.name),
+                            format!("previous definition of '{}'", func_prev.name),
                         ));
 
                         continue;
@@ -569,11 +569,11 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
                             format!(
-                                "{} ‘{}’ overrides {} with different argument types",
+                                "{} '{}' overrides {} with different argument types",
                                 cur.ty, cur.name, func_prev.ty,
                             ),
                             func_prev.loc,
-                            format!("previous definition of ‘{}’", func_prev.name),
+                            format!("previous definition of '{}'", func_prev.name),
                         ));
 
                         continue;
@@ -588,11 +588,11 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
                             format!(
-                                "{} ‘{}’ overrides {} with different return types",
+                                "{} '{}' overrides {} with different return types",
                                 cur.ty, cur.name, func_prev.ty,
                             ),
                             func_prev.loc,
-                            format!("previous definition of ‘{}’", func_prev.name),
+                            format!("previous definition of '{}'", func_prev.name),
                         ));
 
                         continue;
@@ -604,7 +604,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
-                            format!("mutability ‘{}’ of function ‘{}’ is not compatible with mutability ‘{}’", cur.mutability, cur.name, func_prev.mutability),
+                            format!("mutability '{}' of function '{}' is not compatible with mutability '{}'", cur.mutability, cur.name, func_prev.mutability),
                             func_prev.loc,
                             String::from("location of base function")
                         ));
@@ -613,7 +613,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     if !compatible_visibility(&cur.visibility, &func_prev.visibility) {
                         ns.diagnostics.push(ast::Diagnostic::error_with_note(
                             cur.loc,
-                            format!("visibility ‘{}’ of function ‘{}’ is not compatible with visibility ‘{}’", cur.visibility, cur.name, func_prev.visibility),
+                            format!("visibility '{}' of function '{}' is not compatible with visibility '{}'", cur.visibility, cur.name, func_prev.visibility),
                             func_prev.loc,
                             String::from("location of base function")
                         ));
@@ -627,11 +627,11 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                             ns.diagnostics.push(ast::Diagnostic::error_with_note(
                                 cur.loc,
                                 format!(
-                                    "function ‘{}’ overrides function which is not virtual",
+                                    "function '{}' overrides function which is not virtual",
                                     cur.name
                                 ),
                                 func_prev.loc,
-                                format!("previous definition of function ‘{}’", func_prev.name),
+                                format!("previous definition of function '{}'", func_prev.name),
                             ));
 
                             continue;
@@ -641,11 +641,11 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                             ns.diagnostics.push(ast::Diagnostic::error_with_note(
                                 *loc,
                                 format!(
-                                    "function ‘{}’ override list does not contain ‘{}’",
+                                    "function '{}' override list does not contain '{}'",
                                     cur.name, ns.contracts[prev_contract_no].name
                                 ),
                                 func_prev.loc,
-                                format!("previous definition of function ‘{}’", func_prev.name),
+                                format!("previous definition of function '{}'", func_prev.name),
                             ));
                             continue;
                         }
@@ -691,21 +691,21 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
                     ns.diagnostics.push(ast::Diagnostic::error_with_note(
                         loc,
                         format!(
-                            "contract ‘{}’ missing override for ‘{}’ function",
+                            "contract '{}' missing override for '{}' function",
                             ns.contracts[contract_no].name, func.ty
                         ),
                         func.loc,
-                        format!("declaration of ‘{}’ function", func.ty),
+                        format!("declaration of '{}' function", func.ty),
                     ));
                 }
                 _ => ns.diagnostics.push(ast::Diagnostic::error_with_note(
                     loc,
                     format!(
-                        "contract ‘{}’ missing override for function ‘{}’",
+                        "contract '{}' missing override for function '{}'",
                         ns.contracts[contract_no].name, func.name
                     ),
                     func.loc,
-                    format!("declaration of function ‘{}’", func.name),
+                    format!("declaration of function '{}'", func.name),
                 )),
             }
 
@@ -720,7 +720,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
 
                 ast::Note {
                     pos: func.loc,
-                    message: format!("previous definition of function ‘{}’", func.name),
+                    message: format!("previous definition of function '{}'", func.name),
                 }
             })
             .collect();
@@ -728,7 +728,7 @@ fn check_inheritance(contract_no: usize, ns: &mut ast::Namespace) {
         ns.diagnostics.push(ast::Diagnostic::error_with_notes(
             func.loc,
             format!(
-                "function ‘{}’ with this signature already defined",
+                "function '{}' with this signature already defined",
                 func.name
             ),
             notes,
@@ -764,7 +764,7 @@ fn resolve_declarations<'a>(
 ) {
     ns.diagnostics.push(ast::Diagnostic::debug(
         def.loc,
-        format!("found {} ‘{}’", def.ty, def.name.name),
+        format!("found {} '{}'", def.ty, def.name.name),
     ));
 
     let mut function_no_bodies = Vec::new();
@@ -801,7 +801,7 @@ fn resolve_declarations<'a>(
                 .map(|function_no| ast::Note {
                     pos: ns.functions[function_no].loc,
                     message: format!(
-                        "location of function ‘{}’ with no body",
+                        "location of function '{}' with no body",
                         ns.functions[function_no].name
                     ),
                 })
@@ -833,7 +833,7 @@ fn resolve_using(
                         ns.diagnostics.push(ast::Diagnostic::error(
                             using.library.loc,
                             format!(
-                                "library expected but {} ‘{}’ found",
+                                "library expected but {} '{}' found",
                                 ns.contracts[library_no].ty, using.library.name
                             ),
                         ));
@@ -857,7 +857,7 @@ fn resolve_using(
                                 ns.diagnostics.push(ast::Diagnostic::error(
                                     using.library.loc,
                                     format!(
-                                        "using library ‘{}’ to extend library not possible",
+                                        "using library '{}' to extend library not possible",
                                         using.library.name,
                                     ),
                                 ));
@@ -877,7 +877,7 @@ fn resolve_using(
                 } else {
                     ns.diagnostics.push(ast::Diagnostic::error(
                         using.library.loc,
-                        format!("library ‘{}’ not found", using.library.name),
+                        format!("library '{}' not found", using.library.name),
                     ));
                 }
             }
@@ -941,12 +941,12 @@ pub fn collect_base_args<'a>(
                 diagnostics.insert(ast::Diagnostic::error_with_note(
                     *loc,
                     format!(
-                        "duplicate argument for base contract ‘{}’",
+                        "duplicate argument for base contract '{}'",
                         ns.contracts[*base_no].name
                     ),
                     *prev_args.loc,
                     format!(
-                        "previous argument for base contract ‘{}’",
+                        "previous argument for base contract '{}'",
                         ns.contracts[*base_no].name
                     ),
                 ));
@@ -972,12 +972,12 @@ pub fn collect_base_args<'a>(
                 diagnostics.insert(ast::Diagnostic::error_with_note(
                     base.loc,
                     format!(
-                        "duplicate argument for base contract ‘{}’",
+                        "duplicate argument for base contract '{}'",
                         ns.contracts[base.contract_no].name
                     ),
                     *prev_args.loc,
                     format!(
-                        "previous argument for base contract ‘{}’",
+                        "previous argument for base contract '{}'",
                         ns.contracts[base.contract_no].name
                     ),
                 ));
@@ -1049,7 +1049,7 @@ fn check_base_args(contract_no: usize, ns: &mut ast::Namespace) {
                     diagnostics.insert(ast::Diagnostic::error(
                         contract.loc,
                         format!(
-                            "missing arguments to base contract ‘{}’ constructor",
+                            "missing arguments to base contract '{}' constructor",
                             ns.contracts[*base_no].name
                         ),
                     ));
@@ -1066,7 +1066,7 @@ fn check_base_args(contract_no: usize, ns: &mut ast::Namespace) {
                 diagnostics.insert(ast::Diagnostic::error(
                     contract.loc,
                     format!(
-                        "missing arguments to base contract ‘{}’ constructor",
+                        "missing arguments to base contract '{}' constructor",
                         ns.contracts[*base_no].name
                     ),
                 ));

src/sema/dotgraphviz.rs

@@ -1692,7 +1692,7 @@ impl Dot {
             }
             YulExpression::MemberAccess(loc, member, suffix) => {
                 let labels = vec![
-                    format!("yul member ‘{}‘ access", suffix.to_string()),
+                    format!("yul member '{}' access", suffix.to_string()),
                     ns.loc_to_string(loc),
                 ];
 
@@ -1994,7 +1994,7 @@ impl Dot {
         ns: &Namespace,
     ) -> usize {
         let labels = vec![
-            format!("yul function call ‘{}‘", ns.yul_functions[*func_no].name),
+            format!("yul function call '{}'", ns.yul_functions[*func_no].name),
             ns.loc_to_string(loc),
         ];
 
@@ -2022,7 +2022,7 @@ impl Dot {
         ns: &Namespace,
     ) -> usize {
         let labels = vec![
-            format!("yul builtin call ‘{}‘", builtin_ty.to_string()),
+            format!("yul builtin call '{}'", builtin_ty.to_string()),
             ns.loc_to_string(loc),
         ];
 

src/sema/expression.rs

@@ -200,7 +200,7 @@ impl Expression {
                         diagnostics.push(Diagnostic::type_error(
                             *loc,
                             format!(
-                                "implicit conversion cannot change negative number to ‘{}’",
+                                "implicit conversion cannot change negative number to '{}'",
                                 to.to_string(ns)
                             ),
                         ));
@@ -221,7 +221,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "implicit conversion would truncate from ‘{}’ to ‘{}’",
+                            "implicit conversion would truncate from '{}' to '{}'",
                             from.to_string(ns),
                             to.to_string(ns)
                         ),
@@ -242,7 +242,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "implicit conversion would truncate from ‘{}’ to ‘{}’",
+                            "implicit conversion would truncate from '{}' to '{}'",
                             from.to_string(ns),
                             to.to_string(ns)
                         ),
@@ -265,7 +265,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "negative number cannot be converted to type ‘{}’",
+                            "negative number cannot be converted to type '{}'",
                             to.to_string(ns)
                         ),
                     ));
@@ -274,7 +274,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "number of {} bytes cannot be converted to type ‘{}’",
+                            "number of {} bytes cannot be converted to type '{}'",
                             bytes,
                             to.to_string(ns)
                         ),
@@ -323,7 +323,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "implicit conversion would truncate from ‘{}’ to ‘{}’",
+                            "implicit conversion would truncate from '{}' to '{}'",
                             from.to_string(ns),
                             to.to_string(ns)
                         ),
@@ -1025,7 +1025,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "function arguments do not match in conversion from ‘{}’ to ‘{}’",
+                            "function arguments do not match in conversion from '{}' to '{}'",
                             to.to_string(ns),
                             from.to_string(ns)
                         ),
@@ -1035,7 +1035,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "function returns do not match in conversion from ‘{}’ to ‘{}’",
+                            "function returns do not match in conversion from '{}' to '{}'",
                             to.to_string(ns),
                             from.to_string(ns)
                         ),
@@ -1045,7 +1045,7 @@ impl Expression {
                     diagnostics.push(Diagnostic::type_error(
                         *loc,
                         format!(
-                            "function mutability not compatible in conversion from ‘{}’ to ‘{}’",
+                            "function mutability not compatible in conversion from '{}' to '{}'",
                             from.to_string(ns),
                             to.to_string(ns),
                         ),
@@ -1336,7 +1336,7 @@ pub fn bigint_to_expression(
         if !resolve_to.is_integer() {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("expected ‘{}’, found integer", resolve_to.to_string(ns)),
+                format!("expected '{}', found integer", resolve_to.to_string(ns)),
             ));
             return Err(());
         }
@@ -1352,7 +1352,7 @@ pub fn bigint_to_expression(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "negative literal {} not allowed for unsigned type ‘{}’",
+                        "negative literal {} not allowed for unsigned type '{}'",
                         n,
                         resolve_to.to_string(ns)
                     ),
@@ -1362,7 +1362,7 @@ pub fn bigint_to_expression(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "literal {} is too large to fit into type ‘{}’",
+                        "literal {} is too large to fit into type '{}'",
                         n,
                         resolve_to.to_string(ns)
                     ),
@@ -1379,7 +1379,7 @@ pub fn bigint_to_expression(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "literal {} is too large to fit into type ‘{}’",
+                    "literal {} is too large to fit into type '{}'",
                     n,
                     resolve_to.to_string(ns)
                 ),
@@ -1434,7 +1434,7 @@ pub fn bigdecimal_to_expression(
         if !resolve_to.is_rational() {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("expected ‘{}’, found rational", resolve_to.to_string(ns)),
+                format!("expected '{}', found rational", resolve_to.to_string(ns)),
             ));
             return Err(());
         } else {
@@ -1856,7 +1856,7 @@ pub fn expression(
         pt::Expression::ArraySubscript(loc, _, None) => {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                "expected expression before ‘]’ token".to_string(),
+                "expected expression before ']' token".to_string(),
             ));
 
             Err(())
@@ -2100,7 +2100,7 @@ fn hex_number_literal(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "address literal has incorrect checksum, expected ‘{}’",
+                        "address literal has incorrect checksum, expected '{}'",
                         address
                     ),
                 ));
@@ -2111,7 +2111,7 @@ fn hex_number_literal(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "ethereum address literal ‘{}’ not supported on target {}",
+                    "ethereum address literal '{}' not supported on target {}",
                     n, ns.target
                 ),
             ));
@@ -2131,7 +2131,7 @@ fn hex_number_literal(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "hex literal {} must be {} digits for type ‘bytes{}’",
+                    "hex literal {} must be {} digits for type 'bytes{}'",
                     n, expected_length, length,
                 ),
             ));
@@ -2276,7 +2276,7 @@ fn variable(
         return if context.constant {
             diagnostics.push(Diagnostic::error(
                 id.loc,
-                format!("cannot read variable ‘{}’ in constant expression", id.name),
+                format!("cannot read variable '{}' in constant expression", id.name),
             ));
             Err(())
         } else {
@@ -2316,7 +2316,7 @@ fn variable(
                 diagnostics.push(Diagnostic::error(
                     id.loc,
                     format!(
-                        "cannot read contract variable ‘{}’ in constant expression",
+                        "cannot read contract variable '{}' in constant expression",
                         id.name
                     ),
                 ));
@@ -2379,7 +2379,7 @@ fn variable(
             } else {
                 diagnostics.push(Diagnostic::error(
                     id.loc,
-                    format!("function ‘{}’ is overloaded", id.name),
+                    format!("function '{}' is overloaded", id.name),
                 ));
                 Err(())
             }
@@ -2842,7 +2842,7 @@ fn constructor(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "new cannot construct current contract ‘{}’",
+                    "new cannot construct current contract '{}'",
                     ns.contracts[no].name
                 ),
             ));
@@ -2862,7 +2862,7 @@ fn constructor(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "cannot construct ‘{}’ of type ‘{}’",
+                "cannot construct '{}' of type '{}'",
                 ns.contracts[no].name, ns.contracts[no].ty
             ),
         ));
@@ -2875,7 +2875,7 @@ fn constructor(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "circular reference creating contract ‘{}’",
+                "circular reference creating contract '{}'",
                 ns.contracts[no].name
             ),
         ));
@@ -3035,7 +3035,7 @@ pub fn constructor_named_args(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "new cannot construct current contract ‘{}’",
+                    "new cannot construct current contract '{}'",
                     ns.contracts[no].name
                 ),
             ));
@@ -3055,7 +3055,7 @@ pub fn constructor_named_args(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "cannot construct ‘{}’ of type ‘{}’",
+                "cannot construct '{}' of type '{}'",
                 ns.contracts[no].name, ns.contracts[no].ty
             ),
         ));
@@ -3068,7 +3068,7 @@ pub fn constructor_named_args(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "circular reference creating contract ‘{}’",
+                "circular reference creating contract '{}'",
                 ns.contracts[no].name
             ),
         ));
@@ -3085,7 +3085,7 @@ pub fn constructor_named_args(
         if let Some(prev) = arguments.get(arg.name.name.as_str()) {
             diagnostics.push(Diagnostic::error_with_note(
                 *loc,
-                format!("duplicate argument name ‘{}’", arg.name.name),
+                format!("duplicate argument name '{}'", arg.name.name),
                 prev.loc(),
                 String::from("location of previous argument"),
             ));
@@ -3131,7 +3131,7 @@ pub fn constructor_named_args(
                     matches = false;
                     diagnostics.push(Diagnostic::error(
                         *loc,
-                        format!("missing argument ‘{}’ to constructor", param.name_as_str()),
+                        format!("missing argument '{}' to constructor", param.name_as_str()),
                     ));
                     break;
                 }
@@ -3290,7 +3290,7 @@ pub fn type_name_expr(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "containing our own contract code for ‘{}’ would generate infinite size contract",
+                        "containing our own contract code for '{}' would generate infinite size contract",
                         ns.contracts[*no].name
                     ),
                 ));
@@ -3301,7 +3301,7 @@ pub fn type_name_expr(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "circular reference creating contract code for ‘{}’",
+                        "circular reference creating contract code for '{}'",
                         ns.contracts[*no].name
                     ),
                 ));
@@ -3322,7 +3322,7 @@ pub fn type_name_expr(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "type ‘{}’ does not have type function {}",
+                    "type '{}' does not have type function {}",
                     ty.to_string(ns),
                     field.name
                 ),
@@ -3352,7 +3352,7 @@ pub fn new(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "new cannot allocate fixed array type ‘{}’",
+                        "new cannot allocate fixed array type '{}'",
                         ty.to_string(ns)
                     ),
                 ));
@@ -3362,7 +3362,7 @@ pub fn new(
             if let Type::Contract(_) = ty.as_ref() {
                 diagnostics.push(Diagnostic::error(
                     *loc,
-                    format!("new cannot construct array of ‘{}’", ty.to_string(ns)),
+                    format!("new cannot construct array of '{}'", ty.to_string(ns)),
                 ));
                 return Err(());
             }
@@ -3376,7 +3376,7 @@ pub fn new(
         _ => {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("new cannot allocate type ‘{}’", ty.to_string(ns)),
+                format!("new cannot allocate type '{}'", ty.to_string(ns)),
             ));
             return Err(());
         }
@@ -3679,7 +3679,7 @@ fn assign_single(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "cannot assign to constant ‘{}’",
+                    "cannot assign to constant '{}'",
                     ns.contracts[*contract_no].variables[*var_no].name
                 ),
             ));
@@ -3688,7 +3688,7 @@ fn assign_single(
         Expression::ConstantVariable(loc, _, None, var_no) => {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("cannot assign to constant ‘{}’", ns.constants[*var_no].name),
+                format!("cannot assign to constant '{}'", ns.constants[*var_no].name),
             ));
             Err(())
         }
@@ -3701,7 +3701,7 @@ fn assign_single(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "cannot assign to immutable ‘{}’ outside of constructor",
+                                "cannot assign to immutable '{}' outside of constructor",
                                 store_var.name
                             ),
                         ));
@@ -3879,7 +3879,7 @@ fn assign_expr(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "cannot assign to constant ‘{}’",
+                    "cannot assign to constant '{}'",
                     ns.contracts[*contract_no].variables[*var_no].name
                 ),
             ));
@@ -3888,7 +3888,7 @@ fn assign_expr(
         Expression::ConstantVariable(loc, _, None, var_no) => {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("cannot assign to constant ‘{}’", ns.constants[*var_no].name),
+                format!("cannot assign to constant '{}'", ns.constants[*var_no].name),
             ));
             Err(())
         }
@@ -3899,7 +3899,7 @@ fn assign_expr(
                     diagnostics.push(Diagnostic::error(
                         var.loc(),
                         format!(
-                            "variable ‘{}’ of incorrect type {}",
+                            "variable '{}' of incorrect type {}",
                             symtable.get_name(*n),
                             var_ty.to_string(ns)
                         ),
@@ -4020,7 +4020,7 @@ fn incr_decr(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "cannot assign to constant ‘{}’",
+                    "cannot assign to constant '{}'",
                     ns.contracts[*contract_no].variables[*var_no].name
                 ),
             ));
@@ -4029,7 +4029,7 @@ fn incr_decr(
         Expression::ConstantVariable(loc, _, None, var_no) => {
             diagnostics.push(Diagnostic::error(
                 *loc,
-                format!("cannot assign to constant ‘{}’", ns.constants[*var_no].name),
+                format!("cannot assign to constant '{}'", ns.constants[*var_no].name),
             ));
             Err(())
         }
@@ -4040,7 +4040,7 @@ fn incr_decr(
                     diagnostics.push(Diagnostic::error(
                         var.loc(),
                         format!(
-                            "variable ‘{}’ of incorrect type {}",
+                            "variable '{}' of incorrect type {}",
                             symtable.get_name(*n),
                             var_ty.to_string(ns)
                         ),
@@ -4196,7 +4196,7 @@ fn member_access(
         if builtin::builtin_namespace(&namespace.name) {
             diagnostics.push(Diagnostic::error(
                 e.loc(),
-                format!("builtin ‘{}.{}’ does not exist", namespace.name, id.name),
+                format!("builtin '{}.{}' does not exist", namespace.name, id.name),
             ));
 
             return Err(());
@@ -4260,7 +4260,7 @@ fn member_access(
                         diagnostics.push(Diagnostic::error(
                             e.loc(),
                             format!(
-                                "contract ‘{}’ does not have a function called ‘{}’",
+                                "contract '{}' does not have a function called '{}'",
                                 ns.contracts[call_contract_no].name, id.name,
                             ),
                         ));
@@ -4271,7 +4271,7 @@ fn member_access(
                         diagnostics.push(Diagnostic::error(
                             e.loc(),
                             format!(
-                                "function ‘{}’ of contract ‘{}’ is overloaded",
+                                "function '{}' of contract '{}' is overloaded",
                                 id.name, ns.contracts[call_contract_no].name,
                             ),
                         ));
@@ -4305,7 +4305,7 @@ fn member_access(
                 diagnostics.push(Diagnostic::error(
                     id.loc,
                     format!(
-                        "struct ‘{}’ field ‘{}’ is readonly",
+                        "struct '{}' field '{}' is readonly",
                         ns.structs[*struct_no], id.name
                     ),
                 ));
@@ -4330,7 +4330,7 @@ fn member_access(
             diagnostics.push(Diagnostic::error(
                 id.loc,
                 format!(
-                    "struct ‘{}’ does not have a field called ‘{}’",
+                    "struct '{}' does not have a field called '{}'",
                     ns.structs[*struct_no], id.name
                 ),
             ));
@@ -4415,7 +4415,7 @@ fn member_access(
                     diagnostics.push(Diagnostic::error(
                         id.loc,
                         format!(
-                            "struct ‘{}’ does not have a field called ‘{}’",
+                            "struct '{}' does not have a field called '{}'",
                             ns.structs[n].name, id.name
                         ),
                     ));
@@ -4474,7 +4474,7 @@ fn member_access(
                     if !is_this {
                         diagnostics.push(Diagnostic::error(
                             expr.loc(),
-                            "substrate can only retrieve balance of this, like ‘address(this).balance’".to_string(),
+                            "substrate can only retrieve balance of this, like 'address(this).balance'".to_string(),
                         ));
                         return Err(());
                     }
@@ -4520,7 +4520,7 @@ fn member_access(
                 diagnostics.push(Diagnostic::error(
                     id.loc,
                     format!(
-                        "{} ‘{}’ has no public function ‘{}’",
+                        "{} '{}' has no public function '{}'",
                         ns.contracts[ref_contract_no].ty,
                         ns.contracts[ref_contract_no].name,
                         id.name
@@ -4533,7 +4533,7 @@ fn member_access(
                 diagnostics.push(Diagnostic::error(
                     id.loc,
                     format!(
-                        "function ‘{}’ of {} ‘{}’ is overloaded",
+                        "function '{}' of {} '{}' is overloaded",
                         id.name,
                         ns.contracts[ref_contract_no].ty,
                         ns.contracts[ref_contract_no].name
@@ -4578,7 +4578,7 @@ fn member_access(
         _ => (),
     }
 
-    diagnostics.push(Diagnostic::error(*loc, format!("‘{}’ not found", id.name)));
+    diagnostics.push(Diagnostic::error(*loc, format!("'{}' not found", id.name)));
 
     Err(())
 }
@@ -4626,7 +4626,7 @@ fn contract_constant(
                     diagnostics.push(Diagnostic::error(
                         *loc,
                         format!(
-                            "need instance of contract ‘{}’ to get variable value ‘{}’",
+                            "need instance of contract '{}' to get variable value '{}'",
                             ns.contracts[contract_no].name,
                             ns.contracts[contract_no].variables[var_no].name,
                         ),
@@ -4696,7 +4696,7 @@ fn array_subscript(
             diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "array subscript must be an unsigned integer, not ‘{}’",
+                    "array subscript must be an unsigned integer, not '{}'",
                     index.ty().to_string(ns)
                 ),
             ));
@@ -4793,7 +4793,7 @@ fn struct_literal(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "builtin struct ‘{}’ cannot be created using struct literal",
+                "builtin struct '{}' cannot be created using struct literal",
                 struct_def.name,
             ),
         ));
@@ -4802,7 +4802,7 @@ fn struct_literal(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "struct ‘{}’ has {} fields, not {}",
+                "struct '{}' has {} fields, not {}",
                 struct_def.name,
                 struct_def.fields.len(),
                 args.len()
@@ -4917,7 +4917,7 @@ fn call_function_type(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "sending value to function type ‘{}’ which is not payable",
+                        "sending value to function type '{}' which is not payable",
                         function.ty().to_string(ns),
                     ),
                 ));
@@ -5125,7 +5125,7 @@ pub fn call_position_args(
                 *loc,
                 format!("cannot call private {}", func.ty),
                 func.loc,
-                format!("declaration of {} ‘{}’", func.ty, func.name),
+                format!("declaration of {} '{}'", func.ty, func.name),
             ));
 
             continue;
@@ -5156,12 +5156,12 @@ pub fn call_position_args(
             if func_ty == pt::FunctionTy::Modifier {
                 diagnostics.push(Diagnostic::error(
                     id.loc,
-                    format!("unknown modifier ‘{}’", id.name),
+                    format!("unknown modifier '{}'", id.name),
                 ));
             } else {
                 diagnostics.push(Diagnostic::error(
                     id.loc,
-                    format!("unknown {} or type ‘{}’", func_ty, id.name),
+                    format!("unknown {} or type '{}'", func_ty, id.name),
                 ));
             }
         }
@@ -5196,7 +5196,7 @@ fn function_call_with_named_args(
         if arguments.contains_key(arg.name.name.as_str()) {
             diagnostics.push(Diagnostic::error(
                 arg.name.loc,
-                format!("duplicate argument with name ‘{}’", arg.name.name),
+                format!("duplicate argument with name '{}'", arg.name.name),
             ));
             return Err(());
         }
@@ -5245,7 +5245,7 @@ fn function_call_with_named_args(
                     diagnostics.push(Diagnostic::error(
                         *loc,
                         format!(
-                            "missing argument ‘{}’ to function ‘{}’",
+                            "missing argument '{}' to function '{}'",
                             param.name_as_str(),
                             id.name,
                         ),
@@ -5291,7 +5291,7 @@ fn function_call_with_named_args(
                 *loc,
                 "cannot call private function".to_string(),
                 func.loc,
-                format!("declaration of function ‘{}’", func.name),
+                format!("declaration of function '{}'", func.name),
             ));
 
             continue;
@@ -5321,7 +5321,7 @@ fn function_call_with_named_args(
         0 => {
             diagnostics.push(Diagnostic::error(
                 id.loc,
-                format!("unknown function or type ‘{}’", id.name),
+                format!("unknown function or type '{}'", id.name),
             ));
         }
         1 => diagnostics.extend(errors),
@@ -5356,7 +5356,7 @@ fn named_struct_literal(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "builtin struct ‘{}’ cannot be created using struct literal",
+                "builtin struct '{}' cannot be created using struct literal",
                 struct_def.name,
             ),
         ));
@@ -5365,7 +5365,7 @@ fn named_struct_literal(
         diagnostics.push(Diagnostic::error(
             *loc,
             format!(
-                "struct ‘{}’ has {} fields, not {}",
+                "struct '{}' has {} fields, not {}",
                 struct_def.name,
                 struct_def.fields.len(),
                 args.len()
@@ -5395,7 +5395,7 @@ fn named_struct_literal(
                     diagnostics.push(Diagnostic::error(
                         a.name.loc,
                         format!(
-                            "struct ‘{}’ has no field ‘{}’",
+                            "struct '{}' has no field '{}'",
                             struct_def.name, a.name.name,
                         ),
                     ));
@@ -5565,7 +5565,7 @@ fn method_call_pos_args(
             return if args.len() != 1 {
                 diagnostics.push(Diagnostic::error(
                     func.loc,
-                    "method ‘unwrap()’ takes one argument".to_string(),
+                    "method 'unwrap()' takes one argument".to_string(),
                 ));
                 Err(())
             } else {
@@ -5589,7 +5589,7 @@ fn method_call_pos_args(
             return if args.len() != 1 {
                 diagnostics.push(Diagnostic::error(
                     func.loc,
-                    "method ‘wrap()’ takes one argument".to_string(),
+                    "method 'wrap()' takes one argument".to_string(),
                 ));
                 Err(())
             } else {
@@ -5670,7 +5670,7 @@ fn method_call_pos_args(
                     if dim.last().unwrap().is_some() {
                         diagnostics.push(Diagnostic::error(
                             func.loc,
-                            "method ‘push()’ not allowed on fixed length array".to_string(),
+                            "method 'push()' not allowed on fixed length array".to_string(),
                         ));
                         return Err(());
                     }
@@ -5709,7 +5709,7 @@ fn method_call_pos_args(
                         _ => {
                             diagnostics.push(Diagnostic::error(
                                 func.loc,
-                                "method ‘push()’ takes at most 1 argument".to_string(),
+                                "method 'push()' takes at most 1 argument".to_string(),
                             ));
                             return Err(());
                         }
@@ -5726,7 +5726,7 @@ fn method_call_pos_args(
                     if dim.last().unwrap().is_some() {
                         diagnostics.push(Diagnostic::error(
                             func.loc,
-                            "method ‘pop()’ not allowed on fixed length array".to_string(),
+                            "method 'pop()' not allowed on fixed length array".to_string(),
                         ));
 
                         return Err(());
@@ -5735,7 +5735,7 @@ fn method_call_pos_args(
                     if !args.is_empty() {
                         diagnostics.push(Diagnostic::error(
                             func.loc,
-                            "method ‘pop()’ does not take any arguments".to_string(),
+                            "method 'pop()' does not take any arguments".to_string(),
                         ));
                         return Err(());
                     }
@@ -5809,7 +5809,7 @@ fn method_call_pos_args(
                         _ => {
                             diagnostics.push(Diagnostic::error(
                                 func.loc,
-                                "method ‘push()’ takes at most 1 argument".to_string(),
+                                "method 'push()' takes at most 1 argument".to_string(),
                             ));
                             return Err(());
                         }
@@ -5826,7 +5826,7 @@ fn method_call_pos_args(
                     if !args.is_empty() {
                         diagnostics.push(Diagnostic::error(
                             func.loc,
-                            "method ‘pop()’ does not take any arguments".to_string(),
+                            "method 'pop()' does not take any arguments".to_string(),
                         ));
                         return Err(());
                     }
@@ -5848,7 +5848,7 @@ fn method_call_pos_args(
             if ns.target == Target::Solana {
                 diagnostics.push(Diagnostic::error(
                     func.loc,
-                    format!("‘push()’ not supported on ‘bytes’ on target {}", ns.target),
+                    format!("'push()' not supported on 'bytes' on target {}", ns.target),
                 ));
                 return Err(());
             }
@@ -5882,7 +5882,7 @@ fn method_call_pos_args(
                 _ => {
                     diagnostics.push(Diagnostic::error(
                         func.loc,
-                        "method ‘push()’ takes at most 1 argument".to_string(),
+                        "method 'push()' takes at most 1 argument".to_string(),
                     ));
                     return Err(());
                 }
@@ -5899,7 +5899,7 @@ fn method_call_pos_args(
             if ns.target == Target::Solana {
                 diagnostics.push(Diagnostic::error(
                     func.loc,
-                    format!("‘pop()’ not supported on ‘bytes’ on target {}", ns.target),
+                    format!("'pop()' not supported on 'bytes' on target {}", ns.target),
                 ));
                 return Err(());
             }
@@ -5907,7 +5907,7 @@ fn method_call_pos_args(
             if !args.is_empty() {
                 diagnostics.push(Diagnostic::error(
                     func.loc,
-                    "method ‘pop()’ does not take any arguments".to_string(),
+                    "method 'pop()' does not take any arguments".to_string(),
                 ));
                 return Err(());
             }
@@ -5992,7 +5992,7 @@ fn method_call_pos_args(
                 if !ns.functions[*function_no].is_public() {
                     diagnostics.push(Diagnostic::error(
                         *loc,
-                        format!("function ‘{}’ is not ‘public’ or ‘external’", func.name),
+                        format!("function '{}' is not 'public' or 'external'", func.name),
                     ));
                     return Err(());
                 }
@@ -6002,7 +6002,7 @@ fn method_call_pos_args(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "sending value to function ‘{}’ which is not payable",
+                                "sending value to function '{}' which is not payable",
                                 func.name
                             ),
                         ));
@@ -6083,7 +6083,7 @@ fn method_call_pos_args(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "method ‘{}’ available on type ‘address payable’ not ‘address’",
+                        "method '{}' available on type ‘address payable’ not 'address'",
                         func.name,
                     ),
                 ));
@@ -6095,7 +6095,7 @@ fn method_call_pos_args(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "‘{}’ expects 1 argument, {} provided",
+                        "'{}' expects 1 argument, {} provided",
                         func.name,
                         args.len()
                     ),
@@ -6107,7 +6107,7 @@ fn method_call_pos_args(
             if let Some(loc) = call_args_loc {
                 diagnostics.push(Diagnostic::error(
                     loc,
-                    format!("call arguments not allowed on ‘{}’", func.name),
+                    format!("call arguments not allowed on '{}'", func.name),
                 ));
                 return Err(());
             }
@@ -6158,7 +6158,7 @@ fn method_call_pos_args(
             if ty != CallTy::Regular && call_args.value.is_some() {
                 diagnostics.push(Diagnostic::error(
                     *loc,
-                    format!("‘{}’ cannot have value specifed", func.name,),
+                    format!("'{}' cannot have value specifed", func.name,),
                 ));
 
                 return Err(());
@@ -6168,7 +6168,7 @@ fn method_call_pos_args(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "‘{}’ expects 1 argument, {} provided",
+                        "'{}' expects 1 argument, {} provided",
                         func.name,
                         args.len()
                     ),
@@ -6233,7 +6233,7 @@ fn method_call_pos_args(
 
     diagnostics.push(Diagnostic::error(
         func.loc,
-        format!("method ‘{}’ does not exist", func.name),
+        format!("method '{}' does not exist", func.name),
     ));
 
     Err(())
@@ -6342,7 +6342,7 @@ fn resolve_using(
                     *loc,
                     "cannot call private library function".to_string(),
                     libfunc.loc,
-                    format!("declaration of function ‘{}’", libfunc.name),
+                    format!("declaration of function '{}'", libfunc.name),
                 ));
 
                 continue;
@@ -6505,7 +6505,7 @@ fn method_call_named_args(
             if arguments.contains_key(arg.name.name.as_str()) {
                 diagnostics.push(Diagnostic::error(
                     arg.name.loc,
-                    format!("duplicate argument with name ‘{}’", arg.name.name),
+                    format!("duplicate argument with name '{}'", arg.name.name),
                 ));
                 return Err(());
             }
@@ -6552,7 +6552,7 @@ fn method_call_named_args(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "missing argument ‘{}’ to function ‘{}’",
+                                "missing argument '{}' to function '{}'",
                                 param.name_as_str(),
                                 func_name.name,
                             ),
@@ -6590,7 +6590,7 @@ fn method_call_named_args(
                     diagnostics.push(Diagnostic::error(
                         *loc,
                         format!(
-                            "function ‘{}’ is not ‘public’ or ‘external’",
+                            "function '{}' is not 'public' or 'external'",
                             func_name.name
                         ),
                     ));
@@ -6602,7 +6602,7 @@ fn method_call_named_args(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "sending value to function ‘{}’ which is not payable",
+                                "sending value to function '{}' which is not payable",
                                 func_name.name
                             ),
                         ));
@@ -6645,7 +6645,7 @@ fn method_call_named_args(
                 diagnostics.push(Diagnostic::error(
                     *loc,
                     format!(
-                        "contract ‘{}’ does not have function ‘{}’",
+                        "contract '{}' does not have function '{}'",
                         var_ty.deref_any().to_string(ns),
                         func_name.name
                     ),
@@ -6665,7 +6665,7 @@ fn method_call_named_args(
 
     diagnostics.push(Diagnostic::error(
         func_name.loc,
-        format!("method ‘{}’ does not exist", func_name.name),
+        format!("method '{}' does not exist", func_name.name),
     ));
 
     Err(())
@@ -6900,9 +6900,9 @@ fn parse_call_args(
         if let Some(prev) = args.get(&arg.name.name) {
             diagnostics.push(Diagnostic::error_with_note(
                 arg.loc,
-                format!("‘{}’ specified multiple times", arg.name.name),
+                format!("'{}' specified multiple times", arg.name.name),
                 prev.loc,
-                format!("location of previous declaration of ‘{}’", arg.name.name),
+                format!("location of previous declaration of '{}'", arg.name.name),
             ));
             return Err(());
         }
@@ -6944,7 +6944,7 @@ fn parse_call_args(
                     diagnostics.push(Diagnostic::error(
                         arg.loc,
                         format!(
-                            "‘gas’ not permitted for external calls or constructors on {}",
+                            "'gas' not permitted for external calls or constructors on {}",
                             ns.target
                         ),
                     ));
@@ -6974,7 +6974,7 @@ fn parse_call_args(
                     diagnostics.push(Diagnostic::error(
                         arg.loc,
                         format!(
-                            "‘space’ not permitted for external calls or constructors on {}",
+                            "'space' not permitted for external calls or constructors on {}",
                             ns.target
                         ),
                     ));
@@ -6984,7 +6984,7 @@ fn parse_call_args(
                 if external_call {
                     diagnostics.push(Diagnostic::error(
                         arg.loc,
-                        "‘space’ not valid for external calls".to_string(),
+                        "'space' not valid for external calls".to_string(),
                     ));
                     return Err(());
                 }
@@ -7013,7 +7013,7 @@ fn parse_call_args(
                     diagnostics.push(Diagnostic::error(
                         arg.loc,
                         format!(
-                            "‘salt’ not permitted for external calls or constructors on {}",
+                            "'salt' not permitted for external calls or constructors on {}",
                             ns.target
                         ),
                     ));
@@ -7023,7 +7023,7 @@ fn parse_call_args(
                 if external_call {
                     diagnostics.push(Diagnostic::error(
                         arg.loc,
-                        "‘salt’ not valid for external calls".to_string(),
+                        "'salt' not valid for external calls".to_string(),
                     ));
                     return Err(());
                 }
@@ -7050,7 +7050,7 @@ fn parse_call_args(
             _ => {
                 diagnostics.push(Diagnostic::error(
                     arg.loc,
-                    format!("‘{}’ not a valid call parameter", arg.name.name),
+                    format!("'{}' not a valid call parameter", arg.name.name),
                 ));
                 return Err(());
             }
@@ -7258,7 +7258,7 @@ pub fn function_call_expr(
                     if expr.tys().len() > 1 {
                         diagnostics.push(Diagnostic::error(
                             *loc,
-                            format!("builtin function ‘{}’ returns more than one value", id.name),
+                            format!("builtin function '{}' returns more than one value", id.name),
                         ));
                         Err(())
                     } else {

src/sema/format.rs

@@ -47,7 +47,7 @@ pub fn string_format(
                 // ok, let's skip over it
                 format_iterator.next();
             } else {
-                diagnostics.push(Diagnostic::error(loc, String::from("unmatched ‘}’")));
+                diagnostics.push(Diagnostic::error(loc, String::from("unmatched '}'")));
                 return Err(());
             }
         }
@@ -160,7 +160,7 @@ fn parse_format_specifier(
                 Some((loc, ch)) => {
                     diagnostics.push(Diagnostic::error(
                         loc,
-                        format!("unexpected format char ‘{}’", ch),
+                        format!("unexpected format char '{}'", ch),
                     ));
                     return Err(());
                 }
@@ -178,14 +178,14 @@ fn parse_format_specifier(
                 Some((loc, ch)) => {
                     diagnostics.push(Diagnostic::error(
                         loc,
-                        format!("unexpected format char ‘{:}’, expected closing ‘}}’", ch),
+                        format!("unexpected format char '{:}', expected closing '}}'", ch),
                     ));
                     Err(())
                 }
                 None => {
                     diagnostics.push(Diagnostic::error(
                         last_loc,
-                        String::from("missing closing ‘}’"),
+                        String::from("missing closing '}'"),
                     ));
                     Err(())
                 }
@@ -194,14 +194,14 @@ fn parse_format_specifier(
         Some((loc, ch)) => {
             diagnostics.push(Diagnostic::error(
                 loc,
-                format!("unexpected format char ‘{}’", ch),
+                format!("unexpected format char '{}'", ch),
             ));
             Err(())
         }
         None => {
             diagnostics.push(Diagnostic::error(
                 last_loc,
-                String::from("missing closing ‘}’"),
+                String::from("missing closing '}'"),
             ));
             Err(())
         }

src/sema/functions.rs

@@ -92,7 +92,7 @@ pub fn contract_function(
     if let Some(loc) = func.return_not_returns {
         ns.diagnostics.push(Diagnostic::error(
             loc,
-            "‘return’ unexpected. Did you mean ‘returns’?".to_string(),
+            "'return' unexpected. Did you mean 'returns'?".to_string(),
         ));
         success = false;
     }
@@ -108,9 +108,9 @@ pub fn contract_function(
                 if let Some(e) = &mutability {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         m.loc(),
-                        format!("function redeclared `{}'", m),
+                        format!("function redeclared '{}'", m),
                         e.loc(),
-                        format!("location of previous declaration of `{}'", e),
+                        format!("location of previous declaration of '{}'", e),
                     ));
                     success = false;
                     continue;
@@ -119,7 +119,7 @@ pub fn contract_function(
                 if let pt::Mutability::Constant(loc) = m {
                     ns.diagnostics.push(Diagnostic::warning(
                         *loc,
-                        "‘constant’ is deprecated. Use ‘view’ instead".to_string(),
+                        "'constant' is deprecated. Use 'view' instead".to_string(),
                     ));
 
                     mutability = Some(pt::Mutability::View(*loc));
@@ -131,9 +131,9 @@ pub fn contract_function(
                 if let Some(e) = &visibility {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         v.loc().unwrap(),
-                        format!("function redeclared `{}'", v),
+                        format!("function redeclared '{}'", v),
                         e.loc().unwrap(),
-                        format!("location of previous declaration of `{}'", e),
+                        format!("location of previous declaration of '{}'", e),
                     ));
                     success = false;
                     continue;
@@ -145,9 +145,9 @@ pub fn contract_function(
                 if let Some(prev_loc) = &is_virtual {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         *loc,
-                        "function redeclared ‘virtual’".to_string(),
+                        "function redeclared 'virtual'".to_string(),
                         *prev_loc,
-                        "location of previous declaration of ‘virtual’".to_string(),
+                        "location of previous declaration of 'virtual'".to_string(),
                     ));
                     success = false;
                     continue;
@@ -159,9 +159,9 @@ pub fn contract_function(
                 if let Some((prev_loc, _)) = &is_override {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         *loc,
-                        "function redeclared ‘override’".to_string(),
+                        "function redeclared 'override'".to_string(),
                         *prev_loc,
-                        "location of previous declaration of ‘override’".to_string(),
+                        "location of previous declaration of 'override'".to_string(),
                     ));
                     success = false;
                     continue;
@@ -175,13 +175,13 @@ pub fn contract_function(
                             if list.contains(&no) {
                                 ns.diagnostics.push(Diagnostic::error(
                                     name.loc,
-                                    format!("function duplicate override ‘{}’", name.name),
+                                    format!("function duplicate override '{}'", name.name),
                                 ));
                             } else if !is_base(no, contract_no, ns) {
                                 ns.diagnostics.push(Diagnostic::error(
                                     name.loc,
                                     format!(
-                                        "override ‘{}’ is not a base contract of ‘{}’",
+                                        "override '{}' is not a base contract of '{}'",
                                         name.name, ns.contracts[contract_no].name
                                     ),
                                 ));
@@ -192,7 +192,7 @@ pub fn contract_function(
                         None => {
                             ns.diagnostics.push(Diagnostic::error(
                                 name.loc,
-                                format!("contract ‘{}’ in override list not found", name.name),
+                                format!("contract '{}' in override list not found", name.name),
                             ));
                         }
                     }
@@ -222,14 +222,14 @@ pub fn contract_function(
             if func.ty == pt::FunctionTy::Modifier {
                 ns.diagnostics.push(Diagnostic::error(
                     v.loc().unwrap(),
-                    format!("‘{}’: modifiers can not have visibility", v),
+                    format!("'{}': modifiers can not have visibility", v),
                 ));
 
                 pt::Visibility::Internal(v.loc())
             } else if func.ty == pt::FunctionTy::Constructor {
                 ns.diagnostics.push(Diagnostic::warning(
                     v.loc().unwrap(),
-                    format!("‘{}’: visibility for constructors is ignored", v),
+                    format!("'{}': visibility for constructors is ignored", v),
                 ));
 
                 pt::Visibility::Public(v.loc())
@@ -325,7 +325,7 @@ pub fn contract_function(
         } else {
             ns.diagnostics.push(Diagnostic::error(
                 func.loc,
-                "functions must be declared ‘external’ in an interface".to_string(),
+                "functions must be declared 'external' in an interface".to_string(),
             ));
             success = false;
         }
@@ -358,7 +358,7 @@ pub fn contract_function(
     } else if func.ty == pt::FunctionTy::Constructor && is_virtual.is_some() {
         ns.diagnostics.push(Diagnostic::error(
             func.loc,
-            "constructors cannot be declared ‘virtual’".to_string(),
+            "constructors cannot be declared 'virtual'".to_string(),
         ));
     }
 
@@ -388,7 +388,7 @@ pub fn contract_function(
     if !is_virtual && func.body.is_none() {
         ns.diagnostics.push(Diagnostic::error(
             func.loc,
-            "function with no body must be marked ‘virtual’".to_string(),
+            "function with no body must be marked 'virtual'".to_string(),
         ));
         success = false;
     }
@@ -397,7 +397,7 @@ pub fn contract_function(
         if is_virtual {
             ns.diagnostics.push(Diagnostic::error(
                 func.loc,
-                "function marked ‘virtual’ cannot also be ‘private’".to_string(),
+                "function marked 'virtual' cannot also be 'private'".to_string(),
             ));
             success = false;
         }
@@ -475,7 +475,7 @@ pub fn contract_function(
 
                 ns.diagnostics.push(Diagnostic::error_with_note(
                     func.loc,
-                    "all constructors should be defined ‘payable’ or not".to_string(),
+                    "all constructors should be defined 'payable' or not".to_string(),
                     prev_loc,
                     "location of previous definition".to_string(),
                 ));
@@ -632,9 +632,9 @@ pub fn function(
                 if let Some(e) = &mutability {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         m.loc(),
-                        format!("function redeclared `{}'", m),
+                        format!("function redeclared '{}'", m),
                         e.loc(),
-                        format!("location of previous declaration of `{}'", e),
+                        format!("location of previous declaration of '{}'", e),
                     ));
                     success = false;
                     continue;
@@ -643,7 +643,7 @@ pub fn function(
                 if let pt::Mutability::Constant(loc) = m {
                     ns.diagnostics.push(Diagnostic::warning(
                         *loc,
-                        "‘constant’ is deprecated. Use ‘view’ instead".to_string(),
+                        "'constant' is deprecated. Use 'view' instead".to_string(),
                     ));
 
                     mutability = Some(pt::Mutability::View(*loc));
@@ -655,7 +655,7 @@ pub fn function(
                 ns.diagnostics.push(Diagnostic::error(
                     v.loc().unwrap(),
                     format!(
-                        "‘{}’: only functions in contracts can have a visibility specifier",
+                        "'{}': only functions in contracts can have a visibility specifier",
                         v
                     ),
                 ));
@@ -814,7 +814,7 @@ pub fn resolve_params(
 
                     if let Some(ty) = ty.contains_builtins(ns, BuiltinStruct::AccountInfo) {
                         let message = format!(
-                            "parameter of type ‘{}’ not alowed in public or external functions",
+                            "parameter of type '{}' not alowed in public or external functions",
                             ty.to_string(ns)
                         );
                         ns.diagnostics.push(Diagnostic::error(p.ty.loc(), message));
@@ -826,7 +826,7 @@ pub fn resolve_params(
                     if let Some(storage) = &p.storage {
                         diagnostics.push(Diagnostic::error(
                             storage.loc(),
-                                format!("data location ‘{}’ can only be specified for array, struct or mapping",
+                                format!("data location '{}' can only be specified for array, struct or mapping",
                                 storage)
                             ));
                         success = false;
@@ -837,7 +837,7 @@ pub fn resolve_params(
                     if !is_internal {
                         diagnostics.push(Diagnostic::error(
                             loc,
-                            "parameter of type ‘storage’ not allowed public or external functions"
+                            "parameter of type 'storage' not allowed public or external functions"
                                 .to_string(),
                         ));
                         success = false;
@@ -850,7 +850,7 @@ pub fn resolve_params(
                     if ty.contains_mapping(ns) {
                         diagnostics.push(Diagnostic::error(
                             p.ty.loc(),
-                            "parameter with mapping type must be of type ‘storage’".to_string(),
+                            "parameter with mapping type must be of type 'storage'".to_string(),
                         ));
                         success = false;
                     }
@@ -920,7 +920,7 @@ pub fn resolve_returns(
 
                     if let Some(ty) = ty.contains_builtins(ns, BuiltinStruct::AccountInfo) {
                         let message = format!(
-                            "return type ‘{}’ not allowed in public or external functions",
+                            "return type '{}' not allowed in public or external functions",
                             ty.to_string(ns)
                         );
                         ns.diagnostics.push(Diagnostic::error(r.ty.loc(), message));
@@ -931,7 +931,7 @@ pub fn resolve_returns(
                     if let Some(storage) = &r.storage {
                         diagnostics.push(Diagnostic::error(
                             storage.loc(),
-                                format!("data location ‘{}’ can only be specified for array, struct or mapping",
+                                format!("data location '{}' can only be specified for array, struct or mapping",
                                 storage)
                             ));
                         success = false;
@@ -944,7 +944,7 @@ pub fn resolve_returns(
                             if !is_internal {
                                 diagnostics.push(Diagnostic::error(
                                     loc,
-                                    "return type of type ‘storage’ not allowed public or external functions"
+                                    "return type of type 'storage' not allowed public or external functions"
                                         .to_string(),
                                 ));
                                 success = false;
@@ -958,7 +958,7 @@ pub fn resolve_returns(
                             if ty.contains_mapping(ns) {
                                 diagnostics.push(Diagnostic::error(
                                     r.ty.loc(),
-                                    "return type containing mapping must be of type ‘storage’"
+                                    "return type containing mapping must be of type 'storage'"
                                         .to_string(),
                                 ));
                                 success = false;

src/sema/mod.rs

@@ -233,7 +233,7 @@ fn resolve_import(
                     ns.diagnostics.push(ast::Diagnostic::error(
                         from.loc,
                         format!(
-                            "import ‘{}’ does not export ‘{}’",
+                            "import '{}' does not export '{}'",
                             filename.string, from.name
                         ),
                     ));
@@ -294,23 +294,23 @@ fn resolve_pragma(
     if name.name == "solidity" {
         ns.diagnostics.push(ast::Diagnostic::debug(
             *loc,
-            "pragma ‘solidity’ is ignored".to_string(),
+            "pragma 'solidity' is ignored".to_string(),
         ));
     } else if name.name == "experimental" && value.string == "ABIEncoderV2" {
         ns.diagnostics.push(ast::Diagnostic::debug(
             *loc,
-            "pragma ‘experimental’ with value ‘ABIEncoderV2’ is ignored".to_string(),
+            "pragma 'experimental' with value 'ABIEncoderV2' is ignored".to_string(),
         ));
     } else if name.name == "abicoder" && value.string == "v2" {
         ns.diagnostics.push(ast::Diagnostic::debug(
             *loc,
-            "pragma ‘abicoder’ with value ‘v2’ is ignored".to_string(),
+            "pragma 'abicoder' with value 'v2' is ignored".to_string(),
         ));
     } else {
         ns.diagnostics.push(ast::Diagnostic::warning(
             *loc,
             format!(
-                "unknown pragma ‘{}’ with value ‘{}’ ignored",
+                "unknown pragma '{}' with value '{}' ignored",
                 name.name, value.string
             ),
         ));
@@ -368,7 +368,7 @@ impl ast::Namespace {
         if builtin::is_reserved(&id.name) {
             self.diagnostics.push(ast::Diagnostic::error(
                 id.loc,
-                format!("‘{}’ shadows name of a builtin", id.name),
+                format!("'{}' shadows name of a builtin", id.name),
             ));
 
             return false;
@@ -692,7 +692,7 @@ impl ast::Namespace {
                 None if events.is_empty() => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         id.loc,
-                        format!("event ‘{}’ not found", id.name),
+                        format!("event '{}' not found", id.name),
                     ));
                     Err(())
                 }
@@ -728,30 +728,30 @@ impl ast::Namespace {
 
     pub fn wrong_symbol(sym: Option<&ast::Symbol>, id: &pt::Identifier) -> ast::Diagnostic {
         match sym {
-            None => ast::Diagnostic::decl_error(id.loc, format!("`{}' is not found", id.name)),
+            None => ast::Diagnostic::decl_error(id.loc, format!("'{}' is not found", id.name)),
             Some(ast::Symbol::Enum(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is an enum", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is an enum", id.name))
             }
             Some(ast::Symbol::Struct(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is a struct", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is a struct", id.name))
             }
             Some(ast::Symbol::Event(_)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is an event", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is an event", id.name))
             }
             Some(ast::Symbol::Function(_)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is a function", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is a function", id.name))
             }
             Some(ast::Symbol::Contract(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is a contract", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is a contract", id.name))
             }
             Some(ast::Symbol::Import(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is an import", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is an import", id.name))
             }
             Some(ast::Symbol::UserType(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is an user type", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is an user type", id.name))
             }
             Some(ast::Symbol::Variable(..)) => {
-                ast::Diagnostic::decl_error(id.loc, format!("`{}' is a contract variable", id.name))
+                ast::Diagnostic::decl_error(id.loc, format!("'{}' is a contract variable", id.name))
             }
         }
     }
@@ -880,7 +880,7 @@ impl ast::Namespace {
         if builtin::is_reserved(&id.name) {
             self.diagnostics.push(ast::Diagnostic::warning(
                 id.loc,
-                format!("‘{}’ shadows name of a builtin", id.name),
+                format!("'{}' shadows name of a builtin", id.name),
             ));
             return;
         }
@@ -906,7 +906,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of `{}' shadows enum definition", id.name),
+                    format!("declaration of '{}' shadows enum definition", id.name),
                     loc,
                     "previous definition of enum".to_string(),
                 ));
@@ -915,7 +915,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of `{}' shadows struct definition", id.name),
+                    format!("declaration of '{}' shadows struct definition", id.name),
                     loc,
                     "previous definition of struct".to_string(),
                 ));
@@ -931,7 +931,7 @@ impl ast::Namespace {
 
                 self.diagnostics.push(ast::Diagnostic::warning_with_notes(
                     id.loc,
-                    format!("declaration of `{}' shadows event definition", id.name),
+                    format!("declaration of '{}' shadows event definition", id.name),
                     notes,
                 ));
             }
@@ -945,7 +945,7 @@ impl ast::Namespace {
                     .collect();
                 self.diagnostics.push(ast::Diagnostic::warning_with_notes(
                     id.loc,
-                    format!("declaration of ‘{}’ shadows function", id.name),
+                    format!("declaration of '{}' shadows function", id.name),
                     notes,
                 ));
             }
@@ -953,7 +953,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of ‘{}’ shadows state variable", id.name),
+                    format!("declaration of '{}' shadows state variable", id.name),
                     loc,
                     "previous declaration of state variable".to_string(),
                 ));
@@ -962,7 +962,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of ‘{}’ shadows contract name", id.name),
+                    format!("declaration of '{}' shadows contract name", id.name),
                     loc,
                     "previous declaration of contract name".to_string(),
                 ));
@@ -971,7 +971,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of ‘{}’ shadows type", id.name),
+                    format!("declaration of '{}' shadows type", id.name),
                     loc,
                     "previous declaration of type".to_string(),
                 ));
@@ -980,7 +980,7 @@ impl ast::Namespace {
                 let loc = *loc;
                 self.diagnostics.push(ast::Diagnostic::warning_with_note(
                     id.loc,
-                    format!("declaration of ‘{}’ shadows import", id.name),
+                    format!("declaration of '{}' shadows import", id.name),
                     loc,
                     "previous declaration of import".to_string(),
                 ));
@@ -1083,10 +1083,10 @@ impl ast::Namespace {
                                 if let Some(e) = &mutability {
                                     diagnostics.push(ast::Diagnostic::error_with_note(
                                         m.loc(),
-                                        format!("function type mutability redeclared `{}'", m),
+                                        format!("function type mutability redeclared '{}'", m),
                                         e.loc(),
                                         format!(
-                                            "location of previous mutability declaration of `{}'",
+                                            "location of previous mutability declaration of '{}'",
                                             e
                                         ),
                                     ));
@@ -1097,7 +1097,7 @@ impl ast::Namespace {
                                 if let pt::Mutability::Constant(loc) = m {
                                     diagnostics.push(ast::Diagnostic::warning(
                                         *loc,
-                                        "‘constant’ is deprecated. Use ‘view’ instead".to_string(),
+                                        "'constant' is deprecated. Use 'view' instead".to_string(),
                                     ));
 
                                     mutability = Some(pt::Mutability::View(*loc));
@@ -1109,10 +1109,10 @@ impl ast::Namespace {
                                 if let Some(e) = &visibility {
                                     diagnostics.push(ast::Diagnostic::error_with_note(
                                         v.loc().unwrap(),
-                                        format!("function type visibility redeclared `{}'", v),
+                                        format!("function type visibility redeclared '{}'", v),
                                         e.loc().unwrap(),
                                         format!(
-                                            "location of previous visibility declaration of `{}'",
+                                            "location of previous visibility declaration of '{}'",
                                             e
                                         ),
                                     ));
@@ -1132,7 +1132,7 @@ impl ast::Namespace {
                         Some(v) => {
                             diagnostics.push(ast::Diagnostic::error(
                                 v.loc().unwrap(),
-                                format!("function type cannot have visibility attribute `{}'", v),
+                                format!("function type cannot have visibility attribute '{}'", v),
                             ));
                             success = false;
                             false
@@ -1164,14 +1164,14 @@ impl ast::Namespace {
                             pt::FunctionAttribute::Mutability(m) => {
                                 diagnostics.push(ast::Diagnostic::error(
                                     m.loc(),
-                                    format!("mutability `{}' cannot be declared after returns", m),
+                                    format!("mutability '{}' cannot be declared after returns", m),
                                 ));
                                 success = false;
                             }
                             pt::FunctionAttribute::Visibility(v) => {
                                 diagnostics.push(ast::Diagnostic::error(
                                     v.loc().unwrap(),
-                                    format!("visibility `{}' cannot be declared after returns", v),
+                                    format!("visibility '{}' cannot be declared after returns", v),
                                 ));
                                 success = false;
                             }
@@ -1237,7 +1237,7 @@ impl ast::Namespace {
                     if !casting {
                         diagnostics.push(ast::Diagnostic::decl_error(
                             id.loc(),
-                            "‘payable’ cannot be used for type declarations, only casting. use ‘address payable’"
+                            "'payable' cannot be used for type declarations, only casting. use ‘address payable’"
                                 .to_string(),
                         ));
                         return Err(());
@@ -1269,7 +1269,7 @@ impl ast::Namespace {
             None => {
                 diagnostics.push(ast::Diagnostic::decl_error(
                     id.loc,
-                    format!("type ‘{}’ not found", id.name),
+                    format!("type '{}' not found", id.name),
                 ));
                 Err(())
             }
@@ -1293,28 +1293,28 @@ impl ast::Namespace {
             Some(ast::Symbol::Event(_)) => {
                 diagnostics.push(ast::Diagnostic::decl_error(
                     id.loc,
-                    format!("‘{}’ is an event", id.name),
+                    format!("'{}' is an event", id.name),
                 ));
                 Err(())
             }
             Some(ast::Symbol::Function(_)) => {
                 diagnostics.push(ast::Diagnostic::decl_error(
                     id.loc,
-                    format!("‘{}’ is a function", id.name),
+                    format!("'{}' is a function", id.name),
                 ));
                 Err(())
             }
             Some(ast::Symbol::Variable(..)) => {
                 diagnostics.push(ast::Diagnostic::decl_error(
                     id.loc,
-                    format!("‘{}’ is a contract variable", id.name),
+                    format!("'{}' is a contract variable", id.name),
                 ));
                 Err(())
             }
             Some(ast::Symbol::Import(..)) => {
                 diagnostics.push(ast::Diagnostic::decl_error(
                     id.loc,
-                    format!("‘{}’ is an import variable", id.name),
+                    format!("'{}' is an import variable", id.name),
                 ));
                 Err(())
             }
@@ -1358,7 +1358,7 @@ impl ast::Namespace {
                 None => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         id.loc,
-                        format!("contract type ‘{}’ not found", id.name),
+                        format!("contract type '{}' not found", id.name),
                     ));
                     return Err(());
                 }
@@ -1366,7 +1366,7 @@ impl ast::Namespace {
                     if namespace.len() > 1 {
                         diagnostics.push(ast::Diagnostic::decl_error(
                             id.loc,
-                            format!("‘{}’ not found", namespace[1].name),
+                            format!("'{}' not found", namespace[1].name),
                         ));
                         return Err(());
                     };
@@ -1375,42 +1375,42 @@ impl ast::Namespace {
                 Some(ast::Symbol::Function(_)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is a function", contract_name.name),
+                        format!("'{}' is a function", contract_name.name),
                     ));
                     return Err(());
                 }
                 Some(ast::Symbol::Variable(..)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is a contract variable", contract_name.name),
+                        format!("'{}' is a contract variable", contract_name.name),
                     ));
                     return Err(());
                 }
                 Some(ast::Symbol::Event(_)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is an event", contract_name.name),
+                        format!("'{}' is an event", contract_name.name),
                     ));
                     return Err(());
                 }
                 Some(ast::Symbol::Struct(..)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is a struct", contract_name.name),
+                        format!("'{}' is a struct", contract_name.name),
                     ));
                     return Err(());
                 }
                 Some(ast::Symbol::Enum(..)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is an enum variable", contract_name.name),
+                        format!("'{}' is an enum variable", contract_name.name),
                     ));
                     return Err(());
                 }
                 Some(ast::Symbol::UserType(..)) => {
                     diagnostics.push(ast::Diagnostic::decl_error(
                         contract_name.loc,
-                        format!("‘{}’ is an user type", contract_name.name),
+                        format!("'{}' is an user type", contract_name.name),
                     ));
                     return Err(());
                 }

src/sema/mutability.rs

@@ -39,7 +39,7 @@ impl<'a> StateCheck<'a> {
             self.diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "function declared ‘{}’ but this expression writes to state",
+                    "function declared '{}' but this expression writes to state",
                     self.func.mutability
                 ),
             ));
@@ -53,7 +53,7 @@ impl<'a> StateCheck<'a> {
             self.diagnostics.push(Diagnostic::error(
                 *loc,
                 format!(
-                    "function declared ‘{}’ but this expression reads from state",
+                    "function declared '{}' but this expression reads from state",
                     self.func.mutability
                 ),
             ));
@@ -138,14 +138,14 @@ fn check_mutability(func: &Function, ns: &Namespace) -> Vec<Diagnostic> {
                 Mutability::Nonpayable(_) => {
                     state.diagnostics.push(Diagnostic::warning(
                         func.loc,
-                        "function can be declared ‘pure’".to_string(),
+                        "function can be declared 'pure'".to_string(),
                     ));
                 }
                 _ => {
                     state.diagnostics.push(Diagnostic::warning(
                         func.loc,
                         format!(
-                            "function declared ‘{}’ can be declared ‘pure’",
+                            "function declared '{}' can be declared 'pure'",
                             func.mutability
                         ),
                     ));
@@ -156,7 +156,7 @@ fn check_mutability(func: &Function, ns: &Namespace) -> Vec<Diagnostic> {
         if !state.does_write_state && state.does_read_state && func.mutability.is_default() {
             state.diagnostics.push(Diagnostic::warning(
                 func.loc,
-                "function can be declared ‘view’".to_string(),
+                "function can be declared 'view'".to_string(),
             ));
         }
     }

src/sema/statements.rs

@@ -74,7 +74,7 @@ pub fn resolve_function_body(
                             ns.diagnostics.push(Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "contract ‘{}’ is not a base contract of ‘{}’",
+                                    "contract '{}' is not a base contract of '{}'",
                                     base.name.name, ns.contracts[contract_no].name,
                                 ),
                             ));
@@ -82,9 +82,9 @@ pub fn resolve_function_body(
                         } else if let Some(prev) = resolve_bases.get(&base_no) {
                             ns.diagnostics.push(Diagnostic::error_with_note(
                                 *loc,
-                                format!("duplicate base contract ‘{}’", base.name.name),
+                                format!("duplicate base contract '{}'", base.name.name),
                                 *prev,
-                                format!("previous base contract ‘{}’", base.name.name),
+                                format!("previous base contract '{}'", base.name.name),
                             ));
                             all_ok = false;
                         } else if let Some(args) = &base.args {
@@ -115,7 +115,7 @@ pub fn resolve_function_body(
                             ns.diagnostics.push(Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "missing arguments to constructor of contract ‘{}’",
+                                    "missing arguments to constructor of contract '{}'",
                                     base.name.name
                                 ),
                             ));
@@ -126,12 +126,12 @@ pub fn resolve_function_body(
                         if base.args.is_none() {
                             ns.diagnostics.push(Diagnostic::error(
                                 *loc,
-                                format!("unknown function attribute ‘{}’", base.name.name),
+                                format!("unknown function attribute '{}'", base.name.name),
                             ));
                         } else {
                             ns.diagnostics.push(Diagnostic::error(
                                 base.name.loc,
-                                format!("contract ‘{}’ not found", base.name.name),
+                                format!("contract '{}' not found", base.name.name),
                             ));
                         }
                         all_ok = false;
@@ -152,7 +152,7 @@ pub fn resolve_function_body(
                     ns.diagnostics.push(Diagnostic::error(
                         def.loc,
                         format!(
-                            "missing arguments to contract ‘{}’ constructor",
+                            "missing arguments to contract '{}' constructor",
                             ns.contracts[base.contract_no].name
                         ),
                     ));
@@ -288,7 +288,7 @@ pub fn resolve_function_body(
         if !has_underscore {
             ns.diagnostics.push(Diagnostic::error(
                 body.loc().end_range(),
-                "missing ‘_’ in modifier".to_string(),
+                "missing '_' in modifier".to_string(),
             ));
         }
     }
@@ -716,7 +716,7 @@ fn statement(
                         if expr.ty().is_mapping() {
                             ns.diagnostics.push(Diagnostic::error(
                                 *loc,
-                                "‘delete’ cannot be applied to mapping type".to_string(),
+                                "'delete' cannot be applied to mapping type".to_string(),
                             ));
                             return Err(());
                         }
@@ -727,7 +727,7 @@ fn statement(
                     } else {
                         ns.diagnostics.push(Diagnostic::error(
                             *loc,
-                            "argument to ‘delete’ should be storage reference".to_string(),
+                            "argument to 'delete' should be storage reference".to_string(),
                         ));
 
                         Err(())
@@ -843,7 +843,7 @@ fn statement(
                 ns.diagnostics.push(Diagnostic::error(
                     error.loc,
                     format!(
-                        "revert with custom error ‘{}’ not supported yet",
+                        "revert with custom error '{}' not supported yet",
                         error.name
                     ),
                 ));
@@ -927,7 +927,7 @@ fn emit_event(
                     temp_diagnostics.push(Diagnostic::error(
                         *loc,
                         format!(
-                            "event type ‘{}’ has {} fields, {} provided",
+                            "event type '{}' has {} fields, {} provided",
                             event.name,
                             event.fields.len(),
                             args.len()
@@ -1008,7 +1008,7 @@ fn emit_event(
                 if arguments.contains_key(arg.name.name.as_str()) {
                     temp_diagnostics.push(Diagnostic::error(
                         arg.name.loc,
-                        format!("duplicate argument with name ‘{}’", arg.name.name),
+                        format!("duplicate argument with name '{}'", arg.name.name),
                     ));
                 }
 
@@ -1060,7 +1060,7 @@ fn emit_event(
                         temp_diagnostics.push(Diagnostic::error(
                         *loc,
                         format!(
-                            "event ‘{}’ cannot emitted by argument name since argument {} has no name",
+                            "event '{}' cannot emitted by argument name since argument {} has no name",
                             ns.events[*event_no].name, i,
                         ),
                     ));
@@ -1075,7 +1075,7 @@ fn emit_event(
                             temp_diagnostics.push(Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "missing argument ‘{}’ to event ‘{}’",
+                                    "missing argument '{}' to event '{}'",
                                     param.name_as_str(),
                                     ns.events[*event_no].name,
                                 ),
@@ -1178,7 +1178,7 @@ fn destructure(
                 if let Some(storage) = storage {
                     diagnostics.push(Diagnostic::error(
                         storage.loc(),
-                        format!("storage modifier ‘{}’ not permitted on assignment", storage),
+                        format!("storage modifier '{}' not permitted on assignment", storage),
                     ));
                     return Err(());
                 }
@@ -1191,7 +1191,7 @@ fn destructure(
                         diagnostics.push(Diagnostic::error(
                             *loc,
                             format!(
-                                "cannot assign to constant ‘{}’",
+                                "cannot assign to constant '{}'",
                                 ns.contracts[*contract_no].variables[*var_no].name
                             ),
                         ));
@@ -1200,7 +1200,7 @@ fn destructure(
                     Expression::ConstantVariable(_, _, None, var_no) => {
                         diagnostics.push(Diagnostic::error(
                             *loc,
-                            format!("cannot assign to constant ‘{}’", ns.constants[*var_no].name),
+                            format!("cannot assign to constant '{}'", ns.constants[*var_no].name),
                         ));
                         return Err(());
                     }
@@ -1213,7 +1213,7 @@ fn destructure(
                             diagnostics.push(Diagnostic::error(
                                 *loc,
                                 format!(
-                                    "cannot assign to immutable ‘{}’ outside of constructor",
+                                    "cannot assign to immutable '{}' outside of constructor",
                                     store_var.name
                                 ),
                             ));
@@ -1470,7 +1470,7 @@ fn resolve_var_decl_ty(
             diagnostics.push(Diagnostic::error(
                 storage.loc(),
                 format!(
-                    "data location ‘{}’ only allowed for array, struct or mapping type",
+                    "data location '{}' only allowed for array, struct or mapping type",
                     storage
                 ),
             ));
@@ -1954,7 +1954,7 @@ fn try_catch(
                     diagnostics.push(Diagnostic::error(
                         ty.loc(),
                         format!(
-                            "type ‘{}’ does not match return value of function ‘{}’",
+                            "type '{}' does not match return value of function '{}'",
                             ret_ty.to_string(ns),
                             arg_ty.to_string(ns)
                         ),
@@ -2043,7 +2043,7 @@ fn try_catch(
                 if name.is_empty() {
                     "duplicate catch clause".to_string()
                 } else {
-                    format!("duplicate ‘{}’ catch clause", name)
+                    format!("duplicate '{}' catch clause", name)
                 },
             ));
             return Err(());
@@ -2061,7 +2061,7 @@ fn try_catch(
                         diagnostics.push(Diagnostic::error(
                             param.ty.loc(),
                             format!(
-                                "catch can only take ‘bytes memory’, not ‘{}’",
+                                "catch can only take ‘bytes memory’, not '{}'",
                                 catch_ty.to_string(ns)
                             ),
                         ));
@@ -2116,7 +2116,7 @@ fn try_catch(
                     ns.diagnostics.push(Diagnostic::error(
                         id.loc,
                         format!(
-                            "only catch ‘Error’ or ‘Panic’ is supported, not ‘{}’",
+                            "only catch 'Error' or 'Panic' is supported, not '{}'",
                             id.name
                         ),
                     ));
@@ -2130,7 +2130,7 @@ fn try_catch(
                     ns.diagnostics.push(Diagnostic::error(
                         param.ty.loc(),
                         format!(
-                            "catch Error(...) can only take ‘string memory’, not ‘{}’",
+                            "catch Error(...) can only take ‘string memory’, not '{}'",
                             error_ty.to_string(ns)
                         ),
                     ));
@@ -2139,7 +2139,7 @@ fn try_catch(
                     ns.diagnostics.push(Diagnostic::error(
                         param.ty.loc(),
                         format!(
-                            "catch Panic(...) can only take ‘uint256’, not ‘{}’",
+                            "catch Panic(...) can only take 'uint256', not '{}'",
                             error_ty.to_string(ns)
                         ),
                     ));

src/sema/tags.rs

@@ -33,7 +33,7 @@ pub fn resolve_tags(
                 if v.is_empty() || v[0].is_empty() {
                     ns.diagnostics.push(Diagnostic::error(
                         pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                        "tag ‘@param’ missing parameter name".to_string(),
+                        "tag '@param' missing parameter name".to_string(),
                     ));
                     continue;
                 }
@@ -44,7 +44,7 @@ pub fn resolve_tags(
                     if res.iter().any(|e| e.tag == "param" && e.no == no) {
                         ns.diagnostics.push(Diagnostic::error(
                             pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                            format!("duplicate tag ‘@param’ for ‘{}’", name),
+                            format!("duplicate tag '@param' for '{}'", name),
                         ));
                     } else {
                         res.push(Tag {
@@ -56,7 +56,7 @@ pub fn resolve_tags(
                 } else {
                     ns.diagnostics.push(Diagnostic::error(
                         pt::Loc::File(file_no, c.value_offset, c.value_offset + c.value.len()),
-                        format!("tag ‘@param’ no field ‘{}’", name),
+                        format!("tag '@param' no field '{}'", name),
                     ));
                 }
             }
@@ -66,13 +66,13 @@ pub fn resolve_tags(
                 if returns.is_empty() {
                     ns.diagnostics.push(Diagnostic::error(
                         pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                        "tag ‘@return’ for function with no return values".to_string(),
+                        "tag '@return' for function with no return values".to_string(),
                     ));
                 } else if returns.len() == 1 {
                     if res.iter().any(|e| e.tag == "return") {
                         ns.diagnostics.push(Diagnostic::error(
                             pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                            "duplicate tag ‘@return’".to_string(),
+                            "duplicate tag '@return'".to_string(),
                         ));
                     } else {
                         res.push(Tag {
@@ -86,7 +86,7 @@ pub fn resolve_tags(
                     if v.is_empty() || v[0].is_empty() {
                         ns.diagnostics.push(Diagnostic::error(
                             pt::Loc::File(file_no, c.value_offset, c.value_offset + c.value.len()),
-                            "tag ‘@return’ missing parameter name".to_string(),
+                            "tag '@return' missing parameter name".to_string(),
                         ));
                         continue;
                     }
@@ -100,7 +100,7 @@ pub fn resolve_tags(
                         if res.iter().any(|e| e.tag == "return" && e.no == no) {
                             ns.diagnostics.push(Diagnostic::error(
                                 pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                                format!("duplicate tag ‘@return’ for ‘{}’", name),
+                                format!("duplicate tag '@return' for '{}'", name),
                             ));
                         } else {
                             res.push(Tag {
@@ -121,7 +121,7 @@ pub fn resolve_tags(
                     } else {
                         ns.diagnostics.push(Diagnostic::error(
                             pt::Loc::File(file_no, c.value_offset, c.value_offset + c.value.len()),
-                            format!("tag ‘@return’ no matching return value ‘{}’", c.value),
+                            format!("tag '@return' no matching return value '{}'", c.value),
                         ));
                     }
                 }
@@ -130,7 +130,7 @@ pub fn resolve_tags(
                 if c.value.is_empty() {
                     ns.diagnostics.push(Diagnostic::error(
                         pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                        "missing contract for tag ‘@inheritdoc’".to_string(),
+                        "missing contract for tag '@inheritdoc'".to_string(),
                     ));
                 } else if bases.unwrap().iter().any(|s| &c.value == s) {
                     res.push(Tag {
@@ -141,14 +141,14 @@ pub fn resolve_tags(
                 } else {
                     ns.diagnostics.push(Diagnostic::error(
                         pt::Loc::File(file_no, c.value_offset, c.value_offset + c.value.len()),
-                        format!("base contract ‘{}’ not found in tag ‘@inheritdoc’", c.value),
+                        format!("base contract '{}' not found in tag '@inheritdoc'", c.value),
                     ));
                 }
             }
             _ => {
                 ns.diagnostics.push(Diagnostic::error(
                     pt::Loc::File(file_no, c.tag_offset, c.tag_offset + c.tag.len()),
-                    format!("tag ‘@{}’ is not valid for {}", c.tag, ty),
+                    format!("tag '@{}' is not valid for {}", c.tag, ty),
                 ));
             }
         }

src/sema/types.rs

@@ -189,9 +189,9 @@ pub fn resolve_fields(delay: ResolveFields, file_no: usize, ns: &mut Namespace)
                     if structs_visited.contains(&struct_no) {
                         ns.diagnostics.push(Diagnostic::error_with_note(
                             def.loc,
-                            format!("struct ‘{}’ has infinite size", def.name),
+                            format!("struct '{}' has infinite size", def.name),
                             field.loc,
-                            format!("recursive field ‘{}’", field.name_as_str()),
+                            format!("recursive field '{}'", field.name_as_str()),
                         ));
                     } else {
                         structs_visited.push(struct_no);
@@ -253,7 +253,7 @@ fn resolve_contract<'a>(
         ns.diagnostics.push(Diagnostic::error(
             def.name.loc,
             format!(
-                "contract name ‘{}’ is reserved file name on Windows",
+                "contract name '{}' is reserved file name on Windows",
                 def.name.name
             ),
         ));
@@ -365,12 +365,12 @@ pub fn struct_decl(
             ns.diagnostics.push(Diagnostic::error_with_note(
                 field.name.loc,
                 format!(
-                    "struct ‘{}’ has duplicate struct field ‘{}’",
+                    "struct '{}' has duplicate struct field '{}'",
                     def.name.name, field.name.name
                 ),
                 other.loc,
                 format!(
-                    "location of previous declaration of ‘{}’",
+                    "location of previous declaration of '{}'",
                     other.name_as_str()
                 ),
             ));
@@ -386,7 +386,7 @@ pub fn struct_decl(
             ns.diagnostics.push(Diagnostic::error(
                 storage.loc(),
                 format!(
-                    "storage location ‘{}’ not allowed for struct field",
+                    "storage location '{}' not allowed for struct field",
                     storage
                 ),
             ));
@@ -410,7 +410,7 @@ pub fn struct_decl(
         if valid {
             ns.diagnostics.push(Diagnostic::error(
                 def.name.loc,
-                format!("struct definition for ‘{}’ has no fields", def.name.name),
+                format!("struct definition for '{}' has no fields", def.name.name),
             ));
         }
 
@@ -476,12 +476,12 @@ fn event_decl(
                 ns.diagnostics.push(Diagnostic::error_with_note(
                     name.loc,
                     format!(
-                        "event ‘{}’ has duplicate field name ‘{}’",
+                        "event '{}' has duplicate field name '{}'",
                         def.name.name, name.name
                     ),
                     other.loc,
                     format!(
-                        "location of previous declaration of ‘{}’",
+                        "location of previous declaration of '{}'",
                         other.name_as_str()
                     ),
                 ));
@@ -514,7 +514,7 @@ fn event_decl(
         ns.diagnostics.push(Diagnostic::error(
             def.name.loc,
             format!(
-                "anonymous event definition for ‘{}’ has {} indexed fields where 4 permitted",
+                "anonymous event definition for '{}' has {} indexed fields where 4 permitted",
                 def.name.name, indexed_fields
             ),
         ));
@@ -524,7 +524,7 @@ fn event_decl(
         ns.diagnostics.push(Diagnostic::error(
             def.name.loc,
             format!(
-                "event definition for ‘{}’ has {} indexed fields where 3 permitted",
+                "event definition for '{}' has {} indexed fields where 3 permitted",
                 def.name.name, indexed_fields
             ),
         ));
@@ -562,14 +562,14 @@ fn enum_decl(
     if enum_.values.is_empty() {
         ns.diagnostics.push(Diagnostic::error(
             enum_.name.loc,
-            format!("enum ‘{}’ has no fields", enum_.name.name),
+            format!("enum '{}' has no fields", enum_.name.name),
         ));
         valid = false;
     } else if enum_.values.len() > 256 {
         ns.diagnostics.push(Diagnostic::error(
             enum_.name.loc,
             format!(
-                "enum ‘{}’ has {} fields, which is more than the 256 limit",
+                "enum '{}' has {} fields, which is more than the 256 limit",
                 enum_.name.name,
                 enum_.values.len()
             ),

src/sema/unused_variable.rs

@@ -241,7 +241,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "function parameter ‘{}‘ has never been read",
+                        "function parameter '{}' has never been read",
                         variable.id.name
                     ),
                 ));
@@ -254,7 +254,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "return variable ‘{}‘ has never been assigned",
+                        "return variable '{}' has never been assigned",
                         variable.id.name
                     ),
                 ));
@@ -268,7 +268,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "local variable ‘{}‘ has never been read nor assigned",
+                        "local variable '{}' has never been read nor assigned",
                         variable.id.name
                     ),
                 ));
@@ -278,7 +278,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "local variable ‘{}‘ has been assigned, but never read",
+                        "local variable '{}' has been assigned, but never read",
                         variable.id.name
                     ),
                 ));
@@ -291,7 +291,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "destructure variable ‘{}‘ has never been used",
+                        "destructure variable '{}' has never been used",
                         variable.id.name
                     ),
                 ));
@@ -305,7 +305,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "try-catch returns variable ‘{}‘ has never been read",
+                        "try-catch returns variable '{}' has never been read",
                         variable.id.name
                     ),
                 ));
@@ -319,7 +319,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "try-catch error bytes ‘{}‘ has never been used",
+                        "try-catch error bytes '{}' has never been used",
                         variable.id.name
                     ),
                 ));
@@ -333,7 +333,7 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "try-catch error string ‘{}‘ has never been used",
+                        "try-catch error string '{}' has never been used",
                         variable.id.name
                     ),
                 ));
@@ -347,14 +347,14 @@ pub fn emit_warning_local_variable(variable: &symtable::Variable) -> Option<Diag
                 return Some(Diagnostic::warning(
                     variable.id.loc,
                     format!(
-                        "yul variable ‘{}‘ has never been read or assigned",
+                        "yul variable '{}' has never been read or assigned",
                         variable.id.name
                     ),
                 ));
             } else if !variable.read {
                 return Some(Diagnostic::warning(
                     variable.id.loc,
-                    format!("yul variable ‘{}‘ has never been read", variable.id.name),
+                    format!("yul variable '{}' has never been read", variable.id.name),
                 ));
             }
             None
@@ -369,14 +369,14 @@ fn emit_warning_contract_variables(variable: &ast::Variable) -> Option<Diagnosti
         return Some(Diagnostic::warning(
             variable.loc,
             format!(
-                "storage variable ‘{}‘ has been assigned, but never read",
+                "storage variable '{}' has been assigned, but never read",
                 variable.name
             ),
         ));
     } else if !variable.assigned && !variable.read {
         return Some(Diagnostic::warning(
             variable.loc,
-            format!("storage variable ‘{}‘ has never been used", variable.name),
+            format!("storage variable '{}' has never been used", variable.name),
         ));
     }
 
@@ -401,7 +401,7 @@ pub fn check_unused_namespace_variables(ns: &mut Namespace) {
         if !constant.read {
             ns.diagnostics.push(Diagnostic::warning(
                 constant.loc,
-                format!("global constant ‘{}‘ has never been used", constant.name),
+                format!("global constant '{}' has never been used", constant.name),
             ));
         }
     }
@@ -479,7 +479,7 @@ pub fn check_unused_events(ns: &mut Namespace) {
 
             ns.diagnostics.push(Diagnostic::warning(
                 event.loc,
-                format!("event ‘{}‘ has never been emitted", event.name),
+                format!("event '{}' has never been emitted", event.name),
             ));
         }
     }

src/sema/variables.rs

@@ -104,9 +104,9 @@ pub fn variable_decl<'a>(
                 if let Some(prev) = &has_immutable {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         *loc,
-                        "duplicate ‘immutable’ attribute".to_string(),
+                        "duplicate 'immutable' attribute".to_string(),
                         *prev,
-                        "previous ‘immutable’ attribute".to_string(),
+                        "previous 'immutable' attribute".to_string(),
                     ));
                 }
                 has_immutable = Some(*loc);
@@ -115,9 +115,9 @@ pub fn variable_decl<'a>(
                 if let Some(prev) = &has_override {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         *loc,
-                        "duplicate ‘override’ attribute".to_string(),
+                        "duplicate 'override' attribute".to_string(),
                         *prev,
-                        "previous ‘override’ attribute".to_string(),
+                        "previous 'override' attribute".to_string(),
                     ));
                 }
                 has_override = Some(*loc);
@@ -125,7 +125,7 @@ pub fn variable_decl<'a>(
             pt::VariableAttribute::Visibility(v) if contract_no.is_none() => {
                 ns.diagnostics.push(Diagnostic::error(
                     v.loc().unwrap(),
-                    format!("‘{}’: global variable cannot have visibility specifier", v),
+                    format!("'{}': global variable cannot have visibility specifier", v),
                 ));
                 return None;
             }
@@ -140,9 +140,9 @@ pub fn variable_decl<'a>(
                 if let Some(e) = &visibility {
                     ns.diagnostics.push(Diagnostic::error_with_note(
                         v.loc().unwrap(),
-                        format!("variable visibility redeclared `{}'", v),
+                        format!("variable visibility redeclared '{}'", v),
                         e.loc().unwrap(),
-                        format!("location of previous declaration of `{}'", e),
+                        format!("location of previous declaration of '{}'", e),
                     ));
                     return None;
                 }
@@ -156,7 +156,7 @@ pub fn variable_decl<'a>(
         if constant {
             ns.diagnostics.push(Diagnostic::error(
                 *loc,
-                "variable cannot be declared both ‘immutable’ and ‘constant’".to_string(),
+                "variable cannot be declared both 'immutable' and 'constant'".to_string(),
             ));
             constant = false;
         }
@@ -172,7 +172,7 @@ pub fn variable_decl<'a>(
     } else if let Some(loc) = &has_override {
         ns.diagnostics.push(Diagnostic::error(
             *loc,
-            "only public variable can be declared ‘override’".to_string(),
+            "only public variable can be declared 'override'".to_string(),
         ));
         has_override = None;
     }
@@ -184,7 +184,7 @@ pub fn variable_decl<'a>(
             ns.diagnostics.push(Diagnostic::error(
                 def.loc,
                 format!(
-                    "{} ‘{}’ is not allowed to have contract variable ‘{}’",
+                    "{} '{}' is not allowed to have contract variable '{}'",
                     contract.ty, contract.name.name, def.name.name
                 ),
             ));
@@ -216,18 +216,18 @@ pub fn variable_decl<'a>(
         ns.diagnostics.push(Diagnostic::error(
             def.ty.loc(),
             format!(
-                "variable of type internal function cannot be ‘{}’",
+                "variable of type internal function cannot be '{}'",
                 visibility
             ),
         ));
         return None;
     } else if let Some(ty) = ty.contains_builtins(ns, BuiltinStruct::AccountInfo) {
-        let message = format!("variable cannot be of builtin type ‘{}’", ty.to_string(ns));
+        let message = format!("variable cannot be of builtin type '{}'", ty.to_string(ns));
         ns.diagnostics
             .push(Diagnostic::error(def.ty.loc(), message));
         return None;
     } else if let Some(ty) = ty.contains_builtins(ns, BuiltinStruct::AccountMeta) {
-        let message = format!("variable cannot be of builtin type ‘{}’", ty.to_string(ns));
+        let message = format!("variable cannot be of builtin type '{}'", ty.to_string(ns));
         ns.diagnostics
             .push(Diagnostic::error(def.ty.loc(), message));
         return None;

src/sema/yul/expression.rs

@@ -509,14 +509,14 @@ fn resolve_member_access(
             if dims.last().unwrap().is_none() && id.name != "offset" && id.name != "length" {
                 ns.diagnostics.push(Diagnostic::error(
                     resolved_expr.loc(),
-                    "calldata variables only support ‘.offset‘ and ‘.length‘".to_string(),
+                    "calldata variables only support '.offset' and '.length'".to_string(),
                 ));
                 return Err(());
             } else if dims.last().unwrap().is_some() {
                 ns.diagnostics.push(Diagnostic::error(
                     resolved_expr.loc(),
                     format!(
-                        "the given expression does not support ‘.{}‘ suffixes",
+                        "the given expression does not support '.{}' suffixes",
                         suffix_type.to_string()
                     ),
                 ));
@@ -539,7 +539,7 @@ fn resolve_member_access(
             if id.name != "selector" && id.name != "address" {
                 ns.diagnostics.push(Diagnostic::error(
                     id.loc,
-                    "variables of type function pointer only support ‘.selector‘ and ‘.address‘ suffixes".to_string()
+                    "variables of type function pointer only support '.selector' and '.address' suffixes".to_string()
                 ));
                 return Err(());
             }
@@ -550,7 +550,7 @@ fn resolve_member_access(
             if id.name != "slot" && id.name != "offset" {
                 ns.diagnostics.push(Diagnostic::error(
                     id.loc,
-                    "state variables only support ‘.slot‘ and ‘.offset‘".to_string(),
+                    "state variables only support '.slot' and '.offset'".to_string(),
                 ));
                 return Err(());
             }
@@ -577,7 +577,7 @@ fn resolve_member_access(
             ns.diagnostics.push(Diagnostic::error(
                 resolved_expr.loc(),
                 format!(
-                    "the given expression does not support ‘.{}‘ suffixes",
+                    "the given expression does not support '.{}' suffixes",
                     suffix_type.to_string()
                 ),
             ));
@@ -606,7 +606,7 @@ pub(crate) fn check_type(
             | YulExpression::StorageVariable(..) => {
                 return Some(Diagnostic::error(
                     expr.loc(),
-                    "storage variables cannot be assigned any value in assembly. You may use ‘sstore()‘".to_string()
+                    "storage variables cannot be assigned any value in assembly. You may use 'sstore()'".to_string()
                 ));
             }
 
@@ -662,7 +662,7 @@ pub(crate) fn check_type(
         | YulExpression::StorageVariable(..) => {
             return Some(Diagnostic::error(
                 expr.loc(),
-                "Storage variables must be accessed with ‘.slot‘ or ‘.offset‘".to_string(),
+                "Storage variables must be accessed with '.slot' or '.offset'".to_string(),
             ));
         }
 
@@ -675,7 +675,7 @@ pub(crate) fn check_type(
             if dims[0].is_none() {
                 return Some(Diagnostic::error(
                     expr.loc(),
-                    "Calldata arrays must be accessed with ‘.offset‘, ‘.length‘ and the ‘calldatacopy‘ function".to_string()
+                    "Calldata arrays must be accessed with '.offset', '.length' and the 'calldatacopy' function".to_string()
                 ));
             }
         }

src/sema/yul/tests/block.rs

@@ -44,7 +44,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 3);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -100,7 +100,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -153,7 +153,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -219,7 +219,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -248,7 +248,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -297,12 +297,12 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 4);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
     assert!(ns.diagnostics.contains_message("unreachable yul statement"));
     assert!(ns
         .diagnostics
-        .contains_message("yul variable ‘x‘ has never been read"));
+        .contains_message("yul variable 'x' has never been read"));
 }

src/sema/yul/tests/expression.rs

@@ -883,7 +883,7 @@ fn test_member_access() {
     assert_eq!(ns.diagnostics.len(), 1);
     assert_eq!(
         ns.diagnostics.iter().next().unwrap().message,
-        "the given expression does not support ‘.slot‘ suffixes"
+        "the given expression does not support '.slot' suffixes"
     );
     ns.diagnostics = Diagnostics::default();
 
@@ -963,7 +963,7 @@ fn test_check_types() {
     assert!(res.is_some());
     assert_eq!(
         res.unwrap().message,
-        "Storage variables must be accessed with ‘.slot‘ or ‘.offset‘"
+        "Storage variables must be accessed with '.slot' or '.offset'"
     );
 
     let expr = YulExpression::StorageVariable(loc, Type::Int(16), 0, 0);
@@ -971,7 +971,7 @@ fn test_check_types() {
     assert!(res.is_some());
     assert_eq!(
         res.unwrap().message,
-        "Storage variables must be accessed with ‘.slot‘ or ‘.offset‘"
+        "Storage variables must be accessed with '.slot' or '.offset'"
     );
 
     let expr = YulExpression::SolidityLocalVariable(
@@ -982,7 +982,7 @@ fn test_check_types() {
     );
     let res = check_type(&expr, &context, &mut ns, &mut symtable);
     assert!(res.is_some());
-    assert_eq!(res.unwrap().message, "Calldata arrays must be accessed with ‘.offset‘, ‘.length‘ and the ‘calldatacopy‘ function");
+    assert_eq!(res.unwrap().message, "Calldata arrays must be accessed with '.offset', '.length' and the 'calldatacopy' function");
 
     let expr = YulExpression::StringLiteral(loc, vec![0, 255, 20], Type::Uint(256));
     let res = check_type(&expr, &context, &mut ns, &mut symtable);
@@ -1045,7 +1045,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        r#"unrecognised token `:=', expected ")", ",", "address", "bool", "break", "byte", "case", "continue", "default", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
+        r#"unrecognised token ':=', expected ")", ",", "address", "bool", "break", "byte", "case", "continue", "default", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
     ));
 
     let file = r#"
@@ -1115,13 +1115,13 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 3);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
     assert!(ns
         .diagnostics
-        .contains_message("function parameter ‘vl‘ has never been read"));
+        .contains_message("function parameter 'vl' has never been read"));
 
     let file = r#"
     contract testTypes {
@@ -1144,7 +1144,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        "storage variables cannot be assigned any value in assembly. You may use ‘sstore()‘"
+        "storage variables cannot be assigned any value in assembly. You may use 'sstore()'"
     ));
 
     let file = r#"
@@ -1168,7 +1168,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("Storage variables must be accessed with ‘.slot‘ or ‘.offset‘"));
+        .contains_message("Storage variables must be accessed with '.slot' or '.offset'"));
 
     let file = r#"
 contract testTypes {
@@ -1184,7 +1184,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        "Calldata arrays must be accessed with ‘.offset‘, ‘.length‘ and the ‘calldatacopy‘ function"
+        "Calldata arrays must be accessed with '.offset', '.length' and the 'calldatacopy' function"
     ));
 }
 
@@ -1235,7 +1235,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("state variables only support ‘.slot‘ and ‘.offset‘"));
+        .contains_message("state variables only support '.slot' and '.offset'"));
 
     let file = r#"
 contract testTypes {
@@ -1288,7 +1288,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        "variables of type function pointer only support ‘.selector‘ and ‘.address‘ suffixes"
+        "variables of type function pointer only support '.selector' and '.address' suffixes"
     ));
 
     let file = r#"
@@ -1304,7 +1304,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("calldata variables only support ‘.offset‘ and ‘.length‘"));
+        .contains_message("calldata variables only support '.offset' and '.length'"));
 
     let file = r#"
 contract testTypes {
@@ -1411,7 +1411,7 @@ contract C {
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
 
-    assert!(ns.diagnostics.contains_message("found contract ‘C’"));
+    assert!(ns.diagnostics.contains_message("found contract 'C'"));
 }
 
 #[test]
@@ -1433,10 +1433,10 @@ contract test {
     "#;
     let ns = parse(file);
     assert_eq!(ns.diagnostics.len(), 2);
-    assert!(ns.diagnostics.contains_message("found contract ‘test’"));
+    assert!(ns.diagnostics.contains_message("found contract 'test'"));
     assert!(ns
         .diagnostics
-        .contains_message("the given expression does not support ‘.slot‘ suffixes"));
+        .contains_message("the given expression does not support '.slot' suffixes"));
 
     let file = r#"
     contract test {
@@ -1455,10 +1455,10 @@ contract test {
     "#;
     let ns = parse(file);
     assert_eq!(ns.diagnostics.len(), 2);
-    assert!(ns.diagnostics.contains_message("found contract ‘test’"));
+    assert!(ns.diagnostics.contains_message("found contract 'test'"));
     assert!(ns
         .diagnostics
-        .contains_message("the given expression does not support ‘.slot‘ suffixes"));
+        .contains_message("the given expression does not support '.slot' suffixes"));
 
     let file = r#"
     contract test {
@@ -1475,10 +1475,10 @@ contract test {
     "#;
     let ns = parse(file);
     assert_eq!(ns.diagnostics.len(), 2);
-    assert!(ns.diagnostics.contains_message("found contract ‘test’"));
+    assert!(ns.diagnostics.contains_message("found contract 'test'"));
     assert!(ns
         .diagnostics
-        .contains_message("the given expression does not support ‘.offset‘ suffixes"));
+        .contains_message("the given expression does not support '.offset' suffixes"));
 }
 
 #[test]
@@ -1496,7 +1496,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("calldata variables only support ‘.offset‘ and ‘.length‘"));
+        .contains_message("calldata variables only support '.offset' and '.length'"));
 
     let file = r#"
 contract testTypes {
@@ -1512,5 +1512,5 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("the given expression does not support ‘.length‘ suffixes"));
+        .contains_message("the given expression does not support '.length' suffixes"));
 }

src/sema/yul/tests/for_loop.rs

@@ -134,11 +134,11 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 3);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
     assert!(ns
         .diagnostics
-        .contains_message("yul variable ‘x‘ has never been read"));
+        .contains_message("yul variable 'x' has never been read"));
 }

src/sema/yul/tests/mutability.rs

@@ -18,7 +18,7 @@ fn inside_function() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -41,7 +41,7 @@ fn inside_argument() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -61,7 +61,7 @@ fn inside_argument() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -87,7 +87,7 @@ fn block() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -110,7 +110,7 @@ fn assign_declaration() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -130,7 +130,7 @@ fn assign_declaration() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -151,7 +151,7 @@ fn if_block() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -171,7 +171,7 @@ fn if_block() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -195,7 +195,7 @@ fn switch() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -217,7 +217,7 @@ fn switch() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -239,7 +239,7 @@ fn switch() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -259,7 +259,7 @@ fn test_for() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -276,7 +276,7 @@ fn test_for() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -294,7 +294,7 @@ fn test_for() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
     contract testTypes {
@@ -311,7 +311,7 @@ fn test_for() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 }
 
 #[test]
@@ -331,7 +331,7 @@ fn pure_function() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression reads from state"));
+        .contains_message("function declared 'pure' but this expression reads from state"));
 
     let file = r#"
         contract testTypes {
@@ -349,7 +349,7 @@ fn pure_function() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘pure’ but this expression writes to state"));
+        .contains_message("function declared 'pure' but this expression writes to state"));
 }
 
 #[test]
@@ -371,7 +371,7 @@ fn view_function() {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("function declared ‘view’ but this expression writes to state"));
+        .contains_message("function declared 'view' but this expression writes to state"));
 
     let file = r#"
     contract testTypes {
@@ -390,7 +390,7 @@ fn view_function() {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -415,7 +415,7 @@ fn function_without_modifier() {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));

src/sema/yul/tests/statements.rs

@@ -192,7 +192,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -238,7 +238,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -293,7 +293,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));
@@ -348,7 +348,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));

src/sema/yul/tests/switch.rs

@@ -20,7 +20,7 @@ fn case_not_literal() {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        r#"unrecognised token `y', expected "false", "true", hexnumber, hexstring, number, string"#
+        r#"unrecognised token 'y', expected "false", "true", hexnumber, hexstring, number, string"#
     ));
 }
 
@@ -43,7 +43,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        r#"unrecognised token `case', expected "address", "bool", "break", "byte", "continue", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
+        r#"unrecognised token 'case', expected "address", "bool", "break", "byte", "continue", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
     ));
 }
 
@@ -66,7 +66,7 @@ contract testTypes {
 
     let ns = parse(file);
     assert!(ns.diagnostics.contains_message(
-        r#"unrecognised token `default', expected "address", "bool", "break", "byte", "continue", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
+        r#"unrecognised token 'default', expected "address", "bool", "break", "byte", "continue", "for", "function", "if", "leave", "let", "return", "revert", "switch", "{", "}", identifier"#
     ));
 }
 
@@ -101,7 +101,7 @@ contract testTypes {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));

src/sema/yul/tests/unused_variable.rs

@@ -25,7 +25,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("yul variable ‘a‘ has never been read or assigned"));
+        .contains_message("yul variable 'a' has never been read or assigned"));
 
     let file = r#"
 contract testTypes {
@@ -50,7 +50,7 @@ contract testTypes {
     let ns = parse(file);
     assert!(ns
         .diagnostics
-        .contains_message("yul variable ‘c‘ has never been read"));
+        .contains_message("yul variable 'c' has never been read"));
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn correct_contracts() {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(ns
         .diagnostics
-        .contains_message("found contract ‘testTypes’"));
+        .contains_message("found contract 'testTypes'"));
     assert!(ns
         .diagnostics
         .contains_message("inline assembly is not yet supported"));

tests/contract_testcases/ewasm/call/call.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/ewasm/call/call.sol" {
 	contract [label="contract x\ntests/contract_testcases/ewasm/call/call.sol:2:9-20"]
 	f [label="function f\ncontract: x\ntests/contract_testcases/ewasm/call/call.sol:3:13-49\nsignature f(address)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\naddress payable a"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/ewasm/call/call.sol:2:9-20"]
-	diagnostic_6 [label="‘delegatecall’ cannot have value specifed\nlevel Error\ntests/contract_testcases/ewasm/call/call.sol:4:45-73"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/ewasm/call/call.sol:2:9-20"]
+	diagnostic_6 [label="'delegatecall' cannot have value specifed\nlevel Error\ntests/contract_testcases/ewasm/call/call.sol:4:45-73"]
 	contracts -> contract
 	contract -> f [label="function"]
 	f -> parameters [label="parameters"]

tests/contract_testcases/ewasm/call/call_01.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/ewasm/call/call_01.sol" {
 	contract [label="contract x\ntests/contract_testcases/ewasm/call/call_01.sol:2:9-20"]
 	f [label="function f\ncontract: x\ntests/contract_testcases/ewasm/call/call_01.sol:3:13-49\nsignature f(address)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\naddress payable a"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/ewasm/call/call_01.sol:2:9-20"]
-	diagnostic_6 [label="‘staticcall’ cannot have value specifed\nlevel Error\ntests/contract_testcases/ewasm/call/call_01.sol:4:45-71"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/ewasm/call/call_01.sol:2:9-20"]
+	diagnostic_6 [label="'staticcall' cannot have value specifed\nlevel Error\ntests/contract_testcases/ewasm/call/call_01.sol:4:45-71"]
 	contracts -> contract
 	contract -> f [label="function"]
 	f -> parameters [label="parameters"]

tests/contract_testcases/ewasm/call/call_02.dot

@@ -10,10 +10,10 @@ strict digraph "tests/contract_testcases/ewasm/call/call_02.sol" {
 	alloc_array [label="alloc array bytes\ninitializer: \ntests/contract_testcases/ewasm/call/call_02.sol:4:62-64"]
 	number_literal [label="uint32 literal: 0\ntests/contract_testcases/ewasm/call/call_02.sol:4:62-64"]
 	number_literal_11 [label="uint128 literal: 2\ntests/contract_testcases/ewasm/call/call_02.sol:4:59-60"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/ewasm/call/call_02.sol:2:9-20"]
-	diagnostic_14 [label="destructure variable ‘s‘ has never been used\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:4:23-24"]
-	diagnostic_15 [label="destructure variable ‘bs‘ has never been used\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:4:39-41"]
-	diagnostic_16 [label="function can be declared ‘view’\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:3:13-49"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/ewasm/call/call_02.sol:2:9-20"]
+	diagnostic_14 [label="destructure variable 's' has never been used\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:4:23-24"]
+	diagnostic_15 [label="destructure variable 'bs' has never been used\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:4:39-41"]
+	diagnostic_16 [label="function can be declared 'view'\nlevel Warning\ntests/contract_testcases/ewasm/call/call_02.sol:3:13-49"]
 	contracts -> contract
 	contract -> f [label="function"]
 	f -> parameters [label="parameters"]

tests/contract_testcases/ewasm/comment_tests.dot

@@ -156,7 +156,7 @@ strict digraph "tests/contract_testcases/ewasm/comment_tests.sol" {
 	inline_assembly [label="inline assembly\ntests/contract_testcases/ewasm/comment_tests.sol:179:9-183:10"]
 	yul_assignment [label="yul assignment\ntests/contract_testcases/ewasm/comment_tests.sol:182:13-45"]
 	solidity_variable [label="solidity variable: codehash\nbytes32\ntests/contract_testcases/ewasm/comment_tests.sol:182:13-21"]
-	yul_builtin_call [label="yul builtin call ‘extcodehash‘\ntests/contract_testcases/ewasm/comment_tests.sol:182:25-45"]
+	yul_builtin_call [label="yul builtin call 'extcodehash'\ntests/contract_testcases/ewasm/comment_tests.sol:182:25-45"]
 	solidity_variable_160 [label="solidity variable: account\naddress\ntests/contract_testcases/ewasm/comment_tests.sol:182:37-44"]
 	return_161 [label="return\ntests/contract_testcases/ewasm/comment_tests.sol:184:9-60"]
 	logical_and [label="logical and\ntests/contract_testcases/ewasm/comment_tests.sol:184:41-43"]
@@ -275,10 +275,10 @@ strict digraph "tests/contract_testcases/ewasm/comment_tests.sol" {
 	inline_assembly_275 [label="inline assembly\ntests/contract_testcases/ewasm/comment_tests.sol:287:17-290:18"]
 	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/ewasm/comment_tests.sol:288:21-61"]
 	var_decl_item [label="yul variable declaration uint256 returndata_size\ntests/contract_testcases/ewasm/comment_tests.sol:288:25-40"]
-	yul_builtin_call_278 [label="yul builtin call ‘mload‘\ntests/contract_testcases/ewasm/comment_tests.sol:288:44-61"]
+	yul_builtin_call_278 [label="yul builtin call 'mload'\ntests/contract_testcases/ewasm/comment_tests.sol:288:44-61"]
 	solidity_variable_279 [label="solidity variable: returndata\nbytes\ntests/contract_testcases/ewasm/comment_tests.sol:288:50-60"]
-	yul_builtin_call_280 [label="yul builtin call ‘revert‘\ntests/contract_testcases/ewasm/comment_tests.sol:289:21-65"]
-	yul_builtin_call_281 [label="yul builtin call ‘add‘\ntests/contract_testcases/ewasm/comment_tests.sol:289:28-47"]
+	yul_builtin_call_280 [label="yul builtin call 'revert'\ntests/contract_testcases/ewasm/comment_tests.sol:289:21-65"]
+	yul_builtin_call_281 [label="yul builtin call 'add'\ntests/contract_testcases/ewasm/comment_tests.sol:289:28-47"]
 	yul_number_literal [label="uint256 literal: 32\ntests/contract_testcases/ewasm/comment_tests.sol:289:32-34"]
 	solidity_variable_283 [label="solidity variable: returndata\nbytes\ntests/contract_testcases/ewasm/comment_tests.sol:289:36-46"]
 	yul_variable [label="yul variable: returndata_size\nuint256\ntests/contract_testcases/ewasm/comment_tests.sol:289:49-64"]
@@ -812,23 +812,23 @@ strict digraph "tests/contract_testcases/ewasm/comment_tests.sol" {
 	variable_812 [label="variable: owner\naddress\ntests/contract_testcases/ewasm/comment_tests.sol:676:23-28"]
 	variable_813 [label="variable: spender\naddress\ntests/contract_testcases/ewasm/comment_tests.sol:676:30-37"]
 	variable_814 [label="variable: amount\nuint256\ntests/contract_testcases/ewasm/comment_tests.sol:676:39-45"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:10:3-11:24"]
-	diagnostic_817 [label="found interface ‘IERC20’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:16:5-17:12"]
-	diagnostic_818 [label="found library ‘SafeMath’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:71:1-72:18"]
-	diagnostic_819 [label="found abstract contract ‘Context’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:152:1-153:27"]
-	diagnostic_820 [label="found library ‘Address’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:168:1-169:17"]
-	diagnostic_821 [label="found contract ‘Ownable’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:302:1-303:28"]
-	diagnostic_822 [label="‘internal’: visibility for constructors is ignored\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:321:9-17"]
-	diagnostic_823 [label="found contract ‘TigerBNB’\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:374:1-375:46"]
-	diagnostic_824 [label="‘public’: visibility for constructors is ignored\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:417:5-11"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:10:3-11:24"]
+	diagnostic_817 [label="found interface 'IERC20'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:16:5-17:12"]
+	diagnostic_818 [label="found library 'SafeMath'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:71:1-72:18"]
+	diagnostic_819 [label="found abstract contract 'Context'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:152:1-153:27"]
+	diagnostic_820 [label="found library 'Address'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:168:1-169:17"]
+	diagnostic_821 [label="found contract 'Ownable'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:302:1-303:28"]
+	diagnostic_822 [label="'internal': visibility for constructors is ignored\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:321:9-17"]
+	diagnostic_823 [label="found contract 'TigerBNB'\nlevel Debug\ntests/contract_testcases/ewasm/comment_tests.sol:374:1-375:46"]
+	diagnostic_824 [label="'public': visibility for constructors is ignored\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:417:5-11"]
 	diagnostic_825 [label="conversion truncates uint256 to uint128, as value is type uint128 on target ewasm\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:195:50-56"]
 	diagnostic_826 [label="conversion truncates uint256 to uint128, as value is type uint128 on target ewasm\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:276:70-78"]
-	diagnostic_827 [label="function parameter ‘weiValue‘ has never been read\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:268:17-25"]
-	diagnostic_828 [label="function parameter ‘errorMessage‘ has never been read\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:269:23-35"]
+	diagnostic_827 [label="function parameter 'weiValue' has never been read\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:268:17-25"]
+	diagnostic_828 [label="function parameter 'errorMessage' has never been read\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:269:23-35"]
 	diagnostic_829 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/ewasm/comment_tests.sol:179:9-183:10"]
-	diagnostic_830 [label="function can be declared ‘view’\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:188:5-75"]
+	diagnostic_830 [label="function can be declared 'view'\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:188:5-75"]
 	diagnostic_831 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/ewasm/comment_tests.sol:287:17-290:18"]
-	diagnostic_832 [label="function can be declared ‘view’\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:264:5-270:37"]
+	diagnostic_832 [label="function can be declared 'view'\nlevel Warning\ntests/contract_testcases/ewasm/comment_tests.sol:264:5-270:37"]
 	events -> Transfer
 	events -> Approval
 	events -> OwnershipTransferred

tests/contract_testcases/ewasm/interface_inheritance.dot

@@ -76,11 +76,11 @@ strict digraph "tests/contract_testcases/ewasm/interface_inheritance.sol" {
 	external_function_75 [label="function() external pure returns (address)\nIUniswapV2Router01.WETH\ntests/contract_testcases/ewasm/interface_inheritance.sol:46:93-116"]
 	cast_76 [label="cast contract IUniswapV2Router01\ntests/contract_testcases/ewasm/interface_inheritance.sol:46:93-109"]
 	variable_77 [label="variable: _uniswapV2Router\ncontract IUniswapV2Router02\ntests/contract_testcases/ewasm/interface_inheritance.sol:46:93-109"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:1:1-23"]
-	diagnostic_80 [label="found interface ‘IUniswapV2Router01’\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:2:1-3:30"]
-	diagnostic_81 [label="found interface ‘IUniswapV2Router02’\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:8:1-9:51"]
-	diagnostic_82 [label="found interface ‘IUniswapV2Factory’\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:19:1-20:29"]
-	diagnostic_83 [label="found contract ‘BABYLINK’\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:23:1-24:19"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:1:1-23"]
+	diagnostic_80 [label="found interface 'IUniswapV2Router01'\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:2:1-3:30"]
+	diagnostic_81 [label="found interface 'IUniswapV2Router02'\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:8:1-9:51"]
+	diagnostic_82 [label="found interface 'IUniswapV2Factory'\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:19:1-20:29"]
+	diagnostic_83 [label="found contract 'BABYLINK'\nlevel Debug\ntests/contract_testcases/ewasm/interface_inheritance.sol:23:1-24:19"]
 	contracts -> contract
 	contract -> factory [label="function"]
 	factory -> returns [label="returns"]

tests/contract_testcases/ewasm/public_internal_function.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/ewasm/public_internal_function.sol" {
 	A [label="name:A\ncontract: foo\ntests/contract_testcases/ewasm/public_internal_function.sol:2:12-13\nfield name:a ty:function() internal"]
 	contract [label="contract foo\ntests/contract_testcases/ewasm/public_internal_function.sol:1:1-14"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/ewasm/public_internal_function.sol:1:1-14"]
-	diagnostic_7 [label="variable of type internal function cannot be ‘public’\nlevel Error\ntests/contract_testcases/ewasm/public_internal_function.sol:6:5-8"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/ewasm/public_internal_function.sol:1:1-14"]
+	diagnostic_7 [label="variable of type internal function cannot be 'public'\nlevel Error\ntests/contract_testcases/ewasm/public_internal_function.sol:6:5-8"]
 	structs -> A
 	contracts -> contract
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/ewasm/public_mapping.dot

@@ -10,7 +10,7 @@ strict digraph "tests/contract_testcases/ewasm/public_mapping.sol" {
 	subscript [label="subscript struct foo.A[] storage\nimplicit"]
 	storage_var [label="storage variable\nfoo.map\nstruct foo.A[] storage\nimplicit"]
 	variable [label="variable: \nuint256\nimplicit"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/ewasm/public_mapping.sol:1:1-14"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/ewasm/public_mapping.sol:1:1-14"]
 	diagnostic_15 [label="mapping in a struct variable cannot be public\nlevel Error\ntests/contract_testcases/ewasm/public_mapping.sol:6:5-19"]
 	structs -> A
 	contracts -> contract

tests/contract_testcases/ewasm/rubixi.dot

@@ -382,10 +382,10 @@ strict digraph "tests/contract_testcases/ewasm/rubixi.sol" {
 	storage_var_382 [label="storage variable\nRubixi.participants\nstruct Rubixi.Participant[] storage\ntests/contract_testcases/ewasm/rubixi.sol:153:35-47"]
 	variable_383 [label="variable: orderInPyramid\nuint256\ntests/contract_testcases/ewasm/rubixi.sol:153:48-62"]
 	number_literal_384 [label="uint256 literal: 1000000000000000000\ntests/contract_testcases/ewasm/rubixi.sol:153:73-80"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/ewasm/rubixi.sol:2:2-25"]
-	diagnostic_387 [label="found contract ‘Rubixi’\nlevel Debug\ntests/contract_testcases/ewasm/rubixi.sol:4:2-18"]
-	diagnostic_388 [label="local variable ‘payoutToSend‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/ewasm/rubixi.sol:67:31-43"]
-	diagnostic_389 [label="return variable ‘Address‘ has never been assigned\nlevel Warning\ntests/contract_testcases/ewasm/rubixi.sol:150:87-94"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/ewasm/rubixi.sol:2:2-25"]
+	diagnostic_387 [label="found contract 'Rubixi'\nlevel Debug\ntests/contract_testcases/ewasm/rubixi.sol:4:2-18"]
+	diagnostic_388 [label="local variable 'payoutToSend' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/ewasm/rubixi.sol:67:31-43"]
+	diagnostic_389 [label="return variable 'Address' has never been assigned\nlevel Warning\ntests/contract_testcases/ewasm/rubixi.sol:150:87-94"]
 	structs -> Participant
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/ewasm/standalone_call.dot

@@ -138,8 +138,8 @@ strict digraph "tests/contract_testcases/ewasm/standalone_call.sol" {
 	number_literal_138 [label="int256 literal: 2\ntests/contract_testcases/ewasm/standalone_call.sol:54:22-23"]
 	return_139 [label="return\ntests/contract_testcases/ewasm/standalone_call.sol:56:9-17"]
 	variable_140 [label="variable: b\nint256\ntests/contract_testcases/ewasm/standalone_call.sol:56:16-17"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/ewasm/standalone_call.sol:1:1-14"]
-	diagnostic_143 [label="found contract ‘BABYLINK’\nlevel Debug\ntests/contract_testcases/ewasm/standalone_call.sol:6:1-7:19"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/ewasm/standalone_call.sol:1:1-14"]
+	diagnostic_143 [label="found contract 'BABYLINK'\nlevel Debug\ntests/contract_testcases/ewasm/standalone_call.sol:6:1-7:19"]
 	structs -> tts
 	contracts -> contract
 	contract -> bar [label="function"]

tests/contract_testcases/solana/accessor/constant.dot

@@ -5,7 +5,7 @@ strict digraph "tests/contract_testcases/solana/accessor/constant.sol" {
 	returns [label="returns\nbytes32 "]
 	return [label="return\nimplicit"]
 	constant [label="constant variable\nx.z\nbytes32\nimplicit"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/accessor/constant.sol:2:9-20"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/accessor/constant.sol:2:9-20"]
 	diagnostic_10 [label="cannot call function in constant expression\nlevel Error\ntests/contract_testcases/solana/accessor/constant.sol:3:41-53"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/accessor/constant_01.dot

@@ -6,8 +6,8 @@ strict digraph "tests/contract_testcases/solana/accessor/constant_01.sol" {
 	returns [label="returns\nbytes32 "]
 	return [label="return\nimplicit"]
 	constant [label="constant variable\nx.z\nbytes32\nimplicit"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/accessor/constant_01.sol:2:9-20"]
-	diagnostic_11 [label="cannot read contract variable ‘foo’ in constant expression\nlevel Error\ntests/contract_testcases/solana/accessor/constant_01.sol:4:51-54"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/accessor/constant_01.sol:2:9-20"]
+	diagnostic_11 [label="cannot read contract variable 'foo' in constant expression\nlevel Error\ntests/contract_testcases/solana/accessor/constant_01.sol:4:51-54"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	contract -> var_4 [label="variable"]

tests/contract_testcases/solana/account_info.dot

@@ -5,13 +5,13 @@ strict digraph "tests/contract_testcases/solana/account_info.sol" {
 	notpub [label="function notpub\ncontract: c\ntests/contract_testcases/solana/account_info.sol:16:2-60\nsignature notpub((bytes32,uint64,bytes,bytes32,uint64,bool,bool,bool))\nvisibility private\nmutability nonpayable"]
 	parameters [label="parameters\nstruct AccountInfo "]
 	returns [label="returns\nstruct AccountInfo "]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/account_info.sol:1:1-12"]
-	diagnostic_10 [label="variable cannot be of builtin type ‘struct AccountInfo’\nlevel Error\ntests/contract_testcases/solana/account_info.sol:2:2-13"]
-	diagnostic_11 [label="parameter of type ‘struct AccountInfo’ not alowed in public or external functions\nlevel Error\ntests/contract_testcases/solana/account_info.sol:4:15-26"]
-	diagnostic_12 [label="return type ‘struct AccountInfo’ not allowed in public or external functions\nlevel Error\ntests/contract_testcases/solana/account_info.sol:4:44-55"]
-	diagnostic_13 [label="builtin struct ‘AccountInfo’ cannot be created using struct literal\nlevel Error\ntests/contract_testcases/solana/account_info.sol:8:8-36"]
-	diagnostic_14 [label="builtin struct ‘AccountInfo’ cannot be created using struct literal\nlevel Error\ntests/contract_testcases/solana/account_info.sol:13:8-22"]
-	diagnostic_15 [label="struct ‘AccountInfo’ field ‘key’ is readonly\nlevel Error\ntests/contract_testcases/solana/account_info.sol:18:6-9"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/account_info.sol:1:1-12"]
+	diagnostic_10 [label="variable cannot be of builtin type 'struct AccountInfo'\nlevel Error\ntests/contract_testcases/solana/account_info.sol:2:2-13"]
+	diagnostic_11 [label="parameter of type 'struct AccountInfo' not alowed in public or external functions\nlevel Error\ntests/contract_testcases/solana/account_info.sol:4:15-26"]
+	diagnostic_12 [label="return type 'struct AccountInfo' not allowed in public or external functions\nlevel Error\ntests/contract_testcases/solana/account_info.sol:4:44-55"]
+	diagnostic_13 [label="builtin struct 'AccountInfo' cannot be created using struct literal\nlevel Error\ntests/contract_testcases/solana/account_info.sol:8:8-36"]
+	diagnostic_14 [label="builtin struct 'AccountInfo' cannot be created using struct literal\nlevel Error\ntests/contract_testcases/solana/account_info.sol:13:8-22"]
+	diagnostic_15 [label="struct 'AccountInfo' field 'key' is readonly\nlevel Error\ntests/contract_testcases/solana/account_info.sol:18:6-9"]
 	contracts -> contract
 	contract -> f [label="function"]
 	contract -> f2 [label="function"]

tests/contract_testcases/solana/account_meta.dot

@@ -46,9 +46,9 @@ strict digraph "tests/contract_testcases/solana/account_meta.sol" {
 	subscript_46 [label="subscript struct AccountMeta[2]\ntests/contract_testcases/solana/account_meta.sol:13:32-39"]
 	variable_47 [label="variable: meta\nstruct AccountMeta[2]\ntests/contract_testcases/solana/account_meta.sol:13:32-36"]
 	number_literal_48 [label="uint32 literal: 0\ntests/contract_testcases/solana/account_meta.sol:13:37-38"]
-	diagnostic [label="found contract ‘spl’\nlevel Debug\ntests/contract_testcases/solana/account_meta.sol:1:1-14"]
-	diagnostic_51 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/account_meta.sol:2:2-47"]
-	diagnostic_52 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/account_meta.sol:7:2-56"]
+	diagnostic [label="found contract 'spl'\nlevel Debug\ntests/contract_testcases/solana/account_meta.sol:1:1-14"]
+	diagnostic_51 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/account_meta.sol:2:2-47"]
+	diagnostic_52 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/account_meta.sol:7:2-56"]
 	contracts -> contract
 	contract -> foo [label="function"]
 	foo -> returns [label="returns"]

tests/contract_testcases/solana/address_cast.dot

@@ -1,7 +1,7 @@
 strict digraph "tests/contract_testcases/solana/address_cast.sol" {
 	contract [label="contract c\ntests/contract_testcases/solana/address_cast.sol:1:1-12"]
 	foo [label="function foo\ncontract: c\ntests/contract_testcases/solana/address_cast.sol:2:2-23\nsignature foo()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/address_cast.sol:1:1-12"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/address_cast.sol:1:1-12"]
 	diagnostic_6 [label="expression is not assignable\nlevel Error\ntests/contract_testcases/solana/address_cast.sol:6:3-13"]
 	contracts -> contract
 	contract -> foo [label="function"]

tests/contract_testcases/solana/address_member_call.dot

@@ -80,8 +80,8 @@ strict digraph "tests/contract_testcases/solana/address_member_call.sol" {
 	variable_81 [label="variable: _receivers\naddress[]\ntests/contract_testcases/solana/address_member_call.sol:40:13-23"]
 	variable_82 [label="variable: _amounts\nuint64[]\ntests/contract_testcases/solana/address_member_call.sol:41:13-21"]
 	variable_83 [label="variable: _payment\nstring\ntests/contract_testcases/solana/address_member_call.sol:42:13-21"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/address_member_call.sol:1:32-2:24"]
-	diagnostic_86 [label="found contract ‘MyContract’\nlevel Debug\ntests/contract_testcases/solana/address_member_call.sol:3:1-4:21"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/address_member_call.sol:1:32-2:24"]
+	diagnostic_86 [label="found contract 'MyContract'\nlevel Debug\ntests/contract_testcases/solana/address_member_call.sol:3:1-4:21"]
 	events -> Receipt
 	contracts -> contract
 	contract -> send [label="function"]

tests/contract_testcases/solana/asm_reserved_words.dot

@@ -6,7 +6,7 @@ strict digraph "tests/contract_testcases/solana/asm_reserved_words.sol" {
 	return [label="return\ntests/contract_testcases/solana/asm_reserved_words.sol:4:3-15"]
 	not [label="not\ntests/contract_testcases/solana/asm_reserved_words.sol:4:10-11"]
 	variable [label="variable: case\nbool\ntests/contract_testcases/solana/asm_reserved_words.sol:4:11-15"]
-	diagnostic [label="found contract ‘default’\nlevel Debug\ntests/contract_testcases/solana/asm_reserved_words.sol:1:1-2:18"]
+	diagnostic [label="found contract 'default'\nlevel Debug\ntests/contract_testcases/solana/asm_reserved_words.sol:1:1-2:18"]
 	contracts -> contract
 	contract -> switch [label="function"]
 	switch -> parameters [label="parameters"]

tests/contract_testcases/solana/assign_array_in_array.dot

@@ -40,15 +40,15 @@ strict digraph "tests/contract_testcases/solana/assign_array_in_array.sol" {
 	variable_40 [label="variable: iPj\nstruct C.Sdynamic\ntests/contract_testcases/solana/assign_array_in_array.sol:23:3-6"]
 	alloc_array_41 [label="alloc array uint256[]\ntests/contract_testcases/solana/assign_array_in_array.sol:23:12-28"]
 	number_literal_42 [label="uint32 literal: 4\ntests/contract_testcases/solana/assign_array_in_array.sol:23:26-27"]
-	diagnostic [label="found contract ‘C’\nlevel Debug\ntests/contract_testcases/solana/assign_array_in_array.sol:1:60-2:12"]
-	diagnostic_45 [label="local variable ‘iPj‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:4:24-27"]
-	diagnostic_46 [label="local variable ‘iPj‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:9:23-26"]
-	diagnostic_47 [label="local variable ‘iPj‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:17:10-13"]
-	diagnostic_48 [label="local variable ‘iPj‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:22:12-15"]
-	diagnostic_49 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:3:2-25"]
-	diagnostic_50 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:8:2-27"]
-	diagnostic_51 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:16:2-32"]
-	diagnostic_52 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:21:2-34"]
+	diagnostic [label="found contract 'C'\nlevel Debug\ntests/contract_testcases/solana/assign_array_in_array.sol:1:60-2:12"]
+	diagnostic_45 [label="local variable 'iPj' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:4:24-27"]
+	diagnostic_46 [label="local variable 'iPj' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:9:23-26"]
+	diagnostic_47 [label="local variable 'iPj' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:17:10-13"]
+	diagnostic_48 [label="local variable 'iPj' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:22:12-15"]
+	diagnostic_49 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:3:2-25"]
+	diagnostic_50 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:8:2-27"]
+	diagnostic_51 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:16:2-32"]
+	diagnostic_52 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/assign_array_in_array.sol:21:2-34"]
 	structs -> Sfixed
 	structs -> Sdynamic
 	contracts -> contract

tests/contract_testcases/solana/call/abi_encode_call.dot

@@ -5,11 +5,11 @@ strict digraph "tests/contract_testcases/solana/call/abi_encode_call.sol" {
 	contract_5 [label="contract other\ntests/contract_testcases/solana/call/abi_encode_call.sol:10:1-11:16"]
 	foo [label="function foo\ncontract: other\ntests/contract_testcases/solana/call/abi_encode_call.sol:12:5-42\nsignature foo(int256,int256)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\nint256 foo\nint256 bar"]
-	diagnostic [label="found contract ‘abi_encode_call’\nlevel Debug\ntests/contract_testcases/solana/call/abi_encode_call.sol:1:1-26"]
-	diagnostic_10 [label="found contract ‘other’\nlevel Debug\ntests/contract_testcases/solana/call/abi_encode_call.sol:10:1-11:16"]
+	diagnostic [label="found contract 'abi_encode_call'\nlevel Debug\ntests/contract_testcases/solana/call/abi_encode_call.sol:1:1-26"]
+	diagnostic_10 [label="found contract 'other'\nlevel Debug\ntests/contract_testcases/solana/call/abi_encode_call.sol:10:1-11:16"]
 	diagnostic_11 [label="function takes 2 arguments, 1 provided\nlevel Error\ntests/contract_testcases/solana/call/abi_encode_call.sol:3:20-48"]
 	diagnostic_12 [label="conversion from bool to int256 not possible\nlevel Error\ntests/contract_testcases/solana/call/abi_encode_call.sol:7:49-53"]
-	diagnostic_13 [label="declaration of ‘foo’ shadows function\nlevel Warning\ntests/contract_testcases/solana/call/abi_encode_call.sol:12:22-25"]
+	diagnostic_13 [label="declaration of 'foo' shadows function\nlevel Warning\ntests/contract_testcases/solana/call/abi_encode_call.sol:12:22-25"]
 	note [label="previous declaration of function\ntests/contract_testcases/solana/call/abi_encode_call.sol:12:14-17"]
 	contracts -> contract
 	contract -> test1 [label="function"]

tests/contract_testcases/solana/call/calltys.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/call/calltys.sol" {
 	contract [label="contract main\ntests/contract_testcases/solana/call/calltys.sol:2:9-23"]
 	test [label="function test\ncontract: main\ntests/contract_testcases/solana/call/calltys.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘main’\nlevel Debug\ntests/contract_testcases/solana/call/calltys.sol:2:9-23"]
-	diagnostic_6 [label="method ‘staticcall’ does not exist\nlevel Error\ntests/contract_testcases/solana/call/calltys.sol:6:19-29"]
+	diagnostic [label="found contract 'main'\nlevel Debug\ntests/contract_testcases/solana/call/calltys.sol:2:9-23"]
+	diagnostic_6 [label="method 'staticcall' does not exist\nlevel Error\ntests/contract_testcases/solana/call/calltys.sol:6:19-29"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/call/calltys_01.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/call/calltys_01.sol" {
 	contract [label="contract main\ntests/contract_testcases/solana/call/calltys_01.sol:2:9-23"]
 	test [label="function test\ncontract: main\ntests/contract_testcases/solana/call/calltys_01.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘main’\nlevel Debug\ntests/contract_testcases/solana/call/calltys_01.sol:2:9-23"]
-	diagnostic_6 [label="method ‘delegatecall’ does not exist\nlevel Error\ntests/contract_testcases/solana/call/calltys_01.sol:6:19-31"]
+	diagnostic [label="found contract 'main'\nlevel Debug\ntests/contract_testcases/solana/call/calltys_01.sol:2:9-23"]
+	diagnostic_6 [label="method 'delegatecall' does not exist\nlevel Error\ntests/contract_testcases/solana/call/calltys_01.sol:6:19-31"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/call/calltys_02.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/call/calltys_02.sol" {
 	contract [label="contract main\ntests/contract_testcases/solana/call/calltys_02.sol:2:9-23"]
 	test [label="function test\ncontract: main\ntests/contract_testcases/solana/call/calltys_02.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘main’\nlevel Debug\ntests/contract_testcases/solana/call/calltys_02.sol:2:9-23"]
-	diagnostic_6 [label="‘gas’ not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/call/calltys_02.sol:6:51-57"]
+	diagnostic [label="found contract 'main'\nlevel Debug\ntests/contract_testcases/solana/call/calltys_02.sol:2:9-23"]
+	diagnostic_6 [label="'gas' not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/call/calltys_02.sol:6:51-57"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/comment.dot

@@ -1,7 +1,7 @@
 strict digraph "tests/contract_testcases/solana/comment.sol" {
 	contract [label="contract Hello\ntests/contract_testcases/solana/comment.sol:1:24-2:16"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/comment.sol:1:1-23"]
-	diagnostic_6 [label="found contract ‘Hello’\nlevel Debug\ntests/contract_testcases/solana/comment.sol:1:24-2:16"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/comment.sol:1:1-23"]
+	diagnostic_6 [label="found contract 'Hello'\nlevel Debug\ntests/contract_testcases/solana/comment.sol:1:24-2:16"]
 	contracts -> contract
 	diagnostics -> diagnostic [label="Debug"]
 	diagnostics -> diagnostic_6 [label="Debug"]

tests/contract_testcases/solana/constant/not_constant.dot

@@ -9,9 +9,9 @@ strict digraph "tests/contract_testcases/solana/constant/not_constant.sol" {
 	contract_9 [label="contract foo\ntests/contract_testcases/solana/constant/not_constant.sol:6:9-22"]
 	f [label="function f\ncontract: foo\ntests/contract_testcases/solana/constant/not_constant.sol:7:13-47\nsignature f()\nvisibility public\nmutability nonpayable"]
 	returns_11 [label="returns\nuint256 "]
-	diagnostic [label="found contract ‘C’\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant.sol:2:9-20"]
-	diagnostic_14 [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant.sol:6:9-22"]
-	diagnostic_15 [label="`C' is a contract\nlevel Error\ntests/contract_testcases/solana/constant/not_constant.sol:8:26-27"]
+	diagnostic [label="found contract 'C'\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant.sol:2:9-20"]
+	diagnostic_14 [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant.sol:6:9-22"]
+	diagnostic_15 [label="'C' is a contract\nlevel Error\ntests/contract_testcases/solana/constant/not_constant.sol:8:26-27"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	var -> number_literal [label="initializer"]

tests/contract_testcases/solana/constant/not_constant_01.dot

@@ -10,9 +10,9 @@ strict digraph "tests/contract_testcases/solana/constant/not_constant_01.sol" {
 	contract_10 [label="contract foo\ntests/contract_testcases/solana/constant/not_constant_01.sol:6:9-22"]
 	f [label="function f\ncontract: foo\ntests/contract_testcases/solana/constant/not_constant_01.sol:7:13-47\nsignature f()\nvisibility public\nmutability nonpayable"]
 	returns_12 [label="returns\nuint256 "]
-	diagnostic [label="found contract ‘C’\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant_01.sol:2:9-20"]
-	diagnostic_15 [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant_01.sol:6:9-22"]
-	diagnostic_16 [label="need instance of contract ‘C’ to get variable value ‘NOT_CONSTANT’\nlevel Error\ntests/contract_testcases/solana/constant/not_constant_01.sol:8:26-40"]
+	diagnostic [label="found contract 'C'\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant_01.sol:2:9-20"]
+	diagnostic_15 [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/constant/not_constant_01.sol:6:9-22"]
+	diagnostic_16 [label="need instance of contract 'C' to get variable value 'NOT_CONSTANT'\nlevel Error\ntests/contract_testcases/solana/constant/not_constant_01.sol:8:26-40"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	var -> number_literal [label="initializer"]

tests/contract_testcases/solana/contract_var_base_function_init.dot

@@ -16,10 +16,10 @@ strict digraph "tests/contract_testcases/solana/contract_var_base_function_init.
 	var_16 [label="variable sgPtr\nvisibility internal\ntests/contract_testcases/solana/contract_var_base_function_init.sol:9:5-62"]
 	cast_17 [label="cast function(int256) internal pure returns (int256)\ntests/contract_testcases/solana/contract_var_base_function_init.sol:9:55-62"]
 	internal_function [label="function(int256) internal pure returns (int256)\nb.testPtr\ntests/contract_testcases/solana/contract_var_base_function_init.sol:9:55-62"]
-	diagnostic [label="found contract ‘b’\nlevel Debug\ntests/contract_testcases/solana/contract_var_base_function_init.sol:1:1-12"]
-	diagnostic_21 [label="found contract ‘testing’\nlevel Debug\ntests/contract_testcases/solana/contract_var_base_function_init.sol:6:1-7:22"]
-	diagnostic_22 [label="storage variable ‘sfPtr‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/contract_var_base_function_init.sol:8:5-67"]
-	diagnostic_23 [label="storage variable ‘sgPtr‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/contract_var_base_function_init.sol:9:5-62"]
+	diagnostic [label="found contract 'b'\nlevel Debug\ntests/contract_testcases/solana/contract_var_base_function_init.sol:1:1-12"]
+	diagnostic_21 [label="found contract 'testing'\nlevel Debug\ntests/contract_testcases/solana/contract_var_base_function_init.sol:6:1-7:22"]
+	diagnostic_22 [label="storage variable 'sfPtr' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/contract_var_base_function_init.sol:8:5-67"]
+	diagnostic_23 [label="storage variable 'sgPtr' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/contract_var_base_function_init.sol:9:5-62"]
 	contracts -> contract
 	contract -> testPtr [label="function"]
 	testPtr -> parameters [label="parameters"]

tests/contract_testcases/solana/create_contract/base_contract.dot

@@ -4,8 +4,8 @@ strict digraph "tests/contract_testcases/solana/create_contract/base_contract.so
 	contract [label="contract Math\ntests/contract_testcases/solana/create_contract/base_contract.sol:2:9-23"]
 	contract_7 [label="contract IsMath\ntests/contract_testcases/solana/create_contract/base_contract.sol:8:9-32"]
 	base [label="base Math\ntests/contract_testcases/solana/create_contract/base_contract.sol:8:28-32"]
-	diagnostic [label="found contract ‘Math’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract.sol:2:9-23"]
-	diagnostic_11 [label="found contract ‘IsMath’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract.sol:8:9-32"]
+	diagnostic [label="found contract 'Math'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract.sol:2:9-23"]
+	diagnostic_11 [label="found contract 'IsMath'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract.sol:8:9-32"]
 	enums -> MathError
 	structs -> WithMath
 	contracts -> contract

tests/contract_testcases/solana/create_contract/base_contract_01.dot

@@ -7,9 +7,9 @@ strict digraph "tests/contract_testcases/solana/create_contract/base_contract_01
 	base [label="base Logic\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:7:26-31"]
 	contract_10 [label="contract IsMath\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:13:9-32"]
 	base_11 [label="base Math\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:13:28-32"]
-	diagnostic [label="found contract ‘Logic’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:2:9-24"]
-	diagnostic_14 [label="found contract ‘Math’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:7:9-31"]
-	diagnostic_15 [label="found contract ‘IsMath’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:13:9-32"]
+	diagnostic [label="found contract 'Logic'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:2:9-24"]
+	diagnostic_14 [label="found contract 'Math'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:7:9-31"]
+	diagnostic_15 [label="found contract 'IsMath'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_01.sol:13:9-32"]
 	enums -> LogicError
 	enums -> MathError
 	structs -> WithMath

tests/contract_testcases/solana/create_contract/base_contract_02.dot

@@ -6,9 +6,9 @@ strict digraph "tests/contract_testcases/solana/create_contract/base_contract_02
 	base [label="base Logic\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:7:26-31"]
 	contract_8 [label="contract IsMath\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:10:9-32"]
 	base_9 [label="base Math\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:10:28-32"]
-	diagnostic [label="found contract ‘Logic’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:2:9-24"]
-	diagnostic_12 [label="found contract ‘Math’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:7:9-31"]
-	diagnostic_13 [label="found contract ‘IsMath’\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:10:9-32"]
+	diagnostic [label="found contract 'Logic'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:2:9-24"]
+	diagnostic_12 [label="found contract 'Math'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:7:9-31"]
+	diagnostic_13 [label="found contract 'IsMath'\nlevel Debug\ntests/contract_testcases/solana/create_contract/base_contract_02.sol:10:9-32"]
 	structs -> LogicFields
 	structs -> WithMath
 	contracts -> contract

tests/contract_testcases/solana/create_contract/syntax.dot

@@ -2,9 +2,9 @@ strict digraph "tests/contract_testcases/solana/create_contract/syntax.sol" {
 	contract [label="contract y\ntests/contract_testcases/solana/create_contract/syntax.sol:2:9-20"]
 	f [label="function f\ncontract: y\ntests/contract_testcases/solana/create_contract/syntax.sol:3:13-32\nsignature f()\nvisibility public\nmutability nonpayable"]
 	contract_4 [label="contract x\ntests/contract_testcases/solana/create_contract/syntax.sol:7:9-20"]
-	diagnostic [label="found contract ‘y’\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax.sol:2:9-20"]
-	diagnostic_7 [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax.sol:7:9-20"]
-	diagnostic_8 [label="‘gas’ not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/create_contract/syntax.sol:4:29-37"]
+	diagnostic [label="found contract 'y'\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax.sol:2:9-20"]
+	diagnostic_7 [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax.sol:7:9-20"]
+	diagnostic_8 [label="'gas' not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/create_contract/syntax.sol:4:29-37"]
 	contracts -> contract
 	contract -> f [label="function"]
 	contracts -> contract_4

tests/contract_testcases/solana/create_contract/syntax_01.dot

@@ -2,9 +2,9 @@ strict digraph "tests/contract_testcases/solana/create_contract/syntax_01.sol" {
 	contract [label="contract y\ntests/contract_testcases/solana/create_contract/syntax_01.sol:2:9-20"]
 	f [label="function f\ncontract: y\ntests/contract_testcases/solana/create_contract/syntax_01.sol:3:13-32\nsignature f()\nvisibility public\nmutability nonpayable"]
 	contract_4 [label="contract x\ntests/contract_testcases/solana/create_contract/syntax_01.sol:7:9-20"]
-	diagnostic [label="found contract ‘y’\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax_01.sol:2:9-20"]
-	diagnostic_7 [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax_01.sol:7:9-20"]
-	diagnostic_8 [label="‘salt’ not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/create_contract/syntax_01.sol:4:29-38"]
+	diagnostic [label="found contract 'y'\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax_01.sol:2:9-20"]
+	diagnostic_7 [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/create_contract/syntax_01.sol:7:9-20"]
+	diagnostic_8 [label="'salt' not permitted for external calls or constructors on solana\nlevel Error\ntests/contract_testcases/solana/create_contract/syntax_01.sol:4:29-38"]
 	contracts -> contract
 	contract -> f [label="function"]
 	contracts -> contract_4

tests/contract_testcases/solana/destructure_assign_struct_member.dot

@@ -22,8 +22,8 @@ strict digraph "tests/contract_testcases/solana/destructure_assign_struct_member
 	add_22 [label="add\nuint176\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:13:48-49"]
 	variable_23 [label="variable: id\nuint176\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:13:46-48"]
 	number_literal_24 [label="uint176 literal: 2\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:13:49-50"]
-	diagnostic [label="found contract ‘TestContract’\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:1:57-2:23"]
-	diagnostic_27 [label="function parameter ‘needHash‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:12:39-47"]
+	diagnostic [label="found contract 'TestContract'\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:1:57-2:23"]
+	diagnostic_27 [label="function parameter 'needHash' has never been read\nlevel Warning\ntests/contract_testcases/solana/destructure_assign_struct_member.sol:12:39-47"]
 	structs -> Data
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/destructure_assign_struct_member_2.dot

@@ -26,10 +26,10 @@ strict digraph "tests/contract_testcases/solana/destructure_assign_struct_member
 	subscript_26 [label="subscript address[]\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:21:58-68"]
 	variable_27 [label="variable: _tokens\naddress[]\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:21:58-65"]
 	number_literal_28 [label="uint32 literal: 0\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:21:66-67"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:1:57-2:23"]
-	diagnostic_31 [label="found interface ‘IUniswapV2Pair’\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:3:1-4:26"]
-	diagnostic_32 [label="found contract ‘Contract’\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:8:1-9:19"]
-	diagnostic_33 [label="local variable ‘struct_1‘ has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:19:26-34"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:1:57-2:23"]
+	diagnostic_31 [label="found interface 'IUniswapV2Pair'\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:3:1-4:26"]
+	diagnostic_32 [label="found contract 'Contract'\nlevel Debug\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:8:1-9:19"]
+	diagnostic_33 [label="local variable 'struct_1' has been assigned, but never read\nlevel Warning\ntests/contract_testcases/solana/destructure_assign_struct_member_2.sol:19:26-34"]
 	structs -> Struct1
 	contracts -> contract
 	contract -> getReserves [label="function"]

tests/contract_testcases/solana/doccomments_everywhere.dot

@@ -125,12 +125,12 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	variable_126 [label="variable: _newSharesToSell\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:26-42"]
 	sellShares [label="function sellShares\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:77:3-59\nsignature sellShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
 	parameters_128 [label="parameters\nuint256 shares_\nuint256 _id"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:1:1-24"]
-	diagnostic_131 [label="library ‘Counters’ not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:6:9-17"]
-	diagnostic_132 [label="found contract ‘Property’\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:4:107-5:19"]
-	diagnostic_133 [label="contract type ‘Counter’ not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:7:12-19"]
-	diagnostic_134 [label="contract ‘ERC1155’ not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:17:17-24"]
-	diagnostic_135 [label="`_tokenIds' is not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:28:29-38"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:1:1-24"]
+	diagnostic_131 [label="library 'Counters' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:6:9-17"]
+	diagnostic_132 [label="found contract 'Property'\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:4:107-5:19"]
+	diagnostic_133 [label="contract type 'Counter' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:7:12-19"]
+	diagnostic_134 [label="contract 'ERC1155' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:17:17-24"]
+	diagnostic_135 [label="'_tokenIds' is not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:28:29-38"]
 	diagnostic_136 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:53:7-50"]
 	diagnostic_137 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:86:7-38"]
 	events -> MintProperty

tests/contract_testcases/solana/error.dot

@@ -2,9 +2,9 @@ strict digraph "tests/contract_testcases/solana/error.sol" {
 	contract [label="contract error\ntests/contract_testcases/solana/error.sol:1:1-2:16"]
 	foo [label="function foo\ncontract: error\ntests/contract_testcases/solana/error.sol:5:2-30\nsignature foo(bytes32)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\ncontract error x"]
-	diagnostic [label="found contract ‘error’\nlevel Debug\ntests/contract_testcases/solana/error.sol:1:1-2:16"]
-	diagnostic_7 [label="function parameter ‘x‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/error.sol:5:21-22"]
-	diagnostic_8 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/error.sol:5:2-30"]
+	diagnostic [label="found contract 'error'\nlevel Debug\ntests/contract_testcases/solana/error.sol:1:1-2:16"]
+	diagnostic_7 [label="function parameter 'x' has never been read\nlevel Warning\ntests/contract_testcases/solana/error.sol:5:21-22"]
+	diagnostic_8 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/error.sol:5:2-30"]
 	contracts -> contract
 	contract -> foo [label="function"]
 	foo -> parameters [label="parameters"]

tests/contract_testcases/solana/event.dot

@@ -2,18 +2,18 @@ strict digraph "tests/contract_testcases/solana/event.sol" {
 	Foo [label="name:Foo\ntests/contract_testcases/solana/event.sol:3:7-10\nfield name:no ty:int256 indexed:no\nfield name:name ty:string indexed:no"]
 	contract [label="contract c\ntests/contract_testcases/solana/event.sol:4:1-5:12"]
 	foo [label="function foo\ncontract: c\ntests/contract_testcases/solana/event.sol:6:5-26\nsignature foo()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/event.sol:4:1-5:12"]
-	diagnostic_8 [label="`a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:7:18-19"]
-	diagnostic_9 [label="`b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:7:21-22"]
-	diagnostic_10 [label="`a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:8:24-25"]
-	diagnostic_11 [label="`b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:8:33-34"]
-	diagnostic_12 [label="duplicate argument with name ‘no’\nlevel Error\ntests/contract_testcases/solana/event.sol:8:36-38"]
-	diagnostic_13 [label="`c' is a contract\nlevel Error\ntests/contract_testcases/solana/event.sol:8:40-41"]
-	diagnostic_14 [label="event ‘Foo2’ not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:14-18"]
-	diagnostic_15 [label="`a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:25-26"]
-	diagnostic_16 [label="`b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:34-35"]
-	diagnostic_17 [label="duplicate argument with name ‘no’\nlevel Error\ntests/contract_testcases/solana/event.sol:9:37-39"]
-	diagnostic_18 [label="`c' is a contract\nlevel Error\ntests/contract_testcases/solana/event.sol:9:41-42"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/event.sol:4:1-5:12"]
+	diagnostic_8 [label="'a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:7:18-19"]
+	diagnostic_9 [label="'b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:7:21-22"]
+	diagnostic_10 [label="'a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:8:24-25"]
+	diagnostic_11 [label="'b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:8:33-34"]
+	diagnostic_12 [label="duplicate argument with name 'no'\nlevel Error\ntests/contract_testcases/solana/event.sol:8:36-38"]
+	diagnostic_13 [label="'c' is a contract\nlevel Error\ntests/contract_testcases/solana/event.sol:8:40-41"]
+	diagnostic_14 [label="event 'Foo2' not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:14-18"]
+	diagnostic_15 [label="'a' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:25-26"]
+	diagnostic_16 [label="'b' is not found\nlevel Error\ntests/contract_testcases/solana/event.sol:9:34-35"]
+	diagnostic_17 [label="duplicate argument with name 'no'\nlevel Error\ntests/contract_testcases/solana/event.sol:9:37-39"]
+	diagnostic_18 [label="'c' is a contract\nlevel Error\ntests/contract_testcases/solana/event.sol:9:41-42"]
 	events -> Foo
 	contracts -> contract
 	contract -> foo [label="function"]

tests/contract_testcases/solana/expressions/bytes32_0.dot

@@ -18,7 +18,7 @@ strict digraph "tests/contract_testcases/solana/expressions/bytes32_0.sol" {
 	assign_18 [label="assign\nbytes3\ntests/contract_testcases/solana/expressions/bytes32_0.sol:12:19-20"]
 	variable_19 [label="variable: r\nbytes3\ntests/contract_testcases/solana/expressions/bytes32_0.sol:12:17-18"]
 	number_literal_20 [label="bytes3 literal: 74291\ntests/contract_testcases/solana/expressions/bytes32_0.sol:12:21-37"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0.sol:2:9-20"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0.sol:2:9-20"]
 	contracts -> contract
 	contract -> b32 [label="function"]
 	b32 -> returns [label="returns"]

tests/contract_testcases/solana/expressions/bytes32_0_01.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/solana/expressions/bytes32_0_01.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:2:9-22"]
 	b32 [label="function b32\ncontract: foo\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:3:13-59\nsignature b32()\nvisibility public\nmutability pure"]
 	returns [label="returns\nbytes32 r"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:2:9-22"]
-	diagnostic_7 [label="number of 2 bytes cannot be converted to type ‘bytes32’\nlevel Error\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:4:21-36"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:2:9-22"]
+	diagnostic_7 [label="number of 2 bytes cannot be converted to type 'bytes32'\nlevel Error\ntests/contract_testcases/solana/expressions/bytes32_0_01.sol:4:21-36"]
 	contracts -> contract
 	contract -> b32 [label="function"]
 	b32 -> returns [label="returns"]

tests/contract_testcases/solana/expressions/bytes32_0_02.dot

@@ -37,8 +37,8 @@ strict digraph "tests/contract_testcases/solana/expressions/bytes32_0_02.sol" {
 	storage_var_37 [label="storage variable\nfoo.z3\nbytes3 storage\nimplicit"]
 	b32 [label="function b32\ncontract: foo\ntests/contract_testcases/solana/expressions/bytes32_0_02.sol:11:13-59\nsignature b32()\nvisibility public\nmutability pure"]
 	returns_39 [label="returns\nbytes32 r"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0_02.sol:2:9-22"]
-	diagnostic_42 [label="negative number cannot be converted to type ‘bytes32’\nlevel Error\ntests/contract_testcases/solana/expressions/bytes32_0_02.sol:12:21-32"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/bytes32_0_02.sol:2:9-22"]
+	diagnostic_42 [label="negative number cannot be converted to type 'bytes32'\nlevel Error\ntests/contract_testcases/solana/expressions/bytes32_0_02.sol:12:21-32"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	var -> number_literal [label="initializer"]

tests/contract_testcases/solana/expressions/const_in_type.dot

@@ -8,8 +8,8 @@ strict digraph "tests/contract_testcases/solana/expressions/const_in_type.sol" {
 	constant [label="constant variable\nx.Y\nuint256\nimplicit"]
 	node_9 [label="constructor \ncontract: x\ntests/contract_testcases/solana/expressions/const_in_type.sol:5:13-48\nsignature (bytes32[24])\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\nbytes32[24] foo"]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/expressions/const_in_type.sol:2:9-20"]
-	diagnostic_13 [label="function parameter ‘foo‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/expressions/const_in_type.sol:5:43-46"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/expressions/const_in_type.sol:2:9-20"]
+	diagnostic_13 [label="function parameter 'foo' has never been read\nlevel Warning\ntests/contract_testcases/solana/expressions/const_in_type.sol:5:43-46"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	var -> number_literal [label="initializer"]

tests/contract_testcases/solana/expressions/contract_compare.dot

@@ -12,11 +12,11 @@ strict digraph "tests/contract_testcases/solana/expressions/contract_compare.sol
 	returns_12 [label="returns\nbool "]
 	contract_13 [label="contract d\ntests/contract_testcases/solana/expressions/contract_compare.sol:12:1-13:12"]
 	contract_14 [label="contract e\ntests/contract_testcases/solana/expressions/contract_compare.sol:13:14-14:12"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:1:1-2:12"]
-	diagnostic_17 [label="found contract ‘d’\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:12:1-13:12"]
-	diagnostic_18 [label="found contract ‘e’\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:13:14-14:12"]
-	diagnostic_19 [label="function ‘cmp’ overrides function in same contract\nlevel Error\ntests/contract_testcases/solana/expressions/contract_compare.sol:7:2-53"]
-	note [label="previous definition of ‘cmp’\ntests/contract_testcases/solana/expressions/contract_compare.sol:3:2-53"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:1:1-2:12"]
+	diagnostic_17 [label="found contract 'd'\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:12:1-13:12"]
+	diagnostic_18 [label="found contract 'e'\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_compare.sol:13:14-14:12"]
+	diagnostic_19 [label="function 'cmp' overrides function in same contract\nlevel Error\ntests/contract_testcases/solana/expressions/contract_compare.sol:7:2-53"]
+	note [label="previous definition of 'cmp'\ntests/contract_testcases/solana/expressions/contract_compare.sol:3:2-53"]
 	diagnostic_21 [label="expression of type contract d not allowed\nlevel Error\ntests/contract_testcases/solana/expressions/contract_compare.sol:8:10-14"]
 	contracts -> contract
 	contract -> cmp [label="function"]

tests/contract_testcases/solana/expressions/contract_no_init.dot

@@ -26,8 +26,8 @@ strict digraph "tests/contract_testcases/solana/expressions/contract_no_init.sol
 	call_external_function [label="call external function\ntests/contract_testcases/solana/expressions/contract_no_init.sol:14:24-29"]
 	external_function [label="function() external view returns (int256)\nother.a\ntests/contract_testcases/solana/expressions/contract_no_init.sol:14:24-29"]
 	variable_28 [label="variable: o\ncontract other\ntests/contract_testcases/solana/expressions/contract_no_init.sol:14:24-25"]
-	diagnostic [label="found contract ‘other’\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_no_init.sol:2:9-24"]
-	diagnostic_31 [label="found contract ‘testing’\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_no_init.sol:6:9-26"]
+	diagnostic [label="found contract 'other'\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_no_init.sol:2:9-24"]
+	diagnostic_31 [label="found contract 'testing'\nlevel Debug\ntests/contract_testcases/solana/expressions/contract_no_init.sol:6:9-26"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	contract -> a [label="function"]

tests/contract_testcases/solana/expressions/interfaceid.dot

@@ -2,7 +2,7 @@ strict digraph "tests/contract_testcases/solana/expressions/interfaceid.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/interfaceid.sol:2:9-22"]
 	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/expressions/interfaceid.sol:3:13-51\nsignature get()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nbytes4 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/interfaceid.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/interfaceid.sol:2:9-22"]
 	diagnostic_7 [label="type(…).interfaceId is permitted on interface, not contract foo\nlevel Error\ntests/contract_testcases/solana/expressions/interfaceid.sol:4:24-45"]
 	contracts -> contract
 	contract -> get [label="function"]

tests/contract_testcases/solana/expressions/pushpop.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/expressions/pushpop.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/pushpop.sol:2:9-22"]
 	test [label="function test\ncontract: foo\ntests/contract_testcases/solana/expressions/pushpop.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/pushpop.sol:2:9-22"]
-	diagnostic_6 [label="‘push()’ not supported on ‘bytes’ on target solana\nlevel Error\ntests/contract_testcases/solana/expressions/pushpop.sol:6:19-23"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/pushpop.sol:2:9-22"]
+	diagnostic_6 [label="'push()' not supported on 'bytes' on target solana\nlevel Error\ntests/contract_testcases/solana/expressions/pushpop.sol:6:19-23"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/expressions/pushpop_01.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/expressions/pushpop_01.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/pushpop_01.sol:2:9-22"]
 	test [label="function test\ncontract: foo\ntests/contract_testcases/solana/expressions/pushpop_01.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/pushpop_01.sol:2:9-22"]
-	diagnostic_6 [label="‘pop()’ not supported on ‘bytes’ on target solana\nlevel Error\ntests/contract_testcases/solana/expressions/pushpop_01.sol:6:19-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/pushpop_01.sol:2:9-22"]
+	diagnostic_6 [label="'pop()' not supported on 'bytes' on target solana\nlevel Error\ntests/contract_testcases/solana/expressions/pushpop_01.sol:6:19-22"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/expressions/selector_in_free_function.dot

@@ -3,9 +3,9 @@ strict digraph "tests/contract_testcases/solana/expressions/selector_in_free_fun
 	X [label="function X\ncontract: I\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:3:13-39\nsignature X(bytes)\nvisibility external\nmutability nonpayable\nvirtual"]
 	parameters [label="parameters\nbytes "]
 	contract_5 [label="contract foo\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:10:9-22"]
-	diagnostic [label="found interface ‘I’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:2:9-21"]
-	diagnostic_8 [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:10:9-22"]
-	diagnostic_9 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:6:9-38"]
+	diagnostic [label="found interface 'I'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:2:9-21"]
+	diagnostic_8 [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:10:9-22"]
+	diagnostic_9 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function.sol:6:9-38"]
 	contracts -> contract
 	contract -> X [label="function"]
 	X -> parameters [label="parameters"]

tests/contract_testcases/solana/expressions/selector_in_free_function_01.dot

@@ -8,11 +8,11 @@ strict digraph "tests/contract_testcases/solana/expressions/selector_in_free_fun
 	return [label="return\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:8:17-36"]
 	builtins [label="builtin FunctionSelector\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:8:24-27"]
 	internal_function [label="function(bytes) internal returns (void)\nI.X\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:8:24-25"]
-	diagnostic [label="found interface ‘I’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:2:9-21"]
+	diagnostic [label="found interface 'I'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:2:9-21"]
 	diagnostic_13 [label="X is already defined as a contract name\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:3:22-23"]
 	note [label="location of previous definition\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:6:9-20"]
-	diagnostic_15 [label="found contract ‘X’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:6:9-20"]
-	diagnostic_16 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:7:13-49"]
+	diagnostic_15 [label="found contract 'X'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:6:9-20"]
+	diagnostic_16 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_01.sol:7:13-49"]
 	contracts -> contract
 	contract -> X [label="function"]
 	X -> parameters [label="parameters"]

tests/contract_testcases/solana/expressions/selector_in_free_function_02.dot

@@ -9,11 +9,11 @@ strict digraph "tests/contract_testcases/solana/expressions/selector_in_free_fun
 	builtins [label="builtin FunctionSelector\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:8:24-27"]
 	external_function [label="function() external\nI.X\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:8:26-27"]
 	variable [label="variable: t\ncontract I\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:8:24-25"]
-	diagnostic [label="found contract ‘I’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:2:9-20"]
-	diagnostic_14 [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:6:9-22"]
-	diagnostic_15 [label="function parameter ‘t‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:7:26-27"]
-	diagnostic_16 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:3:13-34"]
-	diagnostic_17 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:7:13-52"]
+	diagnostic [label="found contract 'I'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:2:9-20"]
+	diagnostic_14 [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:6:9-22"]
+	diagnostic_15 [label="function parameter 't' has never been read\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:7:26-27"]
+	diagnostic_16 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:3:13-34"]
+	diagnostic_17 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/expressions/selector_in_free_function_02.sol:7:13-52"]
 	contracts -> contract
 	contract -> X [label="function"]
 	contracts -> contract_4

tests/contract_testcases/solana/expressions/slice.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/solana/expressions/slice.sol" {
 	contract [label="contract slice\ntests/contract_testcases/solana/expressions/slice.sol:1:1-2:16"]
 	foo [label="function foo\ncontract: slice\ntests/contract_testcases/solana/expressions/slice.sol:3:5-35\nsignature foo(bytes)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\nbytes foo"]
-	diagnostic [label="found contract ‘slice’\nlevel Debug\ntests/contract_testcases/solana/expressions/slice.sol:1:1-2:16"]
-	diagnostic_7 [label="declaration of ‘foo’ shadows function\nlevel Warning\ntests/contract_testcases/solana/expressions/slice.sol:3:24-27"]
+	diagnostic [label="found contract 'slice'\nlevel Debug\ntests/contract_testcases/solana/expressions/slice.sol:1:1-2:16"]
+	diagnostic_7 [label="declaration of 'foo' shadows function\nlevel Warning\ntests/contract_testcases/solana/expressions/slice.sol:3:24-27"]
 	note [label="previous declaration of function\ntests/contract_testcases/solana/expressions/slice.sol:3:14-17"]
 	diagnostic_9 [label="slice not supported yet\nlevel Error\ntests/contract_testcases/solana/expressions/slice.sol:4:20-27"]
 	contracts -> contract

tests/contract_testcases/solana/expressions/tx.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/solana/expressions/tx.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/tx.sol:2:9-22"]
 	test [label="function test\ncontract: foo\ntests/contract_testcases/solana/expressions/tx.sol:3:13-58\nsignature test()\nvisibility public\nmutability pure"]
 	returns [label="returns\naddress "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/tx.sol:2:9-22"]
-	diagnostic_7 [label="builtin ‘tx.origin’ does not exist\nlevel Error\ntests/contract_testcases/solana/expressions/tx.sol:4:24-26"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/tx.sol:2:9-22"]
+	diagnostic_7 [label="builtin 'tx.origin' does not exist\nlevel Error\ntests/contract_testcases/solana/expressions/tx.sol:4:24-26"]
 	contracts -> contract
 	contract -> test [label="function"]
 	test -> returns [label="returns"]

tests/contract_testcases/solana/expressions/tx_01.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/solana/expressions/tx_01.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/expressions/tx_01.sol:2:9-22"]
 	test [label="function test\ncontract: foo\ntests/contract_testcases/solana/expressions/tx_01.sol:3:13-57\nsignature test()\nvisibility public\nmutability pure"]
 	returns [label="returns\nuint64 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/expressions/tx_01.sol:2:9-22"]
-	diagnostic_7 [label="builtin ‘tx.gasprice’ does not exist\nlevel Error\ntests/contract_testcases/solana/expressions/tx_01.sol:4:24-26"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/expressions/tx_01.sol:2:9-22"]
+	diagnostic_7 [label="builtin 'tx.gasprice' does not exist\nlevel Error\ntests/contract_testcases/solana/expressions/tx_01.sol:4:24-26"]
 	contracts -> contract
 	contract -> test [label="function"]
 	test -> returns [label="returns"]

tests/contract_testcases/solana/garbage_builtin_function_args.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/garbage_builtin_function_args.sol" {
 	contract [label="contract c\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:1:1-12"]
 	f [label="function f\ncontract: c\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:2:2-21\nsignature f()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:1:1-12"]
-	diagnostic_6 [label="`rubbish' is not found\nlevel Error\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:3:11-18"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:1:1-12"]
+	diagnostic_6 [label="'rubbish' is not found\nlevel Error\ntests/contract_testcases/solana/garbage_builtin_function_args.sol:3:11-18"]
 	contracts -> contract
 	contract -> f [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/hash/constants_hash_tests.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/hash/constants_hash_tests.sol" {
 	contract [label="contract tester\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:2:9-25"]
 	test [label="function test\ncontract: tester\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘tester’\nlevel Debug\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:2:9-25"]
-	diagnostic_6 [label="unknown function or type ‘blake2_256’\nlevel Error\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:4:32-42"]
+	diagnostic [label="found contract 'tester'\nlevel Debug\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:2:9-25"]
+	diagnostic_6 [label="unknown function or type 'blake2_256'\nlevel Error\ntests/contract_testcases/solana/hash/constants_hash_tests.sol:4:32-42"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/hash/constants_hash_tests_01.dot

@@ -1,8 +1,8 @@
 strict digraph "tests/contract_testcases/solana/hash/constants_hash_tests_01.sol" {
 	contract [label="contract tester\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:2:9-25"]
 	test [label="function test\ncontract: tester\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:3:13-35\nsignature test()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘tester’\nlevel Debug\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:2:9-25"]
-	diagnostic_6 [label="unknown function or type ‘blake2_128’\nlevel Error\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:4:32-42"]
+	diagnostic [label="found contract 'tester'\nlevel Debug\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:2:9-25"]
+	diagnostic_6 [label="unknown function or type 'blake2_128'\nlevel Error\ntests/contract_testcases/solana/hash/constants_hash_tests_01.sol:4:32-42"]
 	contracts -> contract
 	contract -> test [label="function"]
 	diagnostics -> diagnostic [label="Debug"]

tests/contract_testcases/solana/issues678.dot

@@ -155,8 +155,8 @@ strict digraph "tests/contract_testcases/solana/issues678.sol" {
 	builtins_156 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:53:42-63"]
 	cast_157 [label="cast address\ntests/contract_testcases/solana/issues678.sol:53:42-55"]
 	builtins_158 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:53:50-54"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:1:32-2:23"]
-	diagnostic_161 [label="found contract ‘Shares’\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:3:1-4:17"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:1:32-2:23"]
+	diagnostic_161 [label="found contract 'Shares'\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:3:1-4:17"]
 	structs -> Share
 	events -> Transfer
 	contracts -> contract

tests/contract_testcases/solana/now.dot

@@ -13,9 +13,9 @@ strict digraph "tests/contract_testcases/solana/now.sol" {
 	number_literal [label="int256 literal: 5\ntests/contract_testcases/solana/now.sol:13:13-14"]
 	return [label="return\ntests/contract_testcases/solana/now.sol:14:3-13"]
 	variable [label="variable: now\nint256\ntests/contract_testcases/solana/now.sol:14:10-13"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/now.sol:1:1-12"]
-	diagnostic_18 [label="`now' is not found\nlevel Error\ntests/contract_testcases/solana/now.sol:4:10-13"]
-	diagnostic_19 [label="unknown function or type ‘now’\nlevel Error\ntests/contract_testcases/solana/now.sol:7:3-6"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/now.sol:1:1-12"]
+	diagnostic_18 [label="'now' is not found\nlevel Error\ntests/contract_testcases/solana/now.sol:4:10-13"]
+	diagnostic_19 [label="unknown function or type 'now'\nlevel Error\ntests/contract_testcases/solana/now.sol:7:3-6"]
 	diagnostic_20 [label="'now' was an alias for 'block.timestamp' in older versions of the Solidity language. Please use 'block.timestamp' instead.\nlevel Error\ntests/contract_testcases/solana/now.sol:10:10-13"]
 	structs -> S
 	contracts -> contract

tests/contract_testcases/solana/power.dot

@@ -7,8 +7,8 @@ strict digraph "tests/contract_testcases/solana/power.sol" {
 	power_7 [label="power\nuint256\ntests/contract_testcases/solana/power.sol:5:16-18"]
 	number_literal_8 [label="uint256 literal: 2\ntests/contract_testcases/solana/power.sol:5:14-15"]
 	number_literal_9 [label="uint256 literal: 3\ntests/contract_testcases/solana/power.sol:5:19-20"]
-	diagnostic [label="pragma ‘solidity’ is ignored\nlevel Debug\ntests/contract_testcases/solana/power.sol:1:1-24"]
-	diagnostic_12 [label="found contract ‘AstExample’\nlevel Debug\ntests/contract_testcases/solana/power.sol:2:1-3:21"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/power.sol:1:1-24"]
+	diagnostic_12 [label="found contract 'AstExample'\nlevel Debug\ntests/contract_testcases/solana/power.sol:2:1-3:21"]
 	contracts -> contract
 	contract -> node_3 [label="constructor"]
 	node_3 -> expr [label="body"]

tests/contract_testcases/solana/rational/rational.dot

@@ -2,7 +2,7 @@ strict digraph "tests/contract_testcases/solana/rational/rational.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/rational/rational.sol:2:9-22"]
 	test [label="function test\ncontract: foo\ntests/contract_testcases/solana/rational/rational.sol:3:13-50\nsignature test()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nuint256 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/rational/rational.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/rational/rational.sol:2:9-22"]
 	diagnostic_7 [label="conversion to uint256 from rational not allowed\nlevel Error\ntests/contract_testcases/solana/rational/rational.sol:4:26-29"]
 	contracts -> contract
 	contract -> test [label="function"]

tests/contract_testcases/solana/returns/return_err.dot

@@ -3,7 +3,7 @@ strict digraph "tests/contract_testcases/solana/returns/return_err.sol" {
 	var [label="variable val\nvisibility private\ntests/contract_testcases/solana/returns/return_err.sol:3:13-33"]
 	number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/returns/return_err.sol:3:32-33"]
 	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/returns/return_err.sol:5:13-34\nsignature get()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/returns/return_err.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/returns/return_err.sol:2:9-22"]
 	diagnostic_8 [label="function has no return values\nlevel Error\ntests/contract_testcases/solana/returns/return_err.sol:6:17-27"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/returns/return_err_01.dot

@@ -4,7 +4,7 @@ strict digraph "tests/contract_testcases/solana/returns/return_err_01.sol" {
 	number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/returns/return_err_01.sol:3:32-33"]
 	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/returns/return_err_01.sol:5:13-55\nsignature get()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nuint256 \nuint256 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_01.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_01.sol:2:9-22"]
 	diagnostic_9 [label="incorrect number of return values, expected 2 but got 3\nlevel Error\ntests/contract_testcases/solana/returns/return_err_01.sol:6:17-39"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/returns/return_err_02.dot

@@ -14,7 +14,7 @@ strict digraph "tests/contract_testcases/solana/returns/return_err_02.sol" {
 	storage_var_14 [label="storage variable\nfoo.val\nuint256 storage\ntests/contract_testcases/solana/returns/return_err_02.sol:5:35-38"]
 	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/returns/return_err_02.sol:8:13-55\nsignature get()\nvisibility public\nmutability nonpayable"]
 	returns_16 [label="returns\nuint256 \nuint256 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_02.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_02.sol:2:9-22"]
 	diagnostic_19 [label="incorrect number of return values, expected 2 but got 3\nlevel Error\ntests/contract_testcases/solana/returns/return_err_02.sol:9:17-27"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/returns/return_err_03.dot

@@ -13,7 +13,7 @@ strict digraph "tests/contract_testcases/solana/returns/return_err_03.sol" {
 	storage_load_13 [label="storage load uint256\ntests/contract_testcases/solana/returns/return_err_03.sol:5:17-39"]
 	storage_var_14 [label="storage variable\nfoo.val\nuint256 storage\ntests/contract_testcases/solana/returns/return_err_03.sol:5:35-38"]
 	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/returns/return_err_03.sol:8:13-34\nsignature get()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_03.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_03.sol:2:9-22"]
 	diagnostic_18 [label="function has no return values\nlevel Error\ntests/contract_testcases/solana/returns/return_err_03.sol:9:17-27"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/solana/returns/return_err_04.dot

@@ -2,7 +2,7 @@ strict digraph "tests/contract_testcases/solana/returns/return_err_04.sol" {
 	contract [label="contract foo\ntests/contract_testcases/solana/returns/return_err_04.sol:2:9-22"]
 	f [label="function f\ncontract: foo\ntests/contract_testcases/solana/returns/return_err_04.sol:3:13-59\nsignature f()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nuint256 \nuint256 \nuint256 "]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_04.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/returns/return_err_04.sol:2:9-22"]
 	diagnostic_7 [label="incorrect number of return values, expected 3 but got 1\nlevel Error\ntests/contract_testcases/solana/returns/return_err_04.sol:5:17-31"]
 	contracts -> contract
 	contract -> f [label="function"]

tests/contract_testcases/solana/shift_struct_member.dot

@@ -24,7 +24,7 @@ strict digraph "tests/contract_testcases/solana/shift_struct_member.sol" {
 	variable_24 [label="variable: self\nstruct FixedPoint.uq144x112\ntests/contract_testcases/solana/shift_struct_member.sol:19:24-28"]
 	zero_ext_25 [label="zero extend uint256\ntests/contract_testcases/solana/shift_struct_member.sol:19:32-34"]
 	number_literal_26 [label="uint8 literal: 112\ntests/contract_testcases/solana/shift_struct_member.sol:19:35-38"]
-	diagnostic [label="found library ‘FixedPoint’\nlevel Debug\ntests/contract_testcases/solana/shift_struct_member.sol:1:71-2:20"]
+	diagnostic [label="found library 'FixedPoint'\nlevel Debug\ntests/contract_testcases/solana/shift_struct_member.sol:1:71-2:20"]
 	structs -> uq144x112
 	structs -> uq112x112
 	contracts -> contract

tests/contract_testcases/solana/tags.dot

@@ -34,10 +34,10 @@ strict digraph "tests/contract_testcases/solana/tags.sol" {
 	list_34 [label="list\ntests/contract_testcases/solana/tags.sol:30:54-67"]
 	number_literal_35 [label="int256 literal: 1\ntests/contract_testcases/solana/tags.sol:30:62-63"]
 	number_literal_36 [label="int256 literal: 2\ntests/contract_testcases/solana/tags.sol:30:65-66"]
-	diagnostic [label="found contract ‘C’\nlevel Debug\ntests/contract_testcases/solana/tags.sol:1:1-12"]
-	diagnostic_39 [label="tag ‘@return’ no matching return value ‘feh’\nlevel Error\ntests/contract_testcases/solana/tags.sol:21:15-18"]
-	diagnostic_40 [label="tag ‘@return’ no matching return value ‘foo’\nlevel Error\ntests/contract_testcases/solana/tags.sol:22:15-18"]
-	diagnostic_41 [label="tag ‘@return’ no matching return value ‘foo’\nlevel Error\ntests/contract_testcases/solana/tags.sol:28:15-18"]
+	diagnostic [label="found contract 'C'\nlevel Debug\ntests/contract_testcases/solana/tags.sol:1:1-12"]
+	diagnostic_39 [label="tag '@return' no matching return value 'feh'\nlevel Error\ntests/contract_testcases/solana/tags.sol:21:15-18"]
+	diagnostic_40 [label="tag '@return' no matching return value 'foo'\nlevel Error\ntests/contract_testcases/solana/tags.sol:22:15-18"]
+	diagnostic_41 [label="tag '@return' no matching return value 'foo'\nlevel Error\ntests/contract_testcases/solana/tags.sol:28:15-18"]
 	contracts -> contract
 	contract -> f1 [label="function"]
 	f1 -> tags [label="tags"]

tests/contract_testcases/solana/type_decl.dot

@@ -4,8 +4,8 @@ strict digraph "tests/contract_testcases/solana/type_decl.sol" {
 	contract [label="contract x\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
 	f [label="function f\ncontract: x\ntests/contract_testcases/solana/type_decl.sol:7:2-33\nsignature f(bytes32,bool)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\nusertype Addr \nusertype x.Binary "]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
-	diagnostic_10 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
+	diagnostic_10 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
 	types -> Addr
 	types -> Binary
 	contracts -> contract

tests/contract_testcases/solana/type_decl_broken_more.dot

@@ -4,10 +4,10 @@ strict digraph "tests/contract_testcases/solana/type_decl_broken_more.sol" {
 	contract [label="contract x\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
 	f [label="function f\ncontract: x\ntests/contract_testcases/solana/type_decl.sol:7:2-33\nsignature f(bytes32,bool)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\nusertype Addr \nusertype x.Binary "]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
-	diagnostic_10 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
-	diagnostic_11 [label="‘Addr’ is an user type\nlevel Error\ntests/contract_testcases/solana/type_decl_broken_more.sol:3:14-18"]
-	diagnostic_12 [label="declaration of ‘Addr’ shadows type\nlevel Warning\ntests/contract_testcases/solana/type_decl_broken_more.sol:5:18-22"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
+	diagnostic_10 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
+	diagnostic_11 [label="'Addr' is an user type\nlevel Error\ntests/contract_testcases/solana/type_decl_broken_more.sol:3:14-18"]
+	diagnostic_12 [label="declaration of 'Addr' shadows type\nlevel Warning\ntests/contract_testcases/solana/type_decl_broken_more.sol:5:18-22"]
 	note [label="previous declaration of type\ntests/contract_testcases/solana/type_decl.sol:2:6-10"]
 	types -> Addr
 	types -> Binary

tests/contract_testcases/solana/type_decl_broken_used_as_event.dot

@@ -2,8 +2,8 @@ strict digraph "tests/contract_testcases/solana/type_decl_broken_used_as_event.s
 	X [label="name:X ty:int256\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:1:1-14"]
 	contract [label="contract c\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:2:1-3:12"]
 	f [label="function f\ncontract: c\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:4:2-21\nsignature f()\nvisibility public\nmutability nonpayable"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:2:1-3:12"]
-	diagnostic_8 [label="`X' is an user type\nlevel Error\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:5:8-9"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:2:1-3:12"]
+	diagnostic_8 [label="'X' is an user type\nlevel Error\ntests/contract_testcases/solana/type_decl_broken_used_as_event.sol:5:8-9"]
 	types -> X
 	contracts -> contract
 	contract -> f [label="function"]

tests/contract_testcases/solana/type_decl_import.dot

@@ -19,9 +19,9 @@ strict digraph "tests/contract_testcases/solana/type_decl_import.sol" {
 	contract_20 [label="contract x\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
 	f_21 [label="function f\ncontract: x\ntests/contract_testcases/solana/type_decl.sol:7:2-33\nsignature f(bytes32,bool)\nvisibility public\nmutability nonpayable"]
 	parameters_22 [label="parameters\nusertype Addr \nusertype x.Binary "]
-	diagnostic [label="found contract ‘x’\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
-	diagnostic_25 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
-	diagnostic_26 [label="found contract ‘d’\nlevel Debug\ntests/contract_testcases/solana/type_decl_import.sol:2:1-3:12"]
+	diagnostic [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:3:1-4:12"]
+	diagnostic_25 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
+	diagnostic_26 [label="found contract 'd'\nlevel Debug\ntests/contract_testcases/solana/type_decl_import.sol:2:1-3:12"]
 	types -> Addr
 	types -> Binary
 	contracts -> contract

tests/contract_testcases/solana/yul/function_cal_cond.dot

@@ -8,26 +8,26 @@ strict digraph "tests/contract_testcases/solana/yul/function_cal_cond.sol" {
 	yul_function_return [label="return parameter uint256: c\ntests/contract_testcases/solana/yul/function_cal_cond.sol:5:43-44"]
 	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:21-35"]
 	yul_variable [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:21-22"]
-	yul_builtin_call [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:26-35"]
+	yul_builtin_call [label="yul builtin call 'add'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:26-35"]
 	yul_variable_12 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:30-31"]
 	yul_number_literal [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:33-34"]
 	if [label="yul if\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:21-9:22"]
-	yul_builtin_call_15 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:24-32"]
+	yul_builtin_call_15 [label="yul builtin call 'gt'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:24-32"]
 	yul_variable_16 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:27-28"]
 	yul_number_literal_17 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:30-31"]
 	assembly_block [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:21-9:22"]
 	leave [label="leave\ntests/contract_testcases/solana/yul/function_cal_cond.sol:8:25-30"]
 	yul_assignment_20 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:21-35"]
 	yul_variable_21 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:21-22"]
-	yul_builtin_call_22 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:26-35"]
+	yul_builtin_call_22 [label="yul builtin call 'add'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:26-35"]
 	yul_variable_23 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:30-31"]
 	yul_number_literal_24 [label="uint256 literal: 6\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:33-34"]
 	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:21-39"]
 	yul_variable_26 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:21-22"]
-	yul_function_call [label="yul function call ‘tryThat‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:26-33"]
+	yul_function_call [label="yul function call 'tryThat'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:26-33"]
 	yul_variable_28 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:34-35"]
 	yul_number_literal_29 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:37-38"]
-	yul_builtin_call_30 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:21-33"]
+	yul_builtin_call_30 [label="yul builtin call 'return'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:21-33"]
 	yul_variable_31 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:28-29"]
 	yul_number_literal_32 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:31-32"]
 	yul_function_definition_33 [label="function definition tryThat\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:17-30:18"]
@@ -36,11 +36,11 @@ strict digraph "tests/contract_testcases/solana/yul/function_cal_cond.sol" {
 	yul_function_return_36 [label="return parameter uint256: c\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:43-44"]
 	yul_assignment_37 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:21-35"]
 	yul_variable_38 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:21-22"]
-	yul_builtin_call_39 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:26-35"]
+	yul_builtin_call_39 [label="yul builtin call 'add'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:26-35"]
 	yul_variable_40 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:30-31"]
 	yul_number_literal_41 [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:33-34"]
 	if_42 [label="yul if\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:21-27:22"]
-	yul_builtin_call_43 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:24-32"]
+	yul_builtin_call_43 [label="yul builtin call 'gt'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:24-32"]
 	yul_variable_44 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:27-28"]
 	yul_number_literal_45 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:30-31"]
 	assembly_block_46 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:21-27:22"]
@@ -48,7 +48,7 @@ strict digraph "tests/contract_testcases/solana/yul/function_cal_cond.sol" {
 	yul_assignment_48 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:21-27"]
 	yul_variable_49 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:21-22"]
 	yul_number_literal_50 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:26-27"]
-	yul_builtin_call_51 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:21-33"]
+	yul_builtin_call_51 [label="yul builtin call 'return'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:21-33"]
 	yul_variable_52 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:28-29"]
 	yul_number_literal_53 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:31-32"]
 	yul_function_definition_54 [label="function definition foo\ntests/contract_testcases/solana/yul/function_cal_cond.sol:16:21-18:22"]
@@ -56,23 +56,23 @@ strict digraph "tests/contract_testcases/solana/yul/function_cal_cond.sol" {
 	yul_function_return_56 [label="return parameter uint256: e\ntests/contract_testcases/solana/yul/function_cal_cond.sol:16:40-41"]
 	yul_assignment_57 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:25-39"]
 	yul_variable_58 [label="yul variable: e\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:25-26"]
-	yul_builtin_call_59 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:30-39"]
+	yul_builtin_call_59 [label="yul builtin call 'shr'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:30-39"]
 	yul_variable_60 [label="yul variable: d\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:34-35"]
 	yul_number_literal_61 [label="uint256 literal: 3\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:37-38"]
 	assembly_block_62 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:4:13-32:14"]
 	assembly_block_63 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:15:17-21:18"]
-	yul_builtin_call_64 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:21-50"]
-	yul_function_call_65 [label="yul function call ‘tryThis‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:28-35"]
-	yul_function_call_66 [label="yul function call ‘foo‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:36-39"]
+	yul_builtin_call_64 [label="yul builtin call 'revert'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:21-50"]
+	yul_function_call_65 [label="yul function call 'tryThis'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:28-35"]
+	yul_function_call_66 [label="yul function call 'foo'\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:36-39"]
 	yul_number_literal_67 [label="uint256 literal: 3\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:40-41"]
 	yul_number_literal_68 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:44-45"]
 	yul_number_literal_69 [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:48-49"]
 	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:17-27"]
 	var_decl_item [label="yul variable declaration uint256 x\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:21-22"]
 	yul_number_literal_72 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:26-27"]
-	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/yul/function_cal_cond.sol:1:1-20"]
+	diagnostic [label="found contract 'testTypes'\nlevel Debug\ntests/contract_testcases/solana/yul/function_cal_cond.sol:1:1-20"]
 	diagnostic_75 [label="unreachable yul statement\nlevel Warning\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:17-27"]
-	diagnostic_76 [label="yul variable ‘x‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:21-22"]
+	diagnostic_76 [label="yul variable 'x' has never been read\nlevel Warning\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:21-22"]
 	diagnostic_77 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/function_cal_cond.sol:3:9-33:10"]
 	contracts -> contract
 	contract -> testAsm [label="function"]

tests/contract_testcases/solana/yul/parse.dot

@@ -5,16 +5,16 @@ strict digraph "tests/contract_testcases/solana/yul/parse.sol" {
 	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/parse.sol:4:17-7:18"]
 	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/yul/parse.sol:5:21-55"]
 	var_decl_item [label="yul variable declaration uint256 returndata_size\ntests/contract_testcases/solana/yul/parse.sol:5:25-40"]
-	yul_builtin_call [label="yul builtin call ‘mload‘\ntests/contract_testcases/solana/yul/parse.sol:5:44-55"]
+	yul_builtin_call [label="yul builtin call 'mload'\ntests/contract_testcases/solana/yul/parse.sol:5:44-55"]
 	yul_number_literal [label="uint256 literal: 64\ntests/contract_testcases/solana/yul/parse.sol:5:50-54"]
-	yul_builtin_call_10 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/yul/parse.sol:6:21-59"]
-	yul_builtin_call_11 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/parse.sol:6:28-41"]
+	yul_builtin_call_10 [label="yul builtin call 'revert'\ntests/contract_testcases/solana/yul/parse.sol:6:21-59"]
+	yul_builtin_call_11 [label="yul builtin call 'add'\ntests/contract_testcases/solana/yul/parse.sol:6:28-41"]
 	yul_number_literal_12 [label="uint256 literal: 32\ntests/contract_testcases/solana/yul/parse.sol:6:32-34"]
 	yul_number_literal_13 [label="uint256 literal: 64\ntests/contract_testcases/solana/yul/parse.sol:6:36-40"]
 	yul_variable [label="yul variable: returndata_size\nuint256\ntests/contract_testcases/solana/yul/parse.sol:6:43-58"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/yul/parse.sol:2:9-22"]
+	diagnostic [label="found contract 'foo'\nlevel Debug\ntests/contract_testcases/solana/yul/parse.sol:2:9-22"]
 	diagnostic_17 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/parse.sol:4:17-7:18"]
-	diagnostic_18 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/yul/parse.sol:3:13-51"]
+	diagnostic_18 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/yul/parse.sol:3:13-51"]
 	contracts -> contract
 	contract -> get [label="function"]
 	get -> returns [label="returns"]

tests/contract_testcases/solana/yul/return_in_asm.dot

@@ -2,10 +2,10 @@ strict digraph "tests/contract_testcases/solana/yul/return_in_asm.sol" {
 	contract [label="contract Contract\ntests/contract_testcases/solana/yul/return_in_asm.sol:1:1-19"]
 	node_3 [label="constructor \ncontract: Contract\ntests/contract_testcases/solana/yul/return_in_asm.sol:2:5-19\nsignature ()\nvisibility public\nmutability nonpayable"]
 	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/return_in_asm.sol:3:9-5:10"]
-	yul_builtin_call [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:13-25"]
+	yul_builtin_call [label="yul builtin call 'return'\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:13-25"]
 	yul_number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:20-21"]
 	yul_number_literal_7 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:23-24"]
-	diagnostic [label="found contract ‘Contract’\nlevel Debug\ntests/contract_testcases/solana/yul/return_in_asm.sol:1:1-19"]
+	diagnostic [label="found contract 'Contract'\nlevel Debug\ntests/contract_testcases/solana/yul/return_in_asm.sol:1:1-19"]
 	diagnostic_10 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/return_in_asm.sol:3:9-5:10"]
 	contracts -> contract
 	contract -> node_3 [label="constructor"]

tests/contract_testcases/solana/yul/yul_switch.dot

@@ -8,15 +8,15 @@ strict digraph "tests/contract_testcases/solana/yul/yul_switch.sol" {
 	number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/yul_switch.sol:4:21-22"]
 	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/yul_switch.sol:5:9-14:10"]
 	switch [label="yul switch\ntests/contract_testcases/solana/yul/yul_switch.sol:6:13-11:14"]
-	yul_member_access [label="yul member ‘length‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:6:20-29"]
+	yul_member_access [label="yul member 'length' access\ntests/contract_testcases/solana/yul/yul_switch.sol:6:20-29"]
 	solidity_variable [label="solidity variable: vl\nuint128[]\ntests/contract_testcases/solana/yul/yul_switch.sol:6:20-22"]
 	case [label="yul switch case\ntests/contract_testcases/solana/yul/yul_switch.sol:7:13-41"]
 	yul_number_literal [label="uint256 literal: 1\ntests/contract_testcases/solana/yul/yul_switch.sol:7:18-19"]
 	assembly_block [label="assembly block\ntests/contract_testcases/solana/yul/yul_switch.sol:7:13-41"]
 	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:7:21-40"]
 	solidity_variable_17 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:7:21-22"]
-	yul_builtin_call [label="yul builtin call ‘mul‘\ntests/contract_testcases/solana/yul/yul_switch.sol:7:26-40"]
-	yul_member_access_19 [label="yul member ‘slot‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:7:30-36"]
+	yul_builtin_call [label="yul builtin call 'mul'\ntests/contract_testcases/solana/yul/yul_switch.sol:7:26-40"]
+	yul_member_access_19 [label="yul member 'slot' access\ntests/contract_testcases/solana/yul/yul_switch.sol:7:30-36"]
 	storage_var [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:7:30-31"]
 	yul_number_literal_21 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/yul_switch.sol:7:38-39"]
 	case_22 [label="yul switch case\ntests/contract_testcases/solana/yul/yul_switch.sol:8:13-43"]
@@ -24,8 +24,8 @@ strict digraph "tests/contract_testcases/solana/yul/yul_switch.sol" {
 	assembly_block_24 [label="assembly block\ntests/contract_testcases/solana/yul/yul_switch.sol:8:13-43"]
 	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:8:21-42"]
 	solidity_variable_26 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:8:21-22"]
-	yul_builtin_call_27 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/yul/yul_switch.sol:8:26-42"]
-	yul_member_access_28 [label="yul member ‘offset‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:8:30-38"]
+	yul_builtin_call_27 [label="yul builtin call 'shr'\ntests/contract_testcases/solana/yul/yul_switch.sol:8:26-42"]
+	yul_member_access_28 [label="yul member 'offset' access\ntests/contract_testcases/solana/yul/yul_switch.sol:8:30-38"]
 	storage_var_29 [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:8:30-31"]
 	yul_number_literal_30 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/yul_switch.sol:8:40-41"]
 	default [label="yul switch default\ntests/contract_testcases/solana/yul/yul_switch.sol:9:13-11:14"]
@@ -35,12 +35,12 @@ strict digraph "tests/contract_testcases/solana/yul/yul_switch.sol" {
 	yul_number_literal_35 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/yul_switch.sol:10:22-23"]
 	yul_assignment_36 [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:13:13-27"]
 	solidity_variable_37 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:13:13-14"]
-	yul_builtin_call_38 [label="yul builtin call ‘sub‘\ntests/contract_testcases/solana/yul/yul_switch.sol:13:18-27"]
+	yul_builtin_call_38 [label="yul builtin call 'sub'\ntests/contract_testcases/solana/yul/yul_switch.sol:13:18-27"]
 	solidity_variable_39 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:13:22-23"]
 	yul_number_literal_40 [label="uint256 literal: 1\ntests/contract_testcases/solana/yul/yul_switch.sol:13:25-26"]
 	return [label="return\ntests/contract_testcases/solana/yul/yul_switch.sol:16:9-17"]
 	variable [label="variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:16:16-17"]
-	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/yul/yul_switch.sol:1:1-20"]
+	diagnostic [label="found contract 'testTypes'\nlevel Debug\ntests/contract_testcases/solana/yul/yul_switch.sol:1:1-20"]
 	diagnostic_45 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/yul_switch.sol:5:9-14:10"]
 	contracts -> contract
 	contract -> var [label="variable"]

tests/contract_testcases/substrate/account_info.dot

@@ -1,11 +1,11 @@
 strict digraph "tests/contract_testcases/substrate/account_info.sol" {
 	contract [label="contract c\ntests/contract_testcases/substrate/account_info.sol:1:1-12"]
-	diagnostic [label="found contract ‘c’\nlevel Debug\ntests/contract_testcases/substrate/account_info.sol:1:1-12"]
-	diagnostic_5 [label="type ‘AccountInfo’ not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:2:2-13"]
-	diagnostic_6 [label="type ‘AccountInfo’ not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:4:15-26"]
-	diagnostic_7 [label="type ‘AccountInfo’ not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:4:44-55"]
-	diagnostic_8 [label="type ‘AccountInfo’ not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:5:18-29"]
-	diagnostic_9 [label="type ‘AccountInfo’ not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:5:48-59"]
+	diagnostic [label="found contract 'c'\nlevel Debug\ntests/contract_testcases/substrate/account_info.sol:1:1-12"]
+	diagnostic_5 [label="type 'AccountInfo' not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:2:2-13"]
+	diagnostic_6 [label="type 'AccountInfo' not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:4:15-26"]
+	diagnostic_7 [label="type 'AccountInfo' not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:4:44-55"]
+	diagnostic_8 [label="type 'AccountInfo' not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:5:18-29"]
+	diagnostic_9 [label="type 'AccountInfo' not found\nlevel Error\ntests/contract_testcases/substrate/account_info.sol:5:48-59"]
 	contracts -> contract
 	diagnostics -> diagnostic [label="Debug"]
 	diagnostics -> diagnostic_5 [label="Error"]