Improve Contract Call by not encoding method name (#7455)

## Description

This is an optimisation of contract calls on top of
#7440.

The old version would pass a string with the method name and encode it,
which is `<LEN><BYTES`. Now the compiler generates these bytes directly,
avoiding encoding the method name in the first place.

For that this PR creats the concept of `Literal::Binary` that does not
exist in the language, yet. Would be something like `b""` in Rust.

## Improvements


| Test | Before | After | Percentage |
|------|--------|-------|------------|
| should_pass/empty_fields_in_storage_struct
(test.toml)::test_read_write_bytes | 19298 | 17533 | 9.15% |
| should_pass/empty_fields_in_storage_struct
(test.toml)::test_read_write_map | 14971 | 13986 | 6.58% |
| should_pass/empty_fields_in_storage_struct
(test.toml)::test_read_write_vec | 31061 | 29288 | 5.71% |
| should_pass/language/associated_const_abi (test.toml)::test | 8789 |
7817 | 11.06% |
| should_pass/language/associated_const_abi_multiple (test.toml)::test |
2421 | 2097 | 13.38% |
| should_pass/language/associated_const_in_decls_of_other_constants
(test.toml)::test | 870 | 709 | 18.51% |
| should_pass/language/contract_caller_dynamic_address (test.toml) | 540
| 379 | 29.81% |
| should_pass/language/contract_ret_intrinsic (test.toml)::test | 2133 |
1809 | 15.19% |
| should_pass/language/pusha_popa_multiple_defreg
(test.toml)::incorrect_pusha_popa | 819 | 624 | 23.81% |
| should_pass/language/raw_identifiers (test.error_type.toml)::test |
1236 | 1075 | 13.03% |
| should_pass/language/raw_identifiers (test.toml)::test | 1236 | 1075 |
13.03% |
| should_pass/language/references/mutability_of_references_memcpy_bug
(test.toml)::test | 1364 | 1203 | 11.80% |
| should_pass/language/slice/slice_contract (test.toml)::test_success |
1338 | 1145 | 14.42% |
| should_pass/language/string_slice/string_slice_contract
(test.toml)::test_success | 1515 | 1322 | 12.74% |
| should_pass/stdlib/storage_vec_insert (test.toml)::test_test_function
| 3992 | 3831 | 4.03% |
| should_pass/storage_element_key_modification
(test.toml)::test_storage_key_address | 1300 | 1138 | 12.46% |
| should_pass/storage_element_key_modification
(test.toml)::test_storage_key_modification | 919 | 757 | 17.63% |
| should_pass/storage_slot_key_calculation (test.toml)::test | 3140 |
2979 | 5.13% |
| should_pass/superabi_contract_calls (test.toml)::tests | 2136 | 1812 |
15.17% |
| should_pass/superabi_supertrait_same_methods (test.toml)::tests | 1097
| 936 | 14.68% |
| should_pass/test_abis/abi_impl_methods_callable (test.toml)::tests |
933 | 772 | 17.26% |
| should_pass/test_abis/contract_abi-auto_impl (test.toml)::tests | 933
| 772 | 17.26% |
| should_pass/unit_tests/aggr_indexing (test.toml)::test1 | 6007 | 5443
| 9.39% |
| should_pass/unit_tests/contract-multi-contract-calls
(test.toml)::test_contract_2_call | 966 | 804 | 16.77% |
| should_pass/unit_tests/contract-multi-contract-calls
(test.toml)::test_contract_call | 969 | 807 | 16.72% |
| should_pass/unit_tests/contract-multi-contract-calls
(test.toml)::test_contract_multi_call | 1916 | 1592 | 16.91% |
| should_pass/unit_tests/contract_multi_test (test.toml)::test_fail |
970 | 808 | 16.70% |
| should_pass/unit_tests/contract_multi_test (test.toml)::test_success |
968 | 806 | 16.74% |
| should_pass/unit_tests/script-contract-calls
(test.toml)::test_contract_call | 931 | 736 | 20.95% |
| should_pass/unit_tests/workspace_test (test.toml)::test_fail | 970 |
808 | 16.70% |
| should_pass/unit_tests/workspace_test (test.toml)::test_success | 969
| 807 | 16.72% |


## Failed Test

Only now I realized that the test for array of size zero `[u64; 0]` is
not working. As this is not a useful case, I will solve it in another
PR.

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: xunilrj

sway-core/src/ir_generation/convert.rs

@@ -32,6 +32,7 @@ pub(super) fn convert_literal_to_value(context: &mut Context, ast_literal: &Lite
         Literal::String(s) => ConstantContent::get_string(context, s.as_str().as_bytes().to_vec()),
         Literal::Boolean(b) => ConstantContent::get_bool(context, *b),
         Literal::B256(bs) => ConstantContent::get_b256(context, *bs),
+        Literal::Binary(bytes) => ConstantContent::get_untyped_slice(context, bytes.clone()),
     }
 }
 
