[libclang] Allow skipping function bodies in preamble only

[nik]

Summary

As an addition to CXTranslationUnit_SkipFunctionBodies, provide the
new option CXTranslationUnit_LimitSkipFunctionBodiesToPreamble,
which constraints the skipping of functions bodies to the preamble
only. Function bodies in the main file are not affected if this
option is set.

Skipping function bodies only in the preamble is what clangd already
does and the introduced flag implements it for libclang clients.

[nik]

@ilya: Using SkipFunctionBodies_AllExceptTemplates for the preamble might be also useful for clangd.

[ilya-biryukov]

In D45815#1072094, @nik wrote:

@ilya: Using SkipFunctionBodies_AllExceptTemplates for the preamble might be also useful for clangd.

Unfortunately, that's also the biggest performance win you get when skipping the function bodies.
I.e. most codebases do not have function bodies in headers unless the function is template.

Have you measured the performance gain of skipping only non-template functions, but not skipping the template ones?
Would that really make a significant difference for any real codebase?

include/clang/Frontend/SkipFunctionBodies.h

19

Maybe make it enum class and remove the name prefix from enumerators?
I.e. enum class SkipFunctionBodiesKind { None, ....

[nik]

In D45815#1073418, @ilya-biryukov wrote:

In D45815#1072094, @nik wrote:

@ilya: Using SkipFunctionBodies_AllExceptTemplates for the preamble might be also useful for clangd.

Unfortunately, that's also the biggest performance win you get when skipping the function bodies.
I.e. most codebases do not have function bodies in headers unless the function is template.

Have you measured the performance gain of skipping only non-template functions, but not skipping the template ones?
Would that really make a significant difference for any real codebase?

Here are some rough numbers, based on LIBCLANG_TIMING=1 output: https://dpaste.de/os39/raw

Reparses of Qt Creator's texteditor.cpp
Without any skipping of function bodies in the preamble: 1.9s
Skipping all function bodies in the preamble: 1.0s
Skipping all function bodies in the preamble except function template bodies: 1.2s

Reparses of Clang's SemaDecl.cpp
Without any skipping of function bodies in the preamble: 1.7s
Skipping all function bodies in the preamble: 0.59s
Skipping all function bodies in the preamble except function template bodies: 0.64s

Hmm, that indicates that template function bodies are actually not that
dominant, which I also haven't thought. Now I'm doubting the correctness of
my patch/tests.

I'll recheck this on Tuesday. Until then, you/someone might want to give this also a shot.

include/clang/Frontend/SkipFunctionBodies.h

19

Will do.

[ilya-biryukov]

In D45815#1073581, @nik wrote:

Hmm, that indicates that template function bodies are actually not that
dominant, which I also haven't thought. Now I'm doubting the correctness of
my patch/tests.

The numbers are definitely interesting, we need to double-check if that it's the case. But they definitely make a good point for including this option.
It seems Qt and LLVM are exactly the types of codebases where skipping the templates doesn't bring much value, as most of the code is not templated. On the other hand, skipping inline function might potentially be a win for those.

I'm still tempted to say that we should either skip all bodies or none of them to keep the code simpler, but I see why having errors from template instantiations is preferable.

[ilya-biryukov]

include/clang/Frontend/ASTUnit.h

687

Default ctor will be generated automatically. Maybe remove explicit definition?

include/clang/Frontend/FrontendOptions.h

302

Maybe add a comment to match the code style of other options?

lib/Frontend/ASTUnit.cpp

1649

Maybe use LLVM's make_scope_exit from ADT/ScopeExit.h instead of creating a separate RAII class?
Or even directy set/restore the value of the flag right in the function.
Given that LLVM does not use exceptions, RAII class does not seem to buy much in terms of correctness and doesn't really make the code easier to read, IMO.

But up to you.

lib/Parse/Parser.cpp

1108

Requested in this name is a bit confusing, e.g. it's not clear who requested it.
Maybe rename to TrySkipFunctionBody or something similar?

[yvvan]

include/clang/Frontend/ASTUnit.h

687

or replace by constructor with parameters

[nik]

In D45815#1076434, @ilya-biryukov wrote:

In D45815#1073581, @nik wrote:

Hmm, that indicates that template function bodies are actually not that
dominant, which I also haven't thought. Now I'm doubting the correctness of
my patch/tests.

The numbers are definitely interesting, we need to double-check if that it's the case. But they definitely make a good point for including this option.
It seems Qt and LLVM are exactly the types of codebases where skipping the templates doesn't bring much value, as most of the code is not templated. On the other hand, skipping inline function might potentially be a win for those.

I'm still tempted to say that we should either skip all bodies or none of them to keep the code simpler, but I see why having errors from template instantiations is preferable.

OK, I've rechecked this change. I don't see any obvious mistake :)

In my previous tests/timings I had some modifications to the clang command line applied (extra diagnostics enabled with -Weverything and maybe others, using -isystem instead of -I). I've reverted these and made some runs/timings with only "-Wall -Wextra" (https://dpaste.de/cZgZ/raw) - The difference between skip-all-in-preamble and skip-only-non-template-in-preamble becomes even smaller now for Qt Creator's texteditor.cpp.

include/clang/Frontend/ASTUnit.h

687

The explicit definition is needed to workaround https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58328 ("SkipFunctionBodiesOptions()" is used as default value in some function signatures)

687

That would not really help in this case.

include/clang/Frontend/FrontendOptions.h

302

No comment here is in line with "CodeCompleteOptions CodeCompleteOpts" below. That one has also its comments at definition. Also, I can't come up with a comment that adds more value than the name itself and that does not duplicate the comment from SkipFunctionBodies.h.

lib/Frontend/ASTUnit.cpp

1649

I've added the RAII class solely to minimize duplication. Now I'm just passing the flags to getMainBufferWithPrecompiledPreamble() and set/reset there directly.

lib/Parse/Parser.cpp

1108

TrySkipFunctionBody somewhat collides with the function trySkippingFunctionBody(). I'm using "ShouldSkipFunctionBody" now.

[nik]

Addressed inline comments.

[erikjv]

About the timing testing: I'm not very familiar with boost, but it probably has a library that's using templates more than either LLVM or Qt. Maybe you can test one of those too?

LGTM otherwise.

[ilya-biryukov]

OK, I've rechecked this change. I don't see any obvious mistake :)

I think I got to the bottom of it. We didn't expect a big win, because we expect people to not put their non-template code into the header files. Which is probably true.
The problem with our reasoning, is that this patch also skip bodies of non-template functions inside template classes, e.g.

template <class T>
struct vector {
   template <class It>
   void append(T* pos, It begin, It end) {
        / * This function won't be skipped, it is a template. */ 
   }

   void push_back(T const&) {
        /* However, this function will be skipped! It is not a template! */
   }
};

So it's not surprising that we get a big win. Template function are (probably) much more rare than non-template functions inside templates.

However, note that we will still miss a lot of diagnostics if we skip bodies of non-template functions inside templates.
So I don't see much value in an option like this: it still compromises correctness of diagnostics even inside the main file, while still missing out some performance opportunities that come from skipping the template functions. And it makes the code more complex.

We should either have an option that does not skip functions inside template classes or keep the current boolean value.
We should definitely measure the performance impact of having such an option before adding more complexity to the code.
WDYT?

BTW, maybe split this change out into two patches: one that allows to skip function bodies only in the preamble, the other that turns SkipFunctionBodies boolean into a enum and changes parser, etc.
The ASTUnit changes LG and we could probably LGTM them sooner than the parser changes.

lib/Parse/ParseCXXInlineMethods.cpp

104

Can't this be a template too? Do we need to check for it here?

[nik]

In D45815#1079327, @ilya-biryukov wrote:

