refactor: Bytecode is one word and VaryingOperand does not vary any more (#4978)

in #4827, `VaryingOperand` is not actually varying any more and the name
should reflect as such.
Furthermore, currently there are both `bytecode` and `ByteCode` while
bytecode is supposed to be one word (as far as i can tell).

There are one or two more meaningful things i want to do with vm but
want to raise this issue first so i dont submit a large pr with a lot of
refactor changes + a few non-trivial changes.

Author: zhuzhu81998

core/engine/src/bytecompiler/mod.rs

@@ -34,7 +34,7 @@ use crate::{
     vm::{
         CallFrame, CodeBlock, CodeBlockFlags, Constant, GeneratorResumeKind, GlobalFunctionBinding,
         Handler, InlineCache,
-        opcode::{Address, BindingOpcode, ByteCodeEmitter, RegisterOperand},
+        opcode::{Address, BindingOpcode, BytecodeEmitter, RegisterOperand},
         source_info::{SourceInfo, SourceMap, SourceMapBuilder, SourcePath},
     },
 };
@@ -487,7 +487,7 @@ pub struct ByteCompiler<'ctx> {
     pub(crate) parameter_scope: Scope,
 
     /// Bytecode
-    pub(crate) bytecode: ByteCodeEmitter,
+    pub(crate) bytecode: BytecodeEmitter,
 
     pub(crate) source_map_builder: SourceMapBuilder,
     pub(crate) source_path: SourcePath,
@@ -625,7 +625,7 @@ impl<'ctx> ByteCompiler<'ctx> {
         Self {
             function_name: name,
             length: 0,
-            bytecode: ByteCodeEmitter::new(),
+            bytecode: BytecodeEmitter::new(),
             source_map_builder: SourceMapBuilder::default(),
             constants: ThinVec::default(),
             bindings: Vec::default(),
@@ -1170,15 +1170,15 @@ impl<'ctx> ByteCompiler<'ctx> {
     }
 
     fn try_fused_comparison_branch(&mut self, op: RelationalOp, binary: &Binary) -> Option<Label> {
-        use crate::vm::opcode::ByteCodeEmitter;
+        use crate::vm::opcode::BytecodeEmitter;
 
-        let emit_fn: fn(&mut ByteCodeEmitter, Address, RegisterOperand, RegisterOperand) = match op
+        let emit_fn: fn(&mut BytecodeEmitter, Address, RegisterOperand, RegisterOperand) = match op
         {
-            RelationalOp::LessThan => ByteCodeEmitter::emit_jump_if_not_less_than,
-            RelationalOp::LessThanOrEqual => ByteCodeEmitter::emit_jump_if_not_less_than_or_equal,
-            RelationalOp::GreaterThan => ByteCodeEmitter::emit_jump_if_not_greater_than,
+            RelationalOp::LessThan => BytecodeEmitter::emit_jump_if_not_less_than,
+            RelationalOp::LessThanOrEqual => BytecodeEmitter::emit_jump_if_not_less_than_or_equal,
+            RelationalOp::GreaterThan => BytecodeEmitter::emit_jump_if_not_greater_than,
             RelationalOp::GreaterThanOrEqual => {
-                ByteCodeEmitter::emit_jump_if_not_greater_than_or_equal
+                BytecodeEmitter::emit_jump_if_not_greater_than_or_equal
             }
             _ => return None,
         };

core/engine/src/vm/code_block.rs

@@ -19,7 +19,7 @@ use thin_vec::ThinVec;
 
 use super::{
     InlineCache,
-    opcode::{Address, ByteCode, Instruction, InstructionIterator},
+    opcode::{Address, Bytecode, Instruction, InstructionIterator},
     source_info::{SourceInfo, SourceMap, SourcePath},
 };
 
@@ -144,7 +144,7 @@ pub struct CodeBlock {
 
     /// Bytecode
     #[unsafe_ignore_trace]
-    pub(crate) bytecode: ByteCode,
+    pub(crate) bytecode: Bytecode,
 
     pub(crate) constants: ThinVec<Constant>,
 
@@ -178,7 +178,7 @@ impl CodeBlock {
         let mut flags = CodeBlockFlags::empty();
         flags.set(CodeBlockFlags::STRICT, strict);
         Self {
-            bytecode: ByteCode::default(),
+            bytecode: Bytecode::default(),
             constants: ThinVec::default(),
             bindings: Box::default(),
             flags: Cell::new(flags),
@@ -1040,7 +1040,7 @@ impl Display for CodeBlock {
         } else {
             f.write_char('\n')?;
 
-            let bytecode_len = self.bytecode.bytecode.len() as u32;
+            let bytecode_len = self.bytecode.bytes.len() as u32;
             for (i, handler) in self.source_info().map().entries().windows(2).enumerate() {
                 let current = handler[0];
                 let next = handler.get(1);

core/engine/src/vm/mod.rs

@@ -867,7 +867,7 @@ impl Context {
             .frame()
             .code_block
             .bytecode
-            .bytecode
+            .bytes
             .get(self.vm.frame().pc as usize)
         {
             let opcode = Opcode::decode(*byte);
@@ -905,7 +905,7 @@ impl Context {
             .frame()
             .code_block
             .bytecode
-            .bytecode
+            .bytes
             .get(self.vm.frame().pc as usize)
         {
             let opcode = Opcode::decode(*byte);

core/engine/src/vm/opcode/args.rs

@@ -1,6 +1,6 @@
 use thin_vec::ThinVec;
 
-use super::{Address, RegisterOperand, VaryingOperand};
+use super::{Address, IndexOperand, RegisterOperand};
 
 /// A trait for types that can be read from a byte slice.
 ///
@@ -138,9 +138,9 @@ impl Argument for () {
     }
 }
 
-impl Argument for VaryingOperand {
+impl Argument for IndexOperand {
     fn encode(self, bytes: &mut Vec<u8>) {
-        write_u32(bytes, self.value);
+        write_u32(bytes, self.0);
     }
 
     fn decode(bytes: &[u8], pos: usize) -> (Self, usize) {
@@ -151,7 +151,7 @@ impl Argument for VaryingOperand {
 
 impl Argument for RegisterOperand {
     fn encode(self, bytes: &mut Vec<u8>) {
-        write_u32(bytes, self.value);
+        write_u32(bytes, self.0);
     }
 
     fn decode(bytes: &[u8], pos: usize) -> (Self, usize) {
@@ -163,7 +163,7 @@ impl Argument for RegisterOperand {
 impl Argument for Address {
     #[inline(always)]
     fn encode(self, bytes: &mut Vec<u8>) {
-        write_u32(bytes, self.value);
+        write_u32(bytes, self.0);
     }
 
     #[inline(always)]
@@ -221,7 +221,7 @@ impl_argument_for_int!(u8 u16 u32 u64 i8 i16 i32 f32 f64);
 
 #[cfg(test)]
 mod tests {
-    use super::{Address, Argument, RegisterOperand, VaryingOperand};
+    use super::{Address, Argument, IndexOperand, RegisterOperand};
     use std::mem::size_of;
     use thin_vec::ThinVec;
 
@@ -266,10 +266,8 @@ mod tests {
 
     #[test]
     fn test_varying_operand_round_trip() {
-        round_trip_eq(&VaryingOperand::new(0), |a, b| {
-            u32::from(*a) == u32::from(*b)
-        });
-        round_trip_eq(&VaryingOperand::new(0xFFFF_FFFF), |a, b| {
+        round_trip_eq(&IndexOperand::new(0), |a, b| u32::from(*a) == u32::from(*b));
+        round_trip_eq(&IndexOperand::new(0xFFFF_FFFF), |a, b| {
             u32::from(*a) == u32::from(*b)
         });
     }

core/engine/src/vm/opcode/binary_ops/mod.rs

@@ -1,4 +1,4 @@
-use super::{RegisterOperand, VaryingOperand};
+use super::{IndexOperand, RegisterOperand};
 use crate::{Context, JsResult, error::JsNativeError, vm::opcode::Operation};
 
 pub(crate) mod logical;
@@ -105,7 +105,7 @@ pub(crate) struct InPrivate;
 impl InPrivate {
     #[inline(always)]
     pub(super) fn operation(
-        (dst, index, rhs): (RegisterOperand, VaryingOperand, RegisterOperand),
+        (dst, index, rhs): (RegisterOperand, IndexOperand, RegisterOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let name = context

core/engine/src/vm/opcode/call/mod.rs

@@ -3,7 +3,7 @@ use std::{cell::RefCell, mem::MaybeUninit};
 use boa_string::JsString;
 use dynify::Dynify;
 
-use super::{RegisterOperand, VaryingOperand};
+use super::{IndexOperand, RegisterOperand};
 use crate::{
     Context, JsError, JsObject, JsResult, JsValue, NativeFunction,
     builtins::{Promise, promise::PromiseCapability},
@@ -24,7 +24,7 @@ pub(crate) struct CallEval;
 impl CallEval {
     #[inline(always)]
     pub(super) fn operation(
-        (argument_count, scope_index): (VaryingOperand, VaryingOperand),
+        (argument_count, scope_index): (IndexOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let func = context
@@ -102,7 +102,7 @@ pub(crate) struct CallEvalSpread;
 
 impl CallEvalSpread {
     #[inline(always)]
-    pub(super) fn operation(index: VaryingOperand, context: &mut Context) -> JsResult<()> {
+    pub(super) fn operation(index: IndexOperand, context: &mut Context) -> JsResult<()> {
         // Get the arguments that are stored as an array object on the stack.
         let arguments_array = context.vm.stack.pop();
         let arguments_array_object = arguments_array
@@ -183,7 +183,7 @@ pub(crate) struct Call;
 
 impl Call {
     #[inline(always)]
-    pub(super) fn operation(argument_count: VaryingOperand, context: &mut Context) -> JsResult<()> {
+    pub(super) fn operation(argument_count: IndexOperand, context: &mut Context) -> JsResult<()> {
         let func = context
             .vm
             .stack

core/engine/src/vm/opcode/control_flow/throw.rs

@@ -4,7 +4,7 @@ use crate::{
     Context, JsError, JsNativeError, JsResult,
     vm::{
         CompletionRecord,
-        opcode::{Operation, RegisterOperand, VaryingOperand},
+        opcode::{IndexOperand, Operation, RegisterOperand},
     },
 };
 
@@ -152,7 +152,7 @@ pub(crate) struct ThrowNewTypeError;
 
 impl ThrowNewTypeError {
     #[inline(always)]
-    pub(crate) fn operation(index: VaryingOperand, context: &mut Context) -> JsError {
+    pub(crate) fn operation(index: IndexOperand, context: &mut Context) -> JsError {
         let msg = context
             .vm
             .frame()
@@ -180,7 +180,7 @@ pub(crate) struct ThrowNewReferenceError;
 
 impl ThrowNewReferenceError {
     #[inline(always)]
-    pub(crate) fn operation(index: VaryingOperand, context: &mut Context) -> JsError {
+    pub(crate) fn operation(index: IndexOperand, context: &mut Context) -> JsError {
         let msg = context
             .vm
             .frame()

core/engine/src/vm/opcode/define/class/getter.rs

@@ -5,7 +5,7 @@ use crate::{
     builtins::function::{OrdinaryFunction, set_function_name},
     object::internal_methods::InternalMethodPropertyContext,
     property::PropertyDescriptor,
-    vm::opcode::{Operation, RegisterOperand, VaryingOperand},
+    vm::opcode::{IndexOperand, Operation, RegisterOperand},
 };
 
 /// `DefineClassStaticGetterByName` implements the Opcode Operation for `Opcode::DefineClassStaticGetterByName`
@@ -18,7 +18,7 @@ pub(crate) struct DefineClassStaticGetterByName;
 impl DefineClassStaticGetterByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();
@@ -75,7 +75,7 @@ pub(crate) struct DefineClassGetterByName;
 impl DefineClassGetterByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class_proto, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class_proto, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();

core/engine/src/vm/opcode/define/class/method.rs

@@ -3,7 +3,7 @@ use crate::{
     builtins::function::{OrdinaryFunction, set_function_name},
     object::internal_methods::InternalMethodPropertyContext,
     property::PropertyDescriptor,
-    vm::opcode::{Operation, RegisterOperand, VaryingOperand},
+    vm::opcode::{IndexOperand, Operation, RegisterOperand},
 };
 
 /// `DefineClassStaticMethodByName` implements the Opcode Operation for `Opcode::DefineClassStaticMethodByName`
@@ -16,7 +16,7 @@ pub(crate) struct DefineClassStaticMethodByName;
 impl DefineClassStaticMethodByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();
@@ -69,7 +69,7 @@ pub(crate) struct DefineClassMethodByName;
 impl DefineClassMethodByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class_proto, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class_proto, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();

core/engine/src/vm/opcode/define/class/setter.rs

@@ -5,7 +5,7 @@ use crate::{
     builtins::function::{OrdinaryFunction, set_function_name},
     object::internal_methods::InternalMethodPropertyContext,
     property::PropertyDescriptor,
-    vm::opcode::{Operation, RegisterOperand, VaryingOperand},
+    vm::opcode::{IndexOperand, Operation, RegisterOperand},
 };
 
 /// `DefineClassStaticSetterByName` implements the Opcode Operation for `Opcode::DefineClassStaticSetterByName`
@@ -18,7 +18,7 @@ pub(crate) struct DefineClassStaticSetterByName;
 impl DefineClassStaticSetterByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();
@@ -76,7 +76,7 @@ pub(crate) struct DefineClassSetterByName;
 impl DefineClassSetterByName {
     #[inline(always)]
     pub(crate) fn operation(
-        (function, class_proto, index): (RegisterOperand, RegisterOperand, VaryingOperand),
+        (function, class_proto, index): (RegisterOperand, RegisterOperand, IndexOperand),
         context: &mut Context,
     ) -> JsResult<()> {
         let function = context.vm.get_register(function.into()).clone();