Merge pull request #1033 from seanyoung/bump

Bump various dependencies and depend on rust 1.63.0

.github/Dockerfile

@@ -29,7 +29,7 @@ RUN apt-get clean
 RUN apt-get autoclean
 
 # Get Rust
-RUN curl https://sh.rustup.rs -sSf | bash -s -- -y --default-toolchain 1.59.0
+RUN curl https://sh.rustup.rs -sSf | bash -s -- -y --default-toolchain 1.63.0
 
 COPY --from=builder /llvm13.0 /llvm13.0/
 

.github/workflows/release.yml

@@ -36,7 +36,7 @@ jobs:
     - name: Add LLVM to Path
       run: echo "$(pwd)/llvm13.0/bin" >> $GITHUB_PATH
     - name: Rust stable
-      run: rustup default 1.59.0
+      run: rustup default 1.63.0
     - name: Build
       run: cargo build --verbose --release
     - name: Run tests
@@ -79,7 +79,7 @@ jobs:
     - name: Add LLVM to Path
       run: echo "$(pwd)/llvm13.0/bin" >> $GITHUB_PATH
     - name: Rust stable
-      run: rustup default 1.59.0
+      run: rustup default 1.63.0
     - name: Build
       run: cargo build --verbose --release
     - name: Run tests

.github/workflows/test.yml

@@ -60,7 +60,7 @@ jobs:
       with:
         submodules: recursive
     - name: Rust stable
-      run: rustup default 1.59.0
+      run: rustup default 1.63.0
     - name: Build
       run: cargo build --verbose
     - name: Run tests
@@ -83,7 +83,7 @@ jobs:
       with:
         submodules: recursive
     - name: Rust stable
-      run: rustup default 1.59.0
+      run: rustup default 1.63.0
     - name: Build
       run: cargo build --verbose
     - name: Run tests

Cargo.toml

@@ -8,7 +8,7 @@ license = "Apache-2.0"
 build = "build.rs"
 description = "Solang Solidity Compiler"
 keywords = [ "solidity", "compiler", "solana", "substrate" ]
-rust-version = "1.56.1"
+rust-version = "1.63.0"
 edition = "2021"
 
 [build-dependencies]
@@ -21,8 +21,8 @@ num-bigint = { version = "0.4", features = ["rand"]}
 num-traits = "0.2"
 num-integer = "0.1.44"
 parity-wasm = "0.45"
-clap = "3.2"
-clap_complete = "3.2"
+clap = "4.0"
+clap_complete = "4.0"
 hex = "0.4"
 tiny-keccak = { version = "2.0", features = ["keccak"] }
 serde_json = "1.0"
@@ -48,11 +48,11 @@ indexmap = "1.8"
 once_cell = "1.10"
 solang-parser = { path = "solang-parser", version = "0.1.18" }
 codespan-reporting = "0.11"
-phf = "0.10.1"
+phf = { version = "0.11", features = ["macros"] }
 rust-lapper = "1.0"
 bitflags = "1.3"
 anchor-syn = { version = "0.25", features = ["idl"] }
-convert_case = "0.5"
+convert_case = "0.6"
 
 [dev-dependencies]
 num-derive = "0.3"
@@ -63,7 +63,7 @@ wasmi = "0.11"
 rand_07 = { package = "rand", version = "0.7" }
 sha2 = "0.10"
 # solana_rbpf makes api changes in patch versions
-solana_rbpf = "=0.2.32"
+solana_rbpf = "=0.2.33"
 byteorder = "1.4"
 assert_cmd = "2.0"
 bincode = "1.3"

Dockerfile

@@ -12,7 +12,7 @@ COPY . src
 WORKDIR /src/stdlib/
 RUN make
 
-RUN rustup default 1.59.0
+RUN rustup default 1.63.0
 
 WORKDIR /src
 RUN cargo build --release

build.rs