OK, I've rechecked this change. I don't see any obvious mistake :)

I think I got to the bottom of it. We didn't expect a big win, because we expect people to not put their non-template code into the header files. Which is probably true.
The problem with our reasoning, is that this patch also skip bodies of non-template functions inside template classes, e.g.

template <class T>
struct vector {
   template <class It>
   void append(T* pos, It begin, It end) {
        / * This function won't be skipped, it is a template. */ 
   }

   void push_back(T const&) {
        /* However, this function will be skipped! It is not a template! */
   }
};

So it's not surprising that we get a big win. Template function are (probably) much more rare than non-template functions inside templates.

Oh, right. That makes sense. I didn't have a test for this case and thus didn't notice.

However, note that we will still miss a lot of diagnostics if we skip bodies of non-template functions inside templates.
So I don't see much value in an option like this: it still compromises correctness of diagnostics even inside the main file, while still missing out some performance opportunities that come from skipping the template functions. And it makes the code more complex.

We should either have an option that does not skip functions inside template classes or keep the current boolean value.
We should definitely measure the performance impact of having such an option before adding more complexity to the code.
WDYT?

BTW, maybe split this change out into two patches: one that allows to skip function bodies only in the preamble, the other that turns SkipFunctionBodies boolean into a enum and changes parser, etc.
The ASTUnit changes LG and we could probably LGTM them sooner than the parser changes.

Agree. I'll first reduce this change to the skip-in-preamble-only functionality and then will check some numbers with the new case.

[nik]

Reduction to skip-in-preamble-only functionality.

[nik]

lib/Parse/ParseCXXInlineMethods.cpp

104

Correct. Here is also the point were we would check for the parent class being a template.

[nik]

OK, to skip all function bodies in the preamble except for template functions and functions within a template class, I've amended the previous diff with:

• a/lib/Parse/ParseCXXInlineMethods.cpp +++ b/lib/Parse/ParseCXXInlineMethods.cpp @@ -102,9 +102,14 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, }
  
  if (SkipFunctionBodies != SkipFunctionBodiesKind::None && + TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate && + !isa<ClassTemplateDecl>(getCurrentClass().TagOrTemplate) && + !isa<ClassTemplateSpecializationDecl>(getCurrentClass().TagOrTemplate) && + !isa<ClassTemplatePartialSpecializationDecl>( + getCurrentClass().TagOrTemplate) && (!FnD || Actions.canSkipFunctionBody(FnD)) && trySkippingFunctionBody()) { Actions.ActOnSkippedFunctionBody(FnD);

I'm not sure whether this covers all cases, but here are the timing in relation to others:

Reparse for skipping all function bodies: 0.2s
Reparse for skipping all function bodies except template functions (previous patch set, not handling function bodies within template classes): 0.27s
Reparse for skipping all function bodies with the diff above (fixing another case + ignoring function bodies in templates): 0.44s
Reparse without skipping any function bodies in the preamble: 0.51s

As I said, I'm not sure whether this diff covered all cases, but it can get only more worse than 0.44s :) That's enough for me to stop here.

[nik]

Trying to format the diff in the previous comment:

--- a/lib/Parse/ParseCXXInlineMethods.cpp
+++ b/lib/Parse/ParseCXXInlineMethods.cpp
@@ -102,9 +102,14 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS,
   }
 
   if (SkipFunctionBodies != SkipFunctionBodiesKind::None &&
+      TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate &&
+      !isa<ClassTemplateDecl>(getCurrentClass().TagOrTemplate) &&
+      !isa<ClassTemplateSpecializationDecl>(getCurrentClass().TagOrTemplate) &&
+      !isa<ClassTemplatePartialSpecializationDecl>(
+          getCurrentClass().TagOrTemplate) &&
       (!FnD || Actions.canSkipFunctionBody(FnD)) && trySkippingFunctionBody()) {
     Actions.ActOnSkippedFunctionBody(FnD);

[nik]

Do I miss something? I've uploaded a new diff/version and state is still "(X) Requested Changes to Prior Diff".

Waiting for review.

[ilya-biryukov]

include/clang/Frontend/ASTUnit.h

104

Maybe move this out of ASTUnit? Would allow removing the first qualifier in usages outside the class itself (i.e. ASTUnit::SkipFunctionBodiesScope::Preamble will be shorter!)

374

NIT: Maybe keep the name SkipFunctionBodies? It seems that putting Scp at the end does not add any clarity.

835

This parameter seems slightly out of place.
The scope of skipped function bodies should be a property of the whole ASTUnit, changing it on every reparse would mean more complexity and wouldn't be used anyway.

I suggest storing a field of type SkipFunctionBodiesScope instead of adding parameters to Reparse and LoadFromCompilerInvocation.

[ilya-biryukov]

Sorry for the delay

[nik]

Addressed comments.

[nik]

include/clang/Frontend/ASTUnit.h

374

IIRC I've done that to better distinguish it from e.g. "getFrontendOpts().SkipFunctionBodies", but yes, they are not so often used together, removed "Scp" suffix.

835

Agree, this makes the change significantly shorter :)

[ilya-biryukov]

LGTM

include/clang-c/Index.h

enum CXTranslationUnit_Flags {
    * purposes of an IDE, this is undesirable behavior and as much information
    * as possible should be reported. Use this flag to enable this behavior.
    */
   CXTranslationUnit_KeepGoing = 0x200,
 
   /**
    * \brief Sets the preprocessor in a mode for parsing a single file only.
    */
-  CXTranslationUnit_SingleFileParse = 0x400
+  CXTranslationUnit_SingleFileParse = 0x400,
+
+  /**
+   * \brief Used in combination with CXTranslationUnit_SkipFunctionBodies to
+   * constrain the skipping of function bodies to the preamble.
+   *
+   * The function bodies of the main file are not skipped.
+   */
+  CXTranslationUnit_LimitSkipFunctionBodiesToPreamble = 0x800,
+
+  /**
+   * \brief Used in combination with CXTranslationUnit_SkipFunctionBodies to
+   * exclude template function bodies from being skipped.
+   *
+   * Parsing template function bodies allows diagnostics for wrong/incomplete
+   * template instantiations.
+   */
+  CXTranslationUnit_LimitSkipFunctionBodiesToNonTemplates = 0x1000,
 };
 
 /**
  * \brief Returns the set of flags that is suitable for parsing a translation
  * unit that is being edited.
  *
  * The set of flags returned provide options for \c clang_parseTranslationUnit()
  * to indicate that the translation unit is likely to be reparsed many times,

include/clang/Frontend/ASTUnit.h

struct StandaloneDiagnostic {
     DiagnosticsEngine::Level Level;
     std::string Message;
     std::string Filename;
     unsigned LocOffset;
     std::vector<std::pair<unsigned, unsigned>> Ranges;
     std::vector<StandaloneFixIt> FixIts;
   };
 
+  struct SkipFunctionBodiesOptions {
+    SkipFunctionBodiesOptions() {}
+    enum { None, MainFileAndPreamble, Preamble } Scope = None;
+    bool LimitToNonTemplateFunctions = false;
+  };
+
 private:
   std::shared_ptr<LangOptions>            LangOpts;
   IntrusiveRefCntPtr<DiagnosticsEngine>   Diagnostics;
   IntrusiveRefCntPtr<FileManager>         FileMgr;
   IntrusiveRefCntPtr<SourceManager>       SourceMgr;
   IntrusiveRefCntPtr<MemoryBufferCache>   PCMCache;
   std::unique_ptr<HeaderSearch>           HeaderInfo;
   IntrusiveRefCntPtr<TargetInfo>          Target;
private:
   explicit ASTUnit(bool MainFileIsAST);
 
   bool Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
              std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
              IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
   std::unique_ptr<llvm::MemoryBuffer> getMainBufferWithPrecompiledPreamble(
       std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-      const CompilerInvocation &PreambleInvocationIn,
-      IntrusiveRefCntPtr<vfs::FileSystem> VFS, bool AllowRebuild = true,
-      unsigned MaxLines = 0);
+      CompilerInvocation &PreambleInvocationIn,
+      IntrusiveRefCntPtr<vfs::FileSystem> VFS,
+      SkipFunctionBodiesOptions SkipFunctionBodiesOpts =
+          SkipFunctionBodiesOptions(),
+      bool AllowRebuild = true, unsigned MaxLines = 0);
   void RealizeTopLevelDeclsFromPreamble();
 
   /// \brief Transfers ownership of the objects (like SourceManager) from
   /// \param CI to this ASTUnit.
   void transferASTDataFromCompilerInstance(CompilerInstance &CI);
 
   /// \brief Allows us to assert that ASTUnit is not being used concurrently,
   /// which is not supported.
static std::unique_ptr<ASTUnit> LoadFromASTFile(
       const std::string &Filename, const PCHContainerReader &PCHContainerRdr,
       WhatToLoad ToLoad, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
       const FileSystemOptions &FileSystemOpts, bool UseDebugInfo = false,
       bool OnlyLocalDecls = false, ArrayRef<RemappedFile> RemappedFiles = None,
       bool CaptureDiagnostics = false, bool AllowPCHWithCompilerErrors = false,
       bool UserFilesAreVolatile = false);
 
 private:
   /// \brief Helper function for \c LoadFromCompilerInvocation() and
   /// \c LoadFromCommandLine(), which loads an AST from a compiler invocation.
   ///
   /// \param PrecompilePreambleAfterNParses After how many parses the preamble
   /// of this translation unit should be precompiled, to improve the performance
   /// of reparsing. Set to zero to disable preambles.
   ///
   /// \param VFS - A vfs::FileSystem to be used for all file accesses. Note that
   /// preamble is saved to a temporary directory on a RealFileSystem, so in order
   /// for it to be loaded correctly, VFS should have access to it(i.e., be an
   /// overlay over RealFileSystem).
   ///
   /// \returns \c true if a catastrophic failure occurred (which means that the
   /// \c ASTUnit itself is invalid), or \c false otherwise.
   bool LoadFromCompilerInvocation(
       std::shared_ptr<PCHContainerOperations> PCHContainerOps,
       unsigned PrecompilePreambleAfterNParses,
+      SkipFunctionBodiesOptions SkipFunctionBodiesOpts,
       IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
 public:
   /// \brief Create an ASTUnit from a source file, via a CompilerInvocation
   /// object, by invoking the optionally provided ASTFrontendAction. 
   ///
   /// \param CI - The compiler invocation to use; it must have exactly one input
   /// source file. The ASTUnit takes ownership of the CompilerInvocation object.
static ASTUnit *LoadFromCommandLine(
       IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath,
       bool OnlyLocalDecls = false, bool CaptureDiagnostics = false,
       ArrayRef<RemappedFile> RemappedFiles = None,
       bool RemappedFilesKeepOriginalName = true,
       unsigned PrecompilePreambleAfterNParses = 0,
       TranslationUnitKind TUKind = TU_Complete,
       bool CacheCodeCompletionResults = false,
       bool IncludeBriefCommentsInCodeCompletion = false,
-      bool AllowPCHWithCompilerErrors = false, bool SkipFunctionBodies = false,
-      bool SingleFileParse = false,
-      bool UserFilesAreVolatile = false, bool ForSerialization = false,
+      bool AllowPCHWithCompilerErrors = false,
+      SkipFunctionBodiesOptions SkipFunctionBodiesOpts =
+          SkipFunctionBodiesOptions(),
+      bool SingleFileParse = false, bool UserFilesAreVolatile = false,
+      bool ForSerialization = false,
       llvm::Optional<StringRef> ModuleFormat = llvm::None,
       std::unique_ptr<ASTUnit> *ErrAST = nullptr,
       IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
 
   /// \brief Reparse the source files using the same command-line options that
   /// were originally used to produce this translation unit.
   ///
   /// \param VFS - A vfs::FileSystem to be used for all file accesses. Note that
   /// preamble is saved to a temporary directory on a RealFileSystem, so in order
   /// for it to be loaded correctly, VFS should give an access to this(i.e. be an
   /// overlay over RealFileSystem). FileMgr->getVirtualFileSystem() will be used if
   /// \p VFS is nullptr.
   ///
   /// \returns True if a failure occurred that causes the ASTUnit not to
   /// contain any translation-unit information, false otherwise.
   bool Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                ArrayRef<RemappedFile> RemappedFiles = None,
+               SkipFunctionBodiesOptions SkipFunctionBodiesOpts =
+                   SkipFunctionBodiesOptions(),
                IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
 
   /// \brief Free data that will be re-generated on the next parse.
   ///
   /// Preamble-related data is not affected.
   void ResetForParse();
 
   /// \brief Perform code completion at the given file, line, and

include/clang/Frontend/FrontendOptions.h

 //===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
 #define LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
 
 #include "clang/Frontend/CommandLineSourceLoc.h"
+#include "clang/Frontend/SkipFunctionBodies.h"
 #include "clang/Serialization/ModuleFileExtension.h"
 #include "clang/Sema/CodeCompleteOptions.h"
 #include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <memory>
 #include <string>
 #include <vector>
 #include <unordered_map>
public:
   unsigned FixAndRecompile : 1;
 
   /// Apply fixes to temporary files.
   unsigned FixToTemporaries : 1;
 
   /// Emit ARC errors even if the migrator can fix them.
   unsigned ARCMTMigrateEmitARCErrors : 1;
 
-  /// Skip over function bodies to speed up parsing in cases you do not need
-  /// them (e.g. with code completion).
-  unsigned SkipFunctionBodies : 1;
-
   /// Whether we can use the global module index if available.
   unsigned UseGlobalModuleIndex : 1;
 
   /// Whether we can generate the global module index if needed.
   unsigned GenerateGlobalModuleIndex : 1;
 
   /// Whether we include declaration dumps in AST dumps.
   unsigned ASTDumpDecls : 1;
 
   /// Whether we deserialize all decls when forming AST dumps.
   unsigned ASTDumpAll : 1;
 
   /// Whether we include lookup table dumps in AST dumps.
   unsigned ASTDumpLookups : 1;
 
   /// Whether we are performing an implicit module build.
   unsigned BuildingImplicitModule : 1;
 
   /// Whether we should embed all used files into the PCM file.
   unsigned ModulesEmbedAllFiles : 1;
 
   /// Whether timestamps should be written to the produced PCH file.
   unsigned IncludeTimestamps : 1;
 
+  SkipFunctionBodiesKind SkipFunctionBodies;
+
   CodeCompleteOptions CodeCompleteOpts;
 
   enum {
     ARCMT_None,
     ARCMT_Check,
     ARCMT_Modify,
     ARCMT_Migrate
   } ARCMTAction = ARCMT_None;
public:
   std::string StatsFile;
 
 public:
   FrontendOptions()
       : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
         ShowStats(false), ShowTimers(false), ShowVersion(false),
         FixWhatYouCan(false), FixOnlyWarnings(false), FixAndRecompile(false),
         FixToTemporaries(false), ARCMTMigrateEmitARCErrors(false),
-        SkipFunctionBodies(false), UseGlobalModuleIndex(true),
-        GenerateGlobalModuleIndex(true), ASTDumpDecls(false),
-        ASTDumpLookups(false), BuildingImplicitModule(false),
-        ModulesEmbedAllFiles(false), IncludeTimestamps(true) {}
+        UseGlobalModuleIndex(true), GenerateGlobalModuleIndex(true),
+        ASTDumpDecls(false), ASTDumpLookups(false),
+        BuildingImplicitModule(false), ModulesEmbedAllFiles(false),
+        IncludeTimestamps(true),
+        SkipFunctionBodies(SkipFunctionBodiesKind::None) {}
 
   /// getInputKindForExtension - Return the appropriate input kind for a file
   /// extension. For example, "c" would return InputKind::C.
   ///
   /// \return The input kind for the extension, or InputKind::Unknown if the
   /// extension is not recognized.
   static InputKind getInputKindForExtension(StringRef Extension);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H

include/clang/Frontend/SkipFunctionBodies.h

+//===--- FrontendOptions.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_FRONTEND_SKIPFUNCTIONBODIES_H
+#define LLVM_CLANG_FRONTEND_SKIPFUNCTIONBODIES_H
+
+namespace clang {
+
+/// Skip over function bodies to speed up parsing in cases you do not need
+/// them (e.g. with code completion).
+enum class SkipFunctionBodiesKind {
+  None,
+  All,
+  AllExceptTemplates,
+};
+
+} // end namespace clang
+
+#endif

include/clang/Parse/ParseAST.h

 //  This file defines the clang::ParseAST method.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_PARSE_PARSEAST_H
 #define LLVM_CLANG_PARSE_PARSEAST_H
 
 #include "clang/Basic/LangOptions.h"
+#include "clang/Frontend/SkipFunctionBodies.h"
 
 namespace clang {
   class Preprocessor;
   class ASTConsumer;
   class ASTContext;
   class CodeCompleteConsumer;
   class Sema;
 
   /// \brief Parse the entire file specified, notifying the ASTConsumer as
   /// the file is parsed.
   ///
   /// This operation inserts the parsed decls into the translation
   /// unit held by Ctx.
   ///
   /// \param PrintStats Whether to print LLVM statistics related to parsing.
   /// \param TUKind The kind of translation unit being parsed.
   /// \param CompletionConsumer If given, an object to consume code completion
   /// results.
   /// \param SkipFunctionBodies Whether to skip parsing of function bodies.
   /// This option can be used, for example, to speed up searches for
   /// declarations/definitions when indexing.
-  void ParseAST(Preprocessor &pp, ASTConsumer *C,
-                ASTContext &Ctx, bool PrintStats = false,
-                TranslationUnitKind TUKind = TU_Complete,
-                CodeCompleteConsumer *CompletionConsumer = nullptr,
-                bool SkipFunctionBodies = false);
+  void ParseAST(
+      Preprocessor &pp, ASTConsumer *C, ASTContext &Ctx,
+      bool PrintStats = false, TranslationUnitKind TUKind = TU_Complete,
+      SkipFunctionBodiesKind SkipFunctionBodies = SkipFunctionBodiesKind::None);
 
   /// \brief Parse the main file known to the preprocessor, producing an 
   /// abstract syntax tree.
-  void ParseAST(Sema &S, bool PrintStats = false,
-                bool SkipFunctionBodies = false);
+  void ParseAST(
+      Sema &S, bool PrintStats = false,
+      SkipFunctionBodiesKind SkipFunctionBodies = SkipFunctionBodiesKind::None);
 
 }  // end namespace clang
 
 #endif

include/clang/Parse/Parser.h

 
 #ifndef LLVM_CLANG_PARSE_PARSER_H
 #define LLVM_CLANG_PARSE_PARSER_H
 
 #include "clang/AST/Availability.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/OperatorPrecedence.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Frontend/SkipFunctionBodies.h"
 #include "clang/Lex/CodeCompletionHandler.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/LoopHint.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/PrettyStackTrace.h"
class Parser : public CodeCompletionHandler {
   /// to parse the C-like decls, meaning Actions.getObjCDeclContext() will
   /// be NULL.
   bool ParsingInObjCContainer;
 
   /// Whether to skip parsing of function bodies.
   ///
   /// This option can be used, for example, to speed up searches for
   /// declarations/definitions when indexing.
-  bool SkipFunctionBodies;
+  SkipFunctionBodiesKind SkipFunctionBodies;
 
   /// The location of the expression statement that is being parsed right now.
   /// Used to determine if an expression that is being parsed is a statement or
   /// just a regular sub-expression.
   SourceLocation ExprStatementTokLoc;
 
 public:
-  Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
+  Parser(Preprocessor &PP, Sema &Actions,
+         SkipFunctionBodiesKind SkipFunctionBodies);
   ~Parser() override;
 
   const LangOptions &getLangOpts() const { return PP.getLangOpts(); }
   const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
   Preprocessor &getPreprocessor() const { return PP; }
   Sema &getActions() const { return Actions; }
   AttributeFactory &getAttrFactory() { return AttrFactory; }
 

lib/Frontend/ASTUnit.cpp

 /// can occur within the preamble.
 ///
 /// \returns If the precompiled preamble can be used, returns a newly-allocated
 /// buffer that should be used in place of the main file when doing so.
 /// Otherwise, returns a NULL pointer.
 std::unique_ptr<llvm::MemoryBuffer>
 ASTUnit::getMainBufferWithPrecompiledPreamble(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    const CompilerInvocation &PreambleInvocationIn,
-    IntrusiveRefCntPtr<vfs::FileSystem> VFS, bool AllowRebuild,
+    CompilerInvocation &PreambleInvocationIn,
+    IntrusiveRefCntPtr<vfs::FileSystem> VFS,
+    SkipFunctionBodiesOptions SkipFunctionBodiesOpts, bool AllowRebuild,
     unsigned MaxLines) {
   auto MainFilePath =
       PreambleInvocationIn.getFrontendOpts().Inputs[0].getFile();
   std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
       getBufferForFileHandlingRemapping(PreambleInvocationIn, VFS.get(),
                                         MainFilePath);
   if (!MainFileBuffer)
     return nullptr;
ASTUnitPreambleCallbacks Callbacks;
     if (CaptureDiagnostics)
       Capture.emplace(/*RequestCapture=*/true, *Diagnostics, &NewPreambleDiags,
                       &NewPreambleDiagsStandalone);
 
     // We did not previously compute a preamble, or it can't be reused anyway.
     SimpleTimer PreambleTimer(WantTiming);
     PreambleTimer.setOutput("Precompiling preamble");
 
