[vm/concurrency] Add write-lock assertion to Class::SetFields protecting Class fields.

This is follow-up to https://dart-review.googlesource.com/c/sdk/+/168140 which added write-lock to protect Class functions.

Bug: dart-lang/sdk#36097
Change-Id: Idb2070d005c44509fc6701f2eb297b90e7ded581
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/168772
Reviewed-by: Martin Kustermann <kustermann@google.com>
Commit-Queue: Alexander Aprelev <aam@google.com>

Author: aam

runtime/vm/compiler/aot/precompiler.cc

@@ -1807,6 +1807,7 @@ void Precompiler::DropFields() {
   AbstractType& type = AbstractType::Handle(Z);
   Function& initializer_function = Function::Handle(Z);
 
+  SafepointWriteRwLocker ml(T, T->isolate_group()->program_lock());
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);

runtime/vm/object.cc

@@ -1115,10 +1115,10 @@ void Object::Init(Isolate* isolate) {
   // in the vm isolate. See special handling in Class::SuperClass().
   cls = type_arguments_class_;
   cls.set_interfaces(Object::empty_array());
-  cls.SetFields(Object::empty_array());
   {
     Thread* thread = Thread::Current();
     SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+    cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
   }
 
@@ -4354,6 +4354,9 @@ ErrorPtr Class::EnsureIsAllocateFinalized(Thread* thread) const {
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
+  Thread* thread = Thread::Current();
+  ASSERT(thread->IsMutatorThread());
+  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
   // Verify that all the fields in the array have this class as owner.
   Field& field = Field::Handle();
   intptr_t len = value.Length();
@@ -4368,13 +4371,23 @@ void Class::SetFields(const Array& value) const {
 }
 
 void Class::AddField(const Field& field) const {
+#if defined(DEBUG)
+  Thread* thread = Thread::Current();
+  ASSERT(thread->IsMutatorThread());
+  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
+#endif
   const Array& arr = Array::Handle(fields());
   const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
   new_arr.SetAt(arr.Length(), field);
   SetFields(new_arr);
 }
 
 void Class::AddFields(const GrowableArray<const Field*>& new_fields) const {
+#if defined(DEBUG)
+  Thread* thread = Thread::Current();
+  ASSERT(thread->IsMutatorThread());
+  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
+#endif
   const intptr_t num_new_fields = new_fields.length();
   if (num_new_fields == 0) return;
   const Array& arr = Array::Handle(fields());

runtime/vm/object_test.cc

@@ -207,8 +207,8 @@ ISOLATE_UNIT_TEST_CASE(SixtyThousandDartClasses) {
       SafepointWriteRwLocker ml(thread,
                                 thread->isolate_group()->program_lock());
       cls.SetFunctions(Array::empty_array());
+      cls.SetFields(fields);
     }
-    cls.SetFields(fields);
     cls.Finalize();
 
     instance = Instance::New(cls);
@@ -332,7 +332,10 @@ ISOLATE_UNIT_TEST_CASE(InstanceClass) {
                  Object::dynamic_type(), TokenPosition::kMinSource,
                  TokenPosition::kMinSource));
   one_fields.SetAt(0, field);
-  one_field_class.SetFields(one_fields);
+  {
+    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+    one_field_class.SetFields(one_fields);
+  }
   one_field_class.Finalize();
   intptr_t header_size = sizeof(ObjectLayout);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),