forbid ptr_arg

Author: jesse-shopify

Cargo.toml

@@ -57,11 +57,24 @@ perf = { level = "forbid", priority = 1 }
 
 complexity = { level = "deny", priority = -1 }
 
-style = { level = "allow", priority = -1 }
+style = { level = "deny", priority = -1 }
 pedantic = { level = "allow", priority = -1 }
+restriction = { level = "allow", priority = -1 }
 
 too_many_arguments = "allow"
 identity_op = "allow"
 
-unwrap_or_default = "forbid"
 ptr_arg = "deny"
+ref_option = "forbid"
+inefficient_to_string = "forbid"
+from_over_into = "forbid"
+unwrap_or_default = "forbid"
+redundant_static_lifetimes = "forbid"
+match_like_matches_macro = "forbid"
+field_reassign_with_default = "forbid"
+inherent_to_string = "forbid"
+owned_cow = "forbid"
+redundant_clone = "forbid"
+str_to_string = "forbid"
+single_char_pattern = "forbid"
+single_char_add_str = "forbid"

yjit/src/asm/arm64/opnd.rs

@@ -79,10 +79,7 @@ impl A64Opnd {
 
     /// Convenience function to check if this operand is a register.
     pub fn is_reg(&self) -> bool {
-        match self {
-            A64Opnd::Reg(_) => true,
-            _ => false
-        }
+        matches!(self, A64Opnd::Reg(_))
     }
 
     /// Unwrap a register from an operand.

yjit/src/asm/mod.rs

@@ -378,7 +378,7 @@ impl CodeBlock {
 
         // Unless this comment is the same as the last one at this same line, add it.
         if this_line_comments.last().map(String::as_str) != Some(comment) {
-            this_line_comments.push(comment.to_string());
+            this_line_comments.push(comment.into());
         }
     }
 

yjit/src/asm/x86_64/mod.rs

@@ -163,10 +163,7 @@ impl X86Opnd {
     }
 
     pub fn is_some(&self) -> bool {
-        match self {
-            X86Opnd::None => false,
-            _ => true
-        }
+        !matches!(self, X86Opnd::None)
     }
 
 }

yjit/src/backend/arm64/mod.rs

@@ -1243,7 +1243,7 @@ impl Assembler
                     emit_cmp_zero_jump(cb, opnd.into(), false, compile_side_exit(*target, self, ocb)?);
                 },
                 Insn::IncrCounter { mem, value } => {
-                    let label = cb.new_label("incr_counter_loop".to_string());
+                    let label = cb.new_label("incr_counter_loop".into());
                     cb.write_label(label);
 
                     ldaxr(cb, Self::SCRATCH0, mem.into());

yjit/src/backend/ir.rs

@@ -1186,7 +1186,7 @@ impl Assembler
         assert!(!name.contains(' '), "use underscores in label names, not spaces");
 
         let label_idx = self.label_names.len();
-        self.label_names.push(name.to_string());
+        self.label_names.push(name.into());
         Target::Label(label_idx)
     }
 
@@ -1753,7 +1753,7 @@ impl Assembler {
     }
 
     pub fn bake_string(&mut self, text: &str) {
-        self.push_insn(Insn::BakeString(text.to_string()));
+        self.push_insn(Insn::BakeString(text.into()));
     }
 
     #[allow(dead_code)]

yjit/src/codegen.rs

@@ -404,7 +404,7 @@ impl<'a> JITState<'a> {
         if !self.perf_stack.is_empty() {
             self.perf_symbol_range_end(asm);
         }
-        self.perf_stack.push(symbol_name.to_string());
+        self.perf_stack.push(symbol_name.into());
         self.perf_symbol_range_start(asm, symbol_name);
     }
 