+    const SkipFunctionBodiesKind PreviousSkipFunctionBodies =
+        PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies;
+    if (SkipFunctionBodiesOpts.Scope == SkipFunctionBodiesOptions::Preamble) {
+      PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies =
+          SkipFunctionBodiesOpts.LimitToNonTemplateFunctions
+              ? SkipFunctionBodiesKind::AllExceptTemplates
+              : SkipFunctionBodiesKind::All;
+    }
+
     llvm::ErrorOr<PrecompiledPreamble> NewPreamble = PrecompiledPreamble::Build(
         PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
         PCHContainerOps, /*StoreInMemory=*/false, Callbacks);
+
+    PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies =
+        PreviousSkipFunctionBodies;
+
     if (NewPreamble) {
       Preamble = std::move(*NewPreamble);
       PreambleRebuildCounter = 1;
     } else {
       switch (static_cast<BuildPreambleError>(NewPreamble.getError().value())) {
       case BuildPreambleError::CouldntCreateTempFile:
       case BuildPreambleError::PreambleIsEmpty:
         // Try again next time.
if (OwnAST)
     return OwnAST.release();
   else
     return AST;
 }
 
 bool ASTUnit::LoadFromCompilerInvocation(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     unsigned PrecompilePreambleAfterNParses,
+    SkipFunctionBodiesOptions SkipFunctionBodiesOpts,
     IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   if (!Invocation)
     return true;
 
   assert(VFS && "VFS is null");
 
   // We'll manage file buffers ourselves.
   Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
   Invocation->getFrontendOpts().DisableFree = false;
   getDiagnostics().Reset();
   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
 
   std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
   if (PrecompilePreambleAfterNParses > 0) {
     PreambleRebuildCounter = PrecompilePreambleAfterNParses;
-    OverrideMainBuffer =
-        getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
+    OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
+        PCHContainerOps, *Invocation, VFS, SkipFunctionBodiesOpts);
     getDiagnostics().Reset();
     ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
   }
 
   SimpleTimer ParsingTimer(WantTiming);
   ParsingTimer.setOutput("Parsing " + getMainFileName());
 
   // Recover resources if we crash before exiting this method.
std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
     ASTUnitCleanup(AST.get());
   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
     DiagCleanup(Diags.get());
 
   if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
                                       PrecompilePreambleAfterNParses,
+                                      SkipFunctionBodiesOptions(),
                                       AST->FileMgr->getVirtualFileSystem()))
     return nullptr;
   return AST;
 }
 
 ASTUnit *ASTUnit::LoadFromCommandLine(
     const char **ArgBegin, const char **ArgEnd,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath,
     bool OnlyLocalDecls, bool CaptureDiagnostics,
     ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName,
     unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
     bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
-    bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies,
-    bool SingleFileParse, bool UserFilesAreVolatile, bool ForSerialization,
+    bool AllowPCHWithCompilerErrors,
+    SkipFunctionBodiesOptions SkipFunctionBodiesOpts, bool SingleFileParse,
+    bool UserFilesAreVolatile, bool ForSerialization,
     llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
     IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   assert(Diags.get() && "no DiagnosticsEngine was provided");
 
   SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
 
   std::shared_ptr<CompilerInvocation> CI;
 
ASTUnit *ASTUnit::LoadFromCommandLine(
   PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
   PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName;
   PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors;
   PPOpts.SingleFileParseMode = SingleFileParse;
 
   // Override the resources path.
   CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 
-  CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies;
+  if (SkipFunctionBodiesOpts.Scope == SkipFunctionBodiesOptions::MainFileAndPreamble) {
+    CI->getFrontendOpts().SkipFunctionBodies =
+        SkipFunctionBodiesOpts.LimitToNonTemplateFunctions
+            ? SkipFunctionBodiesKind::AllExceptTemplates
+            : SkipFunctionBodiesKind::All;
+  } else {
+    CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodiesKind::None;
+  }
 
   if (ModuleFormat)
     CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();
 
   // Create the AST unit.
   std::unique_ptr<ASTUnit> AST;
   AST.reset(new ASTUnit(false));
   AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
ASTUnit *ASTUnit::LoadFromCommandLine(
   Diags = nullptr;
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
     ASTUnitCleanup(AST.get());
 
   if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
                                       PrecompilePreambleAfterNParses,
+                                      SkipFunctionBodiesOpts,
                                       VFS)) {
     // Some error occurred, if caller wants to examine diagnostics, pass it the
     // ASTUnit.
     if (ErrAST) {
       AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
       ErrAST->swap(AST);
     }
     return nullptr;
   }
 
   return AST.release();
 }
 
 bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                       ArrayRef<RemappedFile> RemappedFiles,
