Remove divisive terms

Based on guidance in https://developers.google.com/style/

Related to #42247

Change-Id: Iaf37f3372b2b5882738cfa63339dd7b032cdbba9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/150630
Commit-Queue: Vyacheslav Egorov <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: mraleph

runtime/vm/compiler/backend/il_test_helper.cc

@@ -126,7 +126,7 @@ FlowGraph* TestPipeline::RunPasses(
     BlockScheduler::AssignEdgeWeights(flow_graph_);
   }
 
-  SpeculativeInliningPolicy speculative_policy(/*enable_blacklist=*/false);
+  SpeculativeInliningPolicy speculative_policy(/*enable_suppression=*/false);
   pass_state_ = new CompilerPassState(thread, flow_graph_, &speculative_policy);
   pass_state_->reorder_blocks = reorder_blocks;
 
@@ -163,7 +163,7 @@ void TestPipeline::CompileGraphAndAttachFunction() {
   Zone* zone = thread_->zone();
   const bool optimized = true;
 
-  SpeculativeInliningPolicy speculative_policy(/*enable_blacklist=*/false);
+  SpeculativeInliningPolicy speculative_policy(/*enable_suppression=*/false);
 
 #if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
   const bool use_far_branches = false;

runtime/vm/compiler/backend/inliner.h

@@ -31,21 +31,22 @@ class TargetEntryInstr;
 
 class SpeculativeInliningPolicy {
  public:
-  explicit SpeculativeInliningPolicy(bool enable_blacklist, intptr_t limit = -1)
-      : enable_blacklist_(enable_blacklist), remaining_(limit) {}
+  explicit SpeculativeInliningPolicy(bool enable_suppression,
+                                     intptr_t limit = -1)
+      : enable_suppression_(enable_suppression), remaining_(limit) {}
 
   bool AllowsSpeculativeInlining() const {
-    return !enable_blacklist_ || remaining_ > 0;
+    return !enable_suppression_ || remaining_ > 0;
   }
 
   bool IsAllowedForInlining(intptr_t call_deopt_id) const {
-    // If we are not blacklisting, we always enable optimistic inlining.
-    if (!enable_blacklist_) {
+    // If we are not supressing, we always enable optimistic inlining.
+    if (!enable_suppression_) {
       return true;
     }
 
-    // If we have already blacklisted the deopt-id we don't allow inlining it.
-    if (IsBlacklisted(call_deopt_id)) {
+    // If we have already suppressed the deopt-id we don't allow inlining it.
+    if (IsSuppressed(call_deopt_id)) {
       return false;
     }
 
@@ -54,37 +55,37 @@ class SpeculativeInliningPolicy {
   }
 
   bool AddBlockedDeoptId(intptr_t id) {
-    ASSERT(enable_blacklist_);
+    ASSERT(enable_suppression_);
 #if defined(DEBUG)
-    ASSERT(!IsBlacklisted(id));
+    ASSERT(!IsSuppressed(id));
 #endif
 
-    // If we exhausted the number of blacklist entries there is no point
-    // in adding entries to the blacklist.
+    // If we exhausted the number of suppression entries there is no point
+    // in adding entries to the list.
     if (remaining_ <= 0) return false;
 
-    inlining_blacklist_.Add(id);
+    inlining_suppressions_.Add(id);
     remaining_ -= 1;
     return true;
   }
 
-  intptr_t length() const { return inlining_blacklist_.length(); }
+  intptr_t length() const { return inlining_suppressions_.length(); }
 
  private:
-  bool IsBlacklisted(intptr_t id) const {
-    for (intptr_t i = 0; i < inlining_blacklist_.length(); ++i) {
-      if (inlining_blacklist_[i] == id) return true;
+  bool IsSuppressed(intptr_t id) const {
+    for (intptr_t i = 0; i < inlining_suppressions_.length(); ++i) {
+      if (inlining_suppressions_[i] == id) return true;
     }
     return false;
   }
 
-  // Whether we enable blacklisting deopt-ids.
-  const bool enable_blacklist_;
+  // Whether we enable supressing inlining at specific deopt-ids.
+  const bool enable_suppression_;
 
-  // After we reach [remaining_] number of deopt-ids in [inlining_blacklist_]
-  // in the black list, we'll disable speculative inlining entirely.
+  // After we reach [remaining_] number of deopt-ids in [inlining_suppressions_]
+  // list, we'll disable speculative inlining entirely.
   intptr_t remaining_;
-  GrowableArray<intptr_t> inlining_blacklist_;
+  GrowableArray<intptr_t> inlining_suppressions_;
 };
 
 class FlowGraphInliner : ValueObject {

runtime/vm/compiler/jit/compiler.cc

@@ -521,8 +521,8 @@ CodePtr CompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   volatile bool use_far_branches = false;
 
   // In the JIT case we allow speculative inlining and have no need for a
-  // blacklist, since we don't restart optimization.
-  SpeculativeInliningPolicy speculative_policy(/* enable_blacklist= */ false);
+  // suppression, since we don't restart optimization.
+  SpeculativeInliningPolicy speculative_policy(/*enable_suppression=*/false);
 
   Code* volatile result = &Code::ZoneHandle(zone);
   while (!done) {

runtime/vm/isolate.cc

@@ -1299,8 +1299,8 @@ MessageHandler::MessageStatus IsolateMessageHandler::HandleMessage(
   } else {
 #ifndef PRODUCT
     if (!Isolate::IsVMInternalIsolate(I)) {
-      // Mark all the user isolates as white-listed for the simplified timeline
-      // page of Observatory. The internal isolates will be filtered out from
+      // Mark all the user isolates as using a simplified timeline page of
+      // Observatory. The internal isolates will be filtered out from
       // the Timeline due to absence of this argument. We still send them in
       // order to maintain the original behavior of the full timeline and allow
       // the developer to download complete dump files.

runtime/vm/raw_object.h

@@ -1350,7 +1350,7 @@ class NamespaceLayout : public ObjectLayout {
   VISIT_FROM(ObjectPtr, library_);
   LibraryPtr library_;       // library with name dictionary.
   ArrayPtr show_names_;      // list of names that are exported.
-  ArrayPtr hide_names_;      // blacklist of names that are not exported.
+  ArrayPtr hide_names_;      // list of names that are hidden.
   FieldPtr metadata_field_;  // remembers the token pos of metadata if any,
                              // and the metadata values if computed.
   VISIT_TO(ObjectPtr, metadata_field_);

runtime/vm/regexp_parser.cc

@@ -1546,7 +1546,7 @@ bool LookupSpecialPropertyValueName(const char* name,
   return true;
 }
 
-// Explicitly whitelist supported binary properties. The spec forbids supporting
+// Explicitly list supported binary properties. The spec forbids supporting
 // properties outside of this set to ensure interoperability.
 bool IsSupportedBinaryProperty(UProperty property) {
   switch (property) {

runtime/vm/scopes.h

@@ -124,7 +124,7 @@ class LocalVariable : public ZoneAllocated {
   // Variables marked as forced to stack are skipped and not captured by
   // CaptureLocalVariables - which iterates scope chain between two scopes
   // and indiscriminately marks all variables as captured.
-  // TODO(27590) remove the hardcoded blacklist from CaptureLocalVariables
+  // TODO(27590) remove the hardcoded list of names from CaptureLocalVariables
   bool is_forced_stack() const { return is_forced_stack_; }
   void set_is_forced_stack() { is_forced_stack_ = true; }
 
@@ -499,9 +499,9 @@ class LocalScope : public ZoneAllocated {
   LocalScope* parent_;
   LocalScope* child_;
   LocalScope* sibling_;
-  int function_level_;         // Reflects the nesting level of local functions.
-  int loop_level_;             // Reflects the loop nesting level.
-  int context_level_;          // Reflects the level of the runtime context.
+  int function_level_;  // Reflects the nesting level of local functions.
+  int loop_level_;      // Reflects the loop nesting level.
+  int context_level_;   // Reflects the level of the runtime context.
   TokenPosition begin_token_pos_;  // Token index of beginning of scope.
   TokenPosition end_token_pos_;    // Token index of end of scope.
   GrowableArray<LocalVariable*> variables_;

runtime/vm/type_testing_stubs.h

@@ -38,7 +38,7 @@ class TypeTestingStubNamer {
 
 class TypeTestingStubGenerator {
  public:
-  // During bootstrapping it will return `null` for a whitelisted set of types,
+  // During bootstrapping it will return `null` for |void| and |dynamic| types,
   // otherwise it will return a default stub which tail-calls
   // subtypingtest/runtime code.
   static CodePtr DefaultCodeForType(const AbstractType& type,