error for bitfields. tests for bitfield errors. minor pr suggestion change

Author: spall

clang/include/clang/Sema/SemaHLSL.h

@@ -141,7 +141,8 @@ class SemaHLSL : public SemaBase {
   bool diagnoseInputIDType(QualType T, const ParsedAttr &AL);
 
   bool CanPerformScalarCast(QualType SrcTy, QualType DestTy);
-  bool CanPerformAggregateCast(Expr *Src, QualType DestType);
+  bool ContainsBitField(QualType BaseTy);
+  bool CanPerformElementwiseCast(Expr *Src, QualType DestType);
   ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg);
 
   QualType getInoutParameterType(QualType Ty);

clang/lib/CodeGen/CGExpr.cpp

@@ -6417,7 +6417,7 @@ void CodeGenFunction::FlattenAccessAndType(
         llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, I);
         // gep on vector fields is not recommended so combine gep with
         // extract/insert
-        AccessList.push_back({GEP, Idx});
+        AccessList.emplace_back(GEP, Idx);
         FlatTypes.push_back(VT->getElementType());
       }
     } else {

clang/lib/Sema/SemaCast.cpp

@@ -2776,7 +2776,7 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
   // vector cast, vector truncation, or special hlsl splat cases
   QualType SrcTy = SrcExpr.get()->getType();
   if (Self.getLangOpts().HLSL &&
-      Self.HLSL().CanPerformAggregateCast(SrcExpr.get(), DestType)) {
+      Self.HLSL().CanPerformElementwiseCast(SrcExpr.get(), DestType)) {
     if (SrcTy->isConstantArrayType())
       SrcExpr = Self.ImpCastExprToType(
           SrcExpr.get(), Self.Context.getArrayParameterType(SrcTy),

clang/lib/Sema/SemaHLSL.cpp

@@ -2476,9 +2476,43 @@ bool SemaHLSL::CanPerformScalarCast(QualType SrcTy, QualType DestTy) {
   llvm_unreachable("Unhandled scalar cast");
 }
 
-// Can we perform an HLSL Flattened cast?
+// Detect if a type contains a bitfield. Will be removed when
+// bitfield support is added to HLSLElementwiseCast
+bool SemaHLSL::ContainsBitField(QualType BaseTy) {
+  llvm::SmallVector<QualType, 16> WorkList;
+  WorkList.push_back(BaseTy);
+  while (!WorkList.empty()) {
+    QualType T = WorkList.pop_back_val();
+    T = T.getCanonicalType().getUnqualifiedType();
+    // only check aggregate types
+    if (const auto *AT = dyn_cast<ConstantArrayType>(T)) {
+      WorkList.push_back(AT->getElementType());
+      continue;
+    }
+    if (const auto *RT = dyn_cast<RecordType>(T)) {
+      const RecordDecl *RD = RT->getDecl();
+      if (RD->isUnion())
+        continue;
+
+      const CXXRecordDecl *CXXD = dyn_cast<CXXRecordDecl>(RD);
+
+      if (CXXD && CXXD->isStandardLayout())
+        RD = CXXD->getStandardLayoutBaseWithFields();
+
+      for (const auto *FD : RD->fields()) {
+        if (FD->isBitField())
+          return true;
+        WorkList.push_back(FD->getType());
+      }
+      continue;
+    }
+  }
+  return false;
+}
+
+// Can we perform an HLSL Elementwise cast?
 // TODO: update this code when matrices are added; see issue #88060
-bool SemaHLSL::CanPerformAggregateCast(Expr *Src, QualType DestTy) {
+bool SemaHLSL::CanPerformElementwiseCast(Expr *Src, QualType DestTy) {
 
   // Don't handle casts where LHS and RHS are any combination of scalar/vector
   // There must be an aggregate somewhere
@@ -2490,6 +2524,9 @@ bool SemaHLSL::CanPerformAggregateCast(Expr *Src, QualType DestTy) {
       (DestTy->isScalarType() || DestTy->isVectorType()))
     return false;
 
+  if (ContainsBitField(DestTy) || ContainsBitField(SrcTy))
+    return false;
+
   llvm::SmallVector<QualType> DestTypes;
   BuildFlattenedTypeList(DestTy, DestTypes);
   llvm::SmallVector<QualType> SrcTypes;

clang/test/SemaHLSL/Language/ElementwiseCast-errors.hlsl

@@ -6,3 +6,24 @@ export void cantCast() {
   B = (int[4])A;
   // expected-error@-1 {{C-style cast from 'int *' to 'int[4]' is not allowed}}
 }
+
+struct S {
+// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int2' (aka 'vector<int, 2>') to 'const S' for 1st argument}}
+// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int2' (aka 'vector<int, 2>') to 'S' for 1st argument}}
+// expected-note@-3 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+  int A : 8;
+  int B;
+};
+
+// casting types which contain bitfields is not yet supported.
+export void cantCast2() {
+  S s = {1,2};
+  int2 C = (int2)s;
+  // expected-error@-1 {{cannot convert 'S' to 'int2' (aka 'vector<int, 2>') without a conversion operator}}
+}
+
+export void cantCast3() {
+  int2 C = {1,2};
+  S s = (S)C;
+  // expected-error@-1 {{no matching conversion for C-style cast from 'int2' (aka 'vector<int, 2>') to 'S'}}
+}