[SYCL] Add __builtin_num_fields and __builtin_field_type

clang/include/clang/AST/ComputeDependence.h

@@ -101,6 +101,10 @@ class ObjCSubscriptRefExpr;
 class ObjCIsaExpr;
 class ObjCIndirectCopyRestoreExpr;
 class ObjCMessageExpr;
+class SYCLBuiltinNumFieldsExpr;
+class SYCLBuiltinNumBasesExpr;
+class SYCLBuiltinFieldTypeExpr;
+class SYCLBuiltinBaseTypeExpr;
 
 // The following functions are called from constructors of `Expr`, so they
 // should not access anything beyond basic
@@ -192,5 +196,10 @@ ExprDependence computeDependence(ObjCIsaExpr *E);
 ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);
 ExprDependence computeDependence(ObjCMessageExpr *E);
 
+ExprDependence computeDependence(SYCLBuiltinNumFieldsExpr *E);
+ExprDependence computeDependence(SYCLBuiltinNumBasesExpr *E);
+ExprDependence computeDependence(SYCLBuiltinFieldTypeExpr *E);
+ExprDependence computeDependence(SYCLBuiltinBaseTypeExpr *E);
+
 } // namespace clang
 #endif

clang/include/clang/AST/ExprCXX.h

@@ -4902,6 +4902,186 @@ class BuiltinBitCastExpr final
   }
 };
 