@@ -454,12 +454,9 @@ impl<'a> JITState<'a> {
 
     /// Return true if we're compiling a send-like instruction, not an opt_* instruction.
     pub fn is_sendish(&self) -> bool {
-        match unsafe { rb_iseq_opcode_at_pc(self.iseq, self.pc) } as u32 {
-            YARVINSN_send |
+        matches!(unsafe { rb_iseq_opcode_at_pc(self.iseq, self.pc) } as u32, YARVINSN_send |
             YARVINSN_opt_send_without_block |
-            YARVINSN_invokesuper => true,
-            _ => false,
-        }
+            YARVINSN_invokesuper)
     }
 
     /// Return the number of locals in the current ISEQ
@@ -9547,7 +9544,7 @@ fn get_class_name(class: Option<VALUE>) -> String {
         unsafe { RB_TYPE_P(class, RUBY_T_MODULE) || RB_TYPE_P(class, RUBY_T_CLASS) }
     }).and_then(|class| unsafe {
         cstr_to_rust_string(rb_class2name(class))
-    }).unwrap_or_else(|| "Unknown".to_string())
+    }).unwrap_or_else(|| "Unknown".into())
 }
 
 /// Assemble "{class_name}#{method_name}" from a class pointer and a method ID
@@ -9557,15 +9554,15 @@ fn get_method_name(class: Option<VALUE>, mid: u64) -> String {
         unsafe { cstr_to_rust_string(rb_id2name(mid)) }
     } else {
         None
-    }.unwrap_or_else(|| "Unknown".to_string());
+    }.unwrap_or_else(|| "Unknown".into());
     format!("{}#{}", class_name, method_name)
 }
 
 /// Assemble "{label}@{iseq_path}:{lineno}" (iseq_inspect() format) from an ISEQ
 fn get_iseq_name(iseq: IseqPtr) -> String {
     let c_string = unsafe { rb_yjit_iseq_inspect(iseq) };
     let string = unsafe { CStr::from_ptr(c_string) }.to_str()
-        .unwrap_or_else(|_| "not UTF-8").to_string();
+        .unwrap_or_else(|_| "not UTF-8").into();
     unsafe { ruby_xfree(c_string as *mut c_void); }
     string
 }

yjit/src/core.rs

