Update monet.

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),
       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 bases_;
 }
@@ skipping 127 matching lines @@
   }
   // This is a mixin if all GC bases are mixins.
   return true;
 }
 
 // Test if a record is allocated on the managed heap.
 bool RecordInfo::IsGCAllocated() {
   return IsGCDerived() || IsHeapAllocatedCollection();
 }
 
+bool RecordInfo::IsEagerlyFinalized() {
+  if (is_eagerly_finalized_ == kNotComputed) {
+    is_eagerly_finalized_ = kFalse;
+    if (IsGCFinalized()) {
+      for (Decl* decl : record_->decls()) {
+        if (TypedefDecl* typedef_decl = dyn_cast<TypedefDecl>(decl)) {
+          if (typedef_decl->getNameAsString() == kIsEagerlyFinalizedName) {
+            is_eagerly_finalized_ = kTrue;
+            break;
+          }
+        }
+      }
+    }
+  }
+  return is_eagerly_finalized_;
+}
+
+bool RecordInfo::HasDefinition() {
+  return record_->hasDefinition();
+}
+
 RecordInfo* RecordCache::Lookup(CXXRecordDecl* record) {
   // Ignore classes annotated with the GC_PLUGIN_IGNORE macro.
   if (!record || Config::IsIgnoreAnnotated(record))
     return 0;
   Cache::iterator it = cache_.find(record);
   if (it != cache_.end())
     return &it->second;
   return &cache_.insert(std::make_pair(record, RecordInfo(record, this)))
               .first->second;
 }
@@ skipping 382 matching lines @@
     GetFields();
 
   return fields_need_tracing_;
 }
 
 Edge* RecordInfo::CreateEdge(const Type* type) {
   if (!type) {
     return 0;
   }
 
-  if (type->isPointerType()) {
+  if (type->isPointerType() || type->isReferenceType()) {
     if (Edge* ptr = CreateEdge(type->getPointeeType().getTypePtrOrNull()))
-      return new RawPtr(ptr, false);
+      return new RawPtr(ptr, false, type->isReferenceType());
     return 0;
   }
 
   RecordInfo* info = cache_->Lookup(type);
 
   // If the type is neither a pointer or a C++ record we ignore it.
   if (!info) {
     return 0;
   }
 
   TemplateArgs args;
 
   if (Config::IsRawPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
-      return new RawPtr(ptr, true);
+      return new RawPtr(ptr, true, false);
     return 0;
   }
 
   if (Config::IsRefPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new RefPtr(ptr);
     return 0;
   }
 
   if (Config::IsOwnPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
@@ skipping 41 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);
 }