+                      SkipFunctionBodiesOptions SkipFunBodiesOpts,
                       IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   if (!Invocation)
     return true;
 
   if (!VFS) {
     assert(FileMgr && "FileMgr is null on Reparse call");
     VFS = FileMgr->getVirtualFileSystem();
   }
for (const auto &RemappedFile : RemappedFiles) {
     Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
                                                       RemappedFile.second);
   }
 
   // If we have a preamble file lying around, or if we might try to
   // build a precompiled preamble, do so now.
   std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
   if (Preamble || PreambleRebuildCounter > 0)
-    OverrideMainBuffer =
-        getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
+    OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
+        PCHContainerOps, *Invocation, VFS, SkipFunBodiesOpts);
 
   // Clear out the diagnostics state.
   FileMgr.reset();
   getDiagnostics().Reset();
   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
   if (OverrideMainBuffer)
     getDiagnostics().setNumWarnings(NumWarningsInPreamble);
 
if (CompleteFileStatus) {
       llvm::sys::fs::UniqueID CompleteFileID = CompleteFileStatus->getUniqueID();
 
       std::string MainPath(OriginalSourceFile);
       auto MainStatus = VFS->status(MainPath);
       if (MainStatus) {
         llvm::sys::fs::UniqueID MainID = MainStatus->getUniqueID();
         if (CompleteFileID == MainID && Line > 1)
           OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
-              PCHContainerOps, Inv, VFS, false, Line - 1);
+              PCHContainerOps, Inv, VFS, SkipFunctionBodiesOptions(), false,
+              Line - 1);
       }
     }
   }
 
   // If the main file has been overridden due to the use of a preamble,
   // make that override happen and introduce the preamble.
   if (OverrideMainBuffer) {
     assert(Preamble &&

lib/Parse/ParseAST.cpp

 /// ParseAST - Parse the entire file specified, notifying the ASTConsumer as
 /// the file is parsed.  This inserts the parsed decls into the translation unit
 /// held by Ctx.
 ///
 void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
                      ASTContext &Ctx, bool PrintStats,
                      TranslationUnitKind TUKind,
                      CodeCompleteConsumer *CompletionConsumer,
-                     bool SkipFunctionBodies) {
+                     SkipFunctionBodiesKind SkipFunctionBodies) {
 
   std::unique_ptr<Sema> S(
       new Sema(PP, Ctx, *Consumer, TUKind, CompletionConsumer));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(S.get());
   
   ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
 }
 
-void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
+void clang::ParseAST(Sema &S, bool PrintStats,
+                     SkipFunctionBodiesKind SkipFunctionBodies) {
   // Collect global stats on Decls/Stmts (until we have a module streamer).
   if (PrintStats) {
     Decl::EnableStatistics();
     Stmt::EnableStatistics();
   }
 
   // Also turn on collection of stats inside of the Sema object.
   bool OldCollectStats = PrintStats;

lib/Parse/ParseCXXInlineMethods.cpp

if (TryConsumeToken(tok::equal)) {
     } else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
                                 Delete ? "delete" : "default")) {
       SkipUntil(tok::semi);
     }
 
     return FnD;
   }
 
-  if (SkipFunctionBodies && (!FnD || Actions.canSkipFunctionBody(FnD)) &&
-      trySkippingFunctionBody()) {
+  if (SkipFunctionBodies != SkipFunctionBodiesKind::None &&
+      (!FnD || Actions.canSkipFunctionBody(FnD)) && trySkippingFunctionBody()) {
     Actions.ActOnSkippedFunctionBody(FnD);
     return FnD;
   }
 
   // In delayed template parsing mode, if we are within a class template
   // or if we are about to parse function member template then consume
   // the tokens and store them for parsing at the end of the translation unit.
   if (getLangOpts().DelayedTemplateParsing &&

lib/Parse/ParseObjc.cpp

if (AutoreleasePoolBody.isInvalid())
     AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation());
   return Actions.ActOnObjCAutoreleasePoolStmt(atLoc, 
                                                 AutoreleasePoolBody.get());
 }
 
 /// StashAwayMethodOrFunctionBodyTokens -  Consume the tokens and store them 
 /// for later parsing.
 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl *MDecl) {
-  if (SkipFunctionBodies && (!MDecl || Actions.canSkipFunctionBody(MDecl)) &&
+  if (SkipFunctionBodies != SkipFunctionBodiesKind::None &&
+      (!MDecl || Actions.canSkipFunctionBody(MDecl)) &&
       trySkippingFunctionBody()) {
     Actions.ActOnSkippedFunctionBody(MDecl);
     return;
   }
 
   LexedMethod* LM = new LexedMethod(this, MDecl);
   CurParsedObjCImpl->LateParsedObjCMethods.push_back(LM);
   CachedTokens &Toks = LM->Toks;

lib/Parse/Parser.cpp

 IdentifierInfo *Parser::getSEHExceptKeyword() {
   // __except is accepted as a (contextual) keyword 
   if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland))
     Ident__except = PP.getIdentifierInfo("__except");
 
   return Ident__except;
 }
 
-Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
+Parser::Parser(Preprocessor &pp, Sema &actions,
+               SkipFunctionBodiesKind skipFunctionBodies)
     : PP(pp), Actions(actions), Diags(PP.getDiagnostics()),
-    GreaterThanIsOperator(true), ColonIsSacred(false), 
+      GreaterThanIsOperator(true), ColonIsSacred(false),
       InMessageExpression(false), TemplateParameterDepth(0),
       ParsingInObjCContainer(false) {
-  SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies;
+
+  if (pp.isCodeCompletionEnabled())
+    SkipFunctionBodies = SkipFunctionBodiesKind::All;
+  else
+    SkipFunctionBodies = skipFunctionBodies;
   Tok.startToken();
   Tok.setKind(tok::eof);
   Actions.CurScope = nullptr;
   NumCachedScopes = 0;
   CurParsedObjCImpl = nullptr;
 
   // Add #pragma handlers. These are removed and destroyed in the
   // destructor.
while (DtorAttrs) {
           !DtorAttrs->isCXX11Attribute()) {
         Diag(DtorAttrs->getLoc(), diag::warn_attribute_on_function_definition)
           << DtorAttrs->getName();
       }
       DtorAttrs = DtorAttrs->getNext();
     }
   }
 
+  bool ShouldSkipFunctionBody = false;
+  switch (SkipFunctionBodies) {
+  case SkipFunctionBodiesKind::All:
+    ShouldSkipFunctionBody = true;
+    break;
+  case SkipFunctionBodiesKind::AllExceptTemplates:
+    ShouldSkipFunctionBody = TemplateInfo.Kind != ParsedTemplateInfo::Template;
+    break;
+  case SkipFunctionBodiesKind::None:
+  default:
+    ShouldSkipFunctionBody = false;
+  }
+
   // In delayed template parsing mode, for function template we consume the
   // tokens and store them for late parsing at the end of the translation unit.
   if (getLangOpts().DelayedTemplateParsing && Tok.isNot(tok::equal) &&
       TemplateInfo.Kind == ParsedTemplateInfo::Template &&
       Actions.canDelayFunctionBody(D)) {
     MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams);
 
     ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope |
                                    Scope::CompoundStmtScope);
     Scope *ParentScope = getCurScope()->getParent();
 
     D.setFunctionDefinitionKind(FDK_Definition);
     Decl *DP = Actions.HandleDeclarator(ParentScope, D,
                                         TemplateParameterLists);
     D.complete(DP);
     D.getMutableDeclSpec().abort();
 
-    if (SkipFunctionBodies && (!DP || Actions.canSkipFunctionBody(DP)) &&
+    if (ShouldSkipFunctionBody && (!DP || Actions.canSkipFunctionBody(DP)) &&
         trySkippingFunctionBody()) {
       BodyScope.Exit();
       return Actions.ActOnSkippedFunctionBody(DP);
     }
 
     CachedTokens Toks;
     LexTemplateFunctionForLateParsing(Toks);
 
if (Tok.is(tok::comma)) {
       SkipUntil(tok::semi);
     }
 
     Stmt *GeneratedBody = Res ? Res->getBody() : nullptr;
     Actions.ActOnFinishFunctionBody(Res, GeneratedBody, false);
     return Res;
   }
 
