[Frontend] Handle skipped bodies in template instantiations

[ilya-biryukov]

Summary

• Fixed an assert in Sema::InstantiateFunctionDefinition and added support for instantiating a function template with skipped body.
• Properly call setHasSkippedBody for FunctionTemplateDecl passed to Sema::ActOnSkippedFunctionBody.

[sepavloff]

lib/Sema/SemaDecl.cpp

12184

In the case of Decl == nullptr this code would crash. Probably it makes sense to check for this condition at the beginning of the function and use dyn_cast instead of dyn_cast_or_null in the next check.

[ilya-biryukov]

lib/Sema/SemaDecl.cpp

12184

Do we have callsites that pass null to this function? I don't see a meaningful semantics for this function if we pass null here.
I thought that Decls are always passed via pointers by convention, but I may be wrong.

[ilya-biryukov]

• Added a check for null in ActOnSkippedBody

lib/Sema/SemaDecl.cpp

12184

After looking at the callsites, they actually suggest that nulls can be passed. Tried adding an assert and it didn't fire when running check-all, though.

But it's better to be on the safe side. Added a check for null, updated the patch accordingly.

[sepavloff]

LGTM.

Thanks!

lib/Sema/SemaDecl.cpp

bool Sema::canSkipFunctionBody(Decl *D) {
   // because any callers of that function need to know the type.
   if (const FunctionDecl *FD = D->getAsFunction())
     if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
       return false;
   return Consumer.shouldSkipFunctionBody(D);
 }
 
 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
-  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
+  if (FunctionDecl *FD = Decl->getAsFunction())
     FD->setHasSkippedBody();
   else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
     MD->setHasSkippedBody();
   return Decl;
 }
 
 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
   return ActOnFinishFunctionBody(D, BodyArg, false);

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (!Pattern && PatternDecl->isLateTemplateParsed() &&
     auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
     assert(LPTIter != LateParsedTemplateMap.end() &&
            "missing LateParsedTemplate");
     LateTemplateParser(OpaqueParser, *LPTIter->second);
     Pattern = PatternDecl->getBody(PatternDecl);
   }
 
   // Note, we should never try to instantiate a deleted function template.
-  assert((Pattern || PatternDecl->isDefaulted()) &&
+  assert((Pattern || PatternDecl->isDefaulted() ||
+          PatternDecl->hasSkippedBody()) &&
          "unexpected kind of function template definition");
 
   // C++1y [temp.explicit]p10:
   //   Except for inline functions, declarations with types deduced from their
   //   initializer or return value, and class template specializations, other
   //   explicit instantiation declarations have the effect of suppressing the
   //   implicit instantiation of the entity to which they refer.
   if (TSK == TSK_ExplicitInstantiationDeclaration &&
if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
       // If this is an MS ABI dllexport default constructor, instantiate any
       // default arguments.
       if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
           Ctor->isDefaultConstructor()) {
         InstantiateDefaultCtorDefaultArgs(*this, Ctor);
       }
     }
 
+    if (PatternDecl->hasSkippedBody()) {
+      ActOnSkippedFunctionBody(Function);
+    } else {
       // Instantiate the function body.
       StmtResult Body = SubstStmt(Pattern, TemplateArgs);
 
       if (Body.isInvalid())
         Function->setInvalidDecl();
 
       // FIXME: finishing the function body while in an expression evaluation
       // context seems wrong. Investigate more.
       ActOnFinishFunctionBody(Function, Body.get(),
                               /*IsInstantiation=*/true);
+    }
 
     PerformDependentDiagnostics(PatternDecl, TemplateArgs);
 
     if (auto *Listener = getASTMutationListener())
       Listener->FunctionDefinitionInstantiated(Function);
 
     savedContext.pop();
   }

test/Index/skipped-bodies-templates.cpp

+// RUN: env CINDEXTEST_SKIP_FUNCTION_BODIES=1 c-index-test -test-load-source all %s 2>&1 \
+// RUN: | FileCheck %s
+
+
+template <class T>
+struct Foo {
+  inline int with_body() {
+    return 100;
+  }
+
+  inline int without_body();
+};
+
+
+int bar = Foo<int>().with_body() + Foo<int>().without_body();
+// CHECK-NOT: warning: inline function 'Foo<int>::with_body' is not defined
+// CHECK: warning: inline function 'Foo<int>::without_body' is not defined
+
+template <class T>
+inline int with_body() { return 10; }
+
+template <class T>
+inline int without_body();
+
+int baz = with_body<int>() + without_body<int>();
+// CHECK-NOT: warning: inline function 'with_body<int>' is not defined
+// CHECK: warning: inline function 'without_body<int>' is not defined