Switch BlinkGCPluginConsumer to use ranged for-loops.

tools/clang/blink_gc_plugin/BlinkGCPluginConsumer.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "BlinkGCPluginConsumer.h"
 
 #include <algorithm>
 #include <set>
 
 #include "CheckDispatchVisitor.h"
@@ skipping 307 matching lines @@
     if (!err && json_) {
       json_->OpenList();
     } else {
       json_ = 0;
       llvm::errs()
           << "[blink-gc] "
           << "Failed to create an output file for the object graph.\n";
     }
   }
 
-  for (CollectVisitor::RecordVector::iterator it =
-           visitor.record_decls().begin();
-       it != visitor.record_decls().end();
-       ++it) {
-    CheckRecord(cache_.Lookup(*it));
-  }
+  for (const auto& record : visitor.record_decls())
+    CheckRecord(cache_.Lookup(record));
 
-  for (CollectVisitor::MethodVector::iterator it =
-           visitor.trace_decls().begin();
-       it != visitor.trace_decls().end();
-       ++it) {
-    CheckTracingMethod(*it);
-  }
+  for (const auto& method : visitor.trace_decls())
+    CheckTracingMethod(method);
 
   if (json_) {
     json_->CloseList();
     delete json_;
     json_ = 0;
   }
 }
 
 void BlinkGCPluginConsumer::ParseFunctionTemplates(TranslationUnitDecl* decl) {
   if (!instance_.getLangOpts().DelayedTemplateParsing)
@@ skipping 43 matching lines @@
 
   CheckClass(info);
 }
 
 void BlinkGCPluginConsumer::CheckClass(RecordInfo* info) {
   if (!info)
     return;
 
   // Check consistency of stack-allocated hierarchies.
   if (info->IsStackAllocated()) {
-    for (RecordInfo::Bases::iterator it = info->GetBases().begin();
-         it != info->GetBases().end();
-         ++it) {
-      if (!it->second.info()->IsStackAllocated())
-        ReportDerivesNonStackAllocated(info, &it->second);
-    }
+    for (auto& base : info->GetBases())
+      if (!base.second.info()->IsStackAllocated())
+        ReportDerivesNonStackAllocated(info, &base.second);
   }
 
   if (CXXMethodDecl* trace = info->GetTraceMethod()) {
     if (trace->isPure())
       ReportClassDeclaresPureVirtualTrace(info, trace);
   } else if (info->RequiresTraceMethod()) {
     ReportClassRequiresTraceMethod(info);
   }
 
   // Check polymorphic classes that are GC-derived or have a trace method.
   if (info->record()->hasDefinition() && info->record()->isPolymorphic()) {
     // TODO: Check classes that inherit a trace method.
     CXXMethodDecl* trace = info->GetTraceMethod();
     if (trace || info->IsGCDerived())
       CheckPolymorphicClass(info, trace);
   }
 
   {
     CheckFieldsVisitor visitor(options_);
     if (visitor.ContainsInvalidFields(info))
-      ReportClassContainsInvalidFields(info, &visitor.invalid_fields());
+      ReportClassContainsInvalidFields(info, visitor.invalid_fields());
   }
 
   if (info->IsGCDerived()) {
     if (!info->IsGCMixin()) {
       CheckLeftMostDerived(info);
       CheckDispatch(info);
       if (CXXMethodDecl* newop = info->DeclaresNewOperator())
         if (!Config::IsIgnoreAnnotated(newop))
           ReportClassOverridesNew(info, newop);
     }
 
     {
       CheckGCRootsVisitor visitor;
       if (visitor.ContainsGCRoots(info))
-        ReportClassContainsGCRoots(info, &visitor.gc_roots());
+        ReportClassContainsGCRoots(info, visitor.gc_roots());
     }
 
     if (info->NeedsFinalization())
       CheckFinalization(info);
 
     if (options_.warn_unneeded_finalizer && info->IsGCFinalized())
       CheckUnneededFinalization(info);
   }
 
   DumpClass(info);
@@ skipping 182 matching lines @@
 void BlinkGCPluginConsumer::CheckFinalization(RecordInfo* info) {
   CXXDestructorDecl* dtor = info->record()->getDestructor();
 
   // For finalized classes, check the finalization method if possible.
   if (info->IsGCFinalized()) {
     if (dtor && dtor->hasBody()) {
       CheckFinalizerVisitor visitor(&cache_, info->IsEagerlyFinalized());
       visitor.TraverseCXXMethodDecl(dtor);
       if (!visitor.finalized_fields().empty()) {
         ReportFinalizerAccessesFinalizedFields(
-            dtor, &visitor.finalized_fields());
+            dtor, visitor.finalized_fields());
       }
     }
     return;
   }
 
   // Don't require finalization of a mixin that has not yet been "mixed in".
   if (info->IsGCMixin())
     return;
 
   // Report the finalization error, and proceed to print possible causes for
   // the finalization requirement.
   ReportClassRequiresFinalization(info);
 
   if (dtor && dtor->isUserProvided())
     NoteUserDeclaredDestructor(dtor);
 
-  for (RecordInfo::Bases::iterator it = info->GetBases().begin();
-       it != info->GetBases().end();
-       ++it) {
-    if (it->second.info()->NeedsFinalization())
-      NoteBaseRequiresFinalization(&it->second);
-  }
+  for (auto& base : info->GetBases())
+    if (base.second.info()->NeedsFinalization())
+      NoteBaseRequiresFinalization(&base.second);
 
-  for (RecordInfo::Fields::iterator it = info->GetFields().begin();
-       it != info->GetFields().end();
-       ++it) {
-    if (it->second.edge()->NeedsFinalization())
-      NoteField(&it->second, diag_field_requires_finalization_note_);
-  }
+  for (auto& field : info->GetFields())
+    if (field.second.edge()->NeedsFinalization())
+      NoteField(&field.second, diag_field_requires_finalization_note_);
 }
 
 void BlinkGCPluginConsumer::CheckUnneededFinalization(RecordInfo* info) {
   if (!HasNonEmptyFinalizer(info))
     ReportClassDoesNotRequireFinalization(info);
 }
 
 bool BlinkGCPluginConsumer::HasNonEmptyFinalizer(RecordInfo* info) {
   CXXDestructorDecl* dtor = info->record()->getDestructor();
   if (dtor && dtor->isUserProvided()) {
     if (!dtor->hasBody() || !EmptyStmtVisitor::isEmpty(dtor->getBody()))
       return true;
   }
-  for (RecordInfo::Bases::iterator it = info->GetBases().begin();
-       it != info->GetBases().end();
-       ++it) {
-    if (HasNonEmptyFinalizer(it->second.info()))
+  for (auto& base : info->GetBases())
+    if (HasNonEmptyFinalizer(base.second.info()))
       return true;
-  }
-  for (RecordInfo::Fields::iterator it = info->GetFields().begin();
-       it != info->GetFields().end();
-       ++it) {
-    if (it->second.edge()->NeedsFinalization())
+
+  for (auto& field : info->GetFields())
+    if (field.second.edge()->NeedsFinalization())
       return true;
-  }
+
   return false;
 }
 
 void BlinkGCPluginConsumer::CheckTracingMethod(CXXMethodDecl* method) {
   RecordInfo* parent = cache_.Lookup(method->getParent());
   if (IsIgnored(parent))
     return;
 
   // Check templated tracing methods by checking the template instantiations.
   // Specialized templates are handled as ordinary classes.
@@ skipping 23 matching lines @@
   }
   // Dispatch methods are checked when we identify subclasses.
 }
 
 void BlinkGCPluginConsumer::CheckTraceMethod(
     RecordInfo* parent,
     CXXMethodDecl* trace,
     Config::TraceMethodType trace_type) {
   // A trace method must not override any non-virtual trace methods.
   if (trace_type == Config::TRACE_METHOD) {
-    for (RecordInfo::Bases::iterator it = parent->GetBases().begin();
-         it != parent->GetBases().end();
-         ++it) {
-      RecordInfo* base = it->second.info();
-      if (CXXMethodDecl* other = base->InheritsNonVirtualTrace())
+    for (auto& base : parent->GetBases())
+      if (CXXMethodDecl* other = base.second.info()->InheritsNonVirtualTrace())
         ReportOverriddenNonVirtualTrace(parent, trace, other);
-    }
   }
 
   CheckTraceVisitor visitor(trace, parent, &cache_);
   visitor.TraverseCXXMethodDecl(trace);
 
   // Skip reporting if this trace method is a just delegate to
   // traceImpl (or traceAfterDispatchImpl) method. We will report on
   // CheckTraceMethod on traceImpl method.
   if (visitor.delegates_to_traceimpl())
     return;
 
-  for (RecordInfo::Bases::iterator it = parent->GetBases().begin();
-       it != parent->GetBases().end();
-       ++it) {
-    if (!it->second.IsProperlyTraced())
-      ReportBaseRequiresTracing(parent, trace, it->first);
-  }
+  for (auto& base : parent->GetBases())
+    if (!base.second.IsProperlyTraced())
+      ReportBaseRequiresTracing(parent, trace, base.first);
 
-  for (RecordInfo::Fields::iterator it = parent->GetFields().begin();
-       it != parent->GetFields().end();
-       ++it) {
-    if (!it->second.IsProperlyTraced()) {
+  for (auto& field : parent->GetFields()) {
+    if (!field.second.IsProperlyTraced()) {
       // Discontinue once an untraced-field error is found.
       ReportFieldsRequireTracing(parent, trace);
       break;
     }
   }
 }
 
 void BlinkGCPluginConsumer::DumpClass(RecordInfo* info) {
   if (!json_)
     return;
@@ skipping 59 matching lines @@
 
    private:
     JsonWriter* json_;
     RecordInfo* src_;
     FieldPoint* point_;
     std::string loc_;
   };
 
   DumpEdgeVisitor visitor(json_);
 
-  RecordInfo::Bases& bases = info->GetBases();
-  for (RecordInfo::Bases::iterator it = bases.begin();
-       it != bases.end();
-       ++it) {
+  for (auto& base : info->GetBases())
     visitor.DumpEdge(info,
-                     it->second.info(),
+                     base.second.info(),
                      "<super>",
                      Edge::kStrong,
-                     GetLocString(it->second.spec().getLocStart()));
-  }
+                     GetLocString(base.second.spec().getLocStart()));
 
-  RecordInfo::Fields& fields = info->GetFields();
-  for (RecordInfo::Fields::iterator it = fields.begin();
-       it != fields.end();
-       ++it) {
+  for (auto& field : info->GetFields())
     visitor.DumpField(info,
-                      &it->second,
-                      GetLocString(it->second.field()->getLocStart()));
-  }
+                      &field.second,
+                      GetLocString(field.second.field()->getLocStart()));
 }
 
 DiagnosticsEngine::Level BlinkGCPluginConsumer::getErrorLevel() {
   return diagnostic_.getWarningsAsErrors() ? DiagnosticsEngine::Error
                                            : DiagnosticsEngine::Warning;
 }
 
 std::string BlinkGCPluginConsumer::GetLocString(SourceLocation loc) {
   const SourceManager& source_manager = instance_.getSourceManager();
   PresumedLoc ploc = source_manager.getPresumedLoc(loc);
@@ skipping 24 matching lines @@
           options_.ignored_classes.end());
 }
 
 bool BlinkGCPluginConsumer::InIgnoredDirectory(RecordInfo* info) {
   std::string filename;
   if (!GetFilename(info->record()->getLocStart(), &filename))
     return false;  // TODO: should we ignore non-existing file locations?
 #if defined(LLVM_ON_WIN32)
   std::replace(filename.begin(), filename.end(), '\\', '/');
 #endif
-  std::vector<std::string>::iterator it = options_.ignored_directories.begin();
-  for (; it != options_.ignored_directories.end(); ++it)
-    if (filename.find(*it) != std::string::npos)
+  for (const auto& dir : options_.ignored_directories)
+    if (filename.find(dir) != std::string::npos)
       return true;
   return false;
 }
 
 bool BlinkGCPluginConsumer::InCheckedNamespace(RecordInfo* info) {
   if (!info)
     return false;
   for (DeclContext* context = info->record()->getDeclContext();
        !context->isTranslationUnit();
        context = context->getParent()) {
@@ skipping 36 matching lines @@
   ReportDiagnostic(info->record()->getInnerLocStart(),
                    diag_class_must_left_mostly_derive_gc_)
       << info->record();
 }
 
 void BlinkGCPluginConsumer::ReportClassRequiresTraceMethod(RecordInfo* info) {
   ReportDiagnostic(info->record()->getInnerLocStart(),
                    diag_class_requires_trace_method_)
       << info->record();
 
-  for (RecordInfo::Bases::iterator it = info->GetBases().begin();
-       it != info->GetBases().end();
-       ++it) {
-    if (it->second.NeedsTracing().IsNeeded())
-      NoteBaseRequiresTracing(&it->second);
-  }
+  for (auto& base : info->GetBases())
+    if (base.second.NeedsTracing().IsNeeded())
+      NoteBaseRequiresTracing(&base.second);
 
-  for (RecordInfo::Fields::iterator it = info->GetFields().begin();
-       it != info->GetFields().end();
-       ++it) {
-    if (!it->second.IsProperlyTraced())
-      NoteFieldRequiresTracing(info, it->first);
-  }
+  for (auto& field : info->GetFields())
+    if (!field.second.IsProperlyTraced())
+      NoteFieldRequiresTracing(info, field.first);
 }
 
 void BlinkGCPluginConsumer::ReportBaseRequiresTracing(
     RecordInfo* derived,
     CXXMethodDecl* trace,
     CXXRecordDecl* base) {
   ReportDiagnostic(trace->getLocStart(), diag_base_requires_tracing_)
       << base << derived->record();
 }
 
 void BlinkGCPluginConsumer::ReportFieldsRequireTracing(
     RecordInfo* info,
     CXXMethodDecl* trace) {
   ReportDiagnostic(trace->getLocStart(), diag_fields_require_tracing_)
       << info->record();
-  for (RecordInfo::Fields::iterator it = info->GetFields().begin();
-       it != info->GetFields().end();
-       ++it) {
-    if (!it->second.IsProperlyTraced())
-      NoteFieldRequiresTracing(info, it->first);
-  }
+  for (auto& field : info->GetFields())
+    if (!field.second.IsProperlyTraced())
+      NoteFieldRequiresTracing(info, field.first);
 }
 
 void BlinkGCPluginConsumer::ReportClassContainsInvalidFields(
     RecordInfo* info,
-    CheckFieldsVisitor::Errors* errors) {
+    const CheckFieldsVisitor::Errors& errors) {
   bool only_warnings = options_.warn_raw_ptr;
-  for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
-       only_warnings && it != errors->end();
-       ++it) {
-    if (!CheckFieldsVisitor::IsWarning(it->second))
+  for (auto& error : errors)
+    if (!CheckFieldsVisitor::IsWarning(error.second))
       only_warnings = false;
-  }
+
   ReportDiagnostic(info->record()->getLocStart(),
                    only_warnings ?
                    diag_class_contains_invalid_fields_warning_ :
                    diag_class_contains_invalid_fields_)
       << info->record();
 
-  for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
-       it != errors->end();
-       ++it) {
-    unsigned error;
-    if (CheckFieldsVisitor::IsRawPtrError(it->second)) {
-      error = diag_raw_ptr_to_gc_managed_class_note_;
-    } else if (CheckFieldsVisitor::IsReferencePtrError(it->second)) {
-      error = diag_reference_ptr_to_gc_managed_class_note_;
-    } else if (it->second == CheckFieldsVisitor::kRefPtrToGCManaged) {
-      error = diag_ref_ptr_to_gc_managed_class_note_;
-    } else if (it->second == CheckFieldsVisitor::kOwnPtrToGCManaged) {
-      error = diag_own_ptr_to_gc_managed_class_note_;
-    } else if (it->second == CheckFieldsVisitor::kMemberToGCUnmanaged) {
-      error = diag_member_to_gc_unmanaged_class_note_;
-    } else if (it->second == CheckFieldsVisitor::kMemberInUnmanaged) {
-      error = diag_member_in_unmanaged_class_note_;
-    } else if (it->second == CheckFieldsVisitor::kPtrFromHeapToStack) {
-      error = diag_stack_allocated_field_note_;
-    } else if (it->second == CheckFieldsVisitor::kGCDerivedPartObject) {
-      error = diag_part_object_to_gc_derived_class_note_;
+  for (auto& error : errors) {
+    unsigned note;
+    if (CheckFieldsVisitor::IsRawPtrError(error.second)) {
+      note = diag_raw_ptr_to_gc_managed_class_note_;
+    } else if (CheckFieldsVisitor::IsReferencePtrError(error.second)) {
+      note = diag_reference_ptr_to_gc_managed_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kRefPtrToGCManaged) {
+      note = diag_ref_ptr_to_gc_managed_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kOwnPtrToGCManaged) {
+      note = diag_own_ptr_to_gc_managed_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kMemberToGCUnmanaged) {
+      note = diag_member_to_gc_unmanaged_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kMemberInUnmanaged) {
+      note = diag_member_in_unmanaged_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kPtrFromHeapToStack) {
+      note = diag_stack_allocated_field_note_;
+    } else if (error.second == CheckFieldsVisitor::kGCDerivedPartObject) {
+      note = diag_part_object_to_gc_derived_class_note_;
     } else {
       assert(false && "Unknown field error");
     }
-    NoteField(it->first, error);
+    NoteField(error.first, note);
   }
 }
 
 void BlinkGCPluginConsumer::ReportClassContainsGCRoots(
     RecordInfo* info,
-    CheckGCRootsVisitor::Errors* errors) {
-  for (CheckGCRootsVisitor::Errors::iterator it = errors->begin();
-       it != errors->end();
-       ++it) {
-    CheckGCRootsVisitor::RootPath::iterator path = it->begin();
-    FieldPoint* point = *path;
-    ReportDiagnostic(info->record()->getLocStart(),
-                     diag_class_contains_gc_root_)
-        << info->record() << point->field();
-    while (++path != it->end()) {
+    const CheckGCRootsVisitor::Errors& errors) {
+  for (auto& error : errors) {
+    FieldPoint* point = nullptr;
+    for (FieldPoint* path : error) {
+      if (!point) {
+        point = path;
+        ReportDiagnostic(info->record()->getLocStart(),
+                         diag_class_contains_gc_root_)
+            << info->record() << point->field();
+        continue;
+      }
       NotePartObjectContainsGCRoot(point);
-      point = *path;
+      point = path;
     }
     NoteFieldContainsGCRoot(point);
   }
 }
 
 void BlinkGCPluginConsumer::ReportFinalizerAccessesFinalizedFields(
     CXXMethodDecl* dtor,
-    CheckFinalizerVisitor::Errors* fields) {
-  for (CheckFinalizerVisitor::Errors::iterator it = fields->begin();
-       it != fields->end();
-       ++it) {
-    bool as_eagerly_finalized = it->as_eagerly_finalized;
+    const CheckFinalizerVisitor::Errors& errors) {
+  for (auto& error : errors) {
+    bool as_eagerly_finalized = error.as_eagerly_finalized;
     unsigned diag_error = as_eagerly_finalized ?
                           diag_finalizer_eagerly_finalized_field_ :
                           diag_finalizer_accesses_finalized_field_;
     unsigned diag_note = as_eagerly_finalized ?
                          diag_eagerly_finalized_field_note_ :
                          diag_finalized_field_note_;
-    ReportDiagnostic(it->member->getLocStart(), diag_error)
-        << dtor << it->field->field();
-    NoteField(it->field, diag_note);
+    ReportDiagnostic(error.member->getLocStart(), diag_error)
+        << dtor << error.field->field();
+    NoteField(error.field, diag_note);
   }
 }
 
 void BlinkGCPluginConsumer::ReportClassRequiresFinalization(RecordInfo* info) {
   ReportDiagnostic(info->record()->getInnerLocStart(),
                    diag_class_requires_finalization_)
       << info->record();
 }
 
 void BlinkGCPluginConsumer::ReportClassDoesNotRequireFinalization(
@@ skipping 145 matching lines @@
 void BlinkGCPluginConsumer::NoteField(FieldDecl* field, unsigned note) {
   ReportDiagnostic(field->getLocStart(), note) << field;
 }
 
 void BlinkGCPluginConsumer::NoteOverriddenNonVirtualTrace(
     CXXMethodDecl* overridden) {
   ReportDiagnostic(overridden->getLocStart(),
                    diag_overridden_non_virtual_trace_note_)
       << overridden;
 }