-  if (SkipFunctionBodies && (!Res || Actions.canSkipFunctionBody(Res)) &&
+  if (ShouldSkipFunctionBody && (!Res || Actions.canSkipFunctionBody(Res)) &&
       trySkippingFunctionBody()) {
     BodyScope.Exit();
     Actions.ActOnSkippedFunctionBody(Res);
     return Actions.ActOnFinishFunctionBody(Res, nullptr, false);
   }
 
   if (Tok.is(tok::kw_try))
     return ParseFunctionTryBlock(Res, BodyScope);

test/Parser/skip-function-bodies.h

+int header1(int t) {
+  return t;
+}
+
+template <typename T>
+T header2(T t) {
+  return t;
+}

test/Parser/skip-function-bodies.mm

-// RUN: env CINDEXTEST_SKIP_FUNCTION_BODIES=1 c-index-test -test-load-source all %s | FileCheck %s
+#include "skip-function-bodies.h"
 
 class A {
   class B {};
 
 public:
   A() {
     struct C {
       void d() {}
- (void) G {
   class I {};
 }
 @end
 
 void J() {
   class K {};
 }
 
+template <typename T>
+T g(T t) {
+  return t;
+}
+
+// RUN: env CINDEXTEST_SKIP_FUNCTION_BODIES=1 c-index-test -test-load-source all %s | FileCheck %s
 // CHECK: skip-function-bodies.mm:3:7: ClassDecl=A:3:7 (Definition) Extent=[3:1 - 14:2]
 // CHECK: skip-function-bodies.mm:4:9: ClassDecl=B:4:9 (Definition) Extent=[4:3 - 4:13]
 // CHECK: skip-function-bodies.mm:6:1: CXXAccessSpecifier=:6:1 (Definition) Extent=[6:1 - 6:8]
 // CHECK: skip-function-bodies.mm:7:3: CXXConstructor=A:7:3 (default constructor) Extent=[7:3 - 7:6]
 // CHECK-NOT: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
 // CHECK-NOT: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]
 // CHECK: skip-function-bodies.mm:13:13: TypedefDecl=E:13:13 (Definition) Extent=[13:3 - 13:14]
 // CHECK: skip-function-bodies.mm:13:11: TypeRef=class A::B:4:9 Extent=[13:11 - 13:12]
 // CHECK: skip-function-bodies.mm:16:12: ObjCInterfaceDecl=F:16:12 Extent=[16:1 - 18:5]
 // CHECK: skip-function-bodies.mm:17:10: ObjCInstanceMethodDecl=G:17:10 Extent=[17:1 - 17:12]
 // CHECK: skip-function-bodies.mm:19:17: ObjCImplementationDecl=F:19:17 (Definition) Extent=[19:1 - 24:2]
 // CHECK: skip-function-bodies.mm:20:10: ObjCInstanceMethodDecl=G:20:10 Extent=[20:1 - 20:13]
 // CHECK-NOT: skip-function-bodies.mm:21:13: TypedefDecl=H:21:13 (Definition) Extent=[21:3 - 21:14]
 // CHECK-NOT: skip-function-bodies.mm:21:11: TypeRef=class A:3:7 Extent=[21:11 - 21:12]
 // CHECK: skip-function-bodies.mm:26:6: FunctionDecl=J:26:6 Extent=[26:1 - 26:9]
 // CHECK-NOT: skip-function-bodies.mm:27:9: ClassDecl=K:27:9 (Definition) Extent=[27:3 - 27:13]
+// CHECK: skip-function-bodies.mm:31:3: FunctionTemplate=g:31:3 Extent=[30:1 - 31:9]
+// CHECK: skip-function-bodies.mm:30:20: TemplateTypeParameter=T:30:20 (Definition) Extent=[30:11 - 30:21] [access=public]
+// CHECK: skip-function-bodies.mm:31:1: TypeRef=T:30:20 Extent=[31:1 - 31:2]
+// CHECK: skip-function-bodies.mm:31:7: ParmDecl=t:31:7 (Definition) Extent=[31:5 - 31:8]
+// CHECK: skip-function-bodies.mm:31:5: TypeRef=T:30:20 Extent=[31:5 - 31:6]
+// CHECK-NOT: skip-function-bodies.mm:31:10: CompoundStmt= Extent=[31:10 - 33:2]
+// CHECK-NOT: skip-function-bodies.mm:32:3: ReturnStmt= Extent=[32:3 - 32:11]
+// CHECK-NOT: skip-function-bodies.mm:32:10: DeclRefExpr=t:31:7 Extent=[32:10 - 32:11]
+
+// RUN: env CINDEXTEST_SKIP_FUNCTION_BODIES=1 \
+// RUN:  CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_NON_TEMPLATES=1 \
+// RUN:  c-index-test -test-load-source all %s | FileCheck -check-prefix=CHECK-TEMPLATES %s
+// CHECK-TEMPLATES-NOT: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
+// CHECK-TEMPLATES-NOT: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]
+// CHECK-TEMPLATES: skip-function-bodies.mm:31:3: FunctionTemplate=g:31:3 (Definition) Extent=[30:1 - 33:2]
+// CHECK-TEMPLATES: skip-function-bodies.mm:30:20: TemplateTypeParameter=T:30:20 (Definition) Extent=[30:11 - 30:21] [access=public]
+// CHECK-TEMPLATES: skip-function-bodies.mm:31:1: TypeRef=T:30:20 Extent=[31:1 - 31:2]
+// CHECK-TEMPLATES: skip-function-bodies.mm:31:7: ParmDecl=t:31:7 (Definition) Extent=[31:5 - 31:8]
+// CHECK-TEMPLATES: skip-function-bodies.mm:31:5: TypeRef=T:30:20 Extent=[31:5 - 31:6]
+// CHECK-TEMPLATES: skip-function-bodies.mm:31:10: CompoundStmt= Extent=[31:10 - 33:2]
+// CHECK-TEMPLATES: skip-function-bodies.mm:32:3: ReturnStmt= Extent=[32:3 - 32:11]
+// CHECK-TEMPLATES: skip-function-bodies.mm:32:10: DeclRefExpr=t:31:7 Extent=[32:10 - 32:11]
+
+// RUN: env CINDEXTEST_EDITING=1 \
+// RUN:  CINDEXTEST_CREATE_PREAMBLE_ON_FIRST_PARSE=1 \
+// RUN:  CINDEXTEST_SKIP_FUNCTION_BODIES=1 \
+// RUN:  CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_PREAMBLE=1 \
+// RUN:  c-index-test -test-load-source all %s | FileCheck -check-prefix=CHECK-PREAMBLE1 %s
+// CHECK-PREAMBLE1: skip-function-bodies.h:1:5: FunctionDecl=header1:1:5 Extent=[1:1 - 1:19]
+// CHECK-PREAMBLE1-NOT: skip-function-bodies.h:2:3: ReturnStmt= Extent=[2:3 - 2:11]
+// CHECK-PREAMBLE1: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
+// CHECK-PREAMBLE1: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]
+
+// RUN: env CINDEXTEST_EDITING=1 \
+// RUN:  CINDEXTEST_CREATE_PREAMBLE_ON_FIRST_PARSE=1 \
+// RUN:  CINDEXTEST_SKIP_FUNCTION_BODIES=1 \
+// RUN:  CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_PREAMBLE=1 \
+// RUN:  CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_NON_TEMPLATES=1 \
+// RUN:  c-index-test -test-load-source all %s | FileCheck -check-prefix=CHECK-PREAMBLE2 %s
+// CHECK-PREAMBLE2: skip-function-bodies.h:1:5: FunctionDecl=header1:1:5 Extent=[1:1 - 1:19]
+// CHECK-PREAMBLE2-NOT: skip-function-bodies.h:2:3: ReturnStmt= Extent=[2:3 - 2:11]
+// CHECK-PREAMBLE2: skip-function-bodies.h:6:3: FunctionTemplate=header2:6:3 (Definition) Extent=[5:1 - 8:2]
+// CHECK-PREAMBLE2: skip-function-bodies.h:7:3: ReturnStmt= Extent=[7:3 - 7:11]
+// CHECK-PREAMBLE2: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
+// CHECK-PREAMBLE2: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]

tools/c-index-test/c-index-test.c

static unsigned getDefaultParsingOptions() {
   if (getenv("CINDEXTEST_SKIP_FUNCTION_BODIES"))
     options |= CXTranslationUnit_SkipFunctionBodies;
   if (getenv("CINDEXTEST_COMPLETION_BRIEF_COMMENTS"))
     options |= CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
   if (getenv("CINDEXTEST_CREATE_PREAMBLE_ON_FIRST_PARSE"))
     options |= CXTranslationUnit_CreatePreambleOnFirstParse;
   if (getenv("CINDEXTEST_KEEP_GOING"))
     options |= CXTranslationUnit_KeepGoing;
+  if (getenv("CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_PREAMBLE"))
+    options |= CXTranslationUnit_LimitSkipFunctionBodiesToPreamble;
+  if (getenv("CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_NON_TEMPLATES"))
+    options |= CXTranslationUnit_LimitSkipFunctionBodiesToNonTemplates;
 
   return options;
 }
 
 static void ModifyPrintingPolicyAccordingToEnv(CXPrintingPolicy Policy) {
   struct Mapping {
     const char *name;
     enum CXPrintingPolicyProperty property;

tools/libclang/CIndex.cpp

clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
                                           struct CXUnsavedFile *unsaved_files) {
   unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
   return clang_parseTranslationUnit(CIdx, source_filename,
                                     command_line_args, num_command_line_args,
                                     unsaved_files, num_unsaved_files,
                                     Options);
 }
 
+static ASTUnit::SkipFunctionBodiesOptions
+skipFunctionBodiesOptionsFromParseOptions(unsigned options) {
+  ASTUnit::SkipFunctionBodiesOptions SkipFunctionBodiesOpts;
+  if (options & CXTranslationUnit_SkipFunctionBodies) {
+      if (options & CXTranslationUnit_LimitSkipFunctionBodiesToNonTemplates)
+        SkipFunctionBodiesOpts.LimitToNonTemplateFunctions = true;
+      SkipFunctionBodiesOpts.Scope =
+          (options & CXTranslationUnit_LimitSkipFunctionBodiesToPreamble)
+              ? ASTUnit::SkipFunctionBodiesOptions::Preamble
+              : ASTUnit::SkipFunctionBodiesOptions::MainFileAndPreamble;
+  }
+  return SkipFunctionBodiesOpts;
+}
+
 static CXErrorCode
 clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
                                 const char *const *command_line_args,
                                 int num_command_line_args,
                                 ArrayRef<CXUnsavedFile> unsaved_files,
                                 unsigned options, CXTranslationUnit *out_TU) {
   // Set up the initial return values.
   if (out_TU)
clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
   // FIXME: Add a flag for modules.
   TranslationUnitKind TUKind
     = (options & (CXTranslationUnit_Incomplete |
                   CXTranslationUnit_SingleFileParse))? TU_Prefix : TU_Complete;
   bool CacheCodeCompletionResults
     = options & CXTranslationUnit_CacheCompletionResults;
   bool IncludeBriefCommentsInCodeCompletion
     = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
-  bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
   bool SingleFileParse = options & CXTranslationUnit_SingleFileParse;
   bool ForSerialization = options & CXTranslationUnit_ForSerialization;
+  ASTUnit::SkipFunctionBodiesOptions SkipFunctionBodiesOpts =
+      skipFunctionBodiesOptionsFromParseOptions(options);
 
   // Configure the diagnostics.
   IntrusiveRefCntPtr<DiagnosticsEngine>
     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
 
   if (options & CXTranslationUnit_KeepGoing)
     Diags->setSuppressAfterFatalError(false);
 
LibclangInvocationReporter InvocationReporter(
       unsaved_files);
   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
       Args->data(), Args->data() + Args->size(),
       CXXIdx->getPCHContainerOperations(), Diags,
       CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(),
       /*CaptureDiagnostics=*/true, *RemappedFiles.get(),
       /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
       TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
-      /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, SingleFileParse,
+      /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodiesOpts, SingleFileParse,
       /*UserFilesAreVolatile=*/true, ForSerialization,
       CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),
       &ErrUnit));
 
   // Early failures in LoadFromCommandLine may return with ErrUnit unset.
   if (!Unit && !ErrUnit)
     return CXError_ASTReadError;
 
clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
 
   for (auto &UF : unsaved_files) {
     std::unique_ptr<llvm::MemoryBuffer> MB =
         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
   }
 
   if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
-                        *RemappedFiles.get()))
+                        *RemappedFiles.get(),
+                        skipFunctionBodiesOptionsFromParseOptions(TU->ParsingOptions)))
     return CXError_Success;
   if (isASTReadError(CXXUnit))
     return CXError_ASTReadError;
   return CXError_Failure;
 }
 
 int clang_reparseTranslationUnit(CXTranslationUnit TU,
                                  unsigned num_unsaved_files,

tools/libclang/Indexing.cpp

static CXErrorCode clang_indexSourceFile_Impl(
   llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
     CXTUCleanup(CXTU.get());
 
   // Enable the skip-parsed-bodies optimization only for C++; this may be
   // revisited.
   bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
       CInvok->getLangOpts()->CPlusPlus;
   if (SkipBodies)
-    CInvok->getFrontendOpts().SkipFunctionBodies = true;
+    CInvok->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodiesKind::All;
 
   auto DataConsumer =
     std::make_shared<CXIndexDataConsumer>(client_data, CB, index_options,
                                           CXTU->getTU());
   auto InterAction = llvm::make_unique<IndexingFrontendAction>(DataConsumer,
                          SkipBodies ? IdxSession->SkipBodyData.get() : nullptr);
   std::unique_ptr<FrontendAction> IndexAction;
   IndexAction = createIndexingAction(DataConsumer,

unittests/CodeGen/BufferSourceTest.cpp

compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
             Context)));
 
     compiler.createSema(clang::TU_Prefix, nullptr);
 
     clang::SourceManager &sm = compiler.getSourceManager();
     sm.setMainFileID(sm.createFileID(
         llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
 
-    clang::ParseAST(compiler.getSema(), false, false);
+    clang::ParseAST(compiler.getSema(), false, clang::SkipFunctionBodiesKind::None);
 }
 
 } // end anonymous namespace

