avoid method name encoding by generating the expected format directly

Author: xunilrj

sway-core/src/ir_generation/convert.rs

@@ -14,15 +14,6 @@ use sway_types::{integer_bits::IntegerBits, span::Span};
 
 pub(super) fn convert_literal_to_value(context: &mut Context, ast_literal: &Literal) -> Value {
     match ast_literal {
-        // In Sway for now we don't have `as` casting and for integers which may be implicitly cast
-        // between widths we just emit a warning, and essentially ignore it. We also assume a
-        // 'Numeric' integer of undetermined width is 'u64`. The IR would like to be type
-        // consistent and doesn't tolerate missing integers of different width, so for now, until we
-        // do introduce explicit `as` casting, all integers are `u64` as far as the IR is
-        // concerned.
-        //
-        // XXX The above isn't true for other targets.  We need to improved this.
-        // FIXME
         Literal::U8(n) => ConstantContent::get_uint(context, 8, *n as u64),
         Literal::U16(n) => ConstantContent::get_uint(context, 64, *n as u64),
         Literal::U32(n) => ConstantContent::get_uint(context, 64, *n as u64),
@@ -32,6 +23,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()),
     }
 }
 
@@ -40,7 +32,6 @@ pub(super) fn convert_literal_to_constant(
     ast_literal: &Literal,
 ) -> Constant {
     let c = match ast_literal {
-        // All integers are `u64`.  See comment above.
         Literal::U8(n) => ConstantContent::new_uint(context, 8, *n as u64),
         Literal::U16(n) => ConstantContent::new_uint(context, 64, *n as u64),
         Literal::U32(n) => ConstantContent::new_uint(context, 64, *n as u64),
@@ -50,6 +41,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(_) => todo!(),
     };
     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 to 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);
+            }
         }
     }
 }
@@ -111,6 +116,7 @@ impl fmt::Display for Literal {
                 .map(|x| x.to_string())
                 .collect::<Vec<_>>()
                 .join(", "),
+            Literal::Binary(_) => todo!(),
         };
         write!(f, "{s}")
     }
@@ -154,6 +160,7 @@ impl Literal {
             Literal::U256(_) => TypeInfo::UnsignedInteger(IntegerBits::V256),
             Literal::Boolean(_) => TypeInfo::Boolean,
             Literal::B256(_) => TypeInfo::B256,
+            Literal::Binary(_) => todo!(),
         }
     }
 }

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

@@ -180,6 +180,7 @@ 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(_) => todo!(),
         }
     }
 

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().to_string();
+            let len_bytes = (method_name_str.len() as u64).to_be_bytes();
+
+            let mut blob = vec![];
+            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,9 +5347,10 @@ where
 // END TUPLES_DECODE
 use ::ops::*;
 
+#[inline(never)]
 pub fn contract_call<T, TArgs>(
     contract_id: b256,
-    method_name: str,
+    method_name: raw_slice,
     args: TArgs,
     coins: u64,
     asset_id: b256,
@@ -5359,11 +5360,10 @@ where
     T: AbiDecode,
     TArgs: AbiEncode,
 {
-    let first_parameter = encode(method_name);
     let second_parameter = encode(args);
     let params = encode((
         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

@@ -1241,5 +1241,6 @@ fn literal_to_symbol_kind(value: &Literal) -> SymbolKind {
         Literal::String(..) => SymbolKind::StringLiteral,
         Literal::B256(..) => SymbolKind::ByteLiteral,
         Literal::Boolean(..) => SymbolKind::BoolLiteral,
+        Literal::Binary(_) => todo!(),
     }
 }