Now that isPointerType can return a pointer type, avoid stripping off typedef

information in the common case.  On this invalid code:

typedef float float4 __attribute__((vector_size(16)));
typedef int int4 __attribute__((vector_size(16)));
void test(float4 a, int4 *result, int i) {
    result[i] = a;
}

we now generate:
  t.c:5:15: error: incompatible types assigning 'float4' to 'int4'
instead of:
  t.c:5:15: error: incompatible types assigning 'float4' to 'int  __attribute__((vector_size(16)))'

This implements test/Sema/typedef-retain.c

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@39892 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/AST/Type.cpp b/AST/Type.cpp
index 74e47936a90b97ec98019c8d6f14a32919539c4e..0bc058f742a74927602434e02bbaaa5f604fed66 100644 (file)
--- a/AST/Type.cpp
+++ b/AST/Type.cpp
@@ -60,8 +60,12 @@ bool Type::isFunctionType() const {
   return isa<FunctionType>(CanonicalType);
 }
 
-PointerType *Type::isPointerType() const {
-  if (PointerType *PTy = dyn_cast<PointerType>(CanonicalType))
+const PointerType *Type::isPointerType() const {
+  // If this is directly a pointer type, return it.
+  if (const PointerType *PTy = dyn_cast<PointerType>(this))
+    return PTy;
+  // If this is a typedef for a pointer type, strip the typedef off.
+  if (const PointerType *PTy = dyn_cast<PointerType>(CanonicalType))
     return PTy;
   return 0;
 }
@@ -90,6 +94,21 @@ bool Type::isUnionType() const {
   return false;
 }
 
+bool Type::isComplexType() const {
+  return isa<ComplexType>(CanonicalType);
+}
+
+const VectorType *Type::isVectorType() const {
+  // Are we directly a vector type?
+  if (const VectorType *VTy = dyn_cast<VectorType>(this))
+    return VTy;
+  // If this is a typedef for a vector type, strip the typedef off.
+  if (const VectorType *VTy = dyn_cast<VectorType>(CanonicalType))
+    return VTy;
+  return 0;
+}
+
+
 // C99 6.2.7p1: If both are complete types, then the following additional
 // requirements apply...FIXME (handle compatibility across source files).
 bool Type::tagTypesAreCompatible(QualType lhs, QualType rhs) {
@@ -289,16 +308,6 @@ bool Type::isRealType() const {
   return false;
 }
 
-bool Type::isComplexType() const {
-  return isa<ComplexType>(CanonicalType);
-}
-
-VectorType *Type::isVectorType() const {
-  if (VectorType *VTy = dyn_cast<VectorType>(CanonicalType))
-    return VTy;
-  return 0;
-}
-
 bool Type::isArithmeticType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() != BuiltinType::Void;

diff --git a/Sema/SemaExpr.cpp b/Sema/SemaExpr.cpp
index 088d3f1bdb6103b31decae5069f42b38e4236cbd..3a7635b2521451eab26d574211bb9dba478de6a6 100644 (file)
--- a/Sema/SemaExpr.cpp
+++ b/Sema/SemaExpr.cpp
@@ -294,17 +294,18 @@ ParseArraySubscriptExpr(ExprTy *Base, SourceLocation LLoc,
   // and index from the expression types.
   Expr *BaseExpr, *IndexExpr;
   QualType ResultType;
-  if (PointerType *PTy = LHSTy->isPointerType()) {
+  if (const PointerType *PTy = LHSTy->isPointerType()) {
     BaseExpr = LHSExp;
     IndexExpr = RHSExp;
     // FIXME: need to deal with const...
     ResultType = PTy->getPointeeType();
-  } else if (PointerType *PTy = RHSTy->isPointerType()) { // uncommon:  123[Ptr]
+  } else if (const PointerType *PTy = RHSTy->isPointerType()) {
+     // Handle the uncommon case of "123[Ptr]".
     BaseExpr = RHSExp;
     IndexExpr = LHSExp;
     // FIXME: need to deal with const...
     ResultType = PTy->getPointeeType();
-  } else if (VectorType *VTy = LHSTy->isVectorType()) {  // vectors: V[123]
+  } else if (const VectorType *VTy = LHSTy->isVectorType()) { // vectors: V[123]
     BaseExpr = LHSExp;
     IndexExpr = RHSExp;
     // FIXME: need to deal with const...

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index b2ca8eb5d78ee60fa2aafd10fbf49073c3f2fb85..ecce34c64e0ecf0acea62d497e5ef679b4e9ad10 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -230,11 +230,11 @@ public:
   bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
   
   /// Vector types
-  VectorType *isVectorType() const; // GCC vector type.
+  const VectorType *isVectorType() const; // GCC vector type.
   
   /// Derived types (C99 6.2.5p20). isFunctionType() is also a derived type.
   bool isDerivedType() const;
-  PointerType *isPointerType() const;
+  const PointerType *isPointerType() const;
   bool isReferenceType() const;
   bool isArrayType() const;
   bool isStructureType() const;