unittests/CodeGen/CodeGenExternalTest.cpp

compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
                                Context)))));
 
     compiler.createSema(clang::TU_Prefix, nullptr);
 
     clang::SourceManager &sm = compiler.getSourceManager();
     sm.setMainFileID(sm.createFileID(
         llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
 
-    clang::ParseAST(compiler.getSema(), false, false);
+    clang::ParseAST(compiler.getSema(), false, clang::SkipFunctionBodiesKind::None);
 
     ASSERT_TRUE(test_codegen_fns_ran);
 }
 
 } // end anonymous namespace

unittests/CodeGen/IncrementalProcessingTest.cpp

CodeGenerator* CG =
             compiler.getPreprocessorOpts(),
             compiler.getCodeGenOpts(),
             Context);
     compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(CG));
     compiler.createSema(clang::TU_Prefix, nullptr);
     Sema& S = compiler.getSema();
 
     std::unique_ptr<Parser> ParseOP(new Parser(S.getPreprocessor(), S,
-                                               /*SkipFunctionBodies*/ false));
+                                               SkipFunctionBodiesKind::None));
     Parser &P = *ParseOP.get();
 
     std::array<std::unique_ptr<llvm::Module>, 3> M;
     M[0] = IncrementalParseAST(compiler, P, *CG, nullptr);
     ASSERT_TRUE(M[0]);
 
     M[1] = IncrementalParseAST(compiler, P, *CG, TestProgram1);
     ASSERT_TRUE(M[1]);

unittests/CodeGen/TBAAMetadataTest.cpp

void init(const char *TestProgram) {
     compiler.createSema(clang::TU_Prefix, nullptr);
 
     clang::SourceManager &sm = compiler.getSourceManager();
     sm.setMainFileID(sm.createFileID(
         llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
   }
 
   const BasicBlock *compile() {
-    clang::ParseAST(compiler.getSema(), false, false);
+    clang::ParseAST(compiler.getSema(), false, clang::SkipFunctionBodiesKind::None);
     M = CG->GetModule();
 
     // Do not expect more than one function definition.
     auto FuncPtr = M->begin();
     for (; FuncPtr != M->end(); ++FuncPtr)
       if (!FuncPtr->isDeclaration())
         break;
     assert(FuncPtr != M->end());

unittests/Frontend/PCHPreambleTest.cpp

std::unique_ptr<ASTUnit> ParseAST(const std::string &EntryFile) {
 
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
       CI, PCHContainerOpts, Diags, FileMgr, false, false,
       /*PrecompilePreambleAfterNParses=*/1);
     return AST;
   }
 
   bool ReparseAST(const std::unique_ptr<ASTUnit> &AST) {
-    bool reparseFailed = AST->Reparse(PCHContainerOpts, GetRemappedFiles(), VFS);
+    bool reparseFailed =
+        AST->Reparse(PCHContainerOpts, GetRemappedFiles(),
+                     ASTUnit::SkipFunctionBodiesOptions(), VFS);
     return !reparseFailed;
   }
 
   unsigned GetFileReadCount(const std::string &Filename) const {
     return VFS->GetReadCount(Filename);
   }
 
 private:

unittests/Lex/PPCallbacksTest.cpp

PragmaOpenCLExtensionCall(const char* SourceText) {
     // pragma handlers
     ASTContext Context(OpenCLLangOpts, SourceMgr,
                        PP.getIdentifierTable(), PP.getSelectorTable(), 
                        PP.getBuiltinInfo());
     Context.InitBuiltinTypes(*Target);
 
     ASTConsumer Consumer;
     Sema S(PP, Context, Consumer);
-    Parser P(PP, S, false);
+    Parser P(PP, S, SkipFunctionBodiesKind::None);
     PragmaOpenCLExtensionCallbacks* Callbacks = new PragmaOpenCLExtensionCallbacks;
     PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));
 
     // Lex source text.
     PP.EnterMainSourceFile();
     while (true) {
       Token Tok;
       PP.Lex(Tok);

unittests/Tooling/ToolingTest.cpp

bool shouldSkipFunctionBody(Decl *D) override {
     NamedDecl *F = dyn_cast<NamedDecl>(D);
     return F && F->getNameAsString() == "skipMe";
   }
 };
 
 struct SkipBodyAction : public clang::ASTFrontendAction {
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef) override {
-    Compiler.getFrontendOpts().SkipFunctionBodies = true;
+    Compiler.getFrontendOpts().SkipFunctionBodies = SkipFunctionBodiesKind::All;
     return llvm::make_unique<SkipBodyConsumer>();
   }
 };
 
 TEST(runToolOnCode, TestSkipFunctionBody) {
   std::vector<std::string> Args = {"-std=c++11"};
   std::vector<std::string> Args2 = {"-fno-delayed-template-parsing"};