Merge branch 'master' into kayagokalp/tracing-telem

Author: JoshuaBatty

sway-core/src/ir_generation/function.rs

@@ -1977,6 +1977,7 @@ impl<'a> FnCompiler<'a> {
                             block: merge_block,
                             idx: 0,
                             ty: ptr_ty,
+                            is_immutable: false,
                         },
                     );
                     merge_block.add_arg(context, merge_block_ptr);
@@ -1986,6 +1987,7 @@ impl<'a> FnCompiler<'a> {
                             block: merge_block,
                             idx: 1,
                             ty: Type::get_uint64(context),
+                            is_immutable: false,
                         },
                     );
                     merge_block.add_arg(context, merge_block_cap);

sway-core/src/language/call_path.rs

@@ -375,6 +375,13 @@ impl CallPath {
             .collect::<Vec<_>>()
     }
 
+    pub fn as_vec_ident(&self) -> Vec<Ident> {
+        self.as_vec_string()
+            .iter()
+            .map(|s| Ident::new_no_span(s.clone()))
+            .collect::<Vec<_>>()
+    }
+
     /// Create a full [CallPath] from a given [Ident] and the [Namespace] in which the [Ident] is
     /// declared.
     ///

sway-core/src/language/ty/expression/expression.rs

@@ -597,6 +597,9 @@ impl MaterializeConstGenerics for TyExpression {
                 exp.materialize_const_generics(engines, handler, name, value)
             }
             TyExpressionVariant::Continue | TyExpressionVariant::Break => Ok(()),
