win: Make oilpan plugin work better with delayed template parsing.

tools/clang/blink_gc_plugin/BlinkGCPlugin.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.
 
 // This clang plugin checks various invariants of the Blink garbage
 // collection infrastructure.
 //
 // Errors are described at:
 // http://www.chromium.org/developers/blink-gc-plugin-errors
 
 #include "Config.h"
 #include "JsonWriter.h"
 #include "RecordInfo.h"
 
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Sema/Sema.h"
 
 using namespace clang;
 using std::string;
 
 namespace {
 
 const char kClassMustLeftMostlyDeriveGC[] =
     "[blink-gc] Class %0 must derive its GC base in the left-most position.";
 
 const char kClassRequiresTraceMethod[] =
@@ skipping 107 matching lines @@
     " must be polymorphic.";
 
 const char kBaseClassMustDeclareVirtualTrace[] =
     "[blink-gc] Left-most base class %0 of derived class %1"
     " must define a virtual trace method.";
 
 const char kClassMustDeclareGCMixinTraceMethod[] =
     "[blink-gc] Class %0 which inherits from GarbageCollectedMixin must"
     " locally declare and override trace(Visitor*)";
 
+// Use a local RAV implementation to simply collect all FunctionDecls marked for
+// late template parsing. This happens with the flag -fdelayed-template-parsing,
+// which is on by default in MSVC-compatible mode.
+std::set<FunctionDecl*> GetLateParsedFunctionDecls(TranslationUnitDecl* decl) {
+  struct Visitor : public RecursiveASTVisitor<Visitor> {
+    bool VisitFunctionDecl(FunctionDecl* function_decl) {
+      if (function_decl->isLateTemplateParsed())
+        late_parsed_decls.insert(function_decl);
+      return true;
+    }
+
+    std::set<FunctionDecl*> late_parsed_decls;
+  } v;
+  v.TraverseDecl(decl);
+  return v.late_parsed_decls;
+}
+
 struct BlinkGCPluginOptions {
   BlinkGCPluginOptions()
     : enable_oilpan(false)
     , dump_graph(false)
     , warn_raw_ptr(false)
     , warn_unneeded_finalizer(false) {}
   bool enable_oilpan;
   bool dump_graph;
   bool warn_raw_ptr;
   bool warn_unneeded_finalizer;
@@ skipping 853 matching lines @@
         DiagnosticsEngine::Note, kOverriddenNonVirtualTraceNote);
     diag_manual_dispatch_method_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kManualDispatchMethodNote);
   }
 
   void HandleTranslationUnit(ASTContext& context) override {
     // Don't run the plugin if the compilation unit is already invalid.
     if (diagnostic_.hasErrorOccurred())
       return;
 
+    ParseFunctionTemplates(context.getTranslationUnitDecl());
+
     CollectVisitor visitor;
     visitor.TraverseDecl(context.getTranslationUnitDecl());
 
     if (options_.dump_graph) {
       std::error_code err;
       // TODO: Make createDefaultOutputFile or a shorter createOutputFile work.
       json_ = JsonWriter::from(instance_.createOutputFile(
           "",                                      // OutputPath
           err,                                     // Errors
           true,                                    // Binary
@@ skipping 26 matching lines @@
       CheckTracingMethod(*it);
     }
 
     if (json_) {
       json_->CloseList();
       delete json_;
       json_ = 0;
     }
   }
 
+  void ParseFunctionTemplates(TranslationUnitDecl* decl) {
+    std::set<FunctionDecl*> late_parsed_decls =
+        GetLateParsedFunctionDecls(decl);

[Reid Kleckner, 2015/05/15 22:44:32]

Traversing the whole AST might be expensive. Maybe you only want to do this if
DelayedTemplateParsing is true, and then put
'assert(GetLateParsedFunctionDecls(decl).empty())' in the else block?

[Nico, 2015/05/15 22:57:26]

We always build with asserts enabled, so that wouldn't be any faster. I made
this early-return if DelayedTemplateParsing isn't set in LangOpts instead.

+    clang::Sema& sema = instance_.getSema();
+
+    // If we have any late-parsed functions, make sure the
+    // -fdelayed-template-parsing flag is on. Otherwise we don't know where
+    // they came from.
+    assert((instance_.getLangOpts().DelayedTemplateParsing ||
+            late_parsed_decls.empty()) &&
+           "Should not have late-parsed decls without "
+           "-fdelayed-template-parsing.");
+
+    for (const FunctionDecl* fd : late_parsed_decls) {
+      assert(fd->isLateTemplateParsed());
+
+      if (!Config::IsTraceMethod(fd))
+        continue;
+
+      if (instance_.getSourceManager().isInSystemHeader(
+              instance_.getSourceManager().getSpellingLoc(fd->getLocation())))
+        continue;
+
+      // Force parsing and AST building of the yet-uninstantiated function
+      // template trace method bodies.
+      clang::LateParsedTemplate* lpt = sema.LateParsedTemplateMap[fd];
+      sema.LateTemplateParser(sema.OpaqueParser, *lpt);
+    }
+  }
+
   // Main entry for checking a record declaration.
   void CheckRecord(RecordInfo* info) {
     if (IsIgnored(info))
       return;
 
     CXXRecordDecl* record = info->record();
 
     // TODO: what should we do to check unions?
     if (record->isUnion())
       return;
@@ skipping 978 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");