Version 2.12.0-118.0.dev

Merge commit '16f163157aa2b3d6f39a8dae4ce96d9c663e8f0c' into 'dev'

Author: Dart CI

pkg/analysis_server/lib/src/edit/edit_domain.dart

@@ -759,30 +759,26 @@ error.errorCode: ${error.errorCode}
       );
 
       try {
-        List<Assist> assists;
-        try {
-          var processor = AssistProcessor(context);
-          assists = await processor.compute();
-        } on InconsistentAnalysisException {
-          assists = [];
-        } catch (exception, stackTrace) {
-          var parametersFile = '''
-offset: $offset
-length: $length
-      ''';
-          throw CaughtExceptionWithFiles(exception, stackTrace, {
-            file: result.content,
-            'parameters': parametersFile,
-          });
-        }
-
+        var processor = AssistProcessor(context);
+        var assists = await processor.compute();
         assists.sort(Assist.SORT_BY_RELEVANCE);
         for (var assist in assists) {
           changes.add(assist.change);
         }
+      } on InconsistentAnalysisException {
+        // ignore
+      } catch (exception, stackTrace) {
+        var parametersFile = '''
+offset: $offset
+length: $length
+      ''';
+        throw CaughtExceptionWithFiles(exception, stackTrace, {
+          file: result.content,
+          'parameters': parametersFile,
+        });
+      }
 
-        server.requestStatistics?.addItemTimeNow(request, 'computedAssists');
-      } catch (_) {}
+      server.requestStatistics?.addItemTimeNow(request, 'computedAssists');
     }
 
     return changes;

runtime/platform/atomic.h

@@ -100,14 +100,18 @@ class AcqRelAtomic {
   bool compare_exchange_weak(
       T& expected,  // NOLINT
       T desired,
-      std::memory_order order = std::memory_order_acq_rel) {
-    return value_.compare_exchange_weak(expected, desired, order, order);
+      std::memory_order success_order = std::memory_order_acq_rel,
+      std::memory_order failure_order = std::memory_order_seq_cst) {
+    return value_.compare_exchange_weak(expected, desired, success_order,
+                                        failure_order);
   }
   bool compare_exchange_strong(
       T& expected,  // NOLINT
       T desired,
-      std::memory_order order = std::memory_order_acq_rel) {
-    return value_.compare_exchange_strong(expected, desired, order, order);
+      std::memory_order success_order = std::memory_order_acq_rel,
+      std::memory_order failure_order = std::memory_order_seq_cst) {
+    return value_.compare_exchange_strong(expected, desired, success_order,
+                                          failure_order);
   }
 
   // Require explicit loads and stores.

runtime/vm/compiler/backend/type_propagator_test.cc

@@ -187,7 +187,11 @@ ISOLATE_UNIT_TEST_CASE(TypePropagator_Refinement) {
                  /*is_reflectable=*/true,
                  /*is_late=*/false, object_class, Object::dynamic_type(),
                  TokenPosition::kNoSource, TokenPosition::kNoSource));
-  thread->isolate_group()->RegisterStaticField(field, Instance::Handle());
+  {
+    SafepointWriteRwLocker locker(thread,
+                                  thread->isolate_group()->program_lock());
+    thread->isolate_group()->RegisterStaticField(field, Instance::Handle());
+  }
 
   FlowGraphBuilderHelper H;
 

runtime/vm/dart.cc

@@ -697,8 +697,7 @@ static bool CloneIntoChildIsolateAOT(Thread* T,
   }
   I->isolate_object_store()->Init();
   I->isolate_object_store()->PreallocateObjects();
-  I->set_field_table(T, source_isolate_group->initial_field_table()->Clone(
-                            /*is_isolate_field_table=*/true));
+  I->set_field_table(T, source_isolate_group->initial_field_table()->Clone(I));
 
   return true;
 }
@@ -743,8 +742,7 @@ ErrorPtr Dart::InitIsolateFromSnapshot(Thread* T,
       return error.raw();
     }
 
