Restrict reflection operators within lambdas.

Author: katzdm

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3106,10 +3106,9 @@ def err_reflect_nttp : Error<
   "cannot take the reflection of a non-type template parameter">;
 def err_reflect_init_capture : Error<
   "cannot take the reflection of a local entity declared by init-capture">;
-def err_template_arg_bad_reflection_kind : Error<
-  "reflection of this kind cannot appear as a template argument">;
-def err_reflect_dependent_splice : Error<
-  "cannot take the reflection of a dependent splice expression">;
+def err_reflect_intervening_lambda : Error<
+  "cannot take the reflection of a local entity for which there is an "
+  "intervening lambda expression">;
 
 def err_splice_operand_not_reflection : Error<
   "splice operand must be a reflection">;
@@ -3142,6 +3141,9 @@ def err_dependent_splice_implicit_member_reference : Error<
   "cannot implicitly reference a class member through a splice">;
 def note_dependent_splice_explicit_this_may_fix : Note<
   "an explicit 'this' pointer may fix the problem">;
+def err_splice_intervening_lambda : Error<
+  "cannot splice local entity %0 for which there is an intervening lambda "
+  "expression">;
 
 def err_metafunction_empty_args : Error<
   "__metafunction requires arguments">;

clang/lib/Sema/SemaReflect.cpp

@@ -89,7 +89,7 @@ Expr *CreateRefToDecl(Sema &S, ValueDecl *D, SourceLocation ExprLoc) {
   }
 }
 
-static Decl *findInjectionCone(Decl *ContainingDecl) {
+Decl *findInjectionCone(Decl *ContainingDecl) {
   for (Decl *Ctx = ContainingDecl; Ctx;
        Ctx = cast<Decl>(Ctx->getDeclContext())) {
     if (isa<RecordDecl, FunctionDecl, TranslationUnitDecl>(Ctx))
@@ -98,6 +98,56 @@ static Decl *findInjectionCone(Decl *ContainingDecl) {
   llvm_unreachable("should have terminated at a TranslationUnitDecl");
 }
 
+bool CheckReflectVar(Sema &S, VarDecl *VD, SourceRange Range) {
+  // Reflections of 'init-capture's are always ill-formed.
+  if (VD->isInitCapture()) {
+    S.Diag(Range.getBegin(), diag::err_reflect_init_capture) << Range;
+    return true;
+  }
+
+  // All other cases that aren't local entities are fine.
+  if (!VD->isLocalVarDeclOrParm() || VD->isStaticLocal())
+    return false;
+
+  // Check for an intervening lambda scope.
+  for (DeclContext *DC = S.CurContext; DC != VD->getDeclContext();
+       DC = DC->getParent()) {
+    assert(DC && "Var context not a parent of the current context");
+    if (auto *RD = dyn_cast<CXXRecordDecl>(DC); RD && RD->isLambda()) {
+      S.Diag(Range.getBegin(), diag::err_reflect_intervening_lambda) << Range;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CheckSpliceVar(Sema &S, VarDecl *VD, SourceRange Range) {
+  // All non-local entities are fine.
+  if (!VD->isLocalVarDeclOrParm() || VD->isStaticLocal())
+    return false;
+
+  // Unevaluated contexts are fine.
+  //
+  // We should also ignore any enclosing 'typeid' expressions, but clang (as far
+  // as I can tell) doesn't implement that for lambda captures either, so we
+  // likewise ignore that here.
+  if (!S.currentEvaluationContext().isPotentiallyEvaluated())
+    return false;
+
+  // Check for an intervening lambda scope.
+  for (DeclContext *DC = S.CurContext; DC != VD->getDeclContext();
+       DC = DC->getParent()) {
+    assert(DC && "Var context not a parent of the current context");
+    if (auto *RD = dyn_cast<CXXRecordDecl>(DC); RD && RD->isLambda()) {
+      S.Diag(Range.getBegin(), diag::err_splice_intervening_lambda)
+          << VD << Range;
+      S.Diag(VD->getLocation(), diag::note_entity_declared_at) << VD;
+      return true;
+    }
+  }
+  return false;
+}
+
 class MetaActionsImpl : public MetaActions {
   Sema &S;
 
@@ -828,12 +878,8 @@ ExprResult Sema::ActOnCXXReflectExpr(SourceLocation OpLoc,
     return BuildCXXReflectExpr(OpLoc, NameInfo.getBeginLoc(), ND);
 
   if (auto *VD = dyn_cast<VarDecl>(ND);
-      VD && (VD->isInitCapture())) {
-    Diag(Id.StartLocation, diag::err_reflect_init_capture)
-        << Id.getSourceRange();
+      VD && CheckReflectVar(*this, VD, Id.getSourceRange()))
     return ExprError();
-  }
-
 
   // Why do we have to build an expression here? Just stash in an APValue?
   if (isa<VarDecl, BindingDecl, FunctionDecl, FieldDecl, EnumConstantDecl,
@@ -1527,6 +1573,10 @@ ExprResult Sema::BuildReflectionSpliceExpr(SourceLocation TemplateKWLoc,
         return ExprError();
       }
 
+      if (auto *VD = dyn_cast<VarDecl>(TheDecl);
+          VD && CheckSpliceVar(*this, VD, Splice->getSourceRange()))
+        return ExprError();
+
       // Create a new DeclRefExpr, since the operand of the reflect expression
       // was parsed in an unevaluated context (but a splice expression is not
       // necessarily, and frequently not, in such a context).

clang/test/Reflection/lift-operator.cpp

@@ -8,7 +8,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// RUN: %clang_cc1 %s -std=c++23 -freflection
+// RUN: %clang_cc1 %s -std=c++23 -freflection -verify
 
 // Reflecting Types
 using info = decltype(^^void);
@@ -166,18 +166,26 @@ consteval int fn(decltype(^^::) x = ^^x) { return 0; }
 constexpr int x = fn();
 }  // namspace self_reference
 
-                               // ==============
-                               // lambda_capture
-                               // ==============
+                              // =================
+                              // enclosing_lambdas
+                              // =================
 
-namespace lambda_capture {
+namespace enclosing_lambdas {
+static int s1;
 void fn() {
-  int x;
-  [=]<auto r> {
-    static_assert(^^x == r);
-  }.operator()<^^x>();
+  int l1;
+  static int s2;
+  constexpr auto rl1 = ^^l1;
+  (void) [] -> decltype(^^s1, ^^l1, s2) {
+    // expected-error@-1 {{intervening lambda expression}}
+    int l2;
+
+    constexpr auto rl1_2 = ^^l1;
+      // expected-error@-1 {{intervening lambda expression}}
+    constexpr auto rl2 = ^^l2;
+  };
 }
-}  // namespace lambda_capture
+}  // namespace enclosing_lambdas
 
                    // =======================================
                    // bb_clang_p2996_issue_35_regression_test

clang/test/Reflection/splice-expr-errors.cpp

@@ -68,3 +68,19 @@ void fn([:^^int:]);
   // expected-error@-1 {{not usable in a splice expression}}
 
 }  // namespace parameter_declaration_ambiguity
+
+                              // =================
+                              // enclosing_lambdas
+                              // =================
+
+namespace enclosing_lambdas {
+void fn() {
+  int x = 1;  // expected-note {{'x' declared here}}
+  constexpr auto r = ^^x;
+
+  (void) [] -> decltype([:r:]) {
+    return [:r:];
+      // expected-error@-1 {{'x' for which there is an intervening lambda}}
+  };
+}
+}  // namespace enclosing_lambdas