Typos, comments and renamings

ironcev · ironcev · commit f7605f363da2 · 2026-03-02T10:51:28.000+04:00
diff --git a/forc-pkg/src/pkg.rs b/forc-pkg/src/pkg.rs
@@ -1947,7 +1947,6 @@ pub fn compile_ir(
     experimental: ExperimentalFeatures,
     source_map: &mut SourceMap,
 ) -> Result<BuiltPackageBytecode> {
-    // Read main_file into a string
     let source = fs::read_to_string(main_file)
         .with_context(|| format!("Failed to read Sway-IR file: {}", main_file.display()))?;
 
@@ -2005,7 +2004,7 @@ pub fn compile_ir(
     };
 
     let (_, _warnings, _infos) = handler.consume();
-    // TODO Print infos and warnings?
+    // TODO: Print infos and warnings?
     // TODO: Set configurables offset metadata if needed.
 
     let bytecode = BuiltPackageBytecode {
diff --git a/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs b/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs
@@ -343,7 +343,7 @@ impl AllocatedAbstractInstructionSet {
                                     data_id,
                                 ),
                                 owning_span: owning_span.clone(),
-                                comment: "load switch target table address".into(),
+                                comment: "[switch] load switch targets table base address".into(),
                             });
                             // Multiply discriminant by 8 (since each address is 8 bytes) and add to the base address.
                             realized_ops.push(RealizedOp {
@@ -353,7 +353,7 @@ impl AllocatedAbstractInstructionSet {
                                     VirtualImmediate12::new(3),
                                 ),
                                 owning_span: owning_span.clone(),
-                                comment: "multiply discriminant by 8".into(),
+                                comment: "[switch] get discriminant's target offset (discriminant * 8)".into(),
                             });
                             realized_ops.push(RealizedOp {
                                 opcode: AllocatedInstruction::ADD(
@@ -362,7 +362,7 @@ impl AllocatedAbstractInstructionSet {
                                     AllocatedRegister::Constant(ConstantRegister::Scratch),
                                 ),
                                 owning_span: owning_span.clone(),
-                                comment: "add discriminant to switch target table address".into(),
+                                comment: "[switch] add discriminant's target offset to targets base address".into(),
                             });
                             realized_ops.push(RealizedOp {
                                 opcode: AllocatedInstruction::LW(
@@ -371,7 +371,7 @@ impl AllocatedAbstractInstructionSet {
                                     VirtualImmediate12::new(0),
                                 ),
                                 owning_span: owning_span.clone(),
-                                comment: "load switch target address".into(),
+                                comment: "[switch] load discriminant's target address".into(),
                             });
                             // Finally, jump to the loaded address.
                             realized_ops.push(RealizedOp {
@@ -380,7 +380,7 @@ impl AllocatedAbstractInstructionSet {
                                     VirtualImmediate18::new(0),
                                 ),
                                 owning_span,
-                                comment,
+                                comment: "[switch] jump to discriminant's target address".into(),
                             });
                         }
                         ControlFlowOp::DataSectionOffsetPlaceholder => {
@@ -425,10 +425,10 @@ impl AllocatedAbstractInstructionSet {
     /// instructions to be added, and so on.
     ///
     /// For this reason, we take a two-pass approach. On the first pass, we pessimistically assume
-    /// that all jumps may require take two opcodes, and use this assumption to calculate the
+    /// that all jumps may require two opcodes, and use this assumption to calculate the
     /// offsets of labels. Then we see which jumps actually require two opcodes and mark them as such.
     /// This approach is not optimal as it sometimes requires more opcodes than necessary,
-    /// but it is simple and quite works well in practice.
+    /// but it is simple and works quite well in practice.
     fn resolve_labels(&mut self, data_section: &mut DataSection) -> LabeledBlocks {
         let far_jump_indices = self.collect_far_jumps();
         self.map_label_offsets(data_section, &far_jump_indices)
diff --git a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
@@ -33,7 +33,6 @@ use sway_error::{
 use sway_ir::*;
 use sway_types::{span::Span, Spanned};
 
-use core::panic;
 use either::Either;
 use std::collections::HashMap;
 
diff --git a/sway-core/src/asm_lang/mod.rs b/sway-core/src/asm_lang/mod.rs
@@ -281,19 +281,17 @@ impl Op {
         }
     }
 
-    /// Switch
-    pub(crate) fn switch(on: VirtualRegister, cases: Vec<Label>) -> Self {
+    pub(crate) fn switch(discriminant: VirtualRegister, cases: Vec<Label>) -> Self {
         Op {
             opcode: Either::Right(OrganizationalOp::Switch {
-                discriminant: on,
+                discriminant,
                 cases,
             }),
             comment: String::new(),
             owning_span: None,
         }
     }
 
-    /// Switch with comment
     pub(crate) fn switch_comment(
         discriminant: VirtualRegister,
         cases: Vec<Label>,
diff --git a/sway-ir/src/block.rs b/sway-ir/src/block.rs
@@ -314,15 +314,15 @@ impl Block {
     }
 
     /// For a particular successor (if it indeed is one), get the arguments passed.
-    pub fn get_succ_params(&self, context: &Context, succ: &Block) -> Vec<Value> {
+    pub fn get_succ_args(&self, context: &Context, succ: &Block) -> Vec<Value> {
         self.successors(context)
             .iter()
             .find(|branch| &branch.block == succ)
             .map_or(vec![], |branch| branch.args.clone())
     }
 
-    /// For a particular successor (if it indeed is one), get a mut ref to parameters passed.
-    pub fn get_succ_params_mut<'a>(
+    /// For a particular successor (if it indeed is one), get a mutable reference to the arguments passed.
+    pub fn get_succ_args_mut<'a>(
         &'a self,
         context: &'a mut Context,
         succ: &Block,
@@ -358,16 +358,16 @@ impl Block {
                     },
                 ..
             }) => {
-                for (_case_val, branch) in cases.iter_mut() {
-                    if branch.block == *succ {
-                        return Some(&mut branch.args);
-                    }
-                }
                 if let Some(def_branch) = default {
                     if def_branch.block == *succ {
                         return Some(&mut def_branch.args);
                     }
                 }
+                for (_case_val, branch) in cases.iter_mut() {
+                    if branch.block == *succ {
+                        return Some(&mut branch.args);
+                    }
+                }
                 None
             }
             _ => None,
@@ -381,7 +381,7 @@ impl Block {
         context: &mut Context,
         old_succ: Block,
         new_succ: Block,
-        new_params: Vec<Value>,
+        new_args: Vec<Value>,
     ) {
         let mut modified = false;
         if let Some(term) = self.get_terminator_mut(context) {
@@ -406,12 +406,12 @@ impl Block {
                     if old_succ == *true_block {
                         modified = true;
                         *true_block = new_succ;
-                        true_opds.clone_from(&new_params);
+                        true_opds.clone_from(&new_args);
                     }
                     if old_succ == *false_block {
                         modified = true;
                         *false_block = new_succ;
-                        *false_opds = new_params
+                        *false_opds = new_args
                     }
                 }
 
@@ -420,7 +420,7 @@ impl Block {
                     ..
                 } if *block == old_succ => {
                     *block = new_succ;
-                    *args = new_params;
+                    *args = new_args;
                     modified = true;
                 }
 
@@ -437,7 +437,7 @@ impl Block {
                         if branch.block == old_succ {
                             *branch = BranchToWithArgs {
                                 block: new_succ,
-                                args: new_params.clone(),
+                                args: new_args.clone(),
                             };
                             modified = true;
                         }
@@ -446,7 +446,7 @@ impl Block {
                         if def_branch.block == old_succ {
                             *def_branch = BranchToWithArgs {
                                 block: new_succ,
-                                args: new_params,
+                                args: new_args,
                             };
                             modified = true;
                         }
diff --git a/sway-ir/src/instruction.rs b/sway-ir/src/instruction.rs
@@ -597,8 +597,8 @@ impl InstOp {
                 if let Some(default_branch) = default {
                     v.extend_from_slice(&default_branch.args);
                 }
-                for case in cases {
-                    v.extend_from_slice(&case.1.args);
+                for (_case_val, branch) in cases {
+                    v.extend_from_slice(&branch.args);
                 }
                 v
             }
@@ -823,12 +823,12 @@ impl InstOp {
                         default.as_mut().unwrap().args[idx - cur_idx] = replacement;
                     } else {
                         cur_idx += default_args_len;
-                        for case in cases.iter_mut() {
-                            if idx - cur_idx < case.1.args.len() {
-                                case.1.args[idx - cur_idx] = replacement;
+                        for (_case_val, branch) in cases.iter_mut() {
+                            if idx - cur_idx < branch.args.len() {
+                                branch.args[idx - cur_idx] = replacement;
                                 return;
                             }
-                            cur_idx += case.1.args.len();
+                            cur_idx += branch.args.len();
                         }
                         panic!("Invalid index for Switch");
                     }
@@ -1203,8 +1203,8 @@ impl InstOp {
                 if let Some(default_branch) = default {
                     default_branch.args.iter_mut().for_each(replace);
                 }
-                for case in cases {
-                    case.1.args.iter_mut().for_each(replace);
+                for (_case_val, branch) in cases {
+                    branch.args.iter_mut().for_each(replace);
                 }
             }
             InstOp::ContractCall {
diff --git a/sway-ir/src/optimize/arg_demotion.rs b/sway-ir/src/optimize/arg_demotion.rs
@@ -282,7 +282,7 @@ fn demote_block_signature(context: &mut Context, function: &Function, block: Blo
     for pred in preds {
         for (arg_idx, _arg_val, arg_var) in &arg_vars {
             // Get the value which is being passed to the block at this index.
-            let arg_val = pred.get_succ_params(context, &block)[*arg_idx];
+            let arg_val = pred.get_succ_args(context, &block)[*arg_idx];
 
             // Insert a `get_local` and `store` for each candidate argument and insert them at the
             // end of this block, before the terminator.
diff --git a/sway-ir/src/optimize/dce.rs b/sway-ir/src/optimize/dce.rs
@@ -309,12 +309,12 @@ pub fn dce(
                 .map(|arg| cemetery.contains(arg))
                 .collect_vec();
             for pred in block.pred_iter(context).cloned().collect_vec() {
-                let params = pred
-                    .get_succ_params_mut(context, &block)
+                let args = pred
+                    .get_succ_args_mut(context, &block)
                     .expect("Invalid IR");
                 let mut index = 0;
-                // Remove parameters passed to a dead argument.
-                params.retain(|_| {
+                // Remove arguments passed to a dead argument.
+                args.retain(|_| {
                     let retain = !dead_args[index];
                     index += 1;
                     retain
diff --git a/sway-ir/src/optimize/mem2reg.rs b/sway-ir/src/optimize/mem2reg.rs
@@ -373,8 +373,8 @@ pub fn promote_locals(
                             Value::new_constant(context, constant)
                         }
                     };
-                    let params = node.get_succ_params_mut(context, &succ).unwrap();
-                    params.push(new_val);
+                    let succ_args = node.get_succ_args_mut(context, &succ).unwrap();
+                    succ_args.push(new_val);
                 }
             }
         }
diff --git a/sway-ir/src/optimize/simplify_cfg.rs b/sway-ir/src/optimize/simplify_cfg.rs
@@ -63,7 +63,7 @@ fn unlink_empty_blocks(context: &mut Context, function: &Function) -> Result<boo
         block,
         BranchToWithArgs {
             block: to_block,
-            args: cur_params,
+            args: cur_args,
         },
     ) in candidates
     {
@@ -84,21 +84,21 @@ fn unlink_empty_blocks(context: &mut Context, function: &Function) -> Result<boo
         }
         let preds: Vec<_> = block.pred_iter(context).copied().collect();
         for pred in preds {
-            // Whatever parameters "block" passed to "to_block", that
+            // Whatever arguments "block" passed to "to_block", that
             // should now go from "pred" to "to_block".
-            let params_from_pred = pred.get_succ_params(context, &block);
-            let new_params = cur_params
+            let args_from_pred = pred.get_succ_args(context, &block);
+            let new_args = cur_args
                 .iter()
-                .map(|cur_param| match &context.values[cur_param.0].value {
+                .map(|cur_arg| match &context.values[cur_arg.0].value {
                     ValueDatum::Argument(arg) if arg.block == block => {
                         // An argument should map to the actual parameter passed.
-                        params_from_pred[arg.idx]
+                        args_from_pred[arg.idx]
                     }
-                    _ => *cur_param,
+                    _ => *cur_arg,
                 })
                 .collect();
 
-            pred.replace_successor(context, block, to_block, new_params);
+            pred.replace_successor(context, block, to_block, new_args);
             modified = true;
         }
     }
@@ -205,12 +205,12 @@ fn merge_blocks(context: &mut Context, function: &Function) -> Result<bool, IrEr
 
         // Loop for the rest of the chain, to all the `to_block`s.
         for to_block in block_chain {
-            let from_params = from_block.get_succ_params(context, &to_block);
+            let from_args = from_block.get_succ_args(context, &to_block);
             // We collect here so that we can have &mut Context later on.
             let to_blocks: Vec<_> = to_block.arg_iter(context).copied().enumerate().collect();
             for (arg_idx, to_block_arg) in to_blocks {
-                // replace all uses of `to_block_arg` with the parameter from `from_block`.
-                replace_map.insert(to_block_arg, from_params[arg_idx]);
+                // replace all uses of `to_block_arg` with the argument from `from_block`.
+                replace_map.insert(to_block_arg, from_args[arg_idx]);
             }
 
             // Update the parent block field for every instruction

Original file line number	Diff line number	Diff line change
`@@ -281,19 +281,17 @@ impl Op {`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`
`284`		`- /// Switch`
`285`		`- pub(crate) fn switch(on: VirtualRegister, cases: Vec<Label>) -> Self {`
	`284`	`+ pub(crate) fn switch(discriminant: VirtualRegister, cases: Vec<Label>) -> Self {`
`286`	`285`	`Op {`
`287`	`286`	`opcode: Either::Right(OrganizationalOp::Switch {`
`288`		`- discriminant: on,`
	`287`	`+ discriminant,`
`289`	`288`	`cases,`
`290`	`289`	`}),`
`291`	`290`	`comment: String::new(),`
`292`	`291`	`owning_span: None,`
`293`	`292`	`}`
`294`	`293`	`}`
`295`	`294`
`296`		`- /// Switch with comment`
`297`	`295`	`pub(crate) fn switch_comment(`
`298`	`296`	`discriminant: VirtualRegister,`
`299`	`297`	`cases: Vec<Label>,`
Original file line number	Diff line number	Diff line change
`@@ -597,8 +597,8 @@ impl InstOp {`
`597`	`597`	`if let Some(default_branch) = default {`
`598`	`598`	`v.extend_from_slice(&default_branch.args);`
`599`	`599`	`}`
`600`		`- for case in cases {`
`601`		`- v.extend_from_slice(&case.1.args);`
	`600`	`+ for (_case_val, branch) in cases {`
	`601`	`+ v.extend_from_slice(&branch.args);`
`602`	`602`	`}`
`603`	`603`	`v`
`604`	`604`	`}`
`@@ -823,12 +823,12 @@ impl InstOp {`
`823`	`823`	`default.as_mut().unwrap().args[idx - cur_idx] = replacement;`
`824`	`824`	`} else {`
`825`	`825`	`cur_idx += default_args_len;`
`826`		`- for case in cases.iter_mut() {`
`827`		`- if idx - cur_idx < case.1.args.len() {`
`828`		`- case.1.args[idx - cur_idx] = replacement;`
	`826`	`+ for (_case_val, branch) in cases.iter_mut() {`
	`827`	`+ if idx - cur_idx < branch.args.len() {`
	`828`	`+ branch.args[idx - cur_idx] = replacement;`
`829`	`829`	`return;`
`830`	`830`	`}`
`831`		`- cur_idx += case.1.args.len();`
	`831`	`+ cur_idx += branch.args.len();`
`832`	`832`	`}`
`833`	`833`	`panic!("Invalid index for Switch");`
`834`	`834`	`}`
`@@ -1203,8 +1203,8 @@ impl InstOp {`
`1203`	`1203`	`if let Some(default_branch) = default {`
`1204`	`1204`	`default_branch.args.iter_mut().for_each(replace);`
`1205`	`1205`	`}`
`1206`		`- for case in cases {`
`1207`		`- case.1.args.iter_mut().for_each(replace);`
	`1206`	`+ for (_case_val, branch) in cases {`
	`1207`	`+ branch.args.iter_mut().for_each(replace);`
`1208`	`1208`	`}`
`1209`	`1209`	`}`
`1210`	`1210`	`InstOp::ContractCall {`
Original file line number	Diff line number	Diff line change
`@@ -373,8 +373,8 @@ pub fn promote_locals(`
`373`	`373`	`Value::new_constant(context, constant)`
`374`	`374`	`}`
`375`	`375`	`};`
`376`		`- let params = node.get_succ_params_mut(context, &succ).unwrap();`
`377`		`- params.push(new_val);`
	`376`	`+ let succ_args = node.get_succ_args_mut(context, &succ).unwrap();`
	`377`	`+ succ_args.push(new_val);`
`378`	`378`	`}`
`379`	`379`	`}`
`380`	`380`	`}`