Addressed the first round of code review comments from Erich Keane.

Author: tahonermann

clang/include/clang/AST/Decl.h

@@ -4701,11 +4701,6 @@ class OutlinedFunctionDecl final
     : public Decl,
       public DeclContext,
       private llvm::TrailingObjects<OutlinedFunctionDecl, ImplicitParamDecl *> {
-protected:
-  size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
-    return NumParams;
-  }
-
 private:
   /// The number of parameters to the outlined function.
   unsigned NumParams;
@@ -4750,21 +4745,14 @@ class OutlinedFunctionDecl final
     getParams()[i] = P;
   }
 
-  // ArrayRef interface to parameters.
-  ArrayRef<ImplicitParamDecl *> parameters() const {
-    return {getParams(), getNumParams()};
+  // Range interface to parameters.
+  using parameter_const_iterator = const ImplicitParamDecl * const *;
+  using parameter_const_range = llvm::iterator_range<parameter_const_iterator>;
+  parameter_const_range parameters() const {
+    return {param_begin(), param_end()};
   }
-  MutableArrayRef<ImplicitParamDecl *> parameters() {
-    return {getParams(), getNumParams()};
-  }
-
-  using param_iterator = ImplicitParamDecl *const *;
-  using param_range = llvm::iterator_range<param_iterator>;
-
-  /// Retrieve an iterator pointing to the first parameter decl.
-  param_iterator param_begin() const { return getParams(); }
-  /// Retrieve an iterator one past the last parameter decl.
-  param_iterator param_end() const { return getParams() + NumParams; }
+  parameter_const_iterator param_begin() const { return getParams(); }
+  parameter_const_iterator param_end() const { return getParams() + NumParams; }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

clang/include/clang/AST/StmtSYCL.h

@@ -44,16 +44,18 @@ class SYCLKernelCallStmt : public Stmt {
 
 public:
   /// Construct a SYCL kernel call statement.
-  SYCLKernelCallStmt(Stmt *OS, OutlinedFunctionDecl *OFD)
-      : Stmt(SYCLKernelCallStmtClass), OriginalStmt(OS), OFDecl(OFD) {}
+  SYCLKernelCallStmt(CompoundStmt *CS, OutlinedFunctionDecl *OFD)
+      : Stmt(SYCLKernelCallStmtClass), OriginalStmt(CS), OFDecl(OFD) {}
 
   /// Construct an empty SYCL kernel call statement.
   SYCLKernelCallStmt(EmptyShell Empty) : Stmt(SYCLKernelCallStmtClass, Empty) {}
 
   /// Retrieve the model statement.
-  Stmt *getOriginalStmt() { return OriginalStmt; }
-  const Stmt *getOriginalStmt() const { return OriginalStmt; }
-  void setOriginalStmt(Stmt *S) { OriginalStmt = S; }
+  CompoundStmt *getOriginalStmt() { return cast<CompoundStmt>(OriginalStmt); }
+  const CompoundStmt *getOriginalStmt() const {
+    return cast<CompoundStmt>(OriginalStmt);
+  }
+  void setOriginalStmt(CompoundStmt *CS) { OriginalStmt = CS; }
 
   /// Retrieve the outlined function declaration.
   OutlinedFunctionDecl *getOutlinedFunctionDecl() { return OFDecl; }

clang/include/clang/Sema/SemaSYCL.h

@@ -65,7 +65,7 @@ class SemaSYCL : public SemaBase {
   void handleKernelEntryPointAttr(Decl *D, const ParsedAttr &AL);
 
   void CheckSYCLEntryPointFunctionDecl(FunctionDecl *FD);
-  StmtResult BuildSYCLKernelCallStmt(FunctionDecl *FD, Stmt *Body);
+  StmtResult BuildSYCLKernelCallStmt(FunctionDecl *FD, CompoundStmt *Body);
 };
 
 } // namespace clang

clang/lib/Sema/SemaDecl.cpp

@@ -15986,7 +15986,8 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
     }
 
     if (Body && !FD->isTemplated() && !SKEPAttr->isInvalidAttr()) {
-      StmtResult SR = SYCL().BuildSYCLKernelCallStmt(FD, Body);
+      StmtResult SR = SYCL().BuildSYCLKernelCallStmt(FD,
+                                                     cast<CompoundStmt>(Body));
       if (SR.isInvalid())
         return nullptr;
       Body = SR.get();

clang/lib/Sema/SemaSYCL.cpp

@@ -412,7 +412,8 @@ class OutlinedFunctionDeclBodyInstantiator
 
 } // unnamed namespace
 
-StmtResult SemaSYCL::BuildSYCLKernelCallStmt(FunctionDecl *FD, Stmt *Body) {
+StmtResult SemaSYCL::BuildSYCLKernelCallStmt(FunctionDecl *FD,
+                                             CompoundStmt *Body) {
   assert(!FD->isInvalidDecl());
   assert(!FD->isTemplated());
   assert(FD->hasPrototype());

clang/lib/Serialization/ASTReaderDecl.cpp

@@ -1799,10 +1799,9 @@ void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
 void ASTDeclReader::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {
   // NumParams is deserialized by OutlinedFunctionDecl::CreateDeserialized().
   VisitDecl(D);
-  D->setNothrow(Record.readInt() != 0);
-  for (unsigned I = 0; I < D->NumParams; ++I) {
+  for (unsigned I = 0; I < D->NumParams; ++I)
     D->setParam(I, readDeclAs<ImplicitParamDecl>());
-  }
+  D->setNothrow(Record.readInt() != 0);
   D->setBody(cast_or_null<Stmt>(Record.readStmt()));
 }
 

clang/lib/Serialization/ASTReaderStmt.cpp

@@ -531,7 +531,7 @@ void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
 
 void ASTStmtReader::VisitSYCLKernelCallStmt(SYCLKernelCallStmt *S) {
   VisitStmt(S);
-  S->setOriginalStmt(Record.readSubStmt());
+  S->setOriginalStmt(cast<CompoundStmt>(Record.readSubStmt()));
   S->setOutlinedFunctionDecl(readDeclAs<OutlinedFunctionDecl>());
 }
 

clang/lib/Serialization/ASTWriterDecl.cpp

@@ -1381,9 +1381,9 @@ void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
 void ASTDeclWriter::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {
   Record.push_back(D->getNumParams());
   VisitDecl(D);
-  Record.push_back(D->isNothrow() ? 1 : 0);
   for (unsigned I = 0; I < D->getNumParams(); ++I)
     Record.AddDeclRef(D->getParam(I));
+  Record.push_back(D->isNothrow() ? 1 : 0);
   Record.AddStmt(D->getBody());
   Code = serialization::DECL_OUTLINEDFUNCTION;
 }