GC plugin: improve error reporting when tracing illegal fields.

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"
+#include "clang/Sema/Sema.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),
@@ skipping 532 matching lines @@
     if (it->second.info()->NeedsTracing(option).IsNeeded())
       return TracingStatus::Needed();
   }
 
   if (option == Edge::kRecursive)
     GetFields();
 
   return fields_need_tracing_;
 }
 
+static bool isInStdNamespace(clang::Sema& sema, NamespaceDecl* ns)
+{
+  while (ns) {
+    if (sema.getStdNamespace()->InEnclosingNamespaceSetOf(ns))
+      return true;
+    ns = dyn_cast<NamespaceDecl>(ns->getParent());
+  }
+  return false;
+}
+
 Edge* RecordInfo::CreateEdge(const Type* type) {
   if (!type) {
     return 0;
   }
 
   if (type->isPointerType() || type->isReferenceType()) {
     if (Edge* ptr = CreateEdge(type->getPointeeType().getTypePtrOrNull()))
       return new RawPtr(ptr, type->isReferenceType());
     return 0;
   }
@@ skipping 12 matching lines @@
       return new RefPtr(ptr);
     return 0;
   }
 
   if (Config::IsOwnPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new OwnPtr(ptr);
     return 0;
   }
 
+  if (Config::IsUniquePtr(info->name()) && info->GetTemplateArgs(1, &args)) {
+    // Check that this is std::unique_ptr
+    NamespaceDecl* ns =
+        dyn_cast<NamespaceDecl>(info->record()->getDeclContext());
+    clang::Sema& sema = cache_->instance().getSema();
+    if (!isInStdNamespace(sema, ns))
+      return 0;
+    if (Edge* ptr = CreateEdge(args[0]))
+      return new UniquePtr(ptr);
+    return 0;
+  }
+
   if (Config::IsMember(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new Member(ptr);
     return 0;
   }
 
   if (Config::IsWeakMember(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new WeakMember(ptr);
     return 0;
   }
 
-  if (Config::IsPersistent(info->name())) {
+  bool is_persistent = Config::IsPersistent(info->name());
+  if (is_persistent || Config::IsCrossThreadPersistent(info->name())) {
     // Persistent might refer to v8::Persistent, so check the name space.
     // TODO: Consider using a more canonical identification than names.
     NamespaceDecl* ns =
         dyn_cast<NamespaceDecl>(info->record()->getDeclContext());
     if (!ns || ns->getName() != "blink")
       return 0;
     if (!info->GetTemplateArgs(1, &args))
       return 0;
-    if (Edge* ptr = CreateEdge(args[0]))
-      return new Persistent(ptr);
+    if (Edge* ptr = CreateEdge(args[0])) {
+      if (is_persistent)
+        return new Persistent(ptr);
+      else
+        return new CrossThreadPersistent(ptr);
+    }
     return 0;
   }
 
   if (Config::IsGCCollection(info->name()) ||
       Config::IsWTFCollection(info->name())) {
     bool is_root = Config::IsPersistentGCCollection(info->name());
     bool on_heap = is_root || info->IsHeapAllocatedCollection();
     size_t count = Config::CollectionDimension(info->name());
     if (!info->GetTemplateArgs(count, &args))
       return 0;
     Collection* edge = new Collection(info, on_heap, is_root);
     for (TemplateArgs::iterator it = args.begin(); it != args.end(); ++it) {
       if (Edge* member = CreateEdge(*it)) {
         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);
 }