@@ -50,6 +51,7 @@ pub(super) fn convert_literal_to_constant(
         Literal::String(s) => ConstantContent::new_string(context, s.as_str().as_bytes().to_vec()),
         Literal::Boolean(b) => ConstantContent::new_bool(context, *b),
         Literal::B256(bs) => ConstantContent::new_b256(context, *bs),
+        Literal::Binary(bytes) => ConstantContent::new_untyped_slice(context, bytes.clone()),
     };
     Constant::unique(context, c)
 }

sway-core/src/ir_generation/function.rs

@@ -457,12 +457,13 @@ impl<'a> FnCompiler<'a> {
         ))
     }
 
-    fn compile_string_slice(
+    // Can be used for raw untyped slice and string slice
+    fn compile_slice(
         &mut self,
         context: &mut Context,
         span_md_idx: Option<MetadataIndex>,
-        string_data: Value,
-        string_len: u64,
+        slice_ptr: Value,
+        slice_len: u64,
     ) -> Result<TerminatorValue, CompileError> {
         let int_ty = Type::get_uint64(context);
         let ptr_ty = Type::get_ptr(context);
@@ -471,9 +472,9 @@ impl<'a> FnCompiler<'a> {
         let ptr_val = self
             .current_block
             .append(context)
-            .cast_ptr(string_data, ptr_ty)
+            .cast_ptr(slice_ptr, ptr_ty)
             .add_metadatum(context, span_md_idx);
-        let len_val = ConstantContent::get_uint(context, 64, string_len);
+        let len_val = ConstantContent::get_uint(context, 64, slice_len);
 
         // a slice is a pointer and a length
         let field_types = vec![ptr_ty, int_ty];
@@ -569,7 +570,24 @@ impl<'a> FnCompiler<'a> {
                     .append(context)
                     .get_global(string_data_ptr);
                 let string_len = s.as_str().len() as u64;
-                self.compile_string_slice(context, span_md_idx, string_ptr, string_len)
+                self.compile_slice(context, span_md_idx, string_ptr, string_len)
+            }
+            ty::TyExpressionVariant::Literal(Literal::Binary(bytes)) => {
+                let data = ConstantContent::get_untyped_slice(context, bytes.clone())
+                    .get_constant(context)
+                    .unwrap();
+                let data_ptr = self.module.new_unique_global_var(
+                    context,
+                    "__const_global".into(),
+                    data.get_content(context).ty,
+                    Some(*data),
+                    false,
+                );
+
+                let slice_ptr = self.current_block.append(context).get_global(data_ptr);
+                let slice_len = bytes.len() as u64;
+
+                self.compile_slice(context, span_md_idx, slice_ptr, slice_len)
             }
             ty::TyExpressionVariant::Literal(Literal::Numeric(n)) => {
                 let implied_lit = match &*self.engines.te().get(ast_expr.return_type) {

sway-core/src/language/literal.rs

@@ -19,6 +19,7 @@ pub enum Literal {
     Numeric(u64),
     Boolean(bool),
     B256([u8; 32]),
+    Binary(Vec<u8>),
 }
 
 impl Literal {
@@ -74,6 +75,10 @@ impl Hash for Literal {
                 state.write_u8(8);
                 x.hash(state);
             }
+            Binary(x) => {
+                state.write_u8(9);
+                x.hash(state);
+            }
         }
     }
 }
@@ -90,6 +95,7 @@ impl PartialEq for Literal {
             (Self::Numeric(l0), Self::Numeric(r0)) => l0 == r0,
             (Self::Boolean(l0), Self::Boolean(r0)) => l0 == r0,
             (Self::B256(l0), Self::B256(r0)) => l0 == r0,
+            (Self::Binary(l0), Self::Binary(r0)) => l0 == r0,
             _ => false,
         }
     }
@@ -111,6 +117,11 @@ impl fmt::Display for Literal {
                 .map(|x| x.to_string())
                 .collect::<Vec<_>>()
                 .join(", "),
+            Literal::Binary(content) => content
+                .iter()
+                .map(|x| x.to_string())
+                .collect::<Vec<_>>()
+                .join(", "),
         };
         write!(f, "{s}")
     }
@@ -154,6 +165,7 @@ impl Literal {
             Literal::U256(_) => TypeInfo::UnsignedInteger(IntegerBits::V256),
             Literal::Boolean(_) => TypeInfo::Boolean,
             Literal::B256(_) => TypeInfo::B256,
+            Literal::Binary(_) => TypeInfo::RawUntypedSlice,
         }
     }
 }

sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs

@@ -180,6 +180,9 @@ impl Pattern {
             Literal::Boolean(b) => Pattern::Boolean(b),
             Literal::Numeric(x) => Pattern::Numeric(Range::from_single(x)),
             Literal::String(s) => Pattern::String(s.as_str().to_string()),
+            Literal::Binary(_) => {
+                unreachable!("literals cannot be expressed in the language yet")
+            }
         }
     }
 

sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs

@@ -635,6 +635,7 @@ impl ty::TyExpression {
             Literal::U256(_) => type_engine.id_of_u256(),
             Literal::Boolean(_) => type_engine.id_of_bool(),
             Literal::B256(_) => type_engine.id_of_b256(),
+            Literal::Binary(_) => type_engine.id_of_raw_slice(),
         };
         ty::TyExpression {
             expression: ty::TyExpressionVariant::Literal(lit),

sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs

@@ -533,10 +533,17 @@ pub(crate) fn type_check_method_application(
             }
         }
 
-        fn string_slice_literal(ident: &BaseIdent) -> Expression {
+        fn method_name_literal(method_name: &BaseIdent) -> Expression {
+            let method_name_str = method_name.as_str();
+            let len_bytes = (method_name_str.len() as u64).to_be_bytes();
+
+            let mut blob = Vec::with_capacity(len_bytes.len() + method_name_str.len());
+            blob.extend(len_bytes);
+            blob.extend(method_name_str.as_bytes());
+
             Expression {
-                kind: ExpressionKind::Literal(Literal::String(ident.span())),
-                span: ident.span(),
+                kind: ExpressionKind::Literal(Literal::Binary(blob)),
+                span: method_name.span(),
             }
         }
 
@@ -581,7 +588,7 @@ pub(crate) fn type_check_method_application(
             &mut ctx,
             span,
             method.return_type.type_id,
-            string_slice_literal(&method.name),
+            method_name_literal(&method.name),
             old_arguments.first().cloned().unwrap(),
             args,
             arguments.iter().map(|x| x.1.return_type).collect(),

sway-ir/src/constant.rs

@@ -120,6 +120,13 @@ impl ConstantContent {
         }
     }
 
+    pub fn new_untyped_slice(context: &mut Context, bytes: Vec<u8>) -> Self {
+        ConstantContent {
+            ty: Type::new_untyped_slice(context),
+            value: ConstantValue::RawUntypedSlice(bytes),
+        }
+    }
+
     pub fn new_array(context: &mut Context, elm_ty: Type, elems: Vec<ConstantContent>) -> Self {
         ConstantContent {
             ty: Type::new_array(context, elm_ty, elems.len() as u64),
@@ -181,6 +188,12 @@ impl ConstantContent {
         Value::new_constant(context, new_const)
     }
 
+    pub fn get_untyped_slice(context: &mut Context, value: Vec<u8>) -> Value {
+        let new_const_contents = ConstantContent::new_untyped_slice(context, value);
+        let new_const = Constant::unique(context, new_const_contents);
+        Value::new_constant(context, new_const)
+    }
+
     /// `value` must be created as an array constant first, using [`Constant::new_array()`].
     pub fn get_array(context: &mut Context, value: ConstantContent) -> Value {
         assert!(value.ty.is_array(context));

sway-ir/src/irtype.rs

@@ -140,6 +140,10 @@ impl Type {
         Self::get_type(context, &TypeContent::Pointer).expect("create_basic_types not called")
     }
 
+    pub fn new_untyped_slice(context: &mut Context) -> Type {
+        Self::get_or_create_unique_type(context, TypeContent::Slice)
+    }
+
     /// Get string type
     pub fn new_string_array(context: &mut Context, len: u64) -> Type {
         Self::get_or_create_unique_type(context, TypeContent::StringArray(len))

sway-lib-std/src/codec.sw

@@ -5347,7 +5347,7 @@ use ::ops::*;
 
 pub fn contract_call<T, TArgs>(
     contract_id: b256,
-    method_name: str,
+    method_name: raw_slice,
     args: TArgs,
     coins: u64,
     asset_id: b256,
@@ -5357,11 +5357,10 @@ where
     T: AbiDecode,
     TArgs: AbiEncode,
 {
-    let first_parameter = encode(method_name);
     let second_parameter = encode(args);
     let params = (
         contract_id,
-        asm(a: first_parameter.ptr()) {
+        asm(a: method_name.ptr()) {
             a: u64
         },
         asm(a: second_parameter.ptr()) {

sway-lsp/src/traverse/parsed_tree.rs

@@ -1252,5 +1252,6 @@ fn literal_to_symbol_kind(value: &Literal) -> SymbolKind {
         Literal::String(..) => SymbolKind::StringLiteral,
         Literal::B256(..) => SymbolKind::ByteLiteral,
         Literal::Boolean(..) => SymbolKind::BoolLiteral,
+        Literal::Binary(_) => unreachable!("literals cannot be expressed in the language yet"),
     }
 }