Complex Variable defined in InitCapture Crash fix

[bviyer]

Summary

When a variable is defined in the init capture and it is of type struct that is dependent on additional structure, its definition is not found. An exception is created in the findInstantiatedDecl () function.

[erik.pilkington]

Hi Balaji,
Can you try to manually reduce the attached testcase? Its really difficult to understand exactly what is actually happening here, and why your fix is correct, without having a minimal reproducer. Ideally there would just be a few decls that succinctly demonstrate what the problem is.

Thanks!

[aprantl]

test/SemaCXX/lambda-init-capture-vardefine.cpp

4

These kinds of tests that don't check for any output are a bit dangerous, because they will also succeed if clang is symlinked to /bin/true.

[bviyer]

Simplified the case a bit more as requested by Erik. I also induced some errors in the test so that if someone symbolic-linked clang to /bin/true, the test will fail.

[bviyer]

Ping!

[erik.pilkington]

lib/Sema/SemaTemplateInstantiate.cpp

2916–2918

Why are we failing to find the instantiation of the VarDecl in this case? It seems to me like we should of picked it up in the for loop above. Is it not getting added to the LocalInstantiationScope? Or are we looking in the wrong LocalInstantiationScope?

lib/Sema/SemaTemplateInstantiate.cpp

LocalInstantiationScope::findInstantiationOf(const Decl *D) {
   if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
     if (RD->isLocalClass())
       return nullptr;
 
   // Enumeration types referenced prior to definition may appear as a result of
   // error recovery.
   if (isa<EnumDecl>(D))
     return nullptr;
+  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+    if (VD->isInitCapture())
+      return nullptr;
 
   // If we didn't find the decl, then we either have a sema bug, or we have a
   // forward reference to a label declaration.  Return null to indicate that
   // we have an uninstantiated label.
   assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope");
   return nullptr;
 }
 

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
     else
       NeedInstantiate = isa<EnumDecl>(D);
     if (NeedInstantiate) {
       Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
       CurrentInstantiationScope->InstantiatedLocal(D, Inst);
       return cast<TypeDecl>(Inst);
     }
 
+    // If the variable is in InitCapture and variable types are of type
+    // mentioned in the above comment (the comment starting as "Normally
+    // this function...") then its existance won't be known so we have to
+    // make an exclusion for them.
+    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+      if (VD->isInitCapture())
+        return nullptr;
+
     // If we didn't find the decl, then we must have a label decl that hasn't
     // been found yet.  Lazily instantiate it and return it now.
     assert(isa<LabelDecl>(D));
 
     Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
     assert(Inst && "Failed to instantiate label??");
 
     CurrentInstantiationScope->InstantiatedLocal(D, Inst);

test/SemaCXX/lambda-init-capture-vardefine.cpp

+// RUN: %clang_cc1 -std=c++14  -fsyntax-only  -verify %s
+// RUN: %clang_cc1 -std=c++17  -fsyntax-only  -verify %s
+
+template <typename k> void func(k&&);
+
+template <typename k>
+void n(k o) {
+    [f = o](auto) { // expected-note + {{instantiation of function template}}
+        func([](auto)->int { return sizeof(f); }); // expected-error{{recursive template instantiation exceeded}} expected-note + {{instantiation of function template}}
+    }(0);
+}
+
+template <typename k>
+void func(k &&o)
+{
+    o(0);
+    n(o); // expected-note + {{instantiation of function template}} expected-note + {{skipping}}
+}
+
+int main() {
+    auto f = [](auto) {};
+    func(f); // expected-note + {{instantiation of function template}}
+}