reject nested name specifier other than global namespace and add test

Author: changkhothuychung

clang/lib/Parse/ParseReflect.cpp

@@ -21,20 +21,36 @@ ExprResult Parser::ParseCXXReflectExpression(SourceLocation DoubleCaretLoc) {
   EnterExpressionEvaluationContext Unevaluated(
       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
 
+  CXXScopeSpec SS;
+  if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
+                                     /*ObjectHasErrors=*/false,
+                                     /*EnteringContext=*/false)) {
+    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
+    return ExprError();
+  }
+
   SourceLocation OperandLoc = Tok.getLocation();
+  TentativeParsingAction TPA(*this);
 
-  {
-    TentativeParsingAction TPA(*this);
-    // global namespace ::
-    if (Tok.is(tok::coloncolon)) {
-      ConsumeToken();
-      TPA.Commit();
-      Decl *TUDecl = Actions.getASTContext().getTranslationUnitDecl();
-      return Actions.ActOnCXXReflectExpr(DoubleCaretLoc, SourceLocation(),
-                                         TUDecl);
-    }
-    TPA.Revert();
+  // Next, check for an unqualified-id.
+  if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::kw_template,
+                  tok::tilde, tok::annot_template_id)) {
+    // TODO(reflection) : support parsing for
+    // - type-name::
+    // - nested-name-specifier identifier ::
+    // - namespace-name ::
+    // - nested-name-specifier template_opt simple-template-id
+    Diag(OperandLoc, diag::err_cannot_reflect_operand);
+    return ExprError();
+  } else if (SS.isValid() &&
+             SS.getScopeRep().getKind() == NestedNameSpecifier::Kind::Global) {
+    // global namespace ::.
+    TPA.Commit();
+    Decl *TUDecl = Actions.getASTContext().getTranslationUnitDecl();
+    return Actions.ActOnCXXReflectExpr(DoubleCaretLoc, SourceLocation(),
+                                       TUDecl);
   }
+  TPA.Revert();
 
   if (isCXXTypeId(TentativeCXXTypeIdContext::AsReflectionOperand)) {
     TypeResult TR = ParseTypeName(/*TypeOf=*/nullptr);

clang/test/Reflection/parsing-reflection.cpp

@@ -1,13 +1,26 @@
 // RUN: %clang_cc1 %s -std=c++26 -freflection -fsyntax-only -verify
 
 namespace a {
-struct T {};
+struct X {
+    int y;
+    bool operator==(const X& other)
+    {
+        return y == other.y;
+    }
+};
+
 namespace b {
-struct U {};
-int x;
-}
+    struct Y {};
+    int x;
 }
 
+template<typename T>
+struct Z{
+    template<typename U>
+    using type = U;
+};
+
+}
 
 int main()
 {
@@ -30,11 +43,18 @@ int main()
     // Not supported yet.
     (void)^^a; // expected-error {{expected reflectable entity}}
     (void)^^a::; // expected-error {{expected reflectable entity}}
-    (void)^^a::b::T; // expected-error {{expected reflectable entity}}
-    (void)^^a::T::; // expected-error {{expected reflectable entity}}
+    (void)^^a::b::X; // expected-error {{expected reflectable entity}}
+    (void)^^a::X::; // expected-error {{expected reflectable entity}}
     (void)(^^a::b); // expected-error {{expected reflectable entity}}
     (void)^^a::b::; // expected-error {{expected reflectable entity}}
-    (void)^^a::b::U; // expected-error {{expected reflectable entity}}
+    (void)^^a::b::Y; // expected-error {{expected reflectable entity}}
     (void)^^a::b::x; // expected-error {{expected reflectable entity}}
-    (void)^^a::b::U::; // expected-error {{expected reflectable entity}}
+    (void)^^a::b::Y::; // expected-error {{expected reflectable entity}}
+    (void)(^^::a::); // expected-error {{expected reflectable entity}}
+    (void)(^^::a::X::operator==); // expected-error {{expected reflectable entity}}
+    (void)(^^::a::X::~X()); // expected-error {{expected reflectable entity}}
+    (void)(^^::a::Z<int>); // expected-error {{expected reflectable entity}}
+    (void)(^^::a::Z<int>::template type<int>); // expected-error {{expected reflectable entity}}
+    namespace c = a::b;
+    (void)(^^c); // expected-error {{expected reflectable entity}}
 }