perf(vm): ObjectCreateWithShape (#802)

aapoalas · web-flow · commit c05ccec4f4fb · 2025-07-28T15:31:52.000+03:00
diff --git a/nova_vm/src/ecmascript/types/language/object.rs b/nova_vm/src/ecmascript/types/language/object.rs
@@ -339,6 +339,24 @@ impl<'a> OrdinaryObject<'a> {
         Self::create_object_internal(agent, shape, entries)
     }
 
+    pub(crate) fn create_object_with_shape_and_data_properties(
+        agent: &mut Agent,
+        shape: ObjectShape<'a>,
+        values: &[Value<'a>],
+    ) -> Self {
+        // SAFETY: Option<Value> uses a niche in Value enum at discriminant 0.
+        let values = unsafe { core::mem::transmute::<&[Value<'a>], &[Option<Value<'a>>]>(values) };
+        let ElementsVector {
+            elements_index: values,
+            cap,
+            len,
+            len_writable: extensible,
+        } = agent.heap.elements.allocate_property_storage(values, None);
+        agent
+            .heap
+            .create(ObjectHeapData::new(shape, values, cap, len, extensible))
+    }
+
     /// Creates a new "intrinsic" object. An intrinsic object owns its Object
     /// Shape uniquely and thus any changes to the object properties mutate the
     /// Shape directly.
diff --git a/nova_vm/src/engine/bytecode/bytecode_compiler.rs b/nova_vm/src/engine/bytecode/bytecode_compiler.rs
@@ -16,7 +16,9 @@ mod template_literals;
 mod with_statement;
 
 use super::{FunctionExpression, Instruction, SendableRef, executable::ArrowFunctionExpression};
-use crate::ecmascript::execution::agent::ExceptionType;
+use crate::ecmascript::{
+    builtins::ordinary::shape::ObjectShape, execution::agent::ExceptionType, types::IntoObject,
+};
 #[cfg(feature = "regexp")]
 use crate::ecmascript::{
     syntax_directed_operations::{
@@ -436,8 +438,109 @@ impl<'s> CompileEvaluation<'s> for ast::Function<'s> {
     }
 }
 
+fn create_object_with_shape<'s>(
+    expr: &'s ast::ObjectExpression<'s>,
+    ctx: &mut CompileContext<'_, 's, '_, '_>,
+) {
+    let proto_prop = expr.properties.iter().find(|prop| {
+        let ast::ObjectPropertyKind::ObjectProperty(prop) = prop else {
+            unreachable!()
+        };
+        prop.key.is_specific_static_name("__proto__")
+            && prop.kind == ast::PropertyKind::Init
+            && !prop.shorthand
+    });
+    let prototype = if let Some(proto_prop) = proto_prop {
+        let ast::ObjectPropertyKind::ObjectProperty(proto_prop) = proto_prop else {
+            unreachable!()
+        };
+        if proto_prop.value.is_null() {
+            None
+        } else {
+            Some(
+                ctx.get_agent()
+                    .current_realm_record()
+                    .intrinsics()
+                    .object_prototype()
+                    .into_object(),
+            )
+        }
+    } else {
+        Some(
+            ctx.get_agent()
+                .current_realm_record()
+                .intrinsics()
+                .object_prototype()
+                .into_object(),
+        )
+    };
+    let mut shape = ObjectShape::get_shape_for_prototype(ctx.get_agent_mut(), prototype);
+    for prop in expr.properties.iter() {
+        let ast::ObjectPropertyKind::ObjectProperty(prop) = prop else {
+            unreachable!()
+        };
+        if !prop.shorthand && prop.key.is_specific_static_name("__proto__") {
+            continue;
+        }
+        let ast::PropertyKey::StaticIdentifier(id) = &prop.key else {
+            unreachable!()
+        };
+        let identifier = ctx.create_property_key(&id.name);
+        shape = shape.get_child_shape(ctx.get_agent_mut(), identifier);
+        if is_anonymous_function_definition(&prop.value) {
+            ctx.add_instruction_with_constant(Instruction::StoreConstant, identifier);
+            ctx.name_identifier = Some(NamedEvaluationParameter::Result);
+        }
+        prop.value.compile(ctx);
+        if is_reference(&prop.value) {
+            ctx.add_instruction(Instruction::GetValue);
+        }
+        ctx.add_instruction(Instruction::Load);
+    }
+    ctx.add_instruction_with_shape(Instruction::ObjectCreateWithShape, shape);
+}
+
 impl<'s> CompileEvaluation<'s> for ast::ObjectExpression<'s> {
     fn compile(&'s self, ctx: &mut CompileContext<'_, 's, '_, '_>) {
+        if !self.properties.is_empty()
+            && self.properties.iter().all(|prop| {
+                !prop.is_spread() && {
+                    let ast::ObjectPropertyKind::ObjectProperty(prop) = prop else {
+                        unreachable!()
+                    };
+                    prop.kind == ast::PropertyKind::Init
+                        && !prop.method
+                        && prop.key.is_identifier()
+                        && if prop.key.is_specific_static_name("__proto__") && !prop.shorthand {
+                            prop.value.is_null_or_undefined()
+                        } else {
+                            true
+                        }
+                }
+            })
+        {
+            let mut dedup_keys = self
+                .properties
+                .iter()
+                .map(|prop| {
+                    let ast::ObjectPropertyKind::ObjectProperty(prop) = prop else {
+                        unreachable!()
+                    };
+                    let ast::PropertyKey::StaticIdentifier(key) = &prop.key else {
+                        unreachable!()
+                    };
+                    key.name.as_str()
+                })
+                .collect::<Vec<_>>();
+            dedup_keys.sort();
+            dedup_keys.dedup();
+            // Check that there are no duplicates.
+            if dedup_keys.len() == self.properties.len() {
+                // Can create Object Shape beforehand and calculate
+                create_object_with_shape(self, ctx);
+                return;
+            }
+        }
         // TODO: Consider preparing the properties onto the stack and creating
         // the object with a known size.
         ctx.add_instruction(Instruction::ObjectCreate);
diff --git a/nova_vm/src/engine/bytecode/bytecode_compiler/compile_context.rs b/nova_vm/src/engine/bytecode/bytecode_compiler/compile_context.rs
@@ -7,7 +7,7 @@ use wtf8::Wtf8Buf;
 
 use crate::{
     ecmascript::{
-        builtins::regexp::RegExp,
+        builtins::{ordinary::shape::ObjectShape, regexp::RegExp},
         execution::Agent,
         syntax_directed_operations::function_definitions::CompileFunctionBodyData,
         types::{BigInt, Number, PropertyKey, String, Value},
@@ -1010,6 +1010,15 @@ impl<'agent, 'script, 'gc, 'scope> CompileContext<'agent, 'script, 'gc, 'scope>
             )
     }
 
+    pub(super) fn add_instruction_with_shape(
+        &mut self,
+        instruction: Instruction,
+        shape: ObjectShape<'gc>,
+    ) {
+        self.executable
+            .add_instruction_with_shape(instruction, shape);
+    }
+
     pub(super) fn add_arrow_function_expression(
         &mut self,
         arrow_function_expression: ArrowFunctionExpression,
diff --git a/nova_vm/src/engine/bytecode/bytecode_compiler/executable_context.rs b/nova_vm/src/engine/bytecode/bytecode_compiler/executable_context.rs
@@ -8,7 +8,10 @@ use wtf8::Wtf8Buf;
 
 use crate::{
     ecmascript::{
-        builtins::regexp::{RegExp, reg_exp_create_literal},
+        builtins::{
+            ordinary::shape::ObjectShape,
+            regexp::{RegExp, reg_exp_create_literal},
+        },
         execution::Agent,
         types::{BigInt, IntoValue, Number, PropertyKey, String, Value},
     },
@@ -35,6 +38,8 @@ pub(super) struct ExecutableContext<'agent, 'gc, 'scope> {
     instructions: Vec<u8>,
     /// Constants being built
     constants: Vec<Value<'gc>>,
+    /// Object Shapes being built
+    shapes: Vec<ObjectShape<'gc>>,
     /// Function expressions being built
     function_expressions: Vec<FunctionExpression<'gc>>,
     /// Arrow function expressions being built
@@ -50,6 +55,7 @@ impl<'agent, 'gc, 'scope> ExecutableContext<'agent, 'gc, 'scope> {
             current_instruction_pointer_is_unreachable: false,
             instructions: Vec::new(),
             constants: Vec::new(),
+            shapes: Vec::new(),
             function_expressions: Vec::new(),
             arrow_function_expressions: Vec::new(),
             class_initializer_bytecodes: Vec::new(),
@@ -114,6 +120,7 @@ impl<'agent, 'gc, 'scope> ExecutableContext<'agent, 'gc, 'scope> {
         self.agent.heap.create(ExecutableHeapData {
             instructions: self.instructions.into_boxed_slice(),
             constants: self.constants.unbind().into_boxed_slice(),
+            shapes: self.shapes.unbind().into_boxed_slice(),
             function_expressions: self.function_expressions.unbind().into_boxed_slice(),
             arrow_function_expressions: self.arrow_function_expressions.into_boxed_slice(),
             class_initializer_bytecodes: self
@@ -189,6 +196,21 @@ impl<'agent, 'gc, 'scope> ExecutableContext<'agent, 'gc, 'scope> {
         })
     }
 
+    pub(super) fn add_shape(&mut self, shape: ObjectShape<'gc>) -> usize {
+        let duplicate = self
+            .shapes
+            .iter()
+            .enumerate()
+            .find(|item| item.1.eq(&shape))
+            .map(|(idx, _)| idx);
+
+        duplicate.unwrap_or_else(|| {
+            let index = self.shapes.len();
+            self.shapes.push(shape);
+            index
+        })
+    }
+
     pub(super) fn add_instruction_with_immediate(
         &mut self,
         instruction: Instruction,
@@ -299,6 +321,18 @@ impl<'agent, 'gc, 'scope> ExecutableContext<'agent, 'gc, 'scope> {
         index as IndexType
     }
 
+    pub(super) fn add_instruction_with_shape(
+        &mut self,
+        instruction: Instruction,
+        shape: ObjectShape<'gc>,
+    ) {
+        debug_assert_eq!(instruction.argument_count(), 1);
+        debug_assert!(instruction.has_shape_index());
+        self.push_instruction(instruction);
+        let shape = self.add_shape(shape);
+        self.add_index(shape);
+    }
+
     pub(super) fn add_arrow_function_expression(
         &mut self,
         arrow_function_expression: ArrowFunctionExpression,
diff --git a/nova_vm/src/engine/bytecode/executable.rs b/nova_vm/src/engine/bytecode/executable.rs
@@ -10,6 +10,7 @@ use std::marker::PhantomData;
 
 use crate::{
     ecmascript::{
+        builtins::ordinary::shape::ObjectShape,
         execution::Agent,
         scripts_and_modules::{
             module::module_semantics::source_text_module_records::SourceTextModule, script::Script,
@@ -136,6 +137,7 @@ const EXECUTABLE_OPTION_SIZE_IS_U32: () =
 pub struct ExecutableHeapData<'a> {
     pub(crate) instructions: Box<[u8]>,
     pub(crate) constants: Box<[Value<'a>]>,
+    pub(crate) shapes: Box<[ObjectShape<'a>]>,
     pub(crate) function_expressions: Box<[FunctionExpression<'a>]>,
     pub(crate) arrow_function_expressions: Box<[ArrowFunctionExpression]>,
     pub(crate) class_initializer_bytecodes: Box<[(Option<Executable<'a>>, bool)]>,
@@ -326,6 +328,15 @@ impl<'gc> Executable<'gc> {
     ) -> (Option<Executable<'gc>>, bool) {
         agent[self].class_initializer_bytecodes[index]
     }
+
+    fn fetch_object_shape(
+        self,
+        agent: &Agent,
+        index: usize,
+        gc: NoGcScope<'gc, '_>,
+    ) -> ObjectShape<'gc> {
+        agent[self].shapes[index].bind(gc)
+    }
 }
 
 impl Scoped<'_, Executable<'static>> {
@@ -400,6 +411,16 @@ impl Scoped<'_, Executable<'static>> {
         self.get(agent)
             .fetch_class_initializer_bytecode(agent, index, gc)
     }
+
+    #[inline]
+    pub(super) fn fetch_object_shape<'gc>(
+        &self,
+        agent: &Agent,
+        index: usize,
+        gc: NoGcScope<'gc, '_>,
+    ) -> ObjectShape<'gc> {
+        self.get(agent).fetch_object_shape(agent, index, gc)
+    }
 }
 
 impl Index<Executable<'_>> for Agent {
@@ -506,11 +527,13 @@ impl HeapMarkAndSweep for ExecutableHeapData<'static> {
         let Self {
             instructions: _,
             constants,
+            shapes,
             function_expressions: _,
             arrow_function_expressions: _,
             class_initializer_bytecodes,
         } = self;
         constants.mark_values(queues);
+        shapes.mark_values(queues);
         for ele in class_initializer_bytecodes {
             ele.0.mark_values(queues);
         }
@@ -520,11 +543,13 @@ impl HeapMarkAndSweep for ExecutableHeapData<'static> {
         let Self {
             instructions: _,
             constants,
+            shapes,
             function_expressions: _,
             arrow_function_expressions: _,
             class_initializer_bytecodes,
         } = self;
         constants.sweep_values(compactions);
+        shapes.sweep_values(compactions);
         for ele in class_initializer_bytecodes {
             ele.0.sweep_values(compactions);
         }
diff --git a/nova_vm/src/engine/bytecode/instructions.rs b/nova_vm/src/engine/bytecode/instructions.rs
@@ -219,6 +219,9 @@ pub enum Instruction {
     LogicalNot,
     /// Store OrdinaryObjectCreate(%Object.prototype%) on the stack.
     ObjectCreate,
+    /// Store a new as the result Object created with the given shape, with its
+    /// properties coming from the stack.
+    ObjectCreateWithShape,
     /// Call CreateDataPropertyOrThrow(object, key, value) with value being the
     /// result value, key being the top stack value and object being the second
     /// stack value. The object is not popped from the stack.
@@ -527,6 +530,7 @@ impl Instruction {
             | Self::LoadConstant
             | Self::MakePrivateReference
             | Self::MakeSuperPropertyReferenceWithIdentifierKey
+            | Self::ObjectCreateWithShape
             | Self::ClassInitializePrivateValue
             | Self::ResolveBinding
             | Self::StoreConstant
@@ -559,6 +563,10 @@ impl Instruction {
         )
     }
 
+    pub fn has_shape_index(self) -> bool {
+        matches!(self, Self::ObjectCreateWithShape)
+    }
+
     pub fn has_identifier_index(self) -> bool {
         matches!(
             self,
@@ -1177,6 +1185,7 @@ impl TryFrom<u8> for Instruction {
         const EMPTY: u8 = Instruction::Empty.as_u8();
         const LOGICALNOT: u8 = Instruction::LogicalNot.as_u8();
         const OBJECTCREATE: u8 = Instruction::ObjectCreate.as_u8();
+        const OBJECTCREATEWITHSHAPE: u8 = Instruction::ObjectCreateWithShape.as_u8();
         const OBJECTDEFINEPROPERTY: u8 = Instruction::ObjectDefineProperty.as_u8();
         const OBJECTDEFINEMETHOD: u8 = Instruction::ObjectDefineMethod.as_u8();
         const OBJECTDEFINEGETTER: u8 = Instruction::ObjectDefineGetter.as_u8();
@@ -1383,6 +1392,7 @@ impl TryFrom<u8> for Instruction {
             EMPTY => Ok(Instruction::Empty),
             LOGICALNOT => Ok(Instruction::LogicalNot),
             OBJECTCREATE => Ok(Instruction::ObjectCreate),
+            OBJECTCREATEWITHSHAPE => Ok(Instruction::ObjectCreateWithShape),
             OBJECTDEFINEPROPERTY => Ok(Instruction::ObjectDefineProperty),
             OBJECTDEFINEMETHOD => Ok(Instruction::ObjectDefineMethod),
             OBJECTDEFINEGETTER => Ok(Instruction::ObjectDefineGetter),
diff --git a/nova_vm/src/engine/bytecode/vm.rs b/nova_vm/src/engine/bytecode/vm.rs
@@ -1131,6 +1131,19 @@ impl Vm {
                 );
                 vm.stack.push(object.into_value().unbind())
             }
+            Instruction::ObjectCreateWithShape => {
+                let shape =
+                    executable.fetch_object_shape(agent, instr.get_first_index(), gc.into_nogc());
+                let len = shape.get_length(agent);
+                let first_property_index = vm.stack.len() - len as usize;
+                let obj = OrdinaryObject::create_object_with_shape_and_data_properties(
+                    agent,
+                    shape,
+                    &vm.stack[first_property_index..],
+                );
+                vm.stack.truncate(first_property_index);
+                vm.result = Some(obj.unbind().into_value());
+            }
             Instruction::CopyDataProperties => {
                 let source = vm.result.take().unwrap();
                 let Value::Object(target) = *vm.stack.last().unwrap() else {
diff --git a/nova_vm/src/heap/element_array.rs b/nova_vm/src/heap/element_array.rs
