Apply review

boa_engine/src/vm/flowgraph/mod.rs

@@ -18,10 +18,6 @@ use super::{Instruction, InstructionIterator};
 
 impl CodeBlock {
     /// Output the [`CodeBlock`] VM instructions into a [`Graph`].
-    ///
-    /// # Panics
-    ///
-    /// TODO:
     #[allow(clippy::match_same_arms)]
     pub fn to_graph(&self, interner: &Interner, graph: &mut SubGraph) {
         // Have to remove any invalid graph chars like `<` or `>`.

boa_engine/src/vm/mod.rs

@@ -32,11 +32,11 @@ mod runtime_limits;
 #[cfg(feature = "flowgraph")]
 pub mod flowgraph;
 
+pub(crate) use opcode::{Instruction, InstructionIterator, Opcode, VaryingOperandKind};
 pub use runtime_limits::RuntimeLimits;
 pub use {
     call_frame::{CallFrame, GeneratorResumeKind},
     code_block::CodeBlock,
-    opcode::{Instruction, InstructionIterator, Opcode, VaryingOperand, VaryingOperandKind},
 };
 
 pub(crate) use {

boa_engine/src/vm/opcode/mod.rs

@@ -126,17 +126,15 @@ where
 
 /// Represents a varying operand kind.
 #[derive(Default, Debug, Clone, Copy)]
-#[allow(missing_docs)]
-pub enum VaryingOperandKind {
+pub(crate) enum VaryingOperandKind {
     #[default]
     Short,
     Half,
     Wide,
 }
 
 #[derive(Debug, Clone, Copy)]
-#[allow(missing_docs)]
-pub struct VaryingOperand {
+pub(crate) struct VaryingOperand {
     kind: VaryingOperandKind,
     value: u32,
 }
@@ -147,35 +145,34 @@ impl PartialEq for VaryingOperand {
     }
 }
 
-#[allow(missing_docs)]
 impl VaryingOperand {
     #[must_use]
-    pub fn short(value: u8) -> Self {
+    pub(crate) fn short(value: u8) -> Self {
         Self {
             kind: VaryingOperandKind::Short,
             value: u32::from(value),
         }
     }
     #[must_use]
-    pub fn half(value: u16) -> Self {
+    pub(crate) fn half(value: u16) -> Self {
         Self {
             kind: VaryingOperandKind::Half,
             value: u32::from(value),
         }
     }
     #[must_use]
-    pub const fn wide(value: u32) -> Self {
+    pub(crate) const fn wide(value: u32) -> Self {
         Self {
             kind: VaryingOperandKind::Wide,
             value,
         }
     }
     #[must_use]
-    pub const fn value(self) -> u32 {
+    pub(crate) const fn value(self) -> u32 {
         self.value
     }
     #[must_use]
-    pub const fn kind(self) -> VaryingOperandKind {
+    pub(crate) const fn kind(self) -> VaryingOperandKind {
         self.kind
     }
 }
@@ -378,7 +375,7 @@ macro_rules! generate_opcodes {
         /// The opcodes of the vm.
         #[derive(Debug, Clone, Copy, PartialEq, Eq)]
         #[repr(u8)]
-        pub enum Opcode {
+        pub(crate) enum Opcode {
             $(
                 $(#[$inner $($args)*])*
                 $Variant
@@ -409,7 +406,7 @@ macro_rules! generate_opcodes {
 
             /// Name of this opcode.
             #[must_use]
-            pub const fn as_str(self) -> &'static str {
+            pub(crate) const fn as_str(self) -> &'static str {
                 Self::NAMES[self as usize]
             }
 
@@ -421,7 +418,7 @@ macro_rules! generate_opcodes {
 
             /// Name of the profiler event for this opcode.
             #[must_use]
-            pub const fn as_instruction_str(self) -> &'static str {
+            pub(crate) const fn as_instruction_str(self) -> &'static str {
                 Self::INSTRUCTIONS[self as usize]
             }
 
@@ -443,13 +440,12 @@ macro_rules! generate_opcodes {
         //       be a part of `Instruction`.
         #[derive(Debug, Clone, PartialEq)]
         #[repr(u8)]
-        pub enum Instruction {
+        pub(crate) enum Instruction {
             $(
                 $(#[$inner $($args)*])*
                 $Variant $({
                     $(
                         $(#[$fieldinner $($fieldargs)*])*
-                        #[allow(missing_docs)]
                         $FieldName : $FieldType
                     ),*
                 })?
@@ -459,7 +455,8 @@ macro_rules! generate_opcodes {
         impl Instruction {
             /// Convert [`Instruction`] to compact bytecode.
             #[inline]
-            pub fn to_bytecode(&self, bytes: &mut Vec<u8>) {
+            #[allow(dead_code)]
+            pub(crate) fn to_bytecode(&self, bytes: &mut Vec<u8>) {
                 match self {
                     $(
                         Self::$Variant $({
@@ -481,7 +478,7 @@ macro_rules! generate_opcodes {
             /// If the provided bytecode is not valid.
             #[inline]
             #[must_use]
-            pub fn from_bytecode(bytes: &[u8], pc: &mut usize, varying_kind: VaryingOperandKind) -> Self {
+            pub(crate) fn from_bytecode(bytes: &[u8], pc: &mut usize, varying_kind: VaryingOperandKind) -> Self {
                 let opcode = bytes[*pc].into();
                 *pc += 1;
                 match opcode {
@@ -508,7 +505,7 @@ macro_rules! generate_opcodes {
             /// Get the [`Opcode`] of the [`Instruction`].
             #[inline]
             #[must_use]
-            pub const fn opcode(&self) -> Opcode {
+            pub(crate) const fn opcode(&self) -> Opcode {
                 match self {
                     $(
                         Self::$Variant $({ $( $FieldName: _ ),* })? => Opcode::$Variant
@@ -2184,7 +2181,7 @@ pub(crate) enum BindingOpcode {
 
 /// Iterator over the instructions in the compact bytecode.
 #[derive(Debug, Clone)]
-pub struct InstructionIterator<'bytecode> {
+pub(crate) struct InstructionIterator<'bytecode> {
     bytes: &'bytecode [u8],
     pc: usize,
 }
@@ -2193,20 +2190,20 @@ impl<'bytecode> InstructionIterator<'bytecode> {
     /// Create a new [`InstructionIterator`] from bytecode array.
     #[inline]
     #[must_use]
-    pub const fn new(bytes: &'bytecode [u8]) -> Self {
+    pub(crate) const fn new(bytes: &'bytecode [u8]) -> Self {
         Self { bytes, pc: 0 }
     }
 
     /// Create a new [`InstructionIterator`] from bytecode array at pc.
     #[inline]
     #[must_use]
-    pub const fn with_pc(bytes: &'bytecode [u8], pc: usize) -> Self {
+    pub(crate) const fn with_pc(bytes: &'bytecode [u8], pc: usize) -> Self {
         Self { bytes, pc }
     }
 
     /// Return the current program counter.
     #[must_use]
-    pub const fn pc(&self) -> usize {
+    pub(crate) const fn pc(&self) -> usize {
         self.pc
     }
 }

boa_engine/src/vm/opcode/modifier.rs

@@ -23,7 +23,7 @@ impl Operation for Half {
 /// `Wide` implements the Opcode Operation for `Opcode::Wide`
 ///
 /// Operation:
-///  - [`Opcode`] prefix operand modifier, makes all varying operands of an instruction [`u16`] sized.
+///  - [`Opcode`] prefix operand modifier, makes all varying operands of an instruction [`u32`] sized.
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct Wide;