Assorted work leading towards the elimination of CK_Unknown.

llvm-svn: 119138

Author: rjmccall

clang/include/clang/AST/Expr.h

@@ -1961,7 +1961,7 @@ class CastExpr : public Expr {
 private:
   Stmt *Op;
 
-  void CheckBasePath() const {
+  void CheckCastConsistency() const {
 #ifndef NDEBUG
     switch (getCastKind()) {
     case CK_DerivedToBase:
@@ -1973,17 +1973,14 @@ class CastExpr : public Expr {
       break;
 
     // These should not have an inheritance path.
-    case CK_Unknown:
     case CK_BitCast:
     case CK_LValueBitCast:
-    case CK_NoOp:
     case CK_Dynamic:
     case CK_ToUnion:
     case CK_ArrayToPointerDecay:
     case CK_FunctionToPointerDecay:
     case CK_NullToMemberPointer:
     case CK_NullToPointer:
-    case CK_UserDefinedConversion:
     case CK_ConstructorConversion:
     case CK_IntegralToPointer:
     case CK_PointerToIntegral:
@@ -1993,20 +1990,30 @@ class CastExpr : public Expr {
     case CK_IntegralToFloating:
     case CK_FloatingToIntegral:
     case CK_FloatingCast:
-    case CK_MemberPointerToBoolean:
     case CK_AnyPointerToObjCPointerCast:
     case CK_AnyPointerToBlockPointerCast:
     case CK_ObjCObjectLValueCast:
     case CK_FloatingRealToComplex:
     case CK_FloatingComplexToReal:
-    case CK_FloatingComplexToBoolean:
     case CK_FloatingComplexCast:
     case CK_FloatingComplexToIntegralComplex:
     case CK_IntegralRealToComplex:
     case CK_IntegralComplexToReal:
-    case CK_IntegralComplexToBoolean:
     case CK_IntegralComplexCast:
     case CK_IntegralComplexToFloatingComplex:
+      assert(!getType()->isBooleanType() && "unheralded conversion to bool");
+      // fallthrough to check for null base path
+
+    case CK_Dependent:
+    case CK_Unknown:
+    case CK_NoOp:
+    case CK_UserDefinedConversion:
+    case CK_PointerToBoolean:
+    case CK_IntegralToBoolean:
+    case CK_FloatingToBoolean:
+    case CK_MemberPointerToBoolean:
+    case CK_FloatingComplexToBoolean:
+    case CK_IntegralComplexToBoolean:
       assert(path_empty() && "Cast kind should not have a base path!");
       break;
     }
@@ -2029,9 +2036,10 @@ class CastExpr : public Expr {
          // dependent or if the subexpression is value-dependent.
          ty->isDependentType() || (op && op->isValueDependent())),
     Op(op) {
+    assert(kind != CK_Invalid && "creating cast with invalid cast kind");
     CastExprBits.Kind = kind;
     CastExprBits.BasePathSize = BasePathSize;
-    CheckBasePath();
+    CheckCastConsistency();
   }
 
   /// \brief Construct an empty cast.

clang/include/clang/AST/OperationKinds.h

@@ -25,6 +25,10 @@ enum CastKind {
   /// going on.
   CK_Unknown,
 
+  /// CK_Dependent - This explicit cast cannot yet be analyzed because
+  /// the type or expression is dependent.
+  CK_Dependent,
+
   /// CK_BitCast - Used for reinterpret_cast.
   CK_BitCast,
 
@@ -83,6 +87,9 @@ enum CastKind {
 
   /// CK_PointerToIntegral - Pointer to integral
   CK_PointerToIntegral,
+
+  /// CK_PointerToBoolean - Pointer to boolean (i.e. is not null)
+  CK_PointerToBoolean,
 
   /// CK_ToVoid - Cast to void.
   CK_ToVoid,
@@ -92,14 +99,21 @@ enum CastKind {
   /// src expression into the destination expression.
   CK_VectorSplat,
 
-  /// CK_IntegralCast - Casting between integral types of different size.
+  /// CK_IntegralCast - A truncating or extending cast between integral
+  /// types of different size.
   CK_IntegralCast,
 
+  /// CK_IntegralToBoolean - Integral to boolean.
+  CK_IntegralToBoolean,
+
   /// CK_IntegralToFloating - Integral to floating point.
   CK_IntegralToFloating,
 
   /// CK_FloatingToIntegral - Floating point to integral.
   CK_FloatingToIntegral,
+
+  /// CK_FloatingToBoolean - Floating point to boolean.
+  CK_FloatingToBoolean,
 
   /// CK_FloatingCast - Casting between floating types of different size.
   CK_FloatingCast,
@@ -151,6 +165,7 @@ enum CastKind {
   CK_IntegralComplexToFloatingComplex
 };
 
+#define CK_Invalid ((CastKind) -1)
 
 enum BinaryOperatorKind {
   // Operators listed in order of precedence.

clang/include/clang/AST/Type.h

@@ -1123,6 +1123,18 @@ class Type {
   bool isTemplateTypeParmType() const;          // C++ template type parameter
   bool isNullPtrType() const;                   // C++0x nullptr_t
 
+  enum ScalarTypeKind {
+    STK_Pointer,
+    STK_MemberPointer,
+    STK_Bool,
+    STK_Integral,
+    STK_Floating,
+    STK_IntegralComplex,
+    STK_FloatingComplex
+  };
+  /// getScalarTypeKind - Given that this is a scalar type, classify it.
+  ScalarTypeKind getScalarTypeKind() const;
+
   /// isDependentType - Whether this type is a dependent type, meaning
   /// that its definition somehow depends on a template parameter
   /// (C++ [temp.dep.type]).

clang/include/clang/Sema/Sema.h

@@ -4109,7 +4109,8 @@ class Sema {
   /// CheckAssignmentConstraints - Perform type checking for assignment,
   /// argument passing, variable initialization, and function return values.
   /// This routine is only used by the following two methods. C99 6.5.16.
-  AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
+  AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs,
+                                               CastKind &Kind);
 
   // CheckSingleAssignmentConstraints - Currently used by
   // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,

clang/lib/AST/Expr.cpp

@@ -742,6 +742,8 @@ const char *CastExpr::getCastKindName() const {
   switch (getCastKind()) {
   case CK_Unknown:
     return "Unknown";
+  case CK_Dependent:
+    return "Dependent";
   case CK_BitCast:
     return "BitCast";
   case CK_LValueBitCast:
@@ -778,18 +780,24 @@ const char *CastExpr::getCastKindName() const {
     return "IntegralToPointer";
   case CK_PointerToIntegral:
     return "PointerToIntegral";
+  case CK_PointerToBoolean:
+    return "PointerToBoolean";
   case CK_ToVoid:
     return "ToVoid";
   case CK_VectorSplat:
     return "VectorSplat";
   case CK_IntegralCast:
     return "IntegralCast";
+  case CK_IntegralToBoolean:
+    return "IntegralToBoolean";
   case CK_IntegralToFloating:
     return "IntegralToFloating";
   case CK_FloatingToIntegral:
     return "FloatingToIntegral";
   case CK_FloatingCast:
     return "FloatingCast";
+  case CK_FloatingToBoolean:
+    return "FloatingToBoolean";
   case CK_MemberPointerToBoolean:
     return "MemberPointerToBoolean";
   case CK_AnyPointerToObjCPointerCast:

clang/lib/AST/Type.cpp

@@ -572,7 +572,8 @@ bool Type::isArithmeticType() const {
 
 bool Type::isScalarType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
-    return BT->getKind() != BuiltinType::Void && !BT->isPlaceholderType();
+    return BT->getKind() > BuiltinType::Void &&
+           BT->getKind() <= BuiltinType::NullPtr;
   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
     // Enums are scalar types, but only if they are defined.  Incomplete enums
     // are not treated as scalar types.
@@ -584,6 +585,35 @@ bool Type::isScalarType() const {
          isa<ObjCObjectPointerType>(CanonicalType);
 }
 
+Type::ScalarTypeKind Type::getScalarTypeKind() const {
+  assert(isScalarType());
+
+  const Type *T = CanonicalType.getTypePtr();
+  if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) {
+    if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
+    if (BT->getKind() == BuiltinType::NullPtr) return STK_Pointer;
+    if (BT->isInteger()) return STK_Integral;
+    if (BT->isFloatingPoint()) return STK_Floating;
+    llvm_unreachable("unknown scalar builtin type");
+  } else if (isa<PointerType>(T) ||
+             isa<BlockPointerType>(T) ||
+             isa<ObjCObjectPointerType>(T)) {
+    return STK_Pointer;
+  } else if (isa<MemberPointerType>(T)) {
+    return STK_MemberPointer;
+  } else if (isa<EnumType>(T)) {
+    assert(cast<EnumType>(T)->getDecl()->isComplete());
+    return STK_Integral;
+  } else if (const ComplexType *CT = dyn_cast<ComplexType>(T)) {
+    if (CT->getElementType()->isRealFloatingType())
+      return STK_FloatingComplex;
+    return STK_IntegralComplex;
+  }
+
+  llvm_unreachable("unknown scalar type");
+  return STK_Pointer;
+}
+
 /// \brief Determines whether the type is a C++ aggregate type or C
 /// aggregate or union type.
 ///

clang/lib/Checker/GRExprEngine.cpp

@@ -2541,15 +2541,19 @@ void GRExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
     return;
 
   case CK_Unknown:
+  case CK_Dependent:
   case CK_ArrayToPointerDecay:
   case CK_BitCast:
   case CK_LValueBitCast:
   case CK_IntegralCast:
   case CK_NullToPointer:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
+  case CK_PointerToBoolean:
+  case CK_IntegralToBoolean:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
+  case CK_FloatingToBoolean:
   case CK_FloatingCast:
   case CK_FloatingRealToComplex:
   case CK_FloatingComplexToReal:

clang/lib/CodeGen/CGExpr.cpp

@@ -1783,7 +1783,10 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   switch (E->getCastKind()) {
   case CK_ToVoid:
     return EmitUnsupportedLValue(E, "unexpected cast lvalue");
-   
+
+  case CK_Dependent:
+    llvm_unreachable("dependent cast kind in IR gen!");
+
   case CK_NoOp:
     if (E->getSubExpr()->Classify(getContext()).getKind() 
                                           != Expr::Classification::CL_PRValue) {
@@ -1800,7 +1803,7 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
       return LV;
     }
     // Fall through to synthesize a temporary.
-      
+
   case CK_Unknown:
   case CK_BitCast:
   case CK_ArrayToPointerDecay:
@@ -1809,10 +1812,13 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   case CK_NullToPointer:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
+  case CK_PointerToBoolean:
   case CK_VectorSplat:
   case CK_IntegralCast:
+  case CK_IntegralToBoolean:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
+  case CK_FloatingToBoolean:
   case CK_FloatingCast:
   case CK_FloatingRealToComplex:
   case CK_FloatingComplexToReal: