change scope to only parse primitive types for now

Author: changkhothuychung

clang/include/clang/AST/ExprCXX.h

@@ -44,6 +44,7 @@
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
@@ -5509,35 +5510,34 @@ class BuiltinBitCastExpr final
 ///  - an id-expression.
 class CXXReflectExpr : public Expr {
 
-  // Source locations.
-  SourceLocation OperatorLoc;
-  SourceRange OperandRange;
+  // TODO(Reflection): add support for TemplateReference, NamespaceReference and
+  // DeclRefExpr
+  using operand_type = llvm::PointerUnion<const TypeLoc *>;
+
+  SourceLocation CaretCaretLoc;
+  operand_type Operand;
 
-  CXXReflectExpr(const ASTContext &C, QualType T, QualType Operand);
-  CXXReflectExpr(const ASTContext &C, QualType T, Decl *Operand);
+  CXXReflectExpr(SourceLocation CaretCaretLoc, const TypeLoc *TL);
   CXXReflectExpr(EmptyShell Empty);
 
 public:
   static CXXReflectExpr *Create(ASTContext &C, SourceLocation OperatorLoc,
-                                SourceLocation OperandLoc, QualType Operand);
-
-  static CXXReflectExpr *Create(ASTContext &C, SourceLocation OperatorLoc,
-                                SourceLocation OperandLoc, Decl *Operand);
+                                TypeLoc *TL);
 
   static CXXReflectExpr *CreateEmpty(ASTContext &C);
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return llvm::TypeSwitch<operand_type, SourceLocation>(Operand)
+        .Case<const TypeLoc *>([](auto *Ptr) { return Ptr->getBeginLoc(); });
+  }
+
   SourceLocation getEndLoc() const LLVM_READONLY {
-    return OperandRange.getEnd();
+    return llvm::TypeSwitch<operand_type, SourceLocation>(Operand)
+        .Case<const TypeLoc *>([](auto *Ptr) { return Ptr->getEndLoc(); });
   }
 
   /// Returns location of the '^^'-operator.
-  SourceLocation getOperatorLoc() const { return OperatorLoc; }
-  SourceRange getOperandRange() const { return OperandRange; }
-
-  /// Sets the location of the '^^'-operator.
-  void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }
-  void setOperandRange(SourceRange R) { OperandRange = R; }
+  SourceLocation getOperatorLoc() const { return CaretCaretLoc; }
 
   child_range children() {
     // TODO(Reflection)

clang/include/clang/Sema/Sema.h

@@ -14737,14 +14737,9 @@ class Sema final : public SemaBase {
   ///@{
 
 public:
-  ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc, TypeSourceInfo *T);
-  ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc,
-                                 SourceLocation OperandLoc, Decl *D);
-
-  ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc,
-                                 SourceLocation OperandLoc, QualType T);
-  ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc,
-                                 SourceLocation OperandLoc, Decl *D);
+  ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc, TypeLoc *TL);
+
+  ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc, TypeLoc *TL);
 
 public:
   void PushSatisfactionStackEntry(const NamedDecl *D,

clang/lib/AST/ExprCXX.cpp

@@ -1939,34 +1939,17 @@ TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C,
   return new (Mem) TypeTraitExpr(EmptyShell(), IsStoredAsBool);
 }
 
-CXXReflectExpr::CXXReflectExpr(const ASTContext &C, QualType T,
-                               QualType Operand)
-    : Expr(CXXReflectExprClass, T, VK_PRValue, OK_Ordinary) {}
-
-CXXReflectExpr::CXXReflectExpr(const ASTContext &C, QualType T, Decl *Operand)
-    : Expr(CXXReflectExprClass, T, VK_PRValue, OK_Ordinary) {}
-
 CXXReflectExpr::CXXReflectExpr(EmptyShell Empty)
     : Expr(CXXReflectExprClass, Empty) {}
 
