[OpenCL] Allow zero assignment and comparisons between queue_t type variables

[AlistairD]

Summary

This change allows for zero assignment and comparison of queue_t type variables, and extends null_queue.cl to test this.

[Anastasia]

LGTM! Thanks!

lib/Sema/SemaExpr.cpp

if (Diagnose || ConvertRHS) {
       CheckPointerConversion(RHS.get(), LHSType, Kind, Path,
                              /*IgnoreBaseAccess=*/false, Diagnose);
       if (ConvertRHS)
         RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path);
     }
     return Compatible;
   }
 
+  // OpenCL queue_t type assignment.
+  if (LHSType->isQueueT() && RHS.get()->isNullPointerConstant(
+                                 Context, Expr::NPC_ValueDependentIsNull)) {
+    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
+    return Compatible;
+  }
+
   // This check seems unnatural, however it is necessary to ensure the proper
   // conversion of functions/arrays. If the conversion were done for all
   // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
   // expressions that suppress this implicit conversion (&, sizeof).
   //
   // Suppress this for references: C++ 8.5.3p5.
   if (!LHSType->isReferenceType()) {
     // FIXME: We potentially allocate here even if ConvertRHS is false.
QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
   }
   if (!IsRelational && LHSIsNull
       && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
     LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
     return computeResultTy();
   }
 
   if (getLangOpts().OpenCLVersion >= 200) {
+    if (LHSType->isQueueT() && RHSType->isQueueT()) {
+      return computeResultTy();
+    }
+
     if (LHSIsNull && RHSType->isQueueT()) {
       LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
       return computeResultTy();
     }
 
     if (LHSType->isQueueT() && RHSIsNull) {
       RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
       return computeResultTy();

test/SemaOpenCL/null_queue.cl

 // RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
 extern queue_t get_default_queue();
 
-bool compare() {
-  return 1 == get_default_queue() && // expected-error{{invalid operands to binary expression ('int' and 'queue_t')}}
-         get_default_queue() == 1; // expected-error{{invalid operands to binary expression ('queue_t' and 'int')}}
-}
+void queue_arg(queue_t); // expected-note {{passing argument to parameter here}}
 
 void init() {
   queue_t q1 = 1; // expected-error{{initializing 'queue_t' with an expression of incompatible type 'int'}}
   queue_t q = 0;
 }
+
+void assign() {
+  queue_t q2, q3;
+  q2 = 5; // expected-error{{assigning to 'queue_t' from incompatible type 'int'}}
+  q3 = 0;
+  q2 = q3 = 0;
+}
+
+bool compare() {
+  queue_t q4, q5;
+  return 1 == get_default_queue() && // expected-error{{invalid operands to binary expression ('int' and 'queue_t')}}
+         get_default_queue() == 1 && // expected-error{{invalid operands to binary expression ('queue_t' and 'int')}}
+       q4 == q5 &&
+       q4 != 0 &&
+       q4 != 0.0f; // expected-error{{invalid operands to binary expression ('queue_t' and 'float')}}
+}
+
+void call() {
+  queue_arg(5); // expected-error {{passing 'int' to parameter of incompatible type 'queue_t'}}
+  queue_arg(0);
+}