[Sema][C++1z] Ensure structured binding's bindings in dependent foreach have non-null type

[erik.pilkington]

Summary

A DecompositionDecls' bindings have a null type until the initializer is attached, if the initializer is dependent, then the bindings should be set to have dependent type. For non-foreach bindings, this is done in Sema::CheckCompleteDecompositionDeclaration(), this patch ensures that this is done to bindings in a foreach as well. Fixes PR32172.

Thanks for taking a look!
Erik

[rsmith]

LGTM

[bebuch]

I believe this patch is incomplete, I get a very odd warning:

struct A{
    int x;
};

template < typename >
struct B{
    A data_[1];

    void f(){
        for(auto [x]: data_){
            (void)x;
        }
    }
};

int main(){
	B< int > v;
	v.f();
}

$ clang++ -std=c++1z -Wall clang_fail.cpp                                                                                                                                                                                
clang_fail.cpp:10:18: warning: unused variable '' [-Wunused-variable]                                                                                                                                                                                                 
        for(auto [x]: data_){                                                                                                                                                                                                                                         
                 ^                                                                                                                                                                                                                                                    
clang_fail.cpp:18:4: note: in instantiation of member function 'B<int>::f' requested here                                                                                                                                                                             
        v.f();                                                                                                                                                                                                                                                        
          ^                                                                                                                                                                                                                                                           
1 warning generated.

unused variable ''? An unnamed variable, that's odd ;-)

Nevertheless, thanks for what is already done! Great that I can use structured bindings without fear to crash now! :-)

cfe/trunk/lib/Sema/SemaStmt.cpp

Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc,
   ExprResult NotEqExpr = Cond, IncrExpr = Inc;
 
   if (RangeVarType->isDependentType()) {
     // The range is implicitly used as a placeholder when it is dependent.
     RangeVar->markUsed(Context);
 
     // Deduce any 'auto's in the loop variable as 'DependentTy'. We'll fill
     // them in properly when we instantiate the loop.
-    if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check)
+    if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) {
+      if (auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
+        for (auto *Binding : DD->bindings())
+          Binding->setType(Context.DependentTy);
       LoopVar->setType(SubstAutoType(LoopVar->getType(), Context.DependentTy));
+    }
   } else if (!BeginDeclStmt.get()) {
     SourceLocation RangeLoc = RangeVar->getLocation();
 
     const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
 
     ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
                                                 VK_LValue, ColonLoc);
     if (BeginRangeRef.isInvalid())

cfe/trunk/test/SemaCXX/cxx1z-decomposition.cpp

void for_range() {
   }
 }
 
 int error_recovery() {
   auto [foobar]; // expected-error {{requires an initializer}}
   return foobar_; // expected-error {{undeclared identifier 'foobar_'}}
 }
 
+// PR32172
+template <class T> void dependent_foreach(T t) {
+  for (auto [a,b,c] : t)
+    a,b,c;
+}
+
 // FIXME: by-value array copies