Reduce unnecessary COW on Vector by make writing explicit

This commit makes operator[] on Vector const and adds a write proxy to it.  From
now on writes to Vectors need to happen through the .write proxy. So for
instance:

Vector<int> vec;
vec.push_back(10);
std::cout << vec[0] << std::endl;
vec.write[0] = 20;

Failing to use the .write proxy will cause a compilation error.

In addition COWable datatypes can now embed a CowData pointer to their data.
This means that String, CharString, and VMap no longer use or derive from
Vector.

_ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug
builds. This is a lot faster for Vector in the editor and while running tests.
The reason why this difference used to exist is because force-inlined methods
used to give a bad debugging experience. After extensive testing with modern
compilers this is no longer the case.

37 files changed, 218 insertions, 218 deletions

diff --git a/modules/bullet/area_bullet.cpp b/modules/bullet/area_bullet.cpp
index bfb452d109..b004641838 100644
--- a/modules/bullet/area_bullet.cpp
+++ b/modules/bullet/area_bullet.cpp
@@ -80,7 +80,7 @@ void AreaBullet::dispatch_callbacks() {
 
 	// Reverse order because I've to remove EXIT objects
 	for (int i = overlappingObjects.size() - 1; 0 <= i; --i) {
-		OverlappingObjectData &otherObj = overlappingObjects[i];
+		OverlappingObjectData &otherObj = overlappingObjects.write[i];
 
 		switch (otherObj.state) {
 			case OVERLAP_STATE_ENTER:
@@ -199,13 +199,13 @@ void AreaBullet::add_overlap(CollisionObjectBullet *p_otherObject) {
 
 void AreaBullet::put_overlap_as_exit(int p_index) {
 	scratch();
-	overlappingObjects[p_index].state = OVERLAP_STATE_EXIT;
+	overlappingObjects.write[p_index].state = OVERLAP_STATE_EXIT;
 }
 
 void AreaBullet::put_overlap_as_inside(int p_index) {
 	// This check is required to be sure this body was inside
 	if (OVERLAP_STATE_DIRTY == overlappingObjects[p_index].state) {
-		overlappingObjects[p_index].state = OVERLAP_STATE_INSIDE;
+		overlappingObjects.write[p_index].state = OVERLAP_STATE_INSIDE;
 	}
 }
 
diff --git a/modules/bullet/collision_object_bullet.cpp b/modules/bullet/collision_object_bullet.cpp
index 1d63318fd7..271cdb0223 100644
--- a/modules/bullet/collision_object_bullet.cpp
+++ b/modules/bullet/collision_object_bullet.cpp
@@ -223,7 +223,7 @@ void RigidCollisionObjectBullet::add_shape(ShapeBullet *p_shape, const Transform
 }
 
 void RigidCollisionObjectBullet::set_shape(int p_index, ShapeBullet *p_shape) {
-	ShapeWrapper &shp = shapes[p_index];
+	ShapeWrapper &shp = shapes.write[p_index];
 	shp.shape->remove_owner(this);
 	p_shape->add_owner(this);
 	shp.shape = p_shape;
@@ -233,8 +233,8 @@ void RigidCollisionObjectBullet::set_shape(int p_index, ShapeBullet *p_shape) {
 void RigidCollisionObjectBullet::set_shape_transform(int p_index, const Transform &p_transform) {
 	ERR_FAIL_INDEX(p_index, get_shape_count());
 
-	shapes[p_index].set_transform(p_transform);
-	on_shape_changed(shapes[p_index].shape);
+	shapes.write[p_index].set_transform(p_transform);
+	on_shape_changed(shapes.write[p_index].shape);
 }
 
 void RigidCollisionObjectBullet::remove_shape(ShapeBullet *p_shape) {
@@ -287,7 +287,7 @@ void RigidCollisionObjectBullet::on_shape_changed(const ShapeBullet *const p_sha
 	const int size = shapes.size();
 	for (int i = 0; i < size; ++i) {
 		if (shapes[i].shape == p_shape) {
-			bulletdelete(shapes[i].bt_shape);
+			bulletdelete(shapes.write[i].bt_shape);
 		}
 	}
 	on_shapes_changed();
@@ -307,7 +307,7 @@ void RigidCollisionObjectBullet::on_shapes_changed() {
 	// Reset shape if required
 	if (force_shape_reset) {
 		for (i = 0; i < shapes_size; ++i) {
-			shpWrapper = &shapes[i];
+			shpWrapper = &shapes.write[i];
 			bulletdelete(shpWrapper->bt_shape);
 		}
 		force_shape_reset = false;
@@ -316,7 +316,7 @@ void RigidCollisionObjectBullet::on_shapes_changed() {
 	// Insert all shapes
 	btVector3 body_scale(get_bt_body_scale());
 	for (i = 0; i < shapes_size; ++i) {
-		shpWrapper = &shapes[i];
+		shpWrapper = &shapes.write[i];
 		if (shpWrapper->active) {
 			if (!shpWrapper->bt_shape) {
 				shpWrapper->bt_shape = shpWrapper->shape->create_bt_shape(shpWrapper->scale * body_scale);
@@ -334,7 +334,7 @@ void RigidCollisionObjectBullet::on_shapes_changed() {
 }
 
 void RigidCollisionObjectBullet::set_shape_disabled(int p_index, bool p_disabled) {
-	shapes[p_index].active = !p_disabled;
+	shapes.write[p_index].active = !p_disabled;
 	on_shapes_changed();
 }
 
@@ -348,7 +348,7 @@ void RigidCollisionObjectBullet::on_body_scale_changed() {
 }
 
 void RigidCollisionObjectBullet::internal_shape_destroy(int p_index, bool p_permanentlyFromThisBody) {
-	ShapeWrapper &shp = shapes[p_index];
+	ShapeWrapper &shp = shapes.write[p_index];
 	shp.shape->remove_owner(this, p_permanentlyFromThisBody);
 	bulletdelete(shp.bt_shape);
 }
diff --git a/modules/bullet/rigid_body_bullet.cpp b/modules/bullet/rigid_body_bullet.cpp
index 18f8f5f677..52453eae17 100644
--- a/modules/bullet/rigid_body_bullet.cpp
+++ b/modules/bullet/rigid_body_bullet.cpp
@@ -179,7 +179,7 @@ int BulletPhysicsDirectBodyState::get_contact_collider_shape(int p_contact_idx)
 }
 
 Vector3 BulletPhysicsDirectBodyState::get_contact_collider_velocity_at_position(int p_contact_idx) const {
-	RigidBodyBullet::CollisionData &colDat = body->collisions[p_contact_idx];
+	RigidBodyBullet::CollisionData &colDat = body->collisions.write[p_contact_idx];
 
 	btVector3 hitLocation;
 	G_TO_B(colDat.hitLocalLocation, hitLocation);
@@ -224,8 +224,8 @@ void RigidBodyBullet::KinematicUtilities::copyAllOwnerShapes() {
 			continue;
 		}
 
-		shapes[i].transform = shape_wrapper->transform;
-		shapes[i].transform.getOrigin() *= owner_scale;
+		shapes.write[i].transform = shape_wrapper->transform;
+		shapes.write[i].transform.getOrigin() *= owner_scale;
 		switch (shape_wrapper->shape->get_type()) {
 			case PhysicsServer::SHAPE_SPHERE:
 			case PhysicsServer::SHAPE_BOX:
@@ -233,11 +233,11 @@ void RigidBodyBullet::KinematicUtilities::copyAllOwnerShapes() {
 			case PhysicsServer::SHAPE_CYLINDER:
 			case PhysicsServer::SHAPE_CONVEX_POLYGON:
 			case PhysicsServer::SHAPE_RAY: {
-				shapes[i].shape = static_cast<btConvexShape *>(shape_wrapper->shape->create_bt_shape(owner_scale * shape_wrapper->scale, safe_margin));
+				shapes.write[i].shape = static_cast<btConvexShape *>(shape_wrapper->shape->create_bt_shape(owner_scale * shape_wrapper->scale, safe_margin));
 			} break;
 			default:
 				WARN_PRINT("This shape is not supported to be kinematic!");
-				shapes[i].shape = NULL;
+				shapes.write[i].shape = NULL;
 		}
 	}
 }
@@ -245,7 +245,7 @@ void RigidBodyBullet::KinematicUtilities::copyAllOwnerShapes() {
 void RigidBodyBullet::KinematicUtilities::just_delete_shapes(int new_size) {
 	for (int i = shapes.size() - 1; 0 <= i; --i) {
 		if (shapes[i].shape) {
-			bulletdelete(shapes[i].shape);
+			bulletdelete(shapes.write[i].shape);
 		}
 	}
 	shapes.resize(new_size);
@@ -287,7 +287,7 @@ RigidBodyBullet::RigidBodyBullet() :
 
 	areasWhereIam.resize(maxAreasWhereIam);
 	for (int i = areasWhereIam.size() - 1; 0 <= i; --i) {
-		areasWhereIam[i] = NULL;
+		areasWhereIam.write[i] = NULL;
 	}
 	btBody->setSleepingThresholds(0.2, 0.2);
 }
@@ -413,7 +413,7 @@ bool RigidBodyBullet::add_collision_object(RigidBodyBullet *p_otherObject, const
 		return false;
 	}
 
-	CollisionData &cd = collisions[collisionsCount];
+	CollisionData &cd = collisions.write[collisionsCount];
 	cd.hitLocalLocation = p_hitLocalLocation;
 	cd.otherObject = p_otherObject;
 	cd.hitWorldLocation = p_hitWorldLocation;
@@ -817,15 +817,15 @@ void RigidBodyBullet::on_enter_area(AreaBullet *p_area) {
 
 		if (NULL == areasWhereIam[i]) {
 			// This area has the highest priority
-			areasWhereIam[i] = p_area;
+			areasWhereIam.write[i] = p_area;
 			break;
 		} else {
 			if (areasWhereIam[i]->get_spOv_priority() > p_area->get_spOv_priority()) {
 				// The position was found, just shift all elements
 				for (int j = i; j < areaWhereIamCount; ++j) {
-					areasWhereIam[j + 1] = areasWhereIam[j];
+					areasWhereIam.write[j + 1] = areasWhereIam[j];
 				}
-				areasWhereIam[i] = p_area;
+				areasWhereIam.write[i] = p_area;
 				break;
 			}
 		}
@@ -849,7 +849,7 @@ void RigidBodyBullet::on_exit_area(AreaBullet *p_area) {
 		if (p_area == areasWhereIam[i]) {
 			// The area was fount, just shift down all elements
 			for (int j = i; j < areaWhereIamCount; ++j) {
-				areasWhereIam[j] = areasWhereIam[j + 1];
+				areasWhereIam.write[j] = areasWhereIam[j + 1];
 			}
 			wasTheAreaFound = true;
 			break;
@@ -862,7 +862,7 @@ void RigidBodyBullet::on_exit_area(AreaBullet *p_area) {
 		}
 
 		--areaWhereIamCount;
-		areasWhereIam[areaWhereIamCount] = NULL; // Even if this is not required, I clear the last element to be safe
+		areasWhereIam.write[areaWhereIamCount] = NULL; // Even if this is not required, I clear the last element to be safe
 		if (PhysicsServer::AREA_SPACE_OVERRIDE_DISABLED != p_area->get_spOv_mode()) {
 			scratch_space_override_modificator();
 		}
diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index 92e7c2df98..e4c1a5f9b5 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -304,7 +304,7 @@ void ConvexPolygonShapeBullet::get_vertices(Vector<Vector3> &out_vertices) {
 	const int n_of_vertices = vertices.size();
 	out_vertices.resize(n_of_vertices);
 	for (int i = n_of_vertices - 1; 0 <= i; --i) {
-		B_TO_G(vertices[i], out_vertices[i]);
+		B_TO_G(vertices[i], out_vertices.write[i]);
 	}
 }
 
diff --git a/modules/bullet/soft_body_bullet.cpp b/modules/bullet/soft_body_bullet.cpp
index b3680d58db..1686a6e87e 100644
--- a/modules/bullet/soft_body_bullet.cpp
+++ b/modules/bullet/soft_body_bullet.cpp
@@ -90,7 +90,7 @@ void SoftBodyBullet::update_visual_server(SoftBodyVisualServerHandler *p_visual_
 	const btSoftBody::tNodeArray &nodes(bt_soft_body->m_nodes);
 	const int nodes_count = nodes.size();
 
-	Vector<int> *vs_indices;
+	const Vector<int> *vs_indices;
 	const void *vertex_position;
 	const void *vertex_normal;
 
@@ -359,7 +359,7 @@ void SoftBodyBullet::set_trimesh_body_shape(PoolVector<int> p_indices, PoolVecto
 					indices_table.push_back(Vector<int>());
 				}
 
-				indices_table[vertex_id].push_back(vs_vertex_index);
+				indices_table.write[vertex_id].push_back(vs_vertex_index);
 				vs_indices_to_physics_table.push_back(vertex_id);
 			}
 		}
@@ -374,9 +374,9 @@ void SoftBodyBullet::set_trimesh_body_shape(PoolVector<int> p_indices, PoolVecto
 			PoolVector<Vector3>::Read p_vertices_read = p_vertices.read();
 
 			for (int i = 0; i < indices_map_size; ++i) {
-				bt_vertices[3 * i + 0] = p_vertices_read[indices_table[i][0]].x;
-				bt_vertices[3 * i + 1] = p_vertices_read[indices_table[i][0]].y;
-				bt_vertices[3 * i + 2] = p_vertices_read[indices_table[i][0]].z;
+				bt_vertices.write[3 * i + 0] = p_vertices_read[indices_table[i][0]].x;
+				bt_vertices.write[3 * i + 1] = p_vertices_read[indices_table[i][0]].y;
+				bt_vertices.write[3 * i + 2] = p_vertices_read[indices_table[i][0]].z;
 			}
 		}
 
@@ -390,9 +390,9 @@ void SoftBodyBullet::set_trimesh_body_shape(PoolVector<int> p_indices, PoolVecto
 			PoolVector<int>::Read p_indices_read = p_indices.read();
 
 			for (int i = 0; i < triangles_size; ++i) {
-				bt_triangles[3 * i + 0] = vs_indices_to_physics_table[p_indices_read[3 * i + 2]];
-				bt_triangles[3 * i + 1] = vs_indices_to_physics_table[p_indices_read[3 * i + 1]];
-				bt_triangles[3 * i + 2] = vs_indices_to_physics_table[p_indices_read[3 * i + 0]];
+				bt_triangles.write[3 * i + 0] = vs_indices_to_physics_table[p_indices_read[3 * i + 2]];
+				bt_triangles.write[3 * i + 1] = vs_indices_to_physics_table[p_indices_read[3 * i + 1]];
+				bt_triangles.write[3 * i + 2] = vs_indices_to_physics_table[p_indices_read[3 * i + 0]];
 			}
 		}
 
diff --git a/modules/bullet/space_bullet.cpp b/modules/bullet/space_bullet.cpp
index 132c3739d6..1ef631c916 100644
--- a/modules/bullet/space_bullet.cpp
+++ b/modules/bullet/space_bullet.cpp
@@ -686,7 +686,7 @@ void SpaceBullet::check_ghost_overlaps() {
 
 		/// 1. Reset all states
 		for (i = area->overlappingObjects.size() - 1; 0 <= i; --i) {
-			AreaBullet::OverlappingObjectData &otherObj = area->overlappingObjects[i];
+			AreaBullet::OverlappingObjectData &otherObj = area->overlappingObjects.write[i];
 			// This check prevent the overwrite of ENTER state
 			// if this function is called more times before dispatchCallbacks
 			if (otherObj.state != AreaBullet::OVERLAP_STATE_ENTER) {
diff --git a/modules/bullet/space_bullet.h b/modules/bullet/space_bullet.h
index 006c6462cf..6b86fc2f03 100644
--- a/modules/bullet/space_bullet.h
+++ b/modules/bullet/space_bullet.h
@@ -164,7 +164,7 @@ public:
 		contactDebugCount = 0;
 	}
 	_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
-		if (contactDebugCount < contactDebug.size()) contactDebug[contactDebugCount++] = p_contact;
+		if (contactDebugCount < contactDebug.size()) contactDebug.write[contactDebugCount++] = p_contact;
 	}
 	_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contactDebug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contactDebugCount; }
diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index 4e6e701bfd..87c2caec0d 100644
--- a/modules/csg/csg.cpp
+++ b/modules/csg/csg.cpp
@@ -62,7 +62,7 @@ void CSGBrush::build_from_faces(const PoolVector<Vector3> &p_vertices, const Poo
 	faces.resize(p_vertices.size() / 3);
 
 	for (int i = 0; i < faces.size(); i++) {
-		Face &f = faces[i];
+		Face &f = faces.write[i];
 		f.vertices[0] = rv[i * 3 + 0];
 		f.vertices[1] = rv[i * 3 + 1];
 		f.vertices[2] = rv[i * 3 + 2];
@@ -101,7 +101,7 @@ void CSGBrush::build_from_faces(const PoolVector<Vector3> &p_vertices, const Poo
 
 	materials.resize(material_map.size());
 	for (Map<Ref<Material>, int>::Element *E = material_map.front(); E; E = E->next()) {
-		materials[E->get()] = E->key();
+		materials.write[E->get()] = E->key();
 	}
 
 	_regen_face_aabbs();
@@ -111,10 +111,10 @@ void CSGBrush::_regen_face_aabbs() {
 
 	for (int i = 0; i < faces.size(); i++) {
 
-		faces[i].aabb.position = faces[i].vertices[0];
-		faces[i].aabb.expand_to(faces[i].vertices[1]);
-		faces[i].aabb.expand_to(faces[i].vertices[2]);
-		faces[i].aabb.grow_by(faces[i].aabb.get_longest_axis_size() * 0.001); //make it a tad bigger to avoid num precision erros
+		faces.write[i].aabb.position = faces[i].vertices[0];
+		faces.write[i].aabb.expand_to(faces[i].vertices[1]);
+		faces.write[i].aabb.expand_to(faces[i].vertices[2]);
+		faces.write[i].aabb.grow_by(faces[i].aabb.get_longest_axis_size() * 0.001); //make it a tad bigger to avoid num precision erros
 	}
 }
 
@@ -125,7 +125,7 @@ void CSGBrush::copy_from(const CSGBrush &p_brush, const Transform &p_xform) {
 
 	for (int i = 0; i < faces.size(); i++) {
 		for (int j = 0; j < 3; j++) {
-			faces[i].vertices[j] = p_xform.xform(p_brush.faces[i].vertices[j]);
+			faces.write[i].vertices[j] = p_xform.xform(p_brush.faces[i].vertices[j]);
 		}
 	}
 
@@ -341,7 +341,7 @@ void CSGBrushOperation::BuildPoly::_clip_segment(const CSGBrush *p_brush, int p_
 			new_edge.points[0] = edges[i].points[0];
 			new_edge.points[1] = point_idx;
 			new_edge.outer = edges[i].outer;
-			edges[i].points[0] = point_idx;
+			edges.write[i].points[0] = point_idx;
 			edges.insert(i, new_edge);
 			i++; //skip newly inserted edge
 			base_edges++; //will need an extra one in the base triangle
@@ -637,7 +637,7 @@ void CSGBrushOperation::_add_poly_points(const BuildPoly &p_poly, int p_edge, in
 		int to_point = e.edge_point;
 		int current_edge = e.edge;
 
-		edge_process[e.edge] = true; //mark as processed
+		edge_process.write[e.edge] = true; //mark as processed
 
 		int limit = p_poly.points.size() * 4; //avoid infinite recursion
 
@@ -708,7 +708,7 @@ void CSGBrushOperation::_add_poly_points(const BuildPoly &p_poly, int p_edge, in
 
 			prev_point = to_point;
 			to_point = next_point;
-			edge_process[next_edge] = true; //mark this edge as processed
+			edge_process.write[next_edge] = true; //mark this edge as processed
 			current_edge = next_edge;
 
 			limit--;
@@ -792,13 +792,13 @@ void CSGBrushOperation::_merge_poly(MeshMerge &mesh, int p_face_idx, const Build
 
 	//none processed by default
 	for (int i = 0; i < edge_process.size(); i++) {
-		edge_process[i] = false;
+		edge_process.write[i] = false;
 	}
 
 	//put edges in points, so points can go through them
 	for (int i = 0; i < p_poly.edges.size(); i++) {
-		vertex_process[p_poly.edges[i].points[0]].push_back(i);
-		vertex_process[p_poly.edges[i].points[1]].push_back(i);
+		vertex_process.write[p_poly.edges[i].points[0]].push_back(i);
+		vertex_process.write[p_poly.edges[i].points[1]].push_back(i);
 	}
 
 	Vector<PolyPoints> polys;
@@ -854,7 +854,7 @@ void CSGBrushOperation::_merge_poly(MeshMerge &mesh, int p_face_idx, const Build
 			_add_poly_outline(p_poly, p_poly.edges[i].points[0], p_poly.edges[i].points[1], vertex_process, outline);
 
 			if (outline.size() > 1) {
-				polys[intersect_poly].holes.push_back(outline);
+				polys.write[intersect_poly].holes.push_back(outline);
 			}
 		}
 		_add_poly_points(p_poly, i, p_poly.edges[i].points[0], p_poly.edges[i].points[1], vertex_process, edge_process, polys);
@@ -953,18 +953,18 @@ void CSGBrushOperation::_merge_poly(MeshMerge &mesh, int p_face_idx, const Build
 
 					//duplicate point
 					int insert_at = with_outline_vertex;
-					polys[i].points.insert(insert_at, polys[i].points[insert_at]);
+					polys.write[i].points.insert(insert_at, polys[i].points[insert_at]);
 					insert_at++;
 					//insert all others, outline should be backwards (must check)
 					int holesize = polys[i].holes[j].size();
 					for (int k = 0; k <= holesize; k++) {
 						int idx = (from_hole_vertex + k) % holesize;
-						polys[i].points.insert(insert_at, polys[i].holes[j][idx]);
+						polys.write[i].points.insert(insert_at, polys[i].holes[j][idx]);
 						insert_at++;
 					}
 
 					added_hole = true;
-					polys[i].holes.remove(j);
+					polys.write[i].holes.remove(j);
 					break; //got rid of hole, break and continue
 				}
 			}
@@ -980,7 +980,7 @@ void CSGBrushOperation::_merge_poly(MeshMerge &mesh, int p_face_idx, const Build
 		Vector<Vector2> vertices;
 		vertices.resize(polys[i].points.size());
 		for (int j = 0; j < vertices.size(); j++) {
-			vertices[j] = p_poly.points[polys[i].points[j]].point;
+			vertices.write[j] = p_poly.points[polys[i].points[j]].point;
 		}
 
 		Vector<int> indices = Geometry::triangulate_polygon(vertices);
@@ -1267,7 +1267,7 @@ void CSGBrushOperation::MeshMerge::mark_inside_faces() {
 		int intersections = _bvh_count_intersections(bvh, max_depth, max_alloc - 1, center, target, i);
 
 		if (intersections & 1) {
-			faces[i].inside = true;
+			faces.write[i].inside = true;
 		}
 	}
 }
@@ -1419,13 +1419,13 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_A
 				if (mesh_merge.faces[i].inside)
 					continue;
 				for (int j = 0; j < 3; j++) {
-					result.faces[outside_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
-					result.faces[outside_count].uvs[j] = mesh_merge.faces[i].uvs[j];
+					result.faces.write[outside_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
+					result.faces.write[outside_count].uvs[j] = mesh_merge.faces[i].uvs[j];
 				}
 
-				result.faces[outside_count].smooth = mesh_merge.faces[i].smooth;
-				result.faces[outside_count].invert = mesh_merge.faces[i].invert;
-				result.faces[outside_count].material = mesh_merge.faces[i].material_idx;
+				result.faces.write[outside_count].smooth = mesh_merge.faces[i].smooth;
+				result.faces.write[outside_count].invert = mesh_merge.faces[i].invert;
+				result.faces.write[outside_count].material = mesh_merge.faces[i].material_idx;
 				outside_count++;
 			}
 
@@ -1451,13 +1451,13 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_A
 				if (!mesh_merge.faces[i].inside)
 					continue;
 				for (int j = 0; j < 3; j++) {
-					result.faces[inside_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
-					result.faces[inside_count].uvs[j] = mesh_merge.faces[i].uvs[j];
+					result.faces.write[inside_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
+					result.faces.write[inside_count].uvs[j] = mesh_merge.faces[i].uvs[j];
 				}
 
-				result.faces[inside_count].smooth = mesh_merge.faces[i].smooth;
-				result.faces[inside_count].invert = mesh_merge.faces[i].invert;
-				result.faces[inside_count].material = mesh_merge.faces[i].material_idx;
+				result.faces.write[inside_count].smooth = mesh_merge.faces[i].smooth;
+				result.faces.write[inside_count].invert = mesh_merge.faces[i].invert;
+				result.faces.write[inside_count].material = mesh_merge.faces[i].material_idx;
 				inside_count++;
 			}
 
@@ -1489,19 +1489,19 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_A
 					continue;
 
 				for (int j = 0; j < 3; j++) {
-					result.faces[face_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
-					result.faces[face_count].uvs[j] = mesh_merge.faces[i].uvs[j];
+					result.faces.write[face_count].vertices[j] = mesh_merge.points[mesh_merge.faces[i].points[j]];
+					result.faces.write[face_count].uvs[j] = mesh_merge.faces[i].uvs[j];
 				}
 
 				if (mesh_merge.faces[i].from_b) {
 					//invert facing of insides of B
-					SWAP(result.faces[face_count].vertices[1], result.faces[face_count].vertices[2]);
-					SWAP(result.faces[face_count].uvs[1], result.faces[face_count].uvs[2]);
+					SWAP(result.faces.write[face_count].vertices[1], result.faces.write[face_count].vertices[2]);
+					SWAP(result.faces.write[face_count].uvs[1], result.faces.write[face_count].uvs[2]);
 				}
 
-				result.faces[face_count].smooth = mesh_merge.faces[i].smooth;
-				result.faces[face_count].invert = mesh_merge.faces[i].invert;
-				result.faces[face_count].material = mesh_merge.faces[i].material_idx;
+				result.faces.write[face_count].smooth = mesh_merge.faces[i].smooth;
+				result.faces.write[face_count].invert = mesh_merge.faces[i].invert;
+				result.faces.write[face_count].material = mesh_merge.faces[i].material_idx;
 				face_count++;
 			}
 
@@ -1513,6 +1513,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_A
 	//updatelist of materials
 	result.materials.resize(mesh_merge.materials.size());
 	for (const Map<Ref<Material>, int>::Element *E = mesh_merge.materials.front(); E; E = E->next()) {
-		result.materials[E->get()] = E->key();
+		result.materials.write[E->get()] = E->key();
 	}
 }
diff --git a/modules/csg/csg_gizmos.cpp b/modules/csg/csg_gizmos.cpp
index 2150320c4a..3b1ddfe4c0 100644
--- a/modules/csg/csg_gizmos.cpp
+++ b/modules/csg/csg_gizmos.cpp
@@ -278,8 +278,8 @@ void CSGShapeSpatialGizmo::redraw() {
 			int f = i / 6;
 			for (int j = 0; j < 3; j++) {
 				int j_n = (j + 1) % 3;
-				lines[i + j * 2 + 0] = r[f * 3 + j];
-				lines[i + j * 2 + 1] = r[f * 3 + j_n];
+				lines.write[i + j * 2 + 0] = r[f * 3 + j];
+				lines.write[i + j * 2 + 1] = r[f * 3 + j_n];
 			}
 		}
 	}
diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index 67cc7e1ba2..9f2171a82a 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -177,7 +177,7 @@ void CSGShape::_update_shape() {
 	Vector<int> face_count;
 	face_count.resize(n->materials.size() + 1);
 	for (int i = 0; i < face_count.size(); i++) {
-		face_count[i] = 0;
+		face_count.write[i] = 0;
 	}
 
 	for (int i = 0; i < n->faces.size(); i++) {
@@ -200,7 +200,7 @@ void CSGShape::_update_shape() {
 			}
 		}
 
-		face_count[idx]++;
+		face_count.write[idx]++;
 	}
 
 	Vector<ShapeUpdateSurface> surfaces;
@@ -210,18 +210,18 @@ void CSGShape::_update_shape() {
 	//create arrays
 	for (int i = 0; i < surfaces.size(); i++) {
 
-		surfaces[i].vertices.resize(face_count[i] * 3);
-		surfaces[i].normals.resize(face_count[i] * 3);
-		surfaces[i].uvs.resize(face_count[i] * 3);
-		surfaces[i].last_added = 0;
+		surfaces.write[i].vertices.resize(face_count[i] * 3);
+		surfaces.write[i].normals.resize(face_count[i] * 3);
+		surfaces.write[i].uvs.resize(face_count[i] * 3);
+		surfaces.write[i].last_added = 0;
 
 		if (i != surfaces.size() - 1) {
-			surfaces[i].material = n->materials[i];
+			surfaces.write[i].material = n->materials[i];
 		}
 
-		surfaces[i].verticesw = surfaces[i].vertices.write();
-		surfaces[i].normalsw = surfaces[i].normals.write();
-		surfaces[i].uvsw = surfaces[i].uvs.write();
+		surfaces.write[i].verticesw = surfaces.write[i].vertices.write();
+		surfaces.write[i].normalsw = surfaces.write[i].normals.write();
+		surfaces.write[i].uvsw = surfaces.write[i].uvs.write();
 	}
 
 	//fill arrays
@@ -281,7 +281,7 @@ void CSGShape::_update_shape() {
 				surfaces[idx].normalsw[last + order[j]] = normal;
 			}
 
-			surfaces[idx].last_added += 3;
+			surfaces.write[idx].last_added += 3;
 		}
 	}
 
@@ -290,9 +290,9 @@ void CSGShape::_update_shape() {
 
 	for (int i = 0; i < surfaces.size(); i++) {
 
-		surfaces[i].verticesw = PoolVector<Vector3>::Write();
-		surfaces[i].normalsw = PoolVector<Vector3>::Write();
-		surfaces[i].uvsw = PoolVector<Vector2>::Write();
+		surfaces.write[i].verticesw = PoolVector<Vector3>::Write();
+		surfaces.write[i].normalsw = PoolVector<Vector3>::Write();
+		surfaces.write[i].uvsw = PoolVector<Vector2>::Write();
 
 		if (surfaces[i].last_added == 0)
 			continue;
diff --git a/modules/enet/networked_multiplayer_enet.cpp b/modules/enet/networked_multiplayer_enet.cpp
index 88768829d7..25b7f2472d 100644
--- a/modules/enet/networked_multiplayer_enet.cpp
+++ b/modules/enet/networked_multiplayer_enet.cpp
@@ -666,7 +666,7 @@ size_t NetworkedMultiplayerENet::enet_compress(void *context, const ENetBuffer *
 	while (total) {
 		for (size_t i = 0; i < inBufferCount; i++) {
 			int to_copy = MIN(total, int(inBuffers[i].dataLength));
-			copymem(&enet->src_compressor_mem[ofs], inBuffers[i].data, to_copy);
+			copymem(&enet->src_compressor_mem.write[ofs], inBuffers[i].data, to_copy);
 			ofs += to_copy;
 			total -= to_copy;
 		}
diff --git a/modules/gdnative/arvr/arvr_interface_gdnative.cpp b/modules/gdnative/arvr/arvr_interface_gdnative.cpp
index 385c020a78..b525725107 100644
--- a/modules/gdnative/arvr/arvr_interface_gdnative.cpp
+++ b/modules/gdnative/arvr/arvr_interface_gdnative.cpp
@@ -125,7 +125,7 @@ bool ARVRInterfaceGDNative::is_stereo() {
 	return stereo;
 }
 
-bool ARVRInterfaceGDNative::is_initialized() {
+bool ARVRInterfaceGDNative::is_initialized() const {
 	bool initialized;
 
 	ERR_FAIL_COND_V(interface == NULL, false);
diff --git a/modules/gdnative/arvr/arvr_interface_gdnative.h b/modules/gdnative/arvr/arvr_interface_gdnative.h
index e50be6e196..26d0cdf9f4 100644
--- a/modules/gdnative/arvr/arvr_interface_gdnative.h
+++ b/modules/gdnative/arvr/arvr_interface_gdnative.h
@@ -59,7 +59,7 @@ public:
 	virtual StringName get_name() const;
 	virtual int get_capabilities() const;
 
-	virtual bool is_initialized();
+	virtual bool is_initialized() const;
 	virtual bool initialize();
 	virtual void uninitialize();
 
diff --git a/modules/gdnative/gdnative.cpp b/modules/gdnative/gdnative.cpp
index e7ebcc73af..0acd6c27d8 100644
--- a/modules/gdnative/gdnative.cpp
+++ b/modules/gdnative/gdnative.cpp
@@ -277,7 +277,7 @@ void GDNative::set_library(Ref<GDNativeLibrary> p_library) {
 	library = p_library;
 }
 
-Ref<GDNativeLibrary> GDNative::get_library() {
+Ref<GDNativeLibrary> GDNative::get_library() const {
 	return library;
 }
 
@@ -373,7 +373,7 @@ bool GDNative::initialize() {
 	if (library->should_load_once() && !GDNativeLibrary::loaded_libraries->has(lib_path)) {
 		Vector<Ref<GDNative> > gdnatives;
 		gdnatives.resize(1);
-		gdnatives[0] = Ref<GDNative>(this);
+		gdnatives.write[0] = Ref<GDNative>(this);
 		GDNativeLibrary::loaded_libraries->insert(lib_path, gdnatives);
 	}
 
@@ -428,7 +428,7 @@ bool GDNative::terminate() {
 	return true;
 }
 
-bool GDNative::is_initialized() {
+bool GDNative::is_initialized() const {
 	return initialized;
 }
 
@@ -442,7 +442,7 @@ Vector<StringName> GDNativeCallRegistry::get_native_call_types() {
 
 	size_t idx = 0;
 	for (Map<StringName, native_call_cb>::Element *E = native_calls.front(); E; E = E->next(), idx++) {
-		call_types[idx] = E->key();
+		call_types.write[idx] = E->key();
 	}
 
 	return call_types;
@@ -474,7 +474,7 @@ Variant GDNative::call_native(StringName p_native_call_type, StringName p_proced
 	return res;
 }
 
-Error GDNative::get_symbol(StringName p_procedure_name, void *&r_handle, bool p_optional) {
+Error GDNative::get_symbol(StringName p_procedure_name, void *&r_handle, bool p_optional) const {
 
 	if (!initialized) {
 		ERR_PRINT("No valid library handle, can't get symbol from GDNative object");
diff --git a/modules/gdnative/gdnative.h b/modules/gdnative/gdnative.h
index b17bb94f1c..148f85723e 100644
--- a/modules/gdnative/gdnative.h
+++ b/modules/gdnative/gdnative.h
@@ -148,16 +148,16 @@ public:
 	static void _bind_methods();
 
 	void set_library(Ref<GDNativeLibrary> p_library);
-	Ref<GDNativeLibrary> get_library();
+	Ref<GDNativeLibrary> get_library() const;
 
-	bool is_initialized();
+	bool is_initialized() const;
 
 	bool initialize();
 	bool terminate();
 
 	Variant call_native(StringName p_native_call_type, StringName p_procedure_name, Array p_arguments = Array());
 
-	Error get_symbol(StringName p_procedure_name, void *&r_handle, bool p_optional = true);
+	Error get_symbol(StringName p_procedure_name, void *&r_handle, bool p_optional = true) const;
 };
 
 class GDNativeLibraryResourceLoader : public ResourceFormatLoader {
diff --git a/modules/gdnative/gdnative/string.cpp b/modules/gdnative/gdnative/string.cpp
index 7f5dbc12be..8ca57392a3 100644
--- a/modules/gdnative/gdnative/string.cpp
+++ b/modules/gdnative/gdnative/string.cpp
@@ -207,7 +207,7 @@ godot_int GDAPI godot_string_findmk(const godot_string *p_self, const godot_arra
 	Array *keys_proxy = (Array *)p_keys;
 	keys.resize(keys_proxy->size());
 	for (int i = 0; i < keys_proxy->size(); i++) {
-		keys[i] = (*keys_proxy)[i];
+		keys.write[i] = (*keys_proxy)[i];
 	}
 
 	return self->findmk(keys);
@@ -220,7 +220,7 @@ godot_int GDAPI godot_string_findmk_from(const godot_string *p_self, const godot
 	Array *keys_proxy = (Array *)p_keys;
 	keys.resize(keys_proxy->size());
 	for (int i = 0; i < keys_proxy->size(); i++) {
-		keys[i] = (*keys_proxy)[i];
+		keys.write[i] = (*keys_proxy)[i];
 	}
 
 	return self->findmk(keys, p_from);
@@ -233,7 +233,7 @@ godot_int GDAPI godot_string_findmk_from_in_place(const godot_string *p_self, co
 	Array *keys_proxy = (Array *)p_keys;
 	keys.resize(keys_proxy->size());
 	for (int i = 0; i < keys_proxy->size(); i++) {
-		keys[i] = (*keys_proxy)[i];
+		keys.write[i] = (*keys_proxy)[i];
 	}
 
 	return self->findmk(keys, p_from, r_key);
@@ -696,7 +696,7 @@ godot_array GDAPI godot_string_split_floats_mk(const godot_string *p_self, const
 	Array *splitter_proxy = (Array *)p_splitters;
 	splitters.resize(splitter_proxy->size());
 	for (int i = 0; i < splitter_proxy->size(); i++) {
-		splitters[i] = (*splitter_proxy)[i];
+		splitters.write[i] = (*splitter_proxy)[i];
 	}
 
 	godot_array result;
@@ -719,7 +719,7 @@ godot_array GDAPI godot_string_split_floats_mk_allows_empty(const godot_string *
 	Array *splitter_proxy = (Array *)p_splitters;
 	splitters.resize(splitter_proxy->size());
 	for (int i = 0; i < splitter_proxy->size(); i++) {
-		splitters[i] = (*splitter_proxy)[i];
+		splitters.write[i] = (*splitter_proxy)[i];
 	}
 
 	godot_array result;
@@ -774,7 +774,7 @@ godot_array GDAPI godot_string_split_ints_mk(const godot_string *p_self, const g
 	Array *splitter_proxy = (Array *)p_splitters;
 	splitters.resize(splitter_proxy->size());
 	for (int i = 0; i < splitter_proxy->size(); i++) {
-		splitters[i] = (*splitter_proxy)[i];
+		splitters.write[i] = (*splitter_proxy)[i];
 	}
 
 	godot_array result;
@@ -797,7 +797,7 @@ godot_array GDAPI godot_string_split_ints_mk_allows_empty(const godot_string *p_
 	Array *splitter_proxy = (Array *)p_splitters;
 	splitters.resize(splitter_proxy->size());
 	for (int i = 0; i < splitter_proxy->size(); i++) {
-		splitters[i] = (*splitter_proxy)[i];
+		splitters.write[i] = (*splitter_proxy)[i];
 	}
 
 	godot_array result;
diff --git a/modules/gdnative/nativescript/nativescript.cpp b/modules/gdnative/nativescript/nativescript.cpp
index eb52bede24..3a49b3fe71 100644
--- a/modules/gdnative/nativescript/nativescript.cpp
+++ b/modules/gdnative/nativescript/nativescript.cpp
@@ -1157,8 +1157,8 @@ int NativeScriptLanguage::register_binding_functions(godot_instance_binding_func
 	}
 
 	// set the functions
-	binding_functions[idx].first = true;
-	binding_functions[idx].second = p_binding_functions;
+	binding_functions.write[idx].first = true;
+	binding_functions.write[idx].second = p_binding_functions;
 
 	return idx;
 }
@@ -1173,7 +1173,7 @@ void NativeScriptLanguage::unregister_binding_functions(int p_idx) {
 			binding_functions[p_idx].second.free_instance_binding_data(binding_functions[p_idx].second.data, binding_data[p_idx]);
 	}
 
-	binding_functions[p_idx].first = false;
+	binding_functions.write[p_idx].first = false;
 
 	if (binding_functions[p_idx].second.free_func)
 		binding_functions[p_idx].second.free_func(binding_functions[p_idx].second.data);
@@ -1199,7 +1199,7 @@ void *NativeScriptLanguage::get_instance_binding_data(int p_idx, Object *p_objec
 		binding_data->resize(p_idx + 1);
 
 		for (int i = old_size; i <= p_idx; i++) {
-			(*binding_data)[i] = NULL;
+			(*binding_data).write[i] = NULL;
 		}
 	}
 
@@ -1208,7 +1208,7 @@ void *NativeScriptLanguage::get_instance_binding_data(int p_idx, Object *p_objec
 		const void *global_type_tag = global_type_tags[p_idx].get(p_object->get_class_name());
 
 		// no binding data yet, soooooo alloc new one \o/
-		(*binding_data)[p_idx] = binding_functions[p_idx].second.alloc_instance_binding_data(binding_functions[p_idx].second.data, global_type_tag, (godot_object *)p_object);
+		(*binding_data).write[p_idx] = binding_functions[p_idx].second.alloc_instance_binding_data(binding_functions[p_idx].second.data, global_type_tag, (godot_object *)p_object);
 	}
 
 	return (*binding_data)[p_idx];
@@ -1221,7 +1221,7 @@ void *NativeScriptLanguage::alloc_instance_binding_data(Object *p_object) {
 	binding_data->resize(binding_functions.size());
 
 	for (int i = 0; i < binding_functions.size(); i++) {
-		(*binding_data)[i] = NULL;
+		(*binding_data).write[i] = NULL;
 	}
 
 	binding_instances.insert(binding_data);
diff --git a/modules/gdnative/register_types.cpp b/modules/gdnative/register_types.cpp
index d18297f2f8..ae1a218392 100644
--- a/modules/gdnative/register_types.cpp
+++ b/modules/gdnative/register_types.cpp
@@ -341,10 +341,10 @@ void register_gdnative_types() {
 
 		Ref<GDNativeLibrary> lib = ResourceLoader::load(path);
 
-		singleton_gdnatives[i].instance();
-		singleton_gdnatives[i]->set_library(lib);
+		singleton_gdnatives.write[i].instance();
+		singleton_gdnatives.write[i]->set_library(lib);
 
-		if (!singleton_gdnatives[i]->initialize()) {
+		if (!singleton_gdnatives.write[i]->initialize()) {
 			// Can't initialize. Don't make a native_call then
 			continue;
 		}
@@ -374,7 +374,7 @@ void unregister_gdnative_types() {
 			continue;
 		}
 
-		singleton_gdnatives[i]->terminate();
+		singleton_gdnatives.write[i]->terminate();
 	}
 	singleton_gdnatives.clear();
 
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 8bd29ffc55..cff3be76ae 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -730,7 +730,7 @@ Error GDScript::load_byte_code(const String &p_path) {
 		Vector<uint8_t> key;
 		key.resize(32);
 		for (int i = 0; i < key.size(); i++) {
-			key[i] = script_encryption_key[i];
+			key.write[i] = script_encryption_key[i];
 		}
 		Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_READ);
 		ERR_FAIL_COND_V(err, err);
@@ -941,7 +941,7 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 				if (!E->get().data_type.is_type(p_value)) {
 					return false; // Type mismatch
 				}
-				members[E->get().index] = p_value;
+				members.write[E->get().index] = p_value;
 			}
 			return true;
 		}
@@ -1270,7 +1270,7 @@ void GDScriptInstance::reload_members() {
 
 		if (member_indices_cache.has(E->key())) {
 			Variant value = members[member_indices_cache[E->key()]];
-			new_members[E->get().index] = value;
+			new_members.write[E->get().index] = value;
 		}
 	}
 
@@ -1320,7 +1320,7 @@ void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_va
 
 	if (globals.has(p_name)) {
 		//overwrite existing
-		global_array[globals[p_name]] = p_value;
+		global_array.write[globals[p_name]] = p_value;
 		return;
 	}
 	globals[p_name] = global_array.size();
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index d5fe7a000b..79ac9ed413 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -355,10 +355,10 @@ public:
 		Vector<StackInfo> csi;
 		csi.resize(_debug_call_stack_pos);
 		for (int i = 0; i < _debug_call_stack_pos; i++) {
-			csi[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
+			csi.write[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
 			if (_call_stack[i].function)
-				csi[_debug_call_stack_pos - i - 1].func = _call_stack[i].function->get_name();
-			csi[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_path();
+				csi.write[_debug_call_stack_pos - i - 1].func = _call_stack[i].function->get_name();
+			csi.write[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_path();
 		}
 		return csi;
 	}
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index a428ccd306..93585a5342 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -785,8 +785,8 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
-					codegen.opcodes[jump_fail_pos] = codegen.opcodes.size();
-					codegen.opcodes[jump_fail_pos2] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_fail_pos2] = codegen.opcodes.size();
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_FALSE);
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
@@ -818,8 +818,8 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
-					codegen.opcodes[jump_success_pos] = codegen.opcodes.size();
-					codegen.opcodes[jump_success_pos2] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_success_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_success_pos2] = codegen.opcodes.size();
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TRUE);
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
@@ -850,7 +850,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					int jump_past_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
-					codegen.opcodes[jump_fail_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
 					res = _parse_expression(codegen, on->arguments[2], p_stack_level);
 					if (res < 0)
 						return res;
@@ -859,7 +859,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 					codegen.opcodes.push_back(res);
 
-					codegen.opcodes[jump_past_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_past_pos] = codegen.opcodes.size();
 
 					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
 
@@ -1361,10 +1361,10 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 							codegen.opcodes.push_back(break_addr);
 
-							codegen.opcodes[continue_addr + 1] = codegen.opcodes.size();
+							codegen.opcodes.write[continue_addr + 1] = codegen.opcodes.size();
 						}
 
-						codegen.opcodes[break_addr + 1] = codegen.opcodes.size();
+						codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();
 
 					} break;
 
@@ -1393,16 +1393,16 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 							int end_addr = codegen.opcodes.size();
 							codegen.opcodes.push_back(0);
-							codegen.opcodes[else_addr] = codegen.opcodes.size();
+							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
 
 							Error err = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
 							if (err)
 								return err;
 
-							codegen.opcodes[end_addr] = codegen.opcodes.size();
+							codegen.opcodes.write[end_addr] = codegen.opcodes.size();
 						} else {
 							//end without else
-							codegen.opcodes[else_addr] = codegen.opcodes.size();
+							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
 						}
 
 					} break;
@@ -1453,7 +1453,7 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_pos);
-						codegen.opcodes[break_pos + 1] = codegen.opcodes.size();
+						codegen.opcodes.write[break_pos + 1] = codegen.opcodes.size();
 
 						codegen.pop_stack_identifiers();
 
@@ -1479,7 +1479,7 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_addr);
 
-						codegen.opcodes[break_addr + 1] = codegen.opcodes.size();
+						codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();
 
 					} break;
 					case GDScriptParser::ControlFlowNode::CF_SWITCH: {
@@ -1689,7 +1689,7 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		gdfunc->rpc_mode = p_func->rpc_mode;
 		gdfunc->argument_types.resize(p_func->argument_types.size());
 		for (int i = 0; i < p_func->argument_types.size(); i++) {
-			gdfunc->argument_types[i] = _gdtype_from_datatype(p_func->argument_types[i]);
+			gdfunc->argument_types.write[i] = _gdtype_from_datatype(p_func->argument_types[i]);
 		}
 		gdfunc->return_type = _gdtype_from_datatype(p_func->return_type);
 	} else {
@@ -1708,11 +1708,11 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 	if (codegen.constant_map.size()) {
 		gdfunc->_constant_count = codegen.constant_map.size();
 		gdfunc->constants.resize(codegen.constant_map.size());
-		gdfunc->_constants_ptr = &gdfunc->constants[0];
+		gdfunc->_constants_ptr = gdfunc->constants.ptrw();
 		const Variant *K = NULL;
 		while ((K = codegen.constant_map.next(K))) {
 			int idx = codegen.constant_map[*K];
-			gdfunc->constants[idx] = *K;
+			gdfunc->constants.write[idx] = *K;
 		}
 	} else {
 
@@ -1726,7 +1726,7 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		gdfunc->_global_names_ptr = &gdfunc->global_names[0];
 		for (Map<StringName, int>::Element *E = codegen.name_map.front(); E; E = E->next()) {
 
-			gdfunc->global_names[E->get()] = E->key();
+			gdfunc->global_names.write[E->get()] = E->key();
 		}
 		gdfunc->_global_names_count = gdfunc->global_names.size();
 
@@ -1741,7 +1741,7 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		gdfunc->named_globals.resize(codegen.named_globals.size());
 		gdfunc->_named_globals_ptr = gdfunc->named_globals.ptr();
 		for (int i = 0; i < codegen.named_globals.size(); i++) {
-			gdfunc->named_globals[i] = codegen.named_globals[i];
+			gdfunc->named_globals.write[i] = codegen.named_globals[i];
 		}
 		gdfunc->_named_globals_count = gdfunc->named_globals.size();
 	}
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 2e4a4c40dd..2a42524ba7 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -2918,7 +2918,7 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 		}
 
 		//print_line(itos(indent_stack.size())+","+itos(tc)+": "+l);
-		lines[i] = l;
+		lines.write[i] = l;
 	}
 
 	p_code = "";
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index 6a08d86904..ec346a6b46 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -62,7 +62,7 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 			}
 #endif
 			//member indexing is O(1)
-			return &p_instance->members[address];
+			return &p_instance->members.write[address];
 		} break;
 		case ADDR_TYPE_CLASS_CONSTANT: {
 
@@ -1218,7 +1218,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				gdfs->state.stack.resize(alloca_size);
 				//copy variant stack
 				for (int i = 0; i < _stack_size; i++) {
-					memnew_placement(&gdfs->state.stack[sizeof(Variant) * i], Variant(stack[i]));
+					memnew_placement(&gdfs->state.stack.write[sizeof(Variant) * i], Variant(stack[i]));
 				}
 				gdfs->state.stack_size = _stack_size;
 				gdfs->state.self = self;
diff --git a/modules/gdscript/gdscript_functions.cpp b/modules/gdscript/gdscript_functions.cpp
index 7e98b6ced9..63286b2e91 100644
--- a/modules/gdscript/gdscript_functions.cpp
+++ b/modules/gdscript/gdscript_functions.cpp
@@ -1098,7 +1098,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 
 			for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
 				if (d.has(E->key())) {
-					ins->members[E->get().index] = d[E->key()];
+					ins->members.write[E->get().index] = d[E->key()];
 				}
 			}
 
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index ac53f33e9e..d8ce6e7f17 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -1411,8 +1411,8 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				op->op = expression[i].op;
 				op->arguments.push_back(expression[i + 1].node);
 				op->line = op_line; //line might have been changed from a \n
-				expression[i].is_op = false;
-				expression[i].node = op;
+				expression.write[i].is_op = false;
+				expression.write[i].node = op;
 				expression.remove(i + 1);
 			}
 
@@ -1466,7 +1466,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			op->arguments.push_back(expression[next_op + 3].node); //expression after next goes as when-false
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op - 1].node = op;
+			expression.write[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 			expression.remove(next_op);
@@ -1502,7 +1502,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op - 1].node = op;
+			expression.write[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 		}
@@ -1526,7 +1526,7 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			for (int i = 0; i < an->elements.size(); i++) {
 
-				an->elements[i] = _reduce_expression(an->elements[i], p_to_const);
+				an->elements.write[i] = _reduce_expression(an->elements[i], p_to_const);
 				if (an->elements[i]->type != Node::TYPE_CONSTANT)
 					all_constants = false;
 			}
@@ -1556,10 +1556,10 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			for (int i = 0; i < dn->elements.size(); i++) {
 
-				dn->elements[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
+				dn->elements.write[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
 				if (dn->elements[i].key->type != Node::TYPE_CONSTANT)
 					all_constants = false;
-				dn->elements[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
+				dn->elements.write[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
 				if (dn->elements[i].value->type != Node::TYPE_CONSTANT)
 					all_constants = false;
 			}
@@ -1592,7 +1592,7 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			for (int i = 0; i < op->arguments.size(); i++) {
 
-				op->arguments[i] = _reduce_expression(op->arguments[i], p_to_const);
+				op->arguments.write[i] = _reduce_expression(op->arguments[i], p_to_const);
 				if (op->arguments[i]->type != Node::TYPE_CONSTANT) {
 					all_constants = false;
 					last_not_constant = i;
@@ -1620,7 +1620,7 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 						for (int i = 0; i < ptrs.size(); i++) {
 
 							ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i + 1]);
-							ptrs[i] = &cn->value;
+							ptrs.write[i] = &cn->value;
 						}
 
 						vptr = (const Variant **)&ptrs[0];
@@ -5956,7 +5956,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 							id->name = cn->value.operator StringName();
 
 							op->op = OperatorNode::OP_INDEX_NAMED;
-							op->arguments[1] = id;
+							op->arguments.write[1] = id;
 
 							return _reduce_node_type(op);
 						}
@@ -6323,7 +6323,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 			Vector<DataType> par_types;
 			par_types.resize(p_call->arguments.size() - 1);
 			for (int i = 1; i < p_call->arguments.size(); i++) {
-				par_types[i - 1] = _reduce_node_type(p_call->arguments[i]);
+				par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
 			}
 
 			if (error_set) return DataType();
@@ -6949,7 +6949,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 
 	// Class variables
 	for (int i = 0; i < p_class->variables.size(); i++) {
-		ClassNode::Member &v = p_class->variables[i];
+		ClassNode::Member &v = p_class->variables.write[i];
 
 		DataType tmp;
 		if (_get_member_type(p_class->base_type, v.identifier, tmp)) {
@@ -6993,7 +6993,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 					convert_call->arguments.push_back(tgt_type);
 
 					v.expression = convert_call;
-					v.initial_assignment->arguments[1] = convert_call;
+					v.initial_assignment->arguments.write[1] = convert_call;
 				}
 			}
 
@@ -7133,7 +7133,7 @@ void GDScriptParser::_check_function_types(FunctionNode *p_function) {
 	for (int i = 0; i < p_function->arguments.size(); i++) {
 
 		// Resolve types
-		p_function->argument_types[i] = _resolve_type(p_function->argument_types[i], p_function->line);
+		p_function->argument_types.write[i] = _resolve_type(p_function->argument_types[i], p_function->line);
 
 		if (i >= defaults_ofs) {
 			if (p_function->default_values[i - defaults_ofs]->type != Node::TYPE_OPERATOR) {
@@ -7284,7 +7284,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							convert_call->arguments.push_back(tgt_type);
 
 							lv->assign = convert_call;
-							lv->assign_op->arguments[1] = convert_call;
+							lv->assign_op->arguments.write[1] = convert_call;
 						}
 					}
 					if (lv->datatype.infer_type) {
@@ -7402,7 +7402,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 								convert_call->arguments.push_back(op->arguments[1]);
 								convert_call->arguments.push_back(tgt_type);
 
-								op->arguments[1] = convert_call;
+								op->arguments.write[1] = convert_call;
 							}
 						}
 						if (!rh_type.has_type && (op->op != OperatorNode::OP_ASSIGN || lh_type.has_type || op->arguments[0]->type == Node::TYPE_OPERATOR)) {
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 940bdcbc8d..7ae7c72ed3 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -1172,15 +1172,15 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
 		Vector<uint8_t> cs;
 		cs.resize(len);
 		for (int j = 0; j < len; j++) {
-			cs[j] = b[j] ^ 0xb6;
+			cs.write[j] = b[j] ^ 0xb6;
 		}
 
-		cs[cs.size() - 1] = 0;
+		cs.write[cs.size() - 1] = 0;
 		String s;
 		s.parse_utf8((const char *)cs.ptr());
 		b += len;
 		total_len -= len + 4;
-		identifiers[i] = s;
+		identifiers.write[i] = s;
 	}
 
 	constants.resize(constant_count);
@@ -1193,7 +1193,7 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
 			return err;
 		b += len;
 		total_len -= len;
-		constants[i] = v;
+		constants.write[i] = v;
 	}
 
 	ERR_FAIL_COND_V(line_count * 8 > total_len, ERR_INVALID_DATA);
@@ -1218,10 +1218,10 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
 		if ((*b) & TOKEN_BYTE_MASK) { //little endian always
 			ERR_FAIL_COND_V(total_len < 4, ERR_INVALID_DATA);
 
-			tokens[i] = decode_uint32(b) & ~TOKEN_BYTE_MASK;
+			tokens.write[i] = decode_uint32(b) & ~TOKEN_BYTE_MASK;
 			b += 4;
 		} else {
-			tokens[i] = *b;
+			tokens.write[i] = *b;
 			b += 1;
 			total_len--;
 		}
@@ -1320,15 +1320,15 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 
 	//save header
 	buf.resize(24);
-	buf[0] = 'G';
-	buf[1] = 'D';
-	buf[2] = 'S';
-	buf[3] = 'C';
-	encode_uint32(BYTECODE_VERSION, &buf[4]);
-	encode_uint32(identifier_map.size(), &buf[8]);
-	encode_uint32(constant_map.size(), &buf[12]);
-	encode_uint32(line_map.size(), &buf[16]);
-	encode_uint32(token_array.size(), &buf[20]);
+	buf.write[0] = 'G';
+	buf.write[1] = 'D';
+	buf.write[2] = 'S';
+	buf.write[3] = 'C';
+	encode_uint32(BYTECODE_VERSION, &buf.write[4]);
+	encode_uint32(identifier_map.size(), &buf.write[8]);
+	encode_uint32(constant_map.size(), &buf.write[12]);
+	encode_uint32(line_map.size(), &buf.write[16]);
+	encode_uint32(token_array.size(), &buf.write[20]);
 
 	//save identifiers
 
@@ -1360,7 +1360,7 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 		ERR_FAIL_COND_V(err != OK, Vector<uint8_t>());
 		int pos = buf.size();
 		buf.resize(pos + len);
-		encode_variant(E->get(), &buf[pos], len);
+		encode_variant(E->get(), &buf.write[pos], len);
 	}
 
 	for (Map<int, uint32_t>::Element *E = rev_line_map.front(); E; E = E->next()) {
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index 234a59e516..0c5df57d49 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -508,7 +508,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 				continue;
 			PhysicsServer::get_singleton()->body_add_shape(g.static_body, shapes[i].shape->get_rid(), xform * shapes[i].local_transform);
 			if (g.collision_debug.is_valid()) {
-				shapes[i].shape->add_vertices_to_array(col_debug, xform * shapes[i].local_transform);
+				shapes.write[i].shape->add_vertices_to_array(col_debug, xform * shapes[i].local_transform);
 			}
 
 			//print_line("PHIS x: "+xform);
@@ -758,7 +758,7 @@ void GridMap::_update_visibility() {
 	for (Map<OctantKey, Octant *>::Element *e = octant_map.front(); e; e = e->next()) {
 		Octant *octant = e->value();
 		for (int i = 0; i < octant->multimesh_instances.size(); i++) {
-			Octant::MultimeshInstance &mi = octant->multimesh_instances[i];
+			const Octant::MultimeshInstance &mi = octant->multimesh_instances[i];
 			VS::get_singleton()->instance_set_visible(mi.instance, is_visible());
 		}
 	}
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 8471083f49..7d7028a7a6 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -523,7 +523,7 @@ Vector<ScriptLanguage::StackInfo> CSharpLanguage::stack_trace_get_info(MonoObjec
 	si.resize(frame_count);
 
 	for (int i = 0; i < frame_count; i++) {
-		StackInfo &sif = si[i];
+		StackInfo &sif = si.write[i];
 		MonoObject *frame = mono_array_get(frames, MonoObject *, i);
 
 		MonoString *file_name;
diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index 6819c0abe8..76907451e7 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -1650,7 +1650,7 @@ Error BindingsGenerator::_generate_glue_method(const BindingsGenerator::TypeInte
 								   "\t\tvarargs.set(i, GDMonoMarshal::mono_object_to_variant(elem));\n"
 								   "\t\t" C_LOCAL_PTRCALL_ARGS ".set(");
 				p_output.push_back(real_argc_str);
-				p_output.push_back(" + i, &varargs[i]);\n\t" CLOSE_BLOCK);
+				p_output.push_back(" + i, &varargs.write[i]);\n\t" CLOSE_BLOCK);
 			} else {
 				p_output.push_back(c_in_statements);
 				p_output.push_back("\tconst void* " C_LOCAL_PTRCALL_ARGS "[");
diff --git a/modules/mono/mono_gd/gd_mono.cpp b/modules/mono/mono_gd/gd_mono.cpp
index 0f4e211be5..f564b93f8f 100644
--- a/modules/mono/mono_gd/gd_mono.cpp
+++ b/modules/mono/mono_gd/gd_mono.cpp
@@ -77,12 +77,12 @@ void setup_runtime_main_args() {
 	Vector<char *> main_args;
 	main_args.resize(cmdline_args.size() + 1);
 
-	main_args[0] = execpath.ptrw();
+	main_args.write[0] = execpath.ptrw();
 
 	int i = 1;
 	for (List<String>::Element *E = cmdline_args.front(); E; E = E->next()) {
 		CharString &stored = cmdline_args_utf8.push_back(E->get().utf8())->get();
-		main_args[i] = stored.ptrw();
+		main_args.write[i] = stored.ptrw();
 		i++;
 	}
 
diff --git a/modules/mono/mono_gd/gd_mono_class.cpp b/modules/mono/mono_gd/gd_mono_class.cpp
index 53d6b7074c..ad74f73d74 100644
--- a/modules/mono/mono_gd/gd_mono_class.cpp
+++ b/modules/mono/mono_gd/gd_mono_class.cpp
@@ -503,7 +503,7 @@ GDMonoClass::~GDMonoClass() {
 					}
 				}
 
-				deleted_methods[offset] = method;
+				deleted_methods.write[offset] = method;
 				++offset;
 
 				memdelete(method);
diff --git a/modules/recast/navigation_mesh_generator.cpp b/modules/recast/navigation_mesh_generator.cpp
index 64c4b85269..c1ce2592a4 100644
--- a/modules/recast/navigation_mesh_generator.cpp
+++ b/modules/recast/navigation_mesh_generator.cpp
@@ -126,9 +126,9 @@ void NavigationMeshGenerator::_convert_detail_mesh_to_native_navigation_mesh(con
 		for (unsigned int j = 0; j < ntris; j++) {
 			Vector<int> nav_indices;
 			nav_indices.resize(3);
-			nav_indices[0] = ((int)(bverts + tris[j * 4 + 0]));
-			nav_indices[1] = ((int)(bverts + tris[j * 4 + 1]));
-			nav_indices[2] = ((int)(bverts + tris[j * 4 + 2]));
+			nav_indices.write[0] = ((int)(bverts + tris[j * 4 + 0]));
+			nav_indices.write[1] = ((int)(bverts + tris[j * 4 + 1]));
+			nav_indices.write[2] = ((int)(bverts + tris[j * 4 + 2]));
 			p_nav_mesh->add_polygon(nav_indices);
 		}
 	}
diff --git a/modules/regex/regex.cpp b/modules/regex/regex.cpp
index 6f2bb46fc8..733f32277b 100644
--- a/modules/regex/regex.cpp
+++ b/modules/regex/regex.cpp
@@ -265,8 +265,8 @@ Ref<RegExMatch> RegEx::search(const String &p_subject, int p_offset, int p_end)
 
 		for (uint32_t i = 0; i < size; i++) {
 
-			result->data[i].start = ovector[i * 2];
-			result->data[i].end = ovector[i * 2 + 1];
+			result->data.write[i].start = ovector[i * 2];
+			result->data.write[i].end = ovector[i * 2 + 1];
 		}
 
 		pcre2_match_data_free_16(match);
@@ -295,8 +295,8 @@ Ref<RegExMatch> RegEx::search(const String &p_subject, int p_offset, int p_end)
 
 		for (uint32_t i = 0; i < size; i++) {
 
-			result->data[i].start = ovector[i * 2];
-			result->data[i].end = ovector[i * 2 + 1];
+			result->data.write[i].start = ovector[i * 2];
+			result->data.write[i].end = ovector[i * 2 + 1];
 		}
 
 		pcre2_match_data_free_32(match);
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 9dea7a9c9e..de9b3d5a91 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -771,7 +771,7 @@ void VisualScript::custom_signal_set_argument_type(const StringName &p_func, int
 	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
 	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
-	custom_signals[p_func][p_argidx].type = p_type;
+	custom_signals[p_func].write[p_argidx].type = p_type;
 }
 Variant::Type VisualScript::custom_signal_get_argument_type(const StringName &p_func, int p_argidx) const {
 
@@ -783,7 +783,7 @@ void VisualScript::custom_signal_set_argument_name(const StringName &p_func, int
 	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
 	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
-	custom_signals[p_func][p_argidx].name = p_name;
+	custom_signals[p_func].write[p_argidx].name = p_name;
 }
 String VisualScript::custom_signal_get_argument_name(const StringName &p_func, int p_argidx) const {
 
@@ -811,7 +811,7 @@ void VisualScript::custom_signal_swap_argument(const StringName &p_func, int p_a
 	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
 	ERR_FAIL_INDEX(p_with_argidx, custom_signals[p_func].size());
 
-	SWAP(custom_signals[p_func][p_argidx], custom_signals[p_func][p_with_argidx]);
+	SWAP(custom_signals[p_func].write[p_argidx], custom_signals[p_func].write[p_with_argidx]);
 }
 void VisualScript::remove_custom_signal(const StringName &p_name) {
 
diff --git a/modules/visual_script/visual_script_expression.cpp b/modules/visual_script/visual_script_expression.cpp
index d5f9d21348..868d22b541 100644
--- a/modules/visual_script/visual_script_expression.cpp
+++ b/modules/visual_script/visual_script_expression.cpp
@@ -56,11 +56,11 @@ bool VisualScriptExpression::_set(const StringName &p_name, const Variant &p_val
 		int from = inputs.size();
 		inputs.resize(int(p_value));
 		for (int i = from; i < inputs.size(); i++) {
-			inputs[i].name = String::chr('a' + i);
+			inputs.write[i].name = String::chr('a' + i);
 			if (from == 0) {
-				inputs[i].type = output_type;
+				inputs.write[i].type = output_type;
 			} else {
-				inputs[i].type = inputs[from - 1].type;
+				inputs.write[i].type = inputs[from - 1].type;
 			}
 		}
 		expression_dirty = true;
@@ -78,10 +78,10 @@ bool VisualScriptExpression::_set(const StringName &p_name, const Variant &p_val
 
 		if (what == "type") {
 
-			inputs[idx].type = Variant::Type(int(p_value));
+			inputs.write[idx].type = Variant::Type(int(p_value));
 		} else if (what == "name") {
 
-			inputs[idx].name = p_value;
+			inputs.write[idx].name = p_value;
 		} else {
 			return false;
 		}
@@ -1153,8 +1153,8 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 				op->op = expression[i].op;
 				op->nodes[0] = expression[i + 1].node;
 				op->nodes[1] = NULL;
-				expression[i].is_op = false;
-				expression[i].node = op;
+				expression.write[i].is_op = false;
+				expression.write[i].node = op;
 				expression.remove(i + 1);
 			}
 
@@ -1188,7 +1188,7 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 			op->nodes[1] = expression[next_op + 1].node; //next expression goes as right
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op - 1].node = op;
+			expression.write[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 		}
@@ -1370,8 +1370,8 @@ public:
 					bool ret = _execute(p_inputs, constructor->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i] = value;
-					argp[i] = &arr[i];
+					arr.write[i] = value;
+					argp.write[i] = &arr[i];
 				}
 
 				r_ret = Variant::construct(constructor->data_type, (const Variant **)argp.ptr(), argp.size(), ce);
@@ -1397,8 +1397,8 @@ public:
 					bool ret = _execute(p_inputs, bifunc->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i] = value;
-					argp[i] = &arr[i];
+					arr.write[i] = value;
+					argp.write[i] = &arr[i];
 				}
 
 				VisualScriptBuiltinFunc::exec_func(bifunc->func, (const Variant **)argp.ptr(), &r_ret, ce, r_error_str);
@@ -1429,8 +1429,8 @@ public:
 					bool ret = _execute(p_inputs, call->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i] = value;
-					argp[i] = &arr[i];
+					arr.write[i] = value;
+					argp.write[i] = &arr[i];
 				}
 
 				r_ret = base.call(call->method, (const Variant **)argp.ptr(), argp.size(), ce);
diff --git a/modules/visual_script/visual_script_flow_control.cpp b/modules/visual_script/visual_script_flow_control.cpp
index 0f58a20c00..7535f37ffc 100644
--- a/modules/visual_script/visual_script_flow_control.cpp
+++ b/modules/visual_script/visual_script_flow_control.cpp
@@ -684,7 +684,7 @@ bool VisualScriptSwitch::_set(const StringName &p_name, const Variant &p_value)
 		int idx = String(p_name).get_slice("/", 1).to_int();
 		ERR_FAIL_INDEX_V(idx, case_values.size(), false);
 
-		case_values[idx].type = Variant::Type(int(p_value));
+		case_values.write[idx].type = Variant::Type(int(p_value));
 		_change_notify();
 		ports_changed_notify();
 
diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp
index f174300a4c..9f10510d6d 100644
--- a/modules/visual_script/visual_script_nodes.cpp
+++ b/modules/visual_script/visual_script_nodes.cpp
@@ -54,8 +54,8 @@ bool VisualScriptFunction::_set(const StringName &p_name, const Variant &p_value
 		arguments.resize(new_argc);
 
 		for (int i = argc; i < new_argc; i++) {
-			arguments[i].name = "arg" + itos(i + 1);
-			arguments[i].type = Variant::NIL;
+			arguments.write[i].name = "arg" + itos(i + 1);
+			arguments.write[i].type = Variant::NIL;
 		}
 		ports_changed_notify();
 		_change_notify();
@@ -68,7 +68,7 @@ bool VisualScriptFunction::_set(const StringName &p_name, const Variant &p_value
 		if (what == "type") {
 
 			Variant::Type new_type = Variant::Type(int(p_value));
-			arguments[idx].type = new_type;
+			arguments.write[idx].type = new_type;
 			ports_changed_notify();
 
 			return true;
@@ -76,7 +76,7 @@ bool VisualScriptFunction::_set(const StringName &p_name, const Variant &p_value
 
 		if (what == "name") {
 
-			arguments[idx].name = p_value;
+			arguments.write[idx].name = p_value;
 			ports_changed_notify();
 			return true;
 		}
@@ -234,7 +234,7 @@ void VisualScriptFunction::set_argument_type(int p_argidx, Variant::Type p_type)
 
 	ERR_FAIL_INDEX(p_argidx, arguments.size());
 
-	arguments[p_argidx].type = p_type;
+	arguments.write[p_argidx].type = p_type;
 	ports_changed_notify();
 }
 Variant::Type VisualScriptFunction::get_argument_type(int p_argidx) const {
@@ -246,7 +246,7 @@ void VisualScriptFunction::set_argument_name(int p_argidx, const String &p_name)
 
 	ERR_FAIL_INDEX(p_argidx, arguments.size());
 
-	arguments[p_argidx].name = p_name;
+	arguments.write[p_argidx].name = p_name;
 	ports_changed_notify();
 }
 String VisualScriptFunction::get_argument_name(int p_argidx) const {
@@ -3560,8 +3560,8 @@ void VisualScriptDeconstruct::_set_elem_cache(const Array &p_elements) {
 	ERR_FAIL_COND(p_elements.size() % 2 == 1);
 	elements.resize(p_elements.size() / 2);
 	for (int i = 0; i < elements.size(); i++) {
-		elements[i].name = p_elements[i * 2 + 0];
-		elements[i].type = Variant::Type(int(p_elements[i * 2 + 1]));
+		elements.write[i].name = p_elements[i * 2 + 0];
+		elements.write[i].type = Variant::Type(int(p_elements[i * 2 + 1]));
 	}
 }
 
@@ -3606,7 +3606,7 @@ VisualScriptNodeInstance *VisualScriptDeconstruct::instance(VisualScriptInstance
 	instance->instance = p_instance;
 	instance->outputs.resize(elements.size());
 	for (int i = 0; i < elements.size(); i++) {
-		instance->outputs[i] = elements[i].name;
+		instance->outputs.write[i] = elements[i].name;
 	}
 
 	return instance;