-    I->set_field_table(T, I->group()->initial_field_table()->Clone(
-                              /*is_isolate_field_table=*/true));
+    I->set_field_table(T, I->group()->initial_field_table()->Clone(I));
 
 #if defined(SUPPORT_TIMELINE)
     if (tbes.enabled()) {

runtime/vm/field_table.cc

@@ -98,13 +98,13 @@ void FieldTable::Grow(intptr_t new_capacity) {
   // via store to table_.
   std::atomic_thread_fence(std::memory_order_release);
   table_ = new_table;
-  if (is_isolate_field_table_) {
-    Thread::Current()->field_table_values_ = table_;
+  if (isolate_ != nullptr) {
+    isolate_->mutator_thread()->field_table_values_ = table_;
   }
 }
 
-FieldTable* FieldTable::Clone(bool is_isolate_field_table) {
-  FieldTable* clone = new FieldTable(is_isolate_field_table);
+FieldTable* FieldTable::Clone(Isolate* for_isolate) {
+  FieldTable* clone = new FieldTable(for_isolate);
   auto new_table = static_cast<InstancePtr*>(
       malloc(capacity_ * sizeof(InstancePtr)));  // NOLINT
   memmove(new_table, table_, capacity_ * sizeof(InstancePtr));

runtime/vm/field_table.h

@@ -16,17 +16,18 @@
 
 namespace dart {
 
+class Isolate;
 class Field;
 
 class FieldTable {
  public:
-  explicit FieldTable(bool is_isolate_field_table)
+  explicit FieldTable(Isolate* isolate)
       : top_(0),
         capacity_(0),
         free_head_(-1),
         table_(nullptr),
         old_tables_(new MallocGrowableArray<InstancePtr*>()),
-        is_isolate_field_table_(is_isolate_field_table) {}
+        isolate_(isolate) {}
 
   ~FieldTable();
 
@@ -56,7 +57,7 @@ class FieldTable {
   }
   void SetAt(intptr_t index, InstancePtr raw_instance);
 
-  FieldTable* Clone(bool is_isolate_field_table);
+  FieldTable* Clone(Isolate* for_isolate);
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
@@ -83,10 +84,10 @@ class FieldTable {
   // so it will get freed when its are no longer in use.
   MallocGrowableArray<InstancePtr*>* old_tables_;
 
-  // Whether this table is used as a isolate-specific table of it's global field
-  // values and therefore needs to keep the cached field table in the `Thread`
-  // object up-to-date.
-  bool is_isolate_field_table_;
+  // If non-NULL, it will specify the isolate this field table belongs to.
+  // Growing the field table will keep the cached field table on the isolate's
+  // mutator thread up-to-date.
+  Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldTable);
 };

runtime/vm/isolate.cc

@@ -353,7 +353,7 @@ IsolateGroup::IsolateGroup(std::shared_ptr<IsolateGroupSource> source,
       store_buffer_(new StoreBuffer()),
       heap_(nullptr),
       saved_unlinked_calls_(Array::null()),
-      initial_field_table_(new FieldTable(/*is_isolate_field_table=*/false)),
+      initial_field_table_(new FieldTable(/*isolate=*/nullptr)),
       symbols_lock_(new SafepointRwLock()),
       type_canonicalization_mutex_(
           NOT_IN_PRODUCT("IsolateGroup::type_canonicalization_mutex_")),
@@ -907,6 +907,8 @@ void Isolate::ValidateClassTable() {
 
 void IsolateGroup::RegisterStaticField(const Field& field,
                                        const Instance& initial_value) {
+  ASSERT(program_lock()->IsCurrentThreadWriter());
+
   ASSERT(field.is_static());
   initial_field_table()->Register(field);
   initial_field_table()->SetAt(field.field_id(), initial_value.raw());
@@ -1631,7 +1633,7 @@ Isolate::Isolate(IsolateGroup* isolate_group,
       default_tag_(UserTag::null()),
       ic_miss_code_(Code::null()),
       shared_class_table_(isolate_group->shared_class_table()),
-      field_table_(new FieldTable(/*is_isolate_field_table=*/true)),
+      field_table_(new FieldTable(/*isolate=*/this)),
       isolate_group_(isolate_group),
       isolate_object_store_(
           new IsolateObjectStore(isolate_group->object_store())),

runtime/vm/object_test.cc

@@ -3065,7 +3065,11 @@ static FieldPtr CreateTestField(const char* name) {
   const Field& field = Field::Handle(Field::New(
       field_name, true, false, false, true, false, cls, Object::dynamic_type(),
       TokenPosition::kMinSource, TokenPosition::kMinSource));
-  thread->isolate_group()->RegisterStaticField(field, Instance::sentinel());
+  {
+    SafepointWriteRwLocker locker(thread,
+                                  thread->isolate_group()->program_lock());
+    thread->isolate_group()->RegisterStaticField(field, Instance::sentinel());
+  }
   return field.raw();
 }
 

sdk/lib/_internal/vm/lib/growable_array.dart

@@ -261,7 +261,7 @@ class _GrowableList<T> extends ListBase<T> {
   void add(T value) {
     var len = length;
     if (len == _capacity) {
-      _grow(_nextCapacity(len));
+      _growToNextCapacity();
     }
     _setLength(len + 1);
     this[len] = value;
@@ -310,7 +310,7 @@ class _GrowableList<T> extends ListBase<T> {
         if (this.length != newLen) throw new ConcurrentModificationError(this);
         len = newLen;
       }
-      _grow(_nextCapacity(_capacity));
+      _growToNextCapacity();
     } while (true);
   }
 
@@ -370,6 +370,14 @@ class _GrowableList<T> extends ListBase<T> {
     _setData(newData);
   }
 
+  // This method is marked as never-inline to conserve code size.
+  // It is called in rare cases, but used in the add() which is
+  // used very often and always inlined.
+  @pragma("vm:never-inline")
+  void _growToNextCapacity() {
+    _grow(_nextCapacity(_capacity));
+  }
+
   void _shrink(int new_capacity, int new_length) {
     var newData = _allocateData(new_capacity);
     // This is a work-around for dartbug.com/30090. See the comment in _grow.

sdk/lib/ffi/struct.dart

@@ -4,19 +4,48 @@
 
 part of dart.ffi;
 
-/// This class is extended to define structs.
+/// The supertype of all FFI struct types.
 ///
-/// Fields in a struct, annotated with a subtype of [NativeType], are
-/// automatically transformed into wrappers to access the fields of the struct
-/// in native memory.
+/// FFI struct types should extend this class and declare fields corresponding
+/// to the underlying native structure.
 ///
-/// All fields in a struct must either have a type which extends [NativeType] or
-/// else have an annotation indicating the corresponding native type (e.g.
-/// "@Int32()" for "int").
+/// Field declarations in a [Struct] subclass declaration are automatically
+/// given a setter and getter implementation which accesses the native struct's
+/// field in memory.
+///
+/// All field declarations in a [Struct] subclass declaration must either have
+/// type [int] or [float] and be annotated with a [NativeType] representing the
+/// native type, or must be of type [Pointer]. For example:
+///
+/// ```
+/// typedef struct {
+///  int a;
+///  float b;
+///  void* c;
+/// } my_struct;
+/// ```
+///
+/// ```
+/// class MyStruct extends Struct {
+///   @Int32
+///   external int a;
+///
+///   @Float
+///   external double b;
+///
+///   external Pointer<Void> c;
+/// }
+/// ```
+///
+/// All field declarations in a [Struct] subclass declaration must be marked
+/// `external`. You cannot create instances of the class, only have it point to
+/// existing native memory, so there is no memory in which to store non-native
+/// fields. External fields also cannot be initialized by constructors since no
+/// Dart object is being created.
 ///
 /// Instances of a subclass of [Struct] have reference semantics and are backed
 /// by native memory. The may allocated via allocation or loaded from a
-/// [Pointer], but not by a generative constructor.
+/// [Pointer], but cannot be created by a generative constructor.
 abstract class Struct extends NativeType {
   final Object _addressOf;