blink_gc_plugin: Make RecordInfo::Get{Fields,Bases} return deterministic order

tools/clang/blink_gc_plugin/RecordInfo.cpp

 // Copyright 2014 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 "Config.h"
 #include "RecordInfo.h"
 
 using namespace clang;
 using std::string;
 
 RecordInfo::RecordInfo(CXXRecordDecl* record, RecordCache* cache)
     : cache_(cache),
       record_(record),
       name_(record->getName()),
       fields_need_tracing_(TracingStatus::Unknown()),
       bases_(0),
       fields_(0),
+      field_map_(0),
       is_stack_allocated_(kNotComputed),
       is_non_newable_(kNotComputed),
       is_only_placement_newable_(kNotComputed),
       does_need_finalization_(kNotComputed),
       has_gc_mixin_methods_(kNotComputed),
       is_declaring_local_trace_(kNotComputed),
       is_eagerly_finalized_(kNotComputed),
       determined_trace_methods_(false),
       trace_method_(0),
       trace_dispatch_method_(0),
       finalize_dispatch_method_(0),
       is_gc_derived_(false) {}
 
 RecordInfo::~RecordInfo() {
   delete fields_;
+  delete field_map_;
   delete bases_;
 }
 
 // Get |count| number of template arguments. Returns false if there
 // are fewer than |count| arguments or any of the arguments are not
 // of a valid Type structure. If |count| is non-positive, all
 // arguments are collected.
 bool RecordInfo::GetTemplateArgs(size_t count, TemplateArgs* output_args) {
   ClassTemplateSpecializationDecl* tmpl =
       dyn_cast<ClassTemplateSpecializationDecl>(record_);
@@ skipping 269 matching lines @@
   return trace_dispatch_method_;
 }
 
 CXXMethodDecl* RecordInfo::GetFinalizeDispatchMethod() {
   DetermineTracingMethods();
   return finalize_dispatch_method_;
 }
 
 RecordInfo::Bases& RecordInfo::GetBases() {
   if (!bases_)
-    bases_ = CollectBases();
+    CollectBases();
   return *bases_;
 }
 
 bool RecordInfo::InheritsTrace() {
   if (GetTraceMethod())
     return true;
   for (Bases::iterator it = GetBases().begin(); it != GetBases().end(); ++it) {
     if (it->second.info()->InheritsTrace())
       return true;
   }
@@ skipping 43 matching lines @@
   }
   for (CXXRecordDecl::method_iterator it = record_->method_begin();
        it != record_->method_end();
        ++it) {
     if (it->getNameAsString() == kCreateName)
       return false;
   }
   return true;
 }
 
-RecordInfo::Bases* RecordInfo::CollectBases() {
+void RecordInfo::CollectBases() {
   // Compute the collection locally to avoid inconsistent states.
-  Bases* bases = new Bases;
+  assert(!bases_);
+  bases_ = new Bases;
   if (!record_->hasDefinition())
-    return bases;
+    return;
   for (CXXRecordDecl::base_class_iterator it = record_->bases_begin();
        it != record_->bases_end();
        ++it) {
     const CXXBaseSpecifier& spec = *it;
     RecordInfo* info = cache_->Lookup(spec.getType());
     if (!info)
       continue;
     CXXRecordDecl* base = info->record();
     TracingStatus status = info->InheritsTrace()
                                ? TracingStatus::Needed()
                                : TracingStatus::Unneeded();
-    bases->insert(std::make_pair(base, BasePoint(spec, info, status)));
+    bases_->push_back(std::make_pair(base, BasePoint(spec, info, status)));
   }
-  return bases;
 }
 
 RecordInfo::Fields& RecordInfo::GetFields() {
-  if (!fields_)
-    fields_ = CollectFields();
+  if (!fields_) {
+    assert(!field_map_);
+    CollectFields();
+  }
   return *fields_;
 }
 
-RecordInfo::Fields* RecordInfo::CollectFields() {
+bool RecordInfo::HasField(clang::FieldDecl* field) {
+  GetFields();
+  assert(field_map_);
+  return field_map_->count(field);
+}
+
+RecordInfo::Field& RecordInfo::GetField(clang::FieldDecl* field) {
+  assert(HasField(field));
+  return fields_->at((*field_map_)[field]);
+}
+
+void RecordInfo::CollectFields() {
   // Compute the collection locally to avoid inconsistent states.
-  Fields* fields = new Fields;
+  assert(!fields_);
+  fields_ = new Fields;
+  field_map_ = new std::map<clang::FieldDecl*, size_t>;
+
   if (!record_->hasDefinition())
-    return fields;
+    return;
+
   TracingStatus fields_status = TracingStatus::Unneeded();
   for (RecordDecl::field_iterator it = record_->field_begin();
        it != record_->field_end();
        ++it) {
     FieldDecl* field = *it;
     // Ignore fields annotated with the GC_PLUGIN_IGNORE macro.
     if (Config::IsIgnoreAnnotated(field))
       continue;
     if (Edge* edge = CreateEdge(field->getType().getTypePtrOrNull())) {
       fields_status = fields_status.LUB(edge->NeedsTracing(Edge::kRecursive));
-      fields->insert(std::make_pair(field, FieldPoint(field, edge)));
+      (*field_map_)[field] = fields_->size();
+      fields_->push_back(std::make_pair(field, FieldPoint(field, edge)));
     }
   }
   fields_need_tracing_ = fields_status;
-  return fields;
 }
 
 void RecordInfo::DetermineTracingMethods() {
   if (determined_trace_methods_)
     return;
   determined_trace_methods_ = true;
   if (Config::IsGCBase(name_))
     return;
   CXXMethodDecl* trace = nullptr;
   CXXMethodDecl* trace_impl = nullptr;
@@ skipping 211 matching lines @@
         edge->members().push_back(member);
       }
       // TODO: Handle the case where we fail to create an edge (eg, if the
       // argument is a primitive type or just not fully known yet).
     }
     return edge;
   }
 
   return new Value(info);
 }