-CXXReflectExpr *CXXReflectExpr::Create(ASTContext &C,
-                                       SourceLocation OperatorLoc,
-                                       SourceLocation OperandLoc,
-                                       QualType Operand) {
-  CXXReflectExpr *E = new (C) CXXReflectExpr(C, C.VoidTy, Operand);
-  E->setOperatorLoc(OperatorLoc);
-  E->setOperandRange(OperandLoc);
-  return E;
-}
+CXXReflectExpr::CXXReflectExpr(SourceLocation CaretCaretLoc, const TypeLoc *TL)
+    : Expr(CXXReflectExprClass, TL->getType(), VK_PRValue, OK_Ordinary),
+      CaretCaretLoc(CaretCaretLoc), Operand(TL) {}
 
 CXXReflectExpr *CXXReflectExpr::Create(ASTContext &C,
-                                       SourceLocation OperatorLoc,
-                                       SourceLocation OperandLoc,
-                                       Decl *Operand) {
-  CXXReflectExpr *E = new (C) CXXReflectExpr(C, C.VoidTy, Operand);
-  E->setOperatorLoc(OperatorLoc);
-  E->setOperandRange(OperandLoc);
-  return E;
+                                       SourceLocation CaretCaretLoc,
+                                       TypeLoc *TL) {
+  return new (C) CXXReflectExpr(CaretCaretLoc, TL);
 }
 
 CXXReflectExpr *CXXReflectExpr::CreateEmpty(ASTContext &C) {

clang/lib/Parse/ParseReflect.cpp

@@ -21,34 +21,9 @@ ExprResult Parser::ParseCXXReflectExpression() {
   EnterExpressionEvaluationContext Unevaluated(
       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
   assert(Tok.is(tok::caretcaret) && "expecting reflection operator ^^");
-  SourceLocation DoubleCaretLoc = ConsumeToken();
-
-  CXXScopeSpec SS;
-  if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
-                                     /*ObjectHasErrors=*/false,
-                                     /*EnteringContext=*/false)) {
-    return ExprError();
-  }
-
+  SourceLocation CaretCaretLoc = ConsumeToken();
   SourceLocation OperandLoc = Tok.getLocation();
 
-  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 ::.
-    Decl *TUDecl = Actions.getASTContext().getTranslationUnitDecl();
-    return Actions.ActOnCXXReflectExpr(DoubleCaretLoc, SourceLocation(),
-                                       TUDecl);
-  }
-
   if (isCXXTypeId(TentativeCXXTypeIdContext::AsReflectionOperand)) {
     TypeResult TR = ParseTypeName(/*TypeOf=*/nullptr);
     if (TR.isInvalid())
@@ -63,10 +38,11 @@ ExprResult Parser::ParseCXXReflectExpression() {
     if (!TSI)
       TSI = Actions.getASTContext().getTrivialTypeSourceInfo(QT, OperandLoc);
 
+    TypeLoc TL = TSI->getTypeLoc();
     QualType Canon = QT.getCanonicalType();
-    if (Canon->isBuiltinType()) {
+    if (!TL.isNull() && Canon->isBuiltinType()) {
       // Only supports builtin types for now
-      return Actions.ActOnCXXReflectExpr(DoubleCaretLoc, TSI);
+      return Actions.ActOnCXXReflectExpr(CaretCaretLoc, &TL);
     }
   }
 

clang/lib/Sema/SemaExpr.cpp

@@ -17781,25 +17781,14 @@ void Sema::PushExpressionEvaluationContextForFunction(
   }
 }
 
-ExprResult Sema::ActOnCXXReflectExpr(SourceLocation OpLoc,
-                                     TypeSourceInfo *TSI) {
-  return BuildCXXReflectExpr(OpLoc, TSI->getTypeLoc().getBeginLoc(),
-                             TSI->getType());
+ExprResult Sema::ActOnCXXReflectExpr(SourceLocation CaretCaretLoc,
+                                     TypeLoc *TL) {
+  return BuildCXXReflectExpr(CaretCaretLoc, TL);
 }
 
-ExprResult Sema::ActOnCXXReflectExpr(SourceLocation OpLoc,
-                                     SourceLocation OperandLoc, Decl *D) {
-  return BuildCXXReflectExpr(OpLoc, OperandLoc, D);
-}
-
-ExprResult Sema::BuildCXXReflectExpr(SourceLocation OperatorLoc,
-                                     SourceLocation OperandLoc, QualType T) {
-  return CXXReflectExpr::Create(Context, OperatorLoc, OperandLoc, T);
-}
-
-ExprResult Sema::BuildCXXReflectExpr(SourceLocation OperatorLoc,
-                                     SourceLocation OperandLoc, Decl *D) {
-  return CXXReflectExpr::Create(Context, OperatorLoc, OperandLoc, D);
+ExprResult Sema::BuildCXXReflectExpr(SourceLocation CaretCaretLoc,
+                                     TypeLoc *TL) {
+  return CXXReflectExpr::Create(Context, CaretCaretLoc, TL);
 }
 
 namespace {

clang/test/Parser/parsing-reflection.cpp

@@ -1,27 +1,9 @@
 // RUN: %clang_cc1 %s -std=c++26 -freflection -fsyntax-only -verify
 
-namespace a {
-struct X {
-    int y;
-    bool operator==(const X&);
-};
-
-namespace b {
-    struct Y {};
-    int x;
-}
-
-template<typename T>
-struct Z{
-    template<typename U>
-    using type = U;
-};
-
-}
+struct X{};
 
 consteval void test()
 {
-    (void)^^::;
     (void)(^^void);
     (void)(^^bool);
     (void)(^^char);
@@ -38,26 +20,4 @@ consteval void test()
     (void)(^^double);
     (void)(^^const void);
     (void)(^^decltype(nullptr));
-
-    // Not supported yet.
-    (void)^^a; // expected-error {{expected reflectable entity}}
-    (void)^^a::X; // expected-error {{expected reflectable entity}}
-    (void)(^^a::b); // 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::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}}
-
-
-    // ill-formed
-    (void)^^a::; // expected-error {{expected reflectable entity}}
-    (void)^^a::X::; // expected-error {{expected reflectable entity}}
-    (void)^^a::b::; // expected-error {{expected reflectable entity}}
-    (void)(^^::a::); // expected-error {{expected reflectable entity}}
-    (void)^^a::b::Y::; // expected-error {{expected reflectable entity}}
-
 }