Revert "Correct behavior of integration header, now that enterField isn't here."

Temporarily rever the int-header changes to see if this fixes the
validation machine issues I see.

This reverts commit 90ae330.

Conflicts:
	clang/lib/Sema/SemaSYCL.cpp

Author: Erich Keane

clang/lib/Sema/SemaSYCL.cpp

@@ -2176,27 +2176,10 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
 
   void addParam(const FieldDecl *FD, QualType ArgTy,
                 SYCLIntegrationHeader::kernel_param_kind_t Kind) {
-    addParam(FD, ArgTy, Kind, IsArrayElement(FD, ArgTy));
-  }
-  void addParam(const FieldDecl *FD, QualType ArgTy,
-                SYCLIntegrationHeader::kernel_param_kind_t Kind,
-                bool IsArrayElem) {
     uint64_t Size;
     Size = SemaRef.getASTContext().getTypeSizeInChars(ArgTy).getQuantity();
-    uint64_t Offset = CurOffset;
-    if (!IsArrayElem)
-      Offset += offsetOf(FD);
     Header.addParamDesc(Kind, static_cast<unsigned>(Size),
-                        static_cast<unsigned>(Offset));
-  }
-
-  // Returns 'true' if the thing we're visiting (Based on the FD/QualType pair)
-  // is an element of an array.  This will determine whether we do
-  // MemberExprBases in some cases or not, AND determines how we initialize
-  // values.
-  bool IsArrayElement(const FieldDecl *FD, QualType Ty) const {
-    SemaRef.getASTContext().hasSameType(FD->getType(), Ty);
-    return FD->getType() != Ty;
+                        static_cast<unsigned>(CurOffset + offsetOf(FD)));
   }
 
 public:
@@ -2232,10 +2215,8 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
         AccTy->getTemplateArgs()[1].getAsIntegral().getExtValue());
     int Info = getAccessTarget(AccTy) | (Dims << 11);
 
-    uint64_t Offset = CurOffset;
-    if (!IsArrayElement(FD, FieldTy))
-      Offset += offsetOf(FD);
-    Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info, Offset);
+    Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info,
+                        CurOffset + offsetOf(FD));
     return true;
   }
 
@@ -2249,8 +2230,7 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     const ParmVarDecl *SamplerArg = InitMethod->getParamDecl(0);
     assert(SamplerArg && "sampler __init method must have sampler parameter");
 
-    addParam(FD, SamplerArg->getType(), SYCLIntegrationHeader::kind_sampler,
-             IsArrayElement(FD, FieldTy));
+    addParam(FD, SamplerArg->getType(), SYCLIntegrationHeader::kind_sampler);
     return true;
   }
 
@@ -2303,31 +2283,35 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool enterStream(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+  bool enterStream(const CXXRecordDecl *, FieldDecl *FD, QualType) final {
     ++StructDepth;
-    if (!IsArrayElement(FD, Ty))
-      CurOffset += offsetOf(FD);
+    // TODO: Is this right?! I think this only needs to be incremented when we
+    // aren't in an array, otherwise 'enterArray's base offsets should handle
+    // this right.  Otherwise an array of structs is going to be in the middle
+    // of nowhere.
+    CurOffset += offsetOf(FD);
     return true;
   }
 
-  bool leaveStream(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+  bool leaveStream(const CXXRecordDecl *, FieldDecl *FD, QualType) final {
     --StructDepth;
-    if (!IsArrayElement(FD, Ty))
-      CurOffset -= offsetOf(FD);
+    CurOffset -= offsetOf(FD);
     return true;
   }
 
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *FD, QualType) final {
     ++StructDepth;
-    if (!IsArrayElement(FD, Ty))
-      CurOffset += offsetOf(FD);
+    // TODO: Is this right?! I think this only needs to be incremented when we
+    // aren't in an array, otherwise 'enterArray's base offsets should handle
+    // this right.  Otherwise an array of structs is going to be in the middle
+    // of nowhere.
+    CurOffset += offsetOf(FD);
     return true;
   }
 
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType) final {
     --StructDepth;
-    if (!IsArrayElement(FD, Ty))
-      CurOffset -= offsetOf(FD);
+    CurOffset -= offsetOf(FD);
     return true;
   }
 
@@ -2343,12 +2327,8 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool enterArray(FieldDecl *FD, QualType ArrayTy, QualType) final {
-    uint64_t Offset = CurOffset;
-    if (!IsArrayElement(FD, ArrayTy))
-      Offset += offsetOf(FD);
-
-    ArrayBaseOffsets.push_back(Offset);
+  bool enterArray(FieldDecl *, QualType, QualType) final {
+    ArrayBaseOffsets.push_back(CurOffset);
     return true;
   }