@@ -121,24 +121,12 @@ impl Type {
 
     /// Check if the type is an immediate
     pub fn is_imm(&self) -> bool {
-        match self {
-            Type::UnknownImm => true,
-            Type::Nil => true,
-            Type::True => true,
-            Type::False => true,
-            Type::Fixnum => true,
-            Type::Flonum => true,
-            Type::ImmSymbol => true,
-            _ => false,
-        }
+        matches!(self, Type::UnknownImm | Type::Nil | Type::True | Type::False | Type::Fixnum | Type::Flonum | Type::ImmSymbol)
     }
 
     /// Returns true when the type is not specific.
     pub fn is_unknown(&self) -> bool {
-        match self {
-            Type::Unknown | Type::UnknownImm | Type::UnknownHeap => true,
-            _ => false,
-        }
+        matches!(self, Type::Unknown | Type::UnknownImm | Type::UnknownHeap)
     }
 
     /// Returns true when we know the VALUE is a specific handle type,
@@ -150,17 +138,7 @@ impl Type {
 
     /// Check if the type is a heap object
     pub fn is_heap(&self) -> bool {
-        match self {
-            Type::UnknownHeap => true,
-            Type::TArray => true,
-            Type::CArray => true,
-            Type::THash => true,
-            Type::CHash => true,
-            Type::TString => true,
-            Type::CString => true,
-            Type::BlockParamProxy => true,
-            _ => false,
-        }
+        matches!(self, Type::UnknownHeap | Type::TArray | Type::CArray | Type::THash | Type::CHash | Type::TString | Type::CString | Type::BlockParamProxy)
     }
 
     /// Check if it's a T_ARRAY object (both TArray and CArray are T_ARRAY)
@@ -2510,10 +2488,12 @@ impl Context {
 
     /// Create a new Context that is compatible with self but doesn't have type information.
     pub fn get_generic_ctx(&self) -> Context {
-        let mut generic_ctx = Context::default();
-        generic_ctx.stack_size = self.stack_size;
-        generic_ctx.sp_offset = self.sp_offset;
-        generic_ctx.reg_mapping = self.reg_mapping;
+        let mut generic_ctx = Context {
+            stack_size: self.stack_size,
+            sp_offset: self.sp_offset,
+            reg_mapping: self. reg_mapping,
+            ..Default::default()
+         };
         if self.is_return_landing() {
             generic_ctx.set_as_return_landing();
         }
@@ -3233,9 +3213,7 @@ fn gen_entry_point_body(blockid: BlockId, stack_size: u8, ec: EcPtr, jit_excepti
     let (code_ptr, reg_mapping) = gen_entry_prologue(cb, ocb, blockid, stack_size, jit_exception)?;
 
     // Find or compile a block version
-    let mut ctx = Context::default();
-    ctx.stack_size = stack_size;
-    ctx.reg_mapping = reg_mapping;
+    let ctx = Context { stack_size, reg_mapping, ..Default::default()};
     let block = match find_block_version(blockid, &ctx) {
         // If an existing block is found, generate a jump to the block.
         Some(blockref) => {
@@ -3359,9 +3337,7 @@ fn entry_stub_hit_body(
     asm.compile(cb, Some(ocb))?;
 
     // Find or compile a block version
-    let mut ctx = Context::default();
-    ctx.stack_size = stack_size;
-    ctx.reg_mapping = reg_mapping;
+    let ctx = Context { stack_size, reg_mapping, ..Default::default()};
     let blockref = match find_block_version(blockid, &ctx) {
         // If an existing block is found, generate a jump to the block.
         Some(blockref) => {

yjit/src/cruby.rs

@@ -223,7 +223,7 @@ pub fn insn_name(opcode: usize) -> String {
         let op_name = CStr::from_ptr(op_name).to_str().unwrap();
 
         // Convert into an owned string
-        op_name.to_string()
+        op_name.into()
     }
 }
 
@@ -619,7 +619,7 @@ pub fn cstr_to_rust_string(c_char_ptr: *const c_char) -> Option<String> {
     let c_str: &CStr = unsafe { CStr::from_ptr(c_char_ptr) };
 
     match c_str.to_str() {
-        Ok(rust_str) => Some(rust_str.to_string()),
+        Ok(rust_str) => Some(rust_str.into()),
         Err(_) => None
     }
 }

yjit/src/options.rs

@@ -115,7 +115,7 @@ pub static mut OPTIONS: Options = Options {
 
 /// YJIT option descriptions for `ruby --help`.
 /// Note that --help allows only 80 characters per line, including indentation.   80-character limit --> |
-pub const YJIT_OPTIONS: &'static [(&str, &str)] = &[
+pub const YJIT_OPTIONS: &[(&str, &str)] = &[
     ("--yjit-mem-size=num",                "Soft limit on YJIT memory usage in MiB (default: 128)."),
     ("--yjit-exec-mem-size=num",           "Hard limit on executable memory block in MiB."),
     ("--yjit-call-threshold=num",          "Number of calls to trigger JIT."),
@@ -319,7 +319,7 @@ pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> Option<()> {
                 eprintln!("WARNING: the {} option is only available when YJIT is built in dev mode, i.e. ./configure --enable-yjit=dev", opt_name);
             }
 
-            OPTIONS.dump_iseq_disasm = Some(opt_val.to_string());
+            OPTIONS.dump_iseq_disasm = Some(opt_val.into());
         },
 
         ("no-type-prop", "") => unsafe { OPTIONS.no_type_prop = true },
@@ -346,7 +346,7 @@ pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> Option<()> {
                 let log_file_path = if std::path::Path::new(arg_value).is_dir() {
                     format!("{arg_value}/yjit_{}.log", std::process::id())
                 } else {
-                    arg_value.to_string()
+                    arg_value.into()
                 };
 
                 match File::options().create(true).write(true).truncate(true).open(&log_file_path) {