+            TyExpressionVariant::AbiCast { address, .. } => {
+                address.materialize_const_generics(engines, handler, name, value)
+            }
             _ => Err(handler.emit_err(
                 sway_error::error::CompileError::ConstGenericNotSupportedHere {
                     span: self.span.clone(),

sway-core/src/lib.rs

@@ -58,9 +58,9 @@ use sway_error::warning::{CollectedTraitImpl, CompileInfo, CompileWarning, Info,
 use sway_features::ExperimentalFeatures;
 use sway_ir::{
     create_o1_pass_group, register_known_passes, Context, Kind, Module, PassGroup, PassManager,
-    PrintPassesOpts, ARG_DEMOTION_NAME, CONST_DEMOTION_NAME, DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME,
-    FN_INLINE_NAME, GLOBALS_DCE_NAME, MEM2REG_NAME, MEMCPYOPT_NAME, MISC_DEMOTION_NAME,
-    RET_DEMOTION_NAME, SIMPLIFY_CFG_NAME, SROA_NAME,
+    PrintPassesOpts, ARG_DEMOTION_NAME, ARG_POINTEE_MUTABILITY_TAGGER_NAME, CONST_DEMOTION_NAME,
+    DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME, FN_INLINE_NAME, GLOBALS_DCE_NAME, MEM2REG_NAME,
+    MEMCPYOPT_NAME, MISC_DEMOTION_NAME, RET_DEMOTION_NAME, SIMPLIFY_CFG_NAME, SROA_NAME,
 };
 use sway_types::span::Source;
 use sway_types::{SourceEngine, SourceLocation, Span};
@@ -1256,6 +1256,7 @@ pub(crate) fn compile_ast_to_ir_to_asm(
         pass_group.append_pass(MISC_DEMOTION_NAME);
 
         // Convert loads and stores to mem_copies where possible.
+        pass_group.append_pass(ARG_POINTEE_MUTABILITY_TAGGER_NAME);
         pass_group.append_pass(MEMCPYOPT_NAME);
 
         // Run a DCE and simplify-cfg to clean up any obsolete instructions.

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

@@ -900,65 +900,58 @@ fn unify_arguments_and_parameters(
 pub(crate) fn resolve_method_name(
     handler: &Handler,
     mut ctx: TypeCheckContext,
-    method_name: &TypeBinding<MethodName>,
+    method_name_binding: &TypeBinding<MethodName>,
     arguments_types: &[TypeId],
 ) -> Result<(DeclRefFunction, TypeId), ErrorEmitted> {
     ctx.engines
         .obs()
-        .raise_on_before_method_resolution(&ctx, method_name, arguments_types);
+        .raise_on_before_method_resolution(&ctx, method_name_binding, arguments_types);
 
     let type_engine = ctx.engines.te();
     let engines = ctx.engines();
 
-    // retrieve the function declaration using the components of the method name
-    let (decl_ref, type_id) = match &method_name.inner {
+    // Helper: first argument type or an unknown placeholder.
+    let first_arg_or_unknown = || {
+        arguments_types
+            .first()
+            .cloned()
+            .unwrap_or_else(|| type_engine.new_unknown())
+    };
+
+    let (type_id, module_path, method_ident) = match &method_name_binding.inner {
         MethodName::FromType {
             call_path_binding,
             method_name,
         } => {
-            // type check the call path
             let type_id = call_path_binding
                 .type_check_with_type_info(handler, &mut ctx)
                 .unwrap_or_else(|err| type_engine.id_of_error_recovery(err));
 
-            // find the module that the symbol is in
-            let type_info_prefix = &call_path_binding
+            let type_info_path = call_path_binding
                 .inner
-                .to_fullpath(engines, ctx.namespace())
-                .prefixes;
+                .to_fullpath(engines, ctx.namespace());
+            let module_path = type_info_path.prefixes.clone();
             ctx.namespace()
-                .require_module_from_absolute_path(handler, type_info_prefix)?;
+                .require_module_from_absolute_path(handler, &module_path)?;
 
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                type_info_prefix,
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+            (type_id, module_path, method_name)
         }
+
         MethodName::FromTrait { call_path } => {
-            // find the module that the symbol is in
-            let module_path = match call_path.callpath_type {
+            let module_path: Vec<_> = match call_path.callpath_type {
                 CallPathType::RelativeToPackageRoot => {
                     let mut path = vec![ctx.namespace().current_package_name().clone()];
-                    for ident in call_path.prefixes.iter() {
-                        path.push(ident.clone())
-                    }
+                    path.extend(call_path.prefixes.iter().cloned());
                     path
                 }
                 CallPathType::Full => call_path.prefixes.clone(),
                 CallPathType::Ambiguous => {
+                    let first = call_path.prefixes.first().expect("prefixes is non-empty");
                     if ctx
                         .namespace()
                         .current_module()
                         .submodules()
-                        .contains_key(call_path.prefixes.first().unwrap().as_str())
+                        .contains_key(first.as_str())
                     {
                         ctx.namespace().prepend_module_path(&call_path.prefixes)
                     } else {
@@ -967,77 +960,38 @@ pub(crate) fn resolve_method_name(
                 }
             };
 
-            // find the type of the first argument
-            let type_id = arguments_types
-                .first()
-                .cloned()
-                .unwrap_or_else(|| type_engine.new_unknown());
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                &module_path,
-                &call_path.suffix,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+            let type_id = first_arg_or_unknown();
+            (type_id, module_path, &call_path.suffix)
         }
-        MethodName::FromModule { method_name } => {
-            // find the module that the symbol is in
-            let module_path = ctx.namespace().current_mod_path();
 
-            // find the type of the first argument
-            let type_id = arguments_types
-                .first()
-                .cloned()
-                .unwrap_or_else(|| type_engine.new_unknown());
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                module_path.as_slice(),
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+        MethodName::FromModule { method_name } => {
+            let module_path = ctx.namespace().current_mod_path().to_vec();
+            let type_id = first_arg_or_unknown();
+            (type_id, module_path, method_name)
         }
+
         MethodName::FromQualifiedPathRoot {
-            ty,
-            as_trait,
-            method_name,
+            ty, method_name, ..
         } => {
-            // type check the call path
             let type_id = ty.type_id();
-
-            // find the module that the symbol is in
-            let module_path = ctx.namespace().current_mod_path();
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                module_path,
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                Some(*as_trait),
-            )?;
-
-            (decl_ref, type_id)
+            let module_path = ctx.namespace().current_mod_path().to_vec();
+            (type_id, module_path, method_name)
         }
     };
 
+    let decl_ref = ctx.find_method_for_type(
+        handler,
+        type_id,
+        module_path.as_slice(),
+        method_ident,
+        ctx.type_annotation(),
+        arguments_types,
+        Some(&method_name_binding.inner),
+    )?;
+
     ctx.engines.obs().raise_on_after_method_resolution(
         &ctx,
-        method_name,
+        method_name_binding,
         arguments_types,
         decl_ref.clone(),
         type_id,

sway-core/src/semantic_analysis/cei_pattern_analysis.rs

@@ -220,13 +220,11 @@ fn analyze_expression(
     use crate::ty::TyExpressionVariant::*;
     let decl_engine = engines.de();
     match &expr.expression {
-        ConstGenericExpression { .. } => {
-            todo!("Will be implemented by https://github.com/FuelLabs/sway/issues/6860")
-        }
         // base cases: no warnings can be emitted
         Literal(_)
         | ConstantExpression { .. }
         | ConfigurableExpression { .. }
+        | ConstGenericExpression { .. }
         | VariableExpression { .. }
         | FunctionParameter
         | StorageAccess(_)