commit 85f0dc588193fc73c58e73769e266cd83ed415fe
author Steve Naroff <snaroff@apple.com> Mon Oct 15 20:41:53 2007 +0000
committer Steve Naroff <snaroff@apple.com> Mon Oct 15 20:41:53 2007 +0000
tree 3cdd1dbef842c94a71bc31c41bdc105cbe1d5072
parent 36760330e9e1cff31a7bcb5581bc7244e347f9e0

Move type compatibility predicates from Type to ASTContext. In addition, the predicates are now instance methods (they were previously static class methods on Type).

This allowed me to fix the following hack from this weekend...

// FIXME: Devise a way to do this without using strcmp.
// Would like to say..."return getAsStructureType() == IdStructType;", but
// we don't have a pointer to ASTContext.
bool Type::isObjcIdType() const {
  if (const RecordType *RT = getAsStructureType())
    return !strcmp(RT->getDecl()->getName(), "objc_object");
  return false;
}

...which is now...

bool isObjcIdType(QualType T) const {
  return T->getAsStructureType() == IdStructType;
}

Side notes:

- I had to remove a convenience function from the TypesCompatibleExpr class.

int typesAreCompatible() const {return Type::typesAreCompatible(Type1,Type2);}

Which required a couple clients get a little more verbose...

-    Result = TCE->typesAreCompatible();
+    Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2());

Overall, I think this change also makes sense for a couple reasons...

1) Since ASTContext vends types, it makes sense for the type compatibility API to be there.
2) This allows the type compatibility predeciates to refer to data not strictly present in the AST (which I have found problematic on several occasions).



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

Sema/SemaExpr.cpp

diff --git a/Sema/SemaExpr.cpp b/Sema/SemaExpr.cpp
index 9142a25..c7d74e9 100644
--- a/Sema/SemaExpr.cpp
+++ b/Sema/SemaExpr.cpp
@@ -757,8 +757,8 @@
           (lhptee->isObjectType() || lhptee->isIncompleteType()))
         return rexT;
 
-      if (!Type::typesAreCompatible(lhptee.getUnqualifiedType(), 
-                                    rhptee.getUnqualifiedType())) {
+      if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(), 
+                                      rhptee.getUnqualifiedType())) {
         Diag(questionLoc, diag::ext_typecheck_cond_incompatible_pointers,
              lexT.getAsString(), rexT.getAsString(),
              lex->getSourceRange(), rex->getSourceRange());
@@ -997,8 +997,8 @@
     ;
   // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 
   // unqualified versions of compatible types, ...
-  else if (!Type::typesAreCompatible(lhptee.getUnqualifiedType(), 
-                                     rhptee.getUnqualifiedType()))
+  else if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(), 
+                                       rhptee.getUnqualifiedType()))
     r = IncompatiblePointer; // this "trumps" PointerAssignDiscardsQualifiers
   return r;
 }
@@ -1026,7 +1026,7 @@
     return Compatible;
 
   if (lhsType->isReferenceType() || rhsType->isReferenceType()) {
-    if (Type::referenceTypesAreCompatible(lhsType, rhsType))
+    if (Context.referenceTypesAreCompatible(lhsType, rhsType))
       return Compatible;
   } else if (lhsType->isArithmeticType() && rhsType->isArithmeticType()) {
     if (lhsType->isVectorType() || rhsType->isVectorType()) {
@@ -1048,7 +1048,7 @@
     if (lhsType->isPointerType()) 
       return CheckPointerTypesForAssignment(lhsType, rhsType);
   } else if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
-    if (Type::tagTypesAreCompatible(lhsType, rhsType))
+    if (Context.tagTypesAreCompatible(lhsType, rhsType))
       return Compatible;
   }
   return Incompatible;
@@ -1213,8 +1213,8 @@
   // errors (when -pedantic-errors is enabled).
   if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
     if (!LHSIsNull && !RHSIsNull &&
-        !Type::pointerTypesAreCompatible(lType.getUnqualifiedType(),
-                                         rType.getUnqualifiedType())) {
+        !Context.pointerTypesAreCompatible(lType.getUnqualifiedType(),
+                                           rType.getUnqualifiedType())) {
       Diag(loc, diag::ext_typecheck_comparison_of_distinct_pointers,
            lType.getAsString(), rType.getAsString(),
            lex->getSourceRange(), rex->getSourceRange());