@@ -7,7 +7,7 @@ fn main() {
     {
         // compile our linker
         let cxxflags = Command::new("llvm-config")
-            .args(&["--cxxflags"])
+            .args(["--cxxflags"])
             .output()
             .expect("could not execute llvm-config");
 
@@ -29,7 +29,7 @@ fn main() {
 
         // add the llvm linker
         let libdir = Command::new("llvm-config")
-            .args(&["--libdir"])
+            .args(["--libdir"])
             .output()
             .unwrap();
         let libdir = String::from_utf8(libdir.stdout).unwrap();
@@ -46,7 +46,7 @@ fn main() {
     }
 
     let output = Command::new("git")
-        .args(&["describe", "--tags"])
+        .args(["describe", "--tags"])
         .output()
         .unwrap();
     let solang_version = if output.stdout.is_empty() {

docs/installing.rst

@@ -84,7 +84,7 @@ Then you can build the image using:
 Option 5: Build Solang from source
 ----------------------------------
 
-In order to build Solang from source, you will need rust 1.59.0 or higher,
+In order to build Solang from source, you will need rust 1.63.0 or higher,
 and a build of LLVM based on the Solana LLVM tree. There are a few patches which are not upstream yet.
 First, follow the steps below for installing LLVM and then proceed from there.
 

src/abi/substrate.rs

@@ -453,11 +453,12 @@ fn gen_abi(contract_no: usize, ns: &ast::Namespace) -> Abi {
             let payable = matches!(f.mutability, ast::Mutability::Payable(_));
 
             Message {
-                name: conflicting_names
-                    .contains(&f.name)
-                    .then(|| &f.mangled_name)
-                    .unwrap_or(&f.name)
-                    .into(),
+                name: if conflicting_names.contains(&f.name) {
+                    &f.mangled_name
+                } else {
+                    &f.name
+                }
+                .into(),
                 mutates: matches!(
                     f.mutability,
                     ast::Mutability::Payable(_) | ast::Mutability::Nonpayable(_)

src/bin/languageserver/mod.rs

@@ -163,9 +163,8 @@ impl SolangServer {
             let res = self.client.publish_diagnostics(uri, diags, None);
 
             let mut lookup: Vec<HoverEntry> = Vec::new();
-            let mut fnc_map: HashMap<String, String> = HashMap::new();
 
-            SolangServer::traverse(&ns, &mut lookup, &mut fnc_map);
+            SolangServer::traverse(&ns, &mut lookup);
 
             self.files.lock().await.insert(
                 path,
@@ -212,18 +211,17 @@ impl SolangServer {
         stmt: &ast::Statement,
         lookup_tbl: &mut Vec<HoverEntry>,
         symtab: &symtable::Symtable,
-        fnc_map: &HashMap<String, String>,
         ns: &ast::Namespace,
     ) {
         match stmt {
             ast::Statement::Block { statements, .. } => {
                 for stmt in statements {
-                    SolangServer::construct_stmt(stmt, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(stmt, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::VariableDecl(loc, var_no, param, expr) => {
                 if let Some(exp) = expr {
-                    SolangServer::construct_expr(exp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(exp, lookup_tbl, symtab, ns);
                 }
                 let mut val = format!(
                     "{} {}",
@@ -234,7 +232,7 @@ impl SolangServer {
                     match expr {
                         codegen::Expression::BytesLiteral(_, ast::Type::Bytes(_), bs)
                         | codegen::Expression::BytesLiteral(_, ast::Type::DynamicBytes, bs) => {
-                            write!(val, " = hex\"{}\"", hex::encode(&bs)).unwrap();
+                            write!(val, " = hex\"{}\"", hex::encode(bs)).unwrap();
                         }
                         codegen::Expression::BytesLiteral(_, ast::Type::String, bs) => {
                             write!(val, " = \"{}\"", String::from_utf8_lossy(bs)).unwrap();
@@ -260,18 +258,18 @@ impl SolangServer {
                 });
             }
             ast::Statement::If(_locs, _, expr, stat1, stat2) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
                 for st1 in stat1 {
-                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, ns);
                 }
                 for st2 in stat2 {
-                    SolangServer::construct_stmt(st2, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(st2, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::While(_locs, _blval, expr, stat1) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
                 for st1 in stat1 {
-                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::For {
@@ -283,36 +281,36 @@ impl SolangServer {
                 body,
             } => {
                 if let Some(exp) = cond {
-                    SolangServer::construct_expr(exp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(exp, lookup_tbl, symtab, ns);
                 }
                 for stat in init {
-                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, ns);
                 }
                 for stat in next {
-                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, ns);
                 }
                 for stat in body {
-                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(stat, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::DoWhile(_locs, _blval, stat1, expr) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
                 for st1 in stat1 {
-                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(st1, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::Expression(_locs, _, expr) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
             }
             ast::Statement::Delete(_locs, _typ, expr) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
             }
             ast::Statement::Destructure(_locs, _vecdestrfield, expr) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
                 for vecstr in _vecdestrfield {
                     match vecstr {
                         ast::DestructureField::Expression(expr) => {
-                            SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                            SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
                         }
                         _ => continue,
                     }
@@ -322,7 +320,7 @@ impl SolangServer {
             ast::Statement::Break(_) => {}
             ast::Statement::Return(_, None) => {}
             ast::Statement::Return(_, Some(expr)) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
             }
             ast::Statement::Emit {
                 event_no,
@@ -363,20 +361,20 @@ impl SolangServer {
                 });
 
                 for arg in args {
-                    SolangServer::construct_expr(arg, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(arg, lookup_tbl, symtab, ns);
                 }
             }
             ast::Statement::TryCatch(_, _, try_stmt) => {
-                SolangServer::construct_expr(&try_stmt.expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(&try_stmt.expr, lookup_tbl, symtab, ns);
                 for vecstmt in &try_stmt.catch_stmt {
-                    SolangServer::construct_stmt(vecstmt, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(vecstmt, lookup_tbl, symtab, ns);
                 }
                 for vecstmt in &try_stmt.ok_stmt {
-                    SolangServer::construct_stmt(vecstmt, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_stmt(vecstmt, lookup_tbl, symtab, ns);
                 }
                 for okstmt in &try_stmt.errors {
                     for stmts in &okstmt.2 {
-                        SolangServer::construct_stmt(stmts, lookup_tbl, symtab, fnc_map, ns);
+                        SolangServer::construct_stmt(stmts, lookup_tbl, symtab, ns);
                     }
                 }
             }
@@ -393,7 +391,6 @@ impl SolangServer {
         expr: &ast::Expression,
         lookup_tbl: &mut Vec<HoverEntry>,
         symtab: &symtable::Symtable,
-        fnc_map: &HashMap<String, String>,
         ns: &ast::Namespace,
     ) {
         match expr {
@@ -431,17 +428,17 @@ impl SolangServer {
             }
             ast::Expression::StructLiteral(_locs, _typ, expr) => {
                 for expp in expr {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::ArrayLiteral(_locs, _, _arr, expr) => {
                 for expp in expr {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::ConstArrayLiteral(_locs, _, _arr, expr) => {
                 for expp in expr {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
             }
 
@@ -457,8 +454,8 @@ impl SolangServer {
                     ),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Subtract(locs, ty, unchecked, expr1, expr2) => {
                 lookup_tbl.push(HoverEntry {
@@ -471,8 +468,8 @@ impl SolangServer {
                     ),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Multiply(locs, ty, unchecked, expr1, expr2) => {
                 lookup_tbl.push(HoverEntry {
@@ -485,8 +482,8 @@ impl SolangServer {
                     ),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Divide(locs, ty, expr1, expr2) => {
                 lookup_tbl.push(HoverEntry {
@@ -495,8 +492,8 @@ impl SolangServer {
                     val: format!("{} divide", ty.to_string(ns)),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Modulo(locs, ty, expr1, expr2) => {
                 lookup_tbl.push(HoverEntry {
@@ -505,8 +502,8 @@ impl SolangServer {
                     val: format!("{} modulo", ty.to_string(ns)),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Power(locs, ty, unchecked, expr1, expr2) => {
                 lookup_tbl.push(HoverEntry {
@@ -519,30 +516,30 @@ impl SolangServer {
                     ),
                 });
 
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             // Bitwise expresion
             ast::Expression::BitwiseOr(_locs, _typ, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::BitwiseAnd(_locs, _typ, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::BitwiseXor(_locs, _typ, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::ShiftLeft(_locs, _typ, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::ShiftRight(_locs, _typ, expr1, expr2, _bl) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             // Variable expression
@@ -553,7 +550,7 @@ impl SolangServer {
                     match expr {
                         codegen::Expression::BytesLiteral(_, ast::Type::Bytes(_), bs)
                         | codegen::Expression::BytesLiteral(_, ast::Type::DynamicBytes, bs) => {
-                            write!(val, " hex\"{}\"", hex::encode(&bs)).unwrap();
+                            write!(val, " hex\"{}\"", hex::encode(bs)).unwrap();
                         }
                         codegen::Expression::BytesLiteral(_, ast::Type::String, bs) => {
                             write!(val, " \"{}\"", String::from_utf8_lossy(bs)).unwrap();
@@ -597,129 +594,129 @@ impl SolangServer {
 
             // Load expression
             ast::Expression::Load(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::StorageLoad(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::ZeroExt(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::SignExt(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::Trunc(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::Cast(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::BytesCast(_loc, _typ1, _typ2, expr) => {
-                SolangServer::construct_expr(expr, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr, lookup_tbl, symtab, ns);
             }
 
             //Increment-Decrement expression
             ast::Expression::PreIncrement(_locs, _typ, _, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::PreDecrement(_locs, _typ, _, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::PostIncrement(_locs, _typ, _, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::PostDecrement(_locs, _typ, _, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::Assign(_locs, _typ, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             // Compare expression
             ast::Expression::More(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Less(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::MoreEqual(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::LessEqual(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::Equal(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::NotEqual(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             ast::Expression::Not(_locs, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::Complement(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::UnaryMinus(_locs, _typ, expr1) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
 
             ast::Expression::Ternary(_locs, _typ, expr1, expr2, expr3) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr3, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr3, lookup_tbl, symtab, ns);
             }
 
             ast::Expression::Subscript(_locs, _, _, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             ast::Expression::StructMember(_locs, _typ, expr1, _val) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
 
             // Array operation expression
             ast::Expression::AllocDynamicArray(_locs, _typ, expr1, _valvec) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
             }
             ast::Expression::StorageArrayLength { array, .. } => {
-                SolangServer::construct_expr(array, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(array, lookup_tbl, symtab, ns);
             }
 
             // String operations expression
             ast::Expression::StringCompare(_locs, _strloc1, _strloc2) => {
                 if let ast::StringLocation::RunTime(expr1) = _strloc1 {
-                    SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
                 }
                 if let ast::StringLocation::RunTime(expr2) = _strloc1 {
-                    SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::StringConcat(_locs, _typ, _strloc1, _strloc2) => {
                 if let ast::StringLocation::RunTime(expr1) = _strloc1 {
-                    SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
                 }
                 if let ast::StringLocation::RunTime(expr2) = _strloc1 {
-                    SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
                 }
             }
 
             ast::Expression::Or(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
             ast::Expression::And(_locs, expr1, expr2) => {
-                SolangServer::construct_expr(expr1, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(expr2, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(expr1, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(expr2, lookup_tbl, symtab, ns);
             }
 
             // Function call expression
@@ -764,7 +761,7 @@ impl SolangServer {
                 }
 
                 for arg in args {
-                    SolangServer::construct_expr(arg, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(arg, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::ExternalFunctionCall {
@@ -812,15 +809,15 @@ impl SolangServer {
                         val,
                     });
 
-                    SolangServer::construct_expr(address, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(address, lookup_tbl, symtab, ns);
                     for expp in args {
-                        SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                        SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                     }
                     if let Some(value) = &call_args.value {
-                        SolangServer::construct_expr(value, lookup_tbl, symtab, fnc_map, ns);
+                        SolangServer::construct_expr(value, lookup_tbl, symtab, ns);
                     }
                     if let Some(gas) = &call_args.gas {
-                        SolangServer::construct_expr(gas, lookup_tbl, symtab, fnc_map, ns);
+                        SolangServer::construct_expr(gas, lookup_tbl, symtab, ns);
                     }
                 }
             }
@@ -830,13 +827,13 @@ impl SolangServer {
                 call_args,
                 ..
             } => {
-                SolangServer::construct_expr(args, lookup_tbl, symtab, fnc_map, ns);
-                SolangServer::construct_expr(address, lookup_tbl, symtab, fnc_map, ns);
+                SolangServer::construct_expr(args, lookup_tbl, symtab, ns);
+                SolangServer::construct_expr(address, lookup_tbl, symtab, ns);
                 if let Some(value) = &call_args.value {
-                    SolangServer::construct_expr(value, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(value, lookup_tbl, symtab, ns);
                 }
                 if let Some(gas) = &call_args.gas {
-                    SolangServer::construct_expr(gas, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(gas, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::Constructor {
@@ -847,19 +844,19 @@ impl SolangServer {
                 call_args,
             } => {
                 if let Some(gas) = &call_args.gas {
-                    SolangServer::construct_expr(gas, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(gas, lookup_tbl, symtab, ns);
                 }
                 for expp in args {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
                 if let Some(optval) = &call_args.value {
-                    SolangServer::construct_expr(optval, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(optval, lookup_tbl, symtab, ns);
                 }
                 if let Some(optsalt) = &call_args.salt {
-                    SolangServer::construct_expr(optsalt, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(optsalt, lookup_tbl, symtab, ns);
                 }
                 if let Some(space) = &call_args.space {
-                    SolangServer::construct_expr(space, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(space, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::Builtin(_locs, _typ, _builtin, expr) => {
@@ -870,17 +867,17 @@ impl SolangServer {
                     val,
                 });
                 for expp in expr {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::FormatString(_, sections) => {
                 for (_, e) in sections {
-                    SolangServer::construct_expr(e, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(e, lookup_tbl, symtab, ns);
                 }
             }
             ast::Expression::List(_locs, expr) => {
                 for expp in expr {
-                    SolangServer::construct_expr(expp, lookup_tbl, symtab, fnc_map, ns);
+                    SolangServer::construct_expr(expp, lookup_tbl, symtab, ns);
                 }
             }
             _ => {}
@@ -892,7 +889,6 @@ impl SolangServer {
         contvar: &ast::Variable,
         lookup_tbl: &mut Vec<HoverEntry>,
         samptb: &symtable::Symtable,
-        fnc_map: &HashMap<String, String>,
         ns: &ast::Namespace,
     ) {
         let val = format!(
@@ -906,7 +902,7 @@ impl SolangServer {
             val,
         });
         if let Some(expr) = &contvar.initializer {
-            SolangServer::construct_expr(expr, lookup_tbl, samptb, fnc_map, ns);
+            SolangServer::construct_expr(expr, lookup_tbl, samptb, ns);
         }
     }
 
@@ -925,11 +921,7 @@ impl SolangServer {
     }
 
     // Traverses namespace to build messages stored in the lookup table for hover feature.
-    fn traverse(
-        ns: &ast::Namespace,
-        lookup_tbl: &mut Vec<HoverEntry>,
-        fnc_map: &mut HashMap<String, String>,
-    ) {
+    fn traverse(ns: &ast::Namespace, lookup_tbl: &mut Vec<HoverEntry>) {
         for enm in &ns.enums {
             for (nam, vals) in &enm.values {
                 let val = format!("{} {}, \n\n", nam, vals.1);
@@ -988,13 +980,13 @@ impl SolangServer {
             }
 
             for stmt in &fnc.body {
-                SolangServer::construct_stmt(stmt, lookup_tbl, &fnc.symtable, fnc_map, ns);
+                SolangServer::construct_stmt(stmt, lookup_tbl, &fnc.symtable, ns);
             }
         }
 
         for constant in &ns.constants {
             let samptb = symtable::Symtable::new();
-            SolangServer::construct_cont(constant, lookup_tbl, &samptb, fnc_map, ns);
+            SolangServer::construct_cont(constant, lookup_tbl, &samptb, ns);
 
             let val = render(&constant.tags[..]);
             lookup_tbl.push(HoverEntry {
@@ -1014,7 +1006,7 @@ impl SolangServer {
 
             for varscont in &contrct.variables {
                 let samptb = symtable::Symtable::new();
-                SolangServer::construct_cont(varscont, lookup_tbl, &samptb, fnc_map, ns);
+                SolangServer::construct_cont(varscont, lookup_tbl, &samptb, ns);
 
                 let val = render(&varscont.tags[..]);
                 lookup_tbl.push(HoverEntry {

src/bin/solang.rs

@@ -2,7 +2,8 @@
 
 use clap::{
     builder::{ArgAction, ValueParser},
-    value_parser, App, Arg, ArgMatches, Command, ValueSource,
+    parser::ValueSource,
+    value_parser, Arg, ArgMatches, Command,
 };
 use clap_complete::{generate, Shell};
 use itertools::Itertools;
@@ -30,10 +31,11 @@ mod idl;
 mod languageserver;
 
 fn main() {
-    let version = format!("version {}", env!("SOLANG_VERSION"));
+    let version: &'static str = concat!("version ", env!("SOLANG_VERSION"));
+
     let app = || {
         Command::new("solang")
-            .version(&*version)
+            .version(version)
             .author(env!("CARGO_PKG_AUTHORS"))
             .about(env!("CARGO_PKG_DESCRIPTION"))
             .subcommand_required(true)
@@ -45,13 +47,13 @@ fn main() {
                             .help("Solidity input files")
                             .required(true)
                             .value_parser(ValueParser::os_string())
-                            .multiple_values(true),
+                            .num_args(1..),
                     )
                     .arg(
                         Arg::new("EMIT")
                             .help("Emit compiler state at early stage")
                             .long("emit")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser([
                                 "ast-dot", "cfg", "llvm-ir", "llvm-bc", "object", "asm",
                             ]),
@@ -60,7 +62,7 @@ fn main() {
                         Arg::new("OPT")
                             .help("Set llvm optimizer level")
                             .short('O')
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(["none", "less", "default", "aggressive"])
                             .default_value("default"),
                     )
@@ -68,7 +70,7 @@ fn main() {
                         Arg::new("TARGET")
                             .help("Target to build for [possible values: solana, substrate]")
                             .long("target")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(["solana", "substrate", "evm"])
                             .hide_possible_values(true)
                             .required(true),
@@ -77,7 +79,7 @@ fn main() {
                         Arg::new("ADDRESS_LENGTH")
                             .help("Address length on Substrate")
                             .long("address-length")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(value_parser!(u64).range(4..1024))
                             .default_value("32"),
                     )
@@ -86,7 +88,7 @@ fn main() {
                             .help("Value length on Substrate")
                             .long("value-length")
                             .value_parser(value_parser!(u64).range(4..1024))
-                            .takes_value(true)
+                            .num_args(1)
                             .default_value("16"),
                     )
                     .arg(
@@ -99,6 +101,7 @@ fn main() {
                         Arg::new("VERBOSE")
                             .help("show debug messages")
                             .short('v')
+                            .action(ArgAction::SetTrue)
                             .long("verbose"),
                     )
                     .arg(
@@ -106,14 +109,14 @@ fn main() {
                             .help("output directory")
                             .short('o')
                             .long("output")
-                            .takes_value(true),
+                            .num_args(1),
                     )
                     .arg(
                         Arg::new("IMPORTPATH")
                             .help("Directory to search for solidity files")
                             .short('I')
                             .long("importpath")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::path_buf())
                             .action(ArgAction::Append),
                     )
@@ -122,7 +125,7 @@ fn main() {
                             .help("Map directory to search for solidity files [format: map=path]")
                             .short('m')
                             .long("importmap")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::new(parse_import_map))
                             .action(ArgAction::Append),
                     )
@@ -172,7 +175,7 @@ fn main() {
                             .help("Enable generating debug information for LLVM IR")
                             .short('g')
                             .long("generate-debug-info")
-                            .hidden(true),
+                            .hide(true),
                     ),
             )
             .subcommand(
@@ -183,13 +186,13 @@ fn main() {
                             .help("Solidity input files")
                             .required(true)
                             .value_parser(ValueParser::os_string())
-                            .multiple_values(true),
+                            .num_args(1..),
                     )
                     .arg(
                         Arg::new("TARGET")
                             .help("Target to build for")
                             .long("target")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(["solana", "substrate", "evm"])
                             .required(true),
                     )
@@ -197,7 +200,7 @@ fn main() {
                         Arg::new("ADDRESS_LENGTH")
                             .help("Address length on Substrate")
                             .long("address-length")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(value_parser!(u64).range(4..1024))
                             .default_value("32"),
                     )
@@ -206,7 +209,7 @@ fn main() {
                             .help("Value length on Substrate")
                             .long("value-length")
                             .value_parser(value_parser!(u64).range(4..1024))
-                            .takes_value(true)
+                            .num_args(1)
                             .default_value("16"),
                     )
                     .arg(
@@ -214,7 +217,7 @@ fn main() {
                             .help("Directory to search for solidity files")
                             .short('I')
                             .long("importpath")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::path_buf())
                             .action(ArgAction::Append),
                     )
@@ -223,7 +226,7 @@ fn main() {
                             .help("Map directory to search for solidity files [format: map=path]")
                             .short('m')
                             .long("importmap")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::new(parse_import_map))
                             .action(ArgAction::Append),
                     ),
@@ -235,7 +238,7 @@ fn main() {
                         Arg::new("TARGET")
                             .help("Target to build for")
                             .long("target")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(["solana", "substrate", "evm"])
                             .required(true),
                     )
@@ -243,7 +246,7 @@ fn main() {
                         Arg::new("ADDRESS_LENGTH")
                             .help("Address length on Substrate")
                             .long("address-length")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(value_parser!(u64).range(4..1024))
                             .default_value("32"),
                     )
@@ -252,7 +255,7 @@ fn main() {
                             .help("Value length on Substrate")
                             .long("value-length")
                             .value_parser(value_parser!(u64).range(4..1024))
-                            .takes_value(true)
+                            .num_args(1)
                             .default_value("16"),
                     )
                     .arg(
@@ -260,7 +263,7 @@ fn main() {
                             .help("Directory to search for solidity files")
                             .short('I')
                             .long("importpath")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::path_buf())
                             .action(ArgAction::Append),
                     )
@@ -269,7 +272,7 @@ fn main() {
                             .help("Map directory to search for solidity files [format: map=path]")
                             .short('m')
                             .long("importmap")
-                            .takes_value(true)
+                            .num_args(1)
                             .value_parser(ValueParser::new(parse_import_map))
                             .action(ArgAction::Append),
                     ),
@@ -282,14 +285,14 @@ fn main() {
                             .help("Convert IDL files")
                             .required(true)
                             .value_parser(ValueParser::os_string())
-                            .multiple_values(true),
+                            .num_args(1..),
                     )
                     .arg(
                         Arg::new("OUTPUT")
                             .help("output file")
                             .short('o')
                             .long("output")
-                            .takes_value(true),
+                            .num_args(1),
                     ),
             )
             .subcommand(
@@ -323,7 +326,7 @@ fn doc(matches: &ArgMatches) {
     let target = target_arg(matches);
     let mut resolver = imports_arg(matches);
 
-    let verbose = matches.contains_id("VERBOSE");
+    let verbose = *matches.get_one::<bool>("VERBOSE").unwrap();
     let mut success = true;
     let mut files = Vec::new();
 
@@ -357,7 +360,7 @@ fn doc(matches: &ArgMatches) {
 fn compile(matches: &ArgMatches) {
     let target = target_arg(matches);
 
-    let verbose = matches.contains_id("VERBOSE");
+    let verbose = *matches.get_one::<bool>("VERBOSE").unwrap();
     let mut json = JsonResult {
         errors: Vec::new(),
         target: target.to_string(),
@@ -440,7 +443,7 @@ fn compile(matches: &ArgMatches) {
         if !save_intermediates(&binary, matches) {
             let bin_filename = output_file(matches, "bundle", target.file_extension());
 
-            if matches.contains_id("VERBOSE") {
+            if *matches.get_one::<bool>("VERBOSE").unwrap() {
                 eprintln!(
                     "info: Saving binary {} for contracts: {}",
                     bin_filename.display(),
@@ -506,7 +509,7 @@ fn compile(matches: &ArgMatches) {
     }
 }
 
-fn shell_complete(mut app: App, matches: &ArgMatches) {
+fn shell_complete(mut app: Command, matches: &ArgMatches) {
     if let Some(generator) = matches.get_one::<Shell>("SHELL").copied() {
         let name = app.get_name().to_string();
         generate(generator, &mut app, name, &mut std::io::stdout());
@@ -532,7 +535,7 @@ fn process_file(
     json: &mut JsonResult,
     opt: &Options,
 ) -> Result<Namespace, ()> {
-    let verbose = matches.contains_id("VERBOSE");
+    let verbose = *matches.get_one::<bool>("VERBOSE").unwrap();
 
     let mut json_contracts = HashMap::new();
 
@@ -681,7 +684,7 @@ fn process_file(
 }
 
 fn save_intermediates(binary: &solang::emit::binary::Binary, matches: &ArgMatches) -> bool {
-    let verbose = matches.contains_id("VERBOSE");
+    let verbose = *matches.get_one::<bool>("VERBOSE").unwrap();
 
     match matches.get_one::<String>("EMIT").map(|v| v.as_str()) {
         Some("llvm-ir") => {

src/emit/substrate/mod.rs

@@ -1438,7 +1438,6 @@ impl SubstrateTarget {
     /// dereferenced. However, this is already encoded by the fact it is a Type::Ref(..) type. So, the load
     /// argument should be removed from this function.
     pub fn encoded_length<'x>(
-        &self,
         arg: BasicValueEnum<'x>,
         load: bool,
         packed: bool,
@@ -1457,9 +1456,15 @@ impl SubstrateTarget {
                 .context
                 .i32_type()
                 .const_int(ns.address_length as u64, false),
-            ast::Type::Enum(n) => {
-                self.encoded_length(arg, load, packed, &ns.enums[*n].ty, function, binary, ns)
-            }
+            ast::Type::Enum(n) => SubstrateTarget::encoded_length(
+                arg,
+                load,
+                packed,
+                &ns.enums[*n].ty,
+                function,
+                binary,
+                ns,
+            ),
             ast::Type::Struct(str_ty) => {
                 let arg = if load {
                     binary
@@ -1502,7 +1507,7 @@ impl SubstrateTarget {
 
                     normal_sum = binary.builder.build_int_add(
                         normal_sum,
-                        self.encoded_length(
+                        SubstrateTarget::encoded_length(
                             elem.into(),
                             !field.ty.is_fixed_reference_type(),
                             packed,
@@ -1526,7 +1531,7 @@ impl SubstrateTarget {
                 for field in &str_ty.definition(ns).fields {
                     null_sum = binary.builder.build_int_add(
                         null_sum,
-                        self.encoded_length(
+                        SubstrateTarget::encoded_length(
                             binary.default_value(&field.ty, ns),
                             false,
                             packed,
@@ -1602,7 +1607,7 @@ impl SubstrateTarget {
                             };
 
                             *sum = binary.builder.build_int_add(
-                                self.encoded_length(
+                                SubstrateTarget::encoded_length(
                                     elem.into(),
                                     !elem_ty.deref_memory().is_fixed_reference_type(),
                                     packed,
@@ -1626,7 +1631,7 @@ impl SubstrateTarget {
                     let elem = binary.default_value(elem_ty.deref_any(), ns);
 
                     let null_length = binary.builder.build_int_mul(
-                        self.encoded_length(
+                        SubstrateTarget::encoded_length(
                             elem,
                             false,
                             packed,
@@ -1660,7 +1665,7 @@ impl SubstrateTarget {
                     let elem = binary.default_value(elem_ty.deref_any(), ns);
 
                     binary.builder.build_int_mul(
-                        self.encoded_length(
+                        SubstrateTarget::encoded_length(
                             elem,
                             false,
                             packed,
@@ -1725,7 +1730,7 @@ impl SubstrateTarget {
                             );
 
                             *sum = binary.builder.build_int_add(
-                                self.encoded_length(
+                                SubstrateTarget::encoded_length(
                                     elem.into(),
                                     !elem_ty.deref_memory().is_fixed_reference_type(),
                                     packed,
@@ -1748,7 +1753,7 @@ impl SubstrateTarget {
                     binary.builder.build_int_add(
                         encoded_length,
                         binary.builder.build_int_mul(
-                            self.encoded_length(
+                            SubstrateTarget::encoded_length(
                                 elem,
                                 false,
                                 packed,
@@ -1764,7 +1769,9 @@ impl SubstrateTarget {
                     )
                 }
             }
-            ast::Type::Ref(r) => self.encoded_length(arg, load, packed, r, function, binary, ns),
+            ast::Type::Ref(r) => {
+                SubstrateTarget::encoded_length(arg, load, packed, r, function, binary, ns)
+            }
             ast::Type::String | ast::Type::DynamicBytes => {
                 let arg = if load {
                     binary.builder.build_load(arg.into_pointer_value(), "")

src/emit/substrate/target.rs

@@ -775,7 +775,7 @@ impl<'a> TargetRuntime<'a> for SubstrateTarget {
 
             length = binary.builder.build_int_add(
                 length,
-                self.encoded_length(*arg, false, true, ty, function, binary, ns),
+                SubstrateTarget::encoded_length(*arg, false, true, ty, function, binary, ns),
                 "",
             );
         }
@@ -785,7 +785,7 @@ impl<'a> TargetRuntime<'a> for SubstrateTarget {
 
             length = binary.builder.build_int_add(
                 length,
-                self.encoded_length(*arg, false, false, ty, function, binary, ns),
+                SubstrateTarget::encoded_length(*arg, false, false, ty, function, binary, ns),
                 "",
             );
         }
@@ -905,7 +905,7 @@ impl<'a> TargetRuntime<'a> for SubstrateTarget {
         for (i, ty) in tys.iter().enumerate() {
             length = binary.builder.build_int_add(
                 length,
-                self.encoded_length(args[i], load, false, ty, function, binary, ns),
+                SubstrateTarget::encoded_length(args[i], load, false, ty, function, binary, ns),
                 "",
             );
         }

src/file_resolver.rs

@@ -96,7 +96,7 @@ impl FileResolver {
         }
 
         // read the file
-        let mut f = match File::open(&path) {
+        let mut f = match File::open(path) {
             Err(err_info) => {
                 return Err(format!(
                     "cannot open file '{}': {}",

tests/cli.rs

@@ -7,7 +7,7 @@ use std::fs::File;
 fn create_output_dir() {
     let mut cmd = Command::cargo_bin("solang").unwrap();
 
-    cmd.args(&[
+    cmd.args([
         "compile",
         "examples/flipper.sol",
         "--target",
@@ -22,7 +22,7 @@ fn create_output_dir() {
 
     let mut cmd = Command::cargo_bin("solang").unwrap();
 
-    cmd.args(&[
+    cmd.args([
         "compile",
         "examples/flipper.sol",
         "--target",

tests/contract.rs

@@ -137,7 +137,7 @@ fn parse_file(path: PathBuf, target: Target) -> io::Result<()> {
 }
 
 fn add_file(cache: &mut FileResolver, path: &Path, target: Target) -> io::Result<String> {
-    let mut file = File::open(&path)?;
+    let mut file = File::open(path)?;
 
     let mut source = String::new();
 

tests/imports.rs

@@ -6,7 +6,7 @@ use assert_cmd::Command;
 fn import_map_dup() {
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let dup = cmd
-        .args(&[
+        .args([
             "compile",
             "--target",
             "solana",
@@ -34,7 +34,7 @@ fn import_map_dup() {
 fn import_map_badpath() {
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let badpath = cmd
-        .args(&[
+        .args([
             "compile",
             "--target",
             "solana",
@@ -57,7 +57,7 @@ fn import_map_badpath() {
 fn import_map() {
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let assert = cmd
-        .args(&[
+        .args([
             "compile",
             "--target",
             "solana",
@@ -74,7 +74,7 @@ fn import_map() {
 
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let badpath = cmd
-        .args(&["compile", "import_map.sol", "--target", "solana"])
+        .args(["compile", "import_map.sol", "--target", "solana"])
         .current_dir("tests/imports_testcases")
         .assert();
 
@@ -90,7 +90,7 @@ fn import_map() {
 fn import() {
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let assert = cmd
-        .args(&[
+        .args([
             "compile",
             "--target",
             "solana",
@@ -107,7 +107,7 @@ fn import() {
 
     let mut cmd = Command::cargo_bin("solang").unwrap();
     let badpath = cmd
-        .args(&["compile", "--target", "solana", "import.sol"])
+        .args(["compile", "--target", "solana", "import.sol"])
         .current_dir("tests/imports_testcases")
         .assert();
 

tests/solana.rs

@@ -1198,7 +1198,7 @@ fn create_program_address(program_id: &Account, seeds: &[&[u8]]) -> Pubkey {
         hasher.update(seed);
     }
 
-    hasher.update(&program_id);
+    hasher.update(program_id);
     hasher.update(b"ProgramDerivedAddress");
 
     let hash = hasher.finalize();
@@ -1340,9 +1340,9 @@ impl<'a> SyscallObject<UserError> for SyscallInvokeSignedC<'a> {
                         assert_eq!(create_account.instruction, 3);
 
                         let mut hasher = Sha256::new();
-                        hasher.update(&create_account.base);
+                        hasher.update(create_account.base);
                         hasher.update(create_account.seed);
-                        hasher.update(&create_account.program_id);
+                        hasher.update(create_account.program_id);
 
                         let hash = hasher.finalize();
 
@@ -1563,7 +1563,7 @@ impl VirtualMachine {
         self.validate_account_data_heap();
 
         if let Some((_, return_data)) = &self.return_data {
-            println!("return: {}", hex::encode(&return_data));
+            println!("return: {}", hex::encode(return_data));
         }
 
         res
@@ -1572,7 +1572,7 @@ impl VirtualMachine {
     fn constructor(&mut self, name: &str, args: &[Token]) {
         let program = &self.stack[0];
 
-        println!("constructor for {}", hex::encode(&program.data));
+        println!("constructor for {}", hex::encode(program.data));
 
         let mut calldata = VirtualMachine::input(&program.data, &self.origin, name, &[]);
 
@@ -1594,7 +1594,7 @@ impl VirtualMachine {
     ) -> Vec<Token> {
         let program = &self.stack[0];
 
-        println!("function for {}", hex::encode(&program.data));
+        println!("function for {}", hex::encode(program.data));
 
         let mut calldata = VirtualMachine::input(
             &program.data,
@@ -1624,7 +1624,7 @@ impl VirtualMachine {
         };
 
         if let Some((_, return_data)) = &self.return_data {
-            println!("return: {}", hex::encode(&return_data));
+            println!("return: {}", hex::encode(return_data));
 
             let program = &self.stack[0];
 
@@ -1645,7 +1645,7 @@ impl VirtualMachine {
     ) -> Result<u64, EbpfError<UserError>> {
         let program = &self.stack[0];
 
-        println!("function for {}", hex::encode(&program.data));
+        println!("function for {}", hex::encode(program.data));
 
         let mut calldata = VirtualMachine::input(
             &program.data,
@@ -1688,12 +1688,12 @@ impl VirtualMachine {
 
         let seeds_len = seeds.len() as u8;
 
-        calldata.extend(&[seeds_len]);
+        calldata.extend([seeds_len]);
 
         for (_, seed) in seeds {
             let seed_len = seed.len() as u8;
 
-            calldata.extend(&[seed_len]);
+            calldata.extend([seed_len]);
             calldata.extend_from_slice(seed);
         }
 

tests/solana_tests/storage.rs

@@ -349,7 +349,7 @@ fn bytes_push_pop() {
 
     vm.function("push", &[Token::FixedBytes(vec![0x41])], &[], None);
 
-    println!("data:{}", hex::encode(&vm.data()));
+    println!("data:{}", hex::encode(vm.data()));
 
     let returns = vm.function("get_bs", &[], &[], None);
 

tests/substrate.rs

@@ -450,7 +450,7 @@ impl Externals for MockSubstrate {
 
                 hash.copy_from_slice(blake2_rfc::blake2b::blake2b(32, &[], &buf).as_bytes());
 
-                println!("seal_random: {} {}", hex::encode(buf), hex::encode(&hash));
+                println!("seal_random: {} {}", hex::encode(buf), hex::encode(hash));
 
                 let len = self
                     .vm
@@ -826,7 +826,7 @@ impl Externals for MockSubstrate {
 
                 self.accounts.get_mut(&account).unwrap().1 += remaining;
 
-                println!("seal_terminate: {} {}", hex::encode(&account), remaining);
+                println!("seal_terminate: {} {}", hex::encode(account), remaining);
 
                 self.accounts.remove(&self.vm.account);
 
@@ -876,7 +876,7 @@ impl Externals for MockSubstrate {
                     "seal_deposit_event: topic: {} data: {}",
                     topics
                         .iter()
-                        .map(|t| hex::encode(&t))
+                        .map(hex::encode)
                         .collect::<Vec<String>>()
                         .join(" "),
                     hex::encode(&data)
@@ -938,7 +938,7 @@ impl ModuleImportResolver for MockSubstrate {
 
 impl MockSubstrate {
     fn create_module(&self, code: &[u8]) -> ModuleRef {
-        let module = Module::from_buffer(&code).expect("parse wasm should work");
+        let module = Module::from_buffer(code).expect("parse wasm should work");
 
         ModuleInstance::new(
             &module,

tests/substrate_tests/contracts.rs

@@ -228,7 +228,7 @@ fn issue666() {
 
     let flipper_address = runtime.vm.account;
 
-    println!("flipper_address={}", hex::encode(&flipper_address));
+    println!("flipper_address={}", hex::encode(flipper_address));
 
     runtime.set_program(1);
 

tests/substrate_tests/format.rs

@@ -71,7 +71,7 @@ fn output() {
 
     assert_eq!(
         runtime.printbuf,
-        format!("bar:ladida address:{}", hex::encode(&runtime.vm.account))
+        format!("bar:ladida address:{}", hex::encode(runtime.vm.account))
     );
 
     let mut runtime = build_solidity(