+/// Represents a __builtin_num_fields expression.
+class SYCLBuiltinNumFieldsExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+
+public:
+  SYCLBuiltinNumFieldsExpr(SourceLocation Loc, QualType SourceTy,
+                           QualType RetTy)
+      : Expr(SYCLBuiltinNumFieldsExprClass, RetTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinNumFieldsExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinNumFieldsExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+  unsigned getNumFields() const {
+    assert(!SourceTy->isDependentType());
+    assert(SourceTy->isRecordType());
+    const auto *RD = SourceTy->getAsRecordDecl();
+    assert(RD);
+    return static_cast<unsigned>(
+        std::distance(RD->field_begin(), RD->field_end()));
+  }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinNumFieldsExprClass;
+  }
+};
+
+/// Represents a __builtin_field_type expression. This does not actually return
+/// the type itself (it would need to be a new type in the type system rather
+/// than an expression to do that), but instead is a valueless expression of
+/// the field's type. The expected usage is to use decltype to extract the
+/// actual type information. This expression can only be used in an unevaluated
+/// context.
+class SYCLBuiltinFieldTypeExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+  Stmt *Index;
+
+public:
+  SYCLBuiltinFieldTypeExpr(SourceLocation Loc, QualType SourceTy, Expr *Index,
+                           QualType FieldTy, ExprValueKind ValueKind)
+      : Expr(SYCLBuiltinFieldTypeExprClass, FieldTy, ValueKind, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy), Index(Index) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinFieldTypeExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinFieldTypeExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+
+  const Expr *getIndex() const { return static_cast<const Expr *>(Index); }
+  Expr *getIndex() { return static_cast<Expr *>(Index); }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinFieldTypeExprClass;
+  }
+
+  child_range children() { return child_range(&Index, &Index + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&Index, &Index + 1);
+  }
+};
+
+/// Represents a __builtin_num_bases expression.
+class SYCLBuiltinNumBasesExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+
+public:
+  SYCLBuiltinNumBasesExpr(SourceLocation Loc, QualType SourceTy, QualType RetTy)
+      : Expr(SYCLBuiltinNumBasesExprClass, RetTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinNumBasesExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinNumBasesExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+  unsigned getNumBases() const {
+    assert(!SourceTy->isDependentType());
+    assert(SourceTy->isRecordType());
+    const auto *RD = SourceTy->getAsCXXRecordDecl();
+    assert(RD);
+    return RD->getNumBases();
+  }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinNumBasesExprClass;
+  }
+};
+
+/// Represents a __builtin_base_type expression. This has the same behavior and
+/// constraints as __builtin_field_type.
+class SYCLBuiltinBaseTypeExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+  Stmt *Index;
+
+public:
+  SYCLBuiltinBaseTypeExpr(SourceLocation Loc, QualType SourceTy, Expr *Index,
+                          QualType BaseTy)
+      : Expr(SYCLBuiltinBaseTypeExprClass, BaseTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy), Index(Index) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinBaseTypeExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinBaseTypeExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+
+  const Expr *getIndex() const { return static_cast<const Expr *>(Index); }
+  Expr *getIndex() { return static_cast<Expr *>(Index); }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinBaseTypeExprClass;
+  }
+
+  child_range children() { return child_range(&Index, &Index + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&Index, &Index + 1);
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_EXPRCXX_H

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2359,6 +2359,20 @@ DEF_TRAVERSE_STMT(BuiltinBitCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
 
+DEF_TRAVERSE_STMT(SYCLBuiltinFieldTypeExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+DEF_TRAVERSE_STMT(SYCLBuiltinBaseTypeExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+
+DEF_TRAVERSE_STMT(SYCLBuiltinNumFieldsExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+DEF_TRAVERSE_STMT(SYCLBuiltinNumBasesExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
     InitListExpr *S, DataRecursionQueue *Queue) {

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11346,6 +11346,21 @@ def warn_sycl_kernel_too_big_args : Warning<
 def err_sycl_virtual_types : Error<
   "no class with a vtable can be used in a SYCL kernel or any code included in the kernel">;
 def note_sycl_recursive_function_declared_here: Note<"function implemented using recursion declared here">;
+def err_sycl_type_trait_requires_complete_type : Error<
+  "'%select{__builtin_num_fields|__builtin_field_type|__builtin_num_bases|"
+  "__builtin_base_type}0' requires a complete type">;
+def err_sycl_type_trait_requires_record_type : Error<
+  "'%select{__builtin_num_fields|__builtin_field_type|__builtin_num_bases|"
+  "__builtin_base_type}0' requires a structure "
+  "or lambda type">;
+def err_sycl_builtin_type_trait_index_out_of_range : Error<
+  "index %0 is greater than the number of %select{fields|bases}2 in type %1">;
+def err_sycl_type_trait_requires_nonnegative_index : Error<
+  "'%select{__builtin_field_type|__builtin_base_type}0' requires a "
+  "non-negative index">;
+def err_sycl_builtin_type_trait_evaluated : Error<
+  "'%select{__builtin_field_type|__builtin_base_type}0' cannot be used in an "
+  "evaluated context">;
 def err_sycl_non_trivially_copy_ctor_dtor_type
     : Error<"kernel parameter has non-trivially %select{copy "
             "constructible|destructible}0 class/struct type %1">;

clang/include/clang/Basic/StmtNodes.td

@@ -193,6 +193,12 @@ def ObjCBridgedCastExpr : StmtNode<ExplicitCastExpr>;
 // CUDA Expressions.
 def CUDAKernelCallExpr : StmtNode<CallExpr>;
 
+// SYCL Extensions.
+def SYCLBuiltinNumFieldsExpr : StmtNode<Expr>;
+def SYCLBuiltinFieldTypeExpr : StmtNode<Expr>;
+def SYCLBuiltinNumBasesExpr : StmtNode<Expr>;
+def SYCLBuiltinBaseTypeExpr : StmtNode<Expr>;
+
 // Clang Extensions.
 def ShuffleVectorExpr : StmtNode<Expr>;
 def ConvertVectorExpr : StmtNode<Expr>;

clang/include/clang/Basic/TokenKinds.def

@@ -506,6 +506,12 @@ TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 
+// SYCL Type Traits
+KEYWORD(__builtin_num_fields, KEYSYCL)
+KEYWORD(__builtin_field_type, KEYSYCL)
+KEYWORD(__builtin_num_bases, KEYSYCL)
+KEYWORD(__builtin_base_type, KEYSYCL)
+
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 

clang/include/clang/Parse/Parser.h

@@ -3460,6 +3460,12 @@ class Parser : public CodeCompletionHandler {
   ExprResult ParseArrayTypeTrait();
   ExprResult ParseExpressionTrait();
 
+  /// SYCL Type Traits
+  // __builtin_num_fields, __builtin_num_bases
+  ExprResult ParseSYCLBuiltinNum();
+  // __builtin_field_type, __builtin_base_type
+  ExprResult ParseSYCLBuiltinType();
+
   //===--------------------------------------------------------------------===//
   // Preprocessor code-completion pass-through
   void CodeCompleteDirective(bool InConditional) override;

clang/include/clang/Sema/Sema.h

@@ -13245,6 +13245,28 @@ class Sema final {
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);
   void MarkDevices();
 
+  /// Get the number of fields or captures within the parsed type.
+  ExprResult ActOnSYCLBuiltinNumFieldsExpr(ParsedType PT);
+  ExprResult BuildSYCLBuiltinNumFieldsExpr(SourceLocation Loc,
+                                           QualType SourceTy);
+
+  /// Get a value based on the type of the given field number so that callers
+  /// can wrap it in a decltype() to get the actual type of the field.
+  ExprResult ActOnSYCLBuiltinFieldTypeExpr(ParsedType PT, Expr *Idx);
+  ExprResult BuildSYCLBuiltinFieldTypeExpr(SourceLocation Loc,
+                                           QualType SourceTy, Expr *Idx);
+
+  /// Get the number of base classes within the parsed type.
+  ExprResult ActOnSYCLBuiltinNumBasesExpr(ParsedType PT);
+  ExprResult BuildSYCLBuiltinNumBasesExpr(SourceLocation Loc,
+                                          QualType SourceTy);
+
+  /// Get a value based on the type of the given base number so that callers
+  /// can wrap it in a decltype() to get the actual type of the base class.
+  ExprResult ActOnSYCLBuiltinBaseTypeExpr(ParsedType PT, Expr *Idx);
+  ExprResult BuildSYCLBuiltinBaseTypeExpr(SourceLocation Loc, QualType SourceTy,
+                                          Expr *Idx);
+
   /// Emit a diagnostic about the given attribute having a deprecated name, and
   /// also emit a fixit hint to generate the new attribute name.
   void DiagnoseDeprecatedAttribute(const ParsedAttr &A, StringRef NewScope,

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1965,6 +1965,12 @@ enum StmtCode {
 
   // FixedPointLiteral
   EXPR_FIXEDPOINT_LITERAL,
+
+  // SYCL
+  EXPR_SYCL_BUILTIN_NUM_FIELDS,
+  EXPR_SYCL_BUILTIN_FIELD_TYPE,
+  EXPR_SYCL_BUILTIN_NUM_BASES,
+  EXPR_SYCL_BUILTIN_BASE_TYPE,
 };
 
 /// The kinds of designators that can occur in a

clang/lib/AST/ComputeDependence.cpp

@@ -842,3 +842,27 @@ ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
     D |= A->getDependence();
   return D;
 }
+
+ExprDependence clang::computeDependence(SYCLBuiltinNumFieldsExpr *E) {
+  return toExprDependence(E->getSourceType()->getDependence()) &
+         ~ExprDependence::Type;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinNumBasesExpr *E) {
+  return toExprDependence(E->getSourceType()->getDependence()) &
+         ~ExprDependence::Type;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinFieldTypeExpr *E) {
+  auto D = toExprDependence(E->getSourceType()->getDependence()) &
+           ~ExprDependence::Type;
+  D |= E->getIndex()->getDependence();
+  return D;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinBaseTypeExpr *E) {
+  auto D = toExprDependence(E->getSourceType()->getDependence()) &
+           ~ExprDependence::Type;
+  D |= E->getIndex()->getDependence();
+  return D;
+}

clang/lib/AST/Expr.cpp

@@ -3454,6 +3454,10 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case SourceLocExprClass:
   case ConceptSpecializationExprClass:
   case RequiresExprClass:
+  case SYCLBuiltinNumFieldsExprClass:
+  case SYCLBuiltinFieldTypeExprClass:
+  case SYCLBuiltinNumBasesExprClass:
+  case SYCLBuiltinBaseTypeExprClass:
     // These never have a side-effect.
     return false;
 

clang/lib/AST/ExprClassification.cpp

@@ -197,6 +197,10 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
   case Expr::SourceLocExprClass:
   case Expr::ConceptSpecializationExprClass:
   case Expr::RequiresExprClass:
+  case Expr::SYCLBuiltinNumFieldsExprClass:
+  case Expr::SYCLBuiltinFieldTypeExprClass:
+  case Expr::SYCLBuiltinNumBasesExprClass:
+  case Expr::SYCLBuiltinBaseTypeExprClass:
     return Cl::CL_PRValue;
 
   case Expr::ConstantExprClass: