Lines Matching defs:Copy
3393 // - Copy all existing properties in, in the following order: backing store
3396 // * Copy inobject properties from the backing store back into the object.
3567 // Copy (real) inobject properties. If necessary, stop at number_of_fields to
3675 // Copy the next enumeration index from instance descriptor.
3788 Handle<Map> new_map = Map::Copy(old_map, "ForceSetPrototype");
4611 // If the source descriptors had an enum cache we copy it. This ensures
6696 // 2. Let newLenDesc be a copy of Desc.
7506 Handle<Map> new_map = Map::Copy(handle(object->map()), "PreventExtensions");
7700 Map::Copy(handle(object->map()), "SlowCopyForPreventExtensions");
7820 Handle<JSObject> copy;
7828 copy = isolate->factory()->CopyJSObjectWithAllocationSite(
7831 copy = object;
7834 DCHECK(copying || copy.is_identical_to(object));
7836 ElementsKind kind = copy->GetElementsKind();
7838 FixedArray::cast(copy->elements())->map() ==
7846 // Deep copy own properties.
7847 if (copy->HasFastProperties()) {
7848 Handle<DescriptorArray> descriptors(copy->map()->instance_descriptors());
7849 int limit = copy->map()->NumberOfOwnDescriptors();
7854 FieldIndex index = FieldIndex::ForDescriptor(copy->map(), i);
7859 copy->RawFastDoublePropertyAsBitsAtPut(index, value);
7866 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
7869 copy->FastPropertyAtPut(index, *value);
7875 copy->FastPropertyAtPut(index, *value);
7881 // Only deep copy fields from the object literal expression.
7882 // In particular, don't try to copy the length attribute of
7887 accumulator.CollectOwnPropertyNames(copy, copy);
7893 JSObject::GetProperty(copy, name).ToHandleChecked();
7898 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
7901 // Creating object copy for literals. No strict mode needed.
7902 JSObject::SetProperty(copy, name, result, SLOPPY).Assert();
7908 // Deep copy own elements.
7912 Handle<FixedArray> elements(FixedArray::cast(copy->elements()));
7926 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
7938 copy->element_dictionary());
7948 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
7986 return copy;
8007 MaybeHandle<JSObject> copy = v.StructureWalk(object);
8009 DCHECK(!copy.ToHandle(&for_assert) || !for_assert.is_identical_to(object));
8010 return copy;
8609 Handle<Map> new_map = Map::Copy(map, "ImmutablePrototype");
8643 // The copy will use the same descriptors array.
8921 Handle<Map> new_map = Copy(map, "CopyAsElementsKind");
9002 Handle<Map> Map::Copy(Handle<Map> map, const char* reason) {
9016 Handle<Map> copy =
9017 Copy(handle(isolate->object_function()->initial_map()), "MapCreate");
9033 copy->SetInObjectProperties(inobject_properties);
9034 copy->set_unused_property_fields(inobject_properties);
9035 copy->set_instance_size(new_instance_size);
9036 copy->set_visitor_id(Heap::GetStaticVisitorIdForMap(*copy));
9037 return copy;
9303 pair = AccessorPair::Copy(Handle<AccessorPair>::cast(maybe_pair));
9888 // Copy the entries without compacting, since the PrototypeInfo relies on
10129 Handle<AccessorPair> AccessorPair::Copy(Handle<AccessorPair> pair) {
10130 Handle<AccessorPair> copy = pair->GetIsolate()->factory()->NewAccessorPair();
10131 copy->set_getter(pair->getter());
10132 copy->set_setter(pair->setter());
10133 return copy;
11948 // Copy old optimized code map and append one new entry.
11952 // have flushed the optimized code map and the copy we created is full of
12139 Handle<Map> new_map = Map::Copy(handle(object->map()), "CopyAsPrototype");
12436 // copy containing the new prototype. Also complete any in-object
12438 // still tracking the old copy.
12450 Handle<Map> new_map = Map::Copy(initial_map, "SetInstancePrototype");
12494 // Copy the map so this does not affect unrelated functions.
12497 Handle<Map> new_map = Map::Copy(handle(function->map()), "SetPrototype");
13470 // Copy the deoptimization data from the recompiled code.
13772 // copy code
13776 // copy unwinding info, if any
13784 // copy reloc info
14820 copy(i, new_count);
14886 copy(old_count - 1, info_pos);
15032 new_map = Copy(map, "TransitionToPrototype");
15992 Handle<JSRegExp> JSRegExp::Copy(Handle<JSRegExp> regexp) {
16026 // Escape. Copy this and next character.
16325 // Copy prefix to new array.
17237 // |to| is a just-created internalized copy of |from|. Migrate the resource.
17471 // Copy old optimized code map and append one new entry.
17752 // Make sure that HashTable::EnsureCapacity will create a copy.
19354 // Swap with a copy.
20039 // Copy [more_exports] into [exports].
