Spelling runtime vm

Closes #50786

TEST=ci

GitOrigin-RevId: 781a38e
Change-Id: Ia3c615012d1bac3f0cf64dc01c2ceb40d50d1193
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/276684
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: jsoref

runtime/vm/app_snapshot.cc

@@ -7779,7 +7779,7 @@ ZoneGrowableArray<Object*>* Serializer::Serialize(SerializationRoots* roots) {
   // computation. Note that reachability is computed monotonically (an object
   // can change from not reachable to reachable, but never the reverse), which
   // is technically a conservative approximation for WSRs, but doing a strict
-  // analysis that allows non-motonoic reachability may not halt.
+  // analysis that allows non-monotonic reachability may not halt.
   //
   // To see this, take a WSR whose replacement causes the target of another WSR
   // to become reachable, which then causes the target of the first WSR to
@@ -8029,7 +8029,7 @@ void Serializer::WriteDispatchTable(const Array& entries) {
       }
       continue;
     }
-    // Emit any outsanding repeat count before handling the new code value.
+    // Emit any outstanding repeat count before handling the new code value.
     if (repeat_count > 0) {
       Write(repeat_count);
       repeat_count = 0;

runtime/vm/class_table.h

@@ -39,7 +39,7 @@ class PersistentHandle;
 // There is a bit for each word in an instance of the class.
 //
 // Words corresponding to set bits must be ignored by the GC because they
-// don't contain pointers. All words beyound the first 64 words of an object
+// don't contain pointers. All words beyond the first 64 words of an object
 // are expected to contain pointers.
 class UnboxedFieldBitmap {
  public:
@@ -147,7 +147,7 @@ class ClassTableAllocator : public ValueObject {
 
 // A table with the given |Columns| indexed by class id.
 //
-// Each column is a continous array of a the given type. All columns have
+// Each column is a continuous array of a the given type. All columns have
 // the same number of used elements (|num_cids()|) and the same capacity.
 template <typename CidType, typename... Columns>
 class CidIndexedTable {

runtime/vm/dart_api_impl_test.cc

@@ -172,7 +172,7 @@ class InfiniteLoopTask : public ThreadPool::Task {
       ml.Notify();
     }
     Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
-    // Test should run an inifinite loop and expect that to be killed.
+    // Test should run an infinite loop and expect that to be killed.
     EXPECT(Dart_IsError(result));
     EXPECT_STREQ("isolate terminated by Isolate.kill", Dart_GetError(result));
     {
@@ -590,7 +590,7 @@ static Dart_NativeFunction CurrentStackTraceNativeLookup(
 
 TEST_CASE(DartAPI_CurrentStackTraceInfo) {
   const char* kScriptChars = R"(
-@pragma("vm:external-name", "CurrentStackTraceNatve")
+@pragma("vm:external-name", "CurrentStackTraceNative")
 external inspectStack();
 foo(n) => n == 1 ? inspectStack() : foo(n-1);
 testMain() => foo(100);

runtime/vm/datastream.h

@@ -619,7 +619,7 @@ class NonStreamingWriteStream : public BaseWriteStream {
 };
 
 // A non-streaming write stream that uses realloc for reallocation, and frees
-// the buffer when destructed unless ownership is transfered using Steal().
+// the buffer when destructed unless ownership is transferred using Steal().
 class MallocWriteStream : public NonStreamingWriteStream {
  public:
   explicit MallocWriteStream(intptr_t initial_size)

runtime/vm/dwarf.cc

@@ -876,7 +876,7 @@ void Dwarf::WriteLineNumberProgram(DwarfWriteStream* stream) {
       stream->u1(0);  // DW_LNS_const_add_pc, 0 operands
       stream->u1(1);  // DW_LNS_fixed_advance_pc, 1 operands
       stream->u1(0);  // DW_LNS_set_prolog_end, 0 operands
-      stream->u1(0);  // DW_LNS_set_epligoue_begin, 0 operands
+      stream->u1(0);  // DW_LNS_set_epilogue_begin, 0 operands
       stream->u1(1);  // DW_LNS_set_isa, 1 operands
 
       // 10. include_directories (sequence of path names)

runtime/vm/dwarf.h

@@ -98,7 +98,7 @@ struct DwarfCodeKeyValueTrait {
     }
     Pair() : code(nullptr), value{} {}
 
-    // Don't implcitly delete copy and copy assigment constructors.
+    // Don't implicitly delete copy and copy assigment constructors.
     Pair(const Pair& other) = default;
     Pair& operator=(const Pair& other) = default;
 

runtime/vm/elf.cc

@@ -1565,7 +1565,7 @@ ProgramTable* SectionTable::CreateProgramTable(SymbolTable* symtab) {
   //     table to initialize that segment.
   //
   //   - The Android dynamic linker in Jelly Bean incorrectly assumes that all
-  //     non-writable segments are continguous. Thus we write them all together.
+  //     non-writable segments are contiguous. Thus we write them all together.
   //     The bug is here: https://github.com/aosp-mirror/platform_bionic/blob/94963af28e445384e19775a838a29e6a71708179/linker/linker.c#L1991-L2001
   //
   //   - On Android native libraries can be mapped directly from an APK

runtime/vm/field_table.cc

@@ -35,7 +35,7 @@ void FieldTable::MarkReadyToUse() {
   // in new static field registrations.
   //
   // By requiring a read lock here we ensure no other thread is is registering a
-  // new static field at this moment (it would need exlusive writer lock).
+  // new static field at this moment (it would need exclusive writer lock).
   DEBUG_ASSERT(
       IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
   ASSERT(!is_ready_to_use_);

runtime/vm/flag_list.h

@@ -253,7 +253,7 @@ constexpr bool FLAG_support_il_printer = false;
     "Eliminate type checks when allowed by static type analysis.")             \
   D(support_rr, bool, false, "Support running within RR.")                     \
   P(verify_entry_points, bool, false,                                          \
-    "Throw API error on invalid member access throuh native API. See "         \
+    "Throw API error on invalid member access through native API. See "        \
     "entry_point_pragma.md")                                                   \
   P(sound_null_safety, bool, true,                                             \
     "Respect the nullability of types at runtime.")                            \

runtime/vm/heap/become_test.cc

@@ -34,19 +34,19 @@ void TestBecomeForward(Heap::Space before_space, Heap::Space after_space) {
   EXPECT(container.At(0) == after_obj.ptr());
 }
 
-ISOLATE_UNIT_TEST_CASE(BecomeFowardOldToOld) {
+ISOLATE_UNIT_TEST_CASE(BecomeForwardOldToOld) {
   TestBecomeForward(Heap::kOld, Heap::kOld);
 }
 
-ISOLATE_UNIT_TEST_CASE(BecomeFowardNewToNew) {
+ISOLATE_UNIT_TEST_CASE(BecomeForwardNewToNew) {
   TestBecomeForward(Heap::kNew, Heap::kNew);
 }
 
-ISOLATE_UNIT_TEST_CASE(BecomeFowardOldToNew) {
+ISOLATE_UNIT_TEST_CASE(BecomeForwardOldToNew) {
   TestBecomeForward(Heap::kOld, Heap::kNew);
 }
 
-ISOLATE_UNIT_TEST_CASE(BecomeFowardNewToOld) {
+ISOLATE_UNIT_TEST_CASE(BecomeForwardNewToOld) {
   TestBecomeForward(Heap::kNew, Heap::kOld);
 }
 

runtime/vm/heap/compactor.cc

@@ -24,7 +24,7 @@ DEFINE_FLAG(bool,
 // kAllocatablePageSize - 2 * kObjectAlignment bytes belong to the same block).
 // During compaction, all live objects in the same block will slide such that
 // they all end up on the same Page, and all gaps within the block will be
-// closed. During sliding, a bitvector is computed that indictates which
+// closed. During sliding, a bitvector is computed that indicates which
 // allocation units are live, so the new address of any object in the block can
 // be found by adding the number of live allocation units before the object to
 // the block's new start address.

runtime/vm/heap/pointer_block.h

@@ -93,7 +93,7 @@ class BlockStack {
   static void Init();
   static void Cleanup();
 
-  // Partially filled blocks can be reused, and there is an "inifite" supply
+  // Partially filled blocks can be reused, and there is an "infinite" supply
   // of empty blocks (reused or newly allocated). In any case, the caller
   // takes ownership of the returned block.
   Block* PopNonFullBlock();

runtime/vm/heap/scavenger.cc

@@ -1860,7 +1860,7 @@ void Scavenger::ReverseScavenge(SemiSpace** from) {
   // Release any remaining part of the promotion worklist that wasn't completed.
   promotion_stack_.Reset();
 
-  // Release any remaining part of the rememebred set that wasn't completed.
+  // Release any remaining part of the remembered set that wasn't completed.
   StoreBuffer* store_buffer = heap_->isolate_group()->store_buffer();
   StoreBufferBlock* pending = blocks_;
   while (pending != nullptr) {

runtime/vm/image_snapshot.cc

@@ -672,9 +672,9 @@ const char* ImageWriter::SectionSymbol(ProgramSection section, bool vm) {
 // canonicalized and compressed: when building __unwind_info from CFI directives
 // LLVM will fold together similar entries, the same does not happen for
 // __eh_frame. This means that emitting CFI directives for each function would
-// baloon the size of __eh_frame.
+// balloon the size of __eh_frame.
 //
-// Hence to work around the problem of incorrect __unwind_info without balooning
+// Hence to work around the problem of incorrect __unwind_info without ballooning
 // snapshot size when __eh_frame is generated we choose to emit CFI directives
 // per function specifically on ARM64 Mac OS X and iOS.
 //

runtime/vm/image_snapshot.h

@@ -212,10 +212,10 @@ struct ImageWriterCommand {
 
   ImageWriterCommand(intptr_t expected_offset,
                      uint8_t* trampoline_bytes,
-                     intptr_t trampoine_length)
+                     intptr_t trampoline_length)
       : expected_offset(expected_offset),
         op(ImageWriterCommand::InsertBytesOfTrampoline),
-        insert_trampoline_bytes({trampoline_bytes, trampoine_length}) {}
+        insert_trampoline_bytes({trampoline_bytes, trampoline_length}) {}
 
   // The offset (relative to the very first [ImageWriterCommand]) we expect
   // this [ImageWriterCommand] to have.

runtime/vm/instructions_arm.h

@@ -51,7 +51,7 @@ class InstructionPattern : public AllStatic {
   // address of the first instruction in the sequence.  Returns the register
   // being loaded and the index in the pool being read from in the output
   // parameters 'reg' and 'index' respectively.
-  // IMPORANT: When generating code loading values from pool on ARM use
+  // IMPORTANT: When generating code loading values from pool on ARM use
   // LoadWordFromPool macro instruction instead of emitting direct load.
   // The macro instruction takes care of pool offsets that can't be
   // encoded as immediates.

runtime/vm/instructions_arm64.h

@@ -42,7 +42,7 @@ class InstructionPattern : public AllStatic {
   // address of the first instruction in the sequence.  Returns the register
   // being loaded and the index in the pool being read from in the output
   // parameters 'reg' and 'index' respectively.
-  // IMPORANT: When generating code loading values from pool on ARM64 use
+  // IMPORTANT: When generating code loading values from pool on ARM64 use
   // LoadWordFromPool macro instruction instead of emitting direct load.
   // The macro instruction takes care of pool offsets that can't be
   // encoded as immediates.
@@ -55,7 +55,7 @@ class InstructionPattern : public AllStatic {
   // address of the first instruction in the sequence.  Returns the registers
   // being loaded and the index in the pool being read from in the output
   // parameters 'reg1', 'reg2' and 'index' respectively.
-  // IMPORANT: When generating code loading values from pool on ARM64 use
+  // IMPORTANT: When generating code loading values from pool on ARM64 use
   // LoadDoubleWordFromPool macro instruction instead of emitting direct load.
   // The macro instruction takes care of pool offsets that can't be
   // encoded as immediates.

runtime/vm/instructions_riscv.h

@@ -42,7 +42,7 @@ class InstructionPattern : public AllStatic {
   // address of the first instruction in the sequence.  Returns the register
   // being loaded and the index in the pool being read from in the output
   // parameters 'reg' and 'index' respectively.
-  // IMPORANT: When generating code loading values from pool on ARM64 use
+  // IMPORTANT: When generating code loading values from pool on ARM64 use
   // LoadWordFromPool macro instruction instead of emitting direct load.
   // The macro instruction takes care of pool offsets that can't be
   // encoded as immediates.

runtime/vm/isolate.cc

@@ -516,7 +516,7 @@ void IsolateGroup::Shutdown() {
     while (old_space->tasks() > 0) {
       ml.Wait();
     }
-    // Needs to happen before ~PageSpace so TLS and the thread registery are
+    // Needs to happen before ~PageSpace so TLS and the thread registry are
     // still valid.
     old_space->AbandonMarkingForShutdown();
   }
@@ -748,7 +748,7 @@ void IsolateGroup::IncreaseMutatorCount(Isolate* mutator,
   {
     // NOTE: This is performance critical code, we should avoid monitors and use
     // std::atomics in the fast case (where active_mutators <
-    // max_active_mutators) and only use montiors in the uncommon case.
+    // max_active_mutators) and only use monitors in the uncommon case.
     MonitorLocker ml(active_mutators_monitor_.get());
     ASSERT(active_mutators_ <= max_active_mutators_);
     while (active_mutators_ == max_active_mutators_) {
@@ -774,7 +774,7 @@ void IsolateGroup::DecreaseMutatorCount(Isolate* mutator, bool is_nested_exit) {
   {
     // NOTE: This is performance critical code, we should avoid monitors and use
     // std::atomics in the fast case (where active_mutators <
-    // max_active_mutators) and only use montiors in the uncommon case.
+    // max_active_mutators) and only use monitors in the uncommon case.
     MonitorLocker ml(active_mutators_monitor_.get());
     ASSERT(active_mutators_ <= max_active_mutators_);
     active_mutators_--;

runtime/vm/isolate_reload.cc

@@ -199,7 +199,7 @@ InstanceMorpher* InstanceMorpher::CreateFromClassDescriptors(
         mapping->Add({from_field.HostOffset(), from_box_cid});
         mapping->Add({to_field.HostOffset(), to_box_cid});
 
-        // Field did exist in old class deifnition.
+        // Field did exist in old class definition.
         new_field = false;
         break;
       }

runtime/vm/isolate_reload_test.cc

@@ -2111,20 +2111,20 @@ TEST_CASE(IsolateReload_EnumAddition) {
   const char* kReloadScript =
       "enum Fruit {\n"
       "  Apple,\n"
-      "  Cantalope,\n"
+      "  Cantaloupe,\n"
       "  Banana,\n"
       "}\n"
       "var x;\n"
       "main() {\n"
       "  String r = '${Fruit.Apple.index}/${Fruit.Apple} ';\n"
-      "  r += '${Fruit.Cantalope.index}/${Fruit.Cantalope} ';\n"
+      "  r += '${Fruit.Cantaloupe.index}/${Fruit.Cantaloupe} ';\n"
       "  r += '${Fruit.Banana.index}/${Fruit.Banana}';\n"
       "  return r;\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("0/Fruit.Apple 1/Fruit.Cantalope 2/Fruit.Banana",
+  EXPECT_STREQ("0/Fruit.Apple 1/Fruit.Cantaloupe 2/Fruit.Banana",
                SimpleInvokeStr(lib, "main"));
 }
 
@@ -2183,19 +2183,19 @@ TEST_CASE(IsolateReload_EnumDelete) {
       "enum Fruit {\n"
       "  Apple,\n"
       "  Banana,\n"
-      "  Cantalope,\n"
+      "  Cantaloupe,\n"
       "}\n"
       "var x;\n"
       "main() {\n"
-      "  x = Fruit.Cantalope;\n"
+      "  x = Fruit.Cantaloupe;\n"
       "  return Fruit.Apple.toString();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main"));
 
-  // Delete 'Cantalope' but make sure that we can still invoke toString,
+  // Delete 'Cantaloupe' but make sure that we can still invoke toString,
   // and access the hashCode and index properties.
 
   const char* kReloadScript =
@@ -2220,7 +2220,7 @@ TEST_CASE(IsolateReload_EnumIdentityReload) {
       "enum Fruit {\n"
       "  Apple,\n"
       "  Banana,\n"
-      "  Cantalope,\n"
+      "  Cantaloupe,\n"
       "}\n"
       "var x;\n"
       "var y;\n"
@@ -2229,10 +2229,10 @@ TEST_CASE(IsolateReload_EnumIdentityReload) {
       "main() {\n"
       "  x = { Fruit.Apple: Fruit.Apple.index,\n"
       "        Fruit.Banana: Fruit.Banana.index,\n"
-      "        Fruit.Cantalope: Fruit.Cantalope.index};\n"
+      "        Fruit.Cantaloupe: Fruit.Cantaloupe.index};\n"
       "  y = Fruit.Apple;\n"
       "  z = Fruit.Banana;\n"
-      "  w = Fruit.Cantalope;\n"
+      "  w = Fruit.Cantaloupe;\n"
       "  return Fruit.Apple.toString();\n"
       "}\n";
 
@@ -2244,7 +2244,7 @@ TEST_CASE(IsolateReload_EnumIdentityReload) {
       "enum Fruit {\n"
       "  Apple,\n"
       "  Banana,\n"
-      "  Cantalope,\n"
+      "  Cantaloupe,\n"
       "}\n"
       "var x;\n"
       "var y;\n"
@@ -2260,10 +2260,10 @@ TEST_CASE(IsolateReload_EnumIdentityReload) {
       "  });\n"
       "  r += '${x[Fruit.Apple] == Fruit.Apple.index} ';\n"
       "  r += '${x[Fruit.Banana] == Fruit.Banana.index} ';\n"
-      "  r += '${x[Fruit.Cantalope] == Fruit.Cantalope.index} ';\n"
+      "  r += '${x[Fruit.Cantaloupe] == Fruit.Cantaloupe.index} ';\n"
       "  r += '${identical(y, Fruit.values[x[Fruit.Apple]])} ';\n"
       "  r += '${identical(z, Fruit.values[x[Fruit.Banana]])} ';\n"
-      "  r += '${identical(w, Fruit.values[x[Fruit.Cantalope]])} ';\n"
+      "  r += '${identical(w, Fruit.values[x[Fruit.Cantaloupe]])} ';\n"
       "  return r;\n"
       "}\n";
 
@@ -2329,28 +2329,28 @@ TEST_CASE(IsolateReload_EnumValuesToString) {
   EXPECT_VALID(lib);
   EXPECT_STREQ("Fruit.Apple Fruit.Banana", SimpleInvokeStr(lib, "main"));
 
-  // Insert 'Cantalope'.
+  // Insert 'Cantaloupe'.
 
   const char* kReloadScript =
       "enum Fruit {\n"
       "  Apple,\n"
-      "  Cantalope,\n"
+      "  Cantaloupe,\n"
       "  Banana\n"
       "}\n"
       "var x;\n"
       "main() {\n"
       "  String r = '';\n"
       "  r += Fruit.Apple.toString();\n"
       "  r += ' ';\n"
-      "  r += Fruit.Cantalope.toString();\n"
+      "  r += Fruit.Cantaloupe.toString();\n"
       "  r += ' ';\n"
       "  r += Fruit.Banana.toString();\n"
       "  return r;\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("Fruit.Apple Fruit.Cantalope Fruit.Banana",
+  EXPECT_STREQ("Fruit.Apple Fruit.Cantaloupe Fruit.Banana",
                SimpleInvokeStr(lib, "main"));
 }
 
@@ -2974,7 +2974,7 @@ TEST_CASE(IsolateReload_ShapeChange_Const_AddSlot) {
   // change, they are allocated old. Because instructions normally contain
   // pointers only to old objects, the scavenger does not bother to ensure code
   // pages are writable when visiting the remembered set. Visiting the
-  // remembered involes writing to update the pointer for any target that gets
+  // remembered involves writing to update the pointer for any target that gets
   // promoted.
   const char* kScript = R"(
     import 'file:///test:isolate_reload_helper';

runtime/vm/libfuzzer/dart_libfuzzer.cc

@@ -81,7 +81,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc_in, char*** argv_in) {
 
 // Libfuzzer target functions:
 //  0 : unicode
-//  1 : utilies
+//  1 : utilities
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   switch (target) {
     case 0: