[AST][RecoveryExpr] Part3: Support dependent conditional operators in C for error recovery.

[hokein]

Summary

suppress spurious "typecheck_cond_expect_scalar" diagnostic.

[hokein]

clang/lib/Sema/SemaExpr.cpp

8072

This follows the same way of how C++ codepath handles dependent code, see the above Line 8069 CXXCheckConditionalOperands.

[sammccall]

clang/test/Sema/error-dependence.c

14

nit: parens would help me understand here :-)

I don't find this example compelling because we should know that "ptr > f" is a boolean.

Can we just have undefined ? ptr : f, expecting the only diag to be the undeclared ident?

[hokein]

rebase and add ast-dump test.

clang/test/Sema/error-dependence.c

14

I don't find this example compelling because we should know that "ptr > f" is a boolean.

this is a reasonable impression, but in this case, there is no binary-operator > -- operands ptr, f have different types, and invalid for binary operator, instead we build a recovery-expr.

so the AST looks like (added in the dump-recovery.c test as well)

ConditionalOperator> '<dependent type>' contains-errors
  | |-RecoveryExpr  '<dependent type>' contains-errors lvalue
  | | |-DeclRefExpr  'int *' lvalue Var 0x8fdb620 'ptr' 'int *'
  | | `-DeclRefExpr  'float' lvalue Var 0x8ffd388 'f' 'float'
  | |-DeclRefExpr  'int *' lvalue Var 0x8fdb620 'ptr' 'int *'
  | `-DeclRefExpr  'float' lvalue Var 0x8ffd388 'f' 'float'

Can we just have undefined ? ptr : f, expecting the only diag to be the undeclared ident?

no unfortunately. the whole statement is being dropped (we don't preserve this in C/C++).

[sammccall]

clang/test/AST/ast-dump-recovery.c

75

add to comment: (comparison is invalid)

83

again - parens

clang/test/Sema/error-dependence.c

14

undefined() ? ptr : f then?

[hokein]

address comments

clang/test/Sema/error-dependence.c

14

oh, yeah. undefined() is not working (undefined function is implicitly treated as int () in C), but call() would work.

clang/lib/Sema/SemaExpr.cpp

QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
 
   // C++ is sufficiently different to merit its own checker.
   if (getLangOpts().CPlusPlus)
     return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
 
   VK = VK_RValue;
   OK = OK_Ordinary;
 
+  if (Context.isDependenceAllowed() &&
+      (Cond.get()->isTypeDependent() || LHS.get()->isTypeDependent() ||
+       RHS.get()->isTypeDependent())) {
+    assert(!getLangOpts().CPlusPlus);
+    assert(Cond.get()->containsErrors() || LHS.get()->containsErrors() ||
+           RHS.get()->containsErrors() &&
+               "should only occur in error-recovery path.");
+    return Context.DependentTy;
+  }
+
   // The OpenCL operator with a vector condition is sufficiently
   // different to merit its own checker.
   if ((getLangOpts().OpenCL && Cond.get()->getType()->isVectorType()) ||
       Cond.get()->getType()->isExtVectorType())
     return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);
 
   // First, check the condition.
   Cond = UsualUnaryConversions(Cond.get());

clang/test/AST/ast-dump-recovery.c

void test2() {
   // CHECK-NEXT: `-RecoveryExpr {{.*}}
   // CHECK-NEXT:   `-DeclRefExpr {{.*}} 'some_func'
   1, some_func();
   // CHECK:     BinaryOperator {{.*}} 'int' contains-errors ','
   // CHECK-NEXT: |-RecoveryExpr {{.*}} '<dependent type>'
   // CHECK-NEXT: | `-DeclRefExpr {{.*}} 'some_func'
   // CHECK-NEXT: `-IntegerLiteral {{.*}} 'int' 1
   some_func(), 1;
+
+  // conditional operator (comparison is invalid)
+  float f;
+  // CHECK:     ConditionalOperator {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT: |-RecoveryExpr {{.*}} '<dependent type>'
+  // CHECK-NEXT: | |-DeclRefExpr {{.*}} 'int *' lvalue
+  // CHECK-NEXT: | `-DeclRefExpr {{.*}} 'float' lvalue
+  // CHECK-NEXT: |-DeclRefExpr {{.*}} 'int *' lvalue
+  // CHECK-NEXT: `-DeclRefExpr {{.*}} 'float' lvalue
+  (ptr > f ? ptr : f);
 }

clang/test/Sema/error-dependence.c

 // RUN: %clang_cc1 -fsyntax-only -verify -frecovery-ast -fno-recovery-ast-type %s
 
-int call(int); // expected-note {{'call' declared here}}
+int call(int); // expected-note2 {{'call' declared here}}
 
 void test1(int s) {
   // verify "assigning to 'int' from incompatible type '<dependent type>'" is
   // not emitted.
   s = call(); // expected-error {{too few arguments to function call}}
 }
+
+void test2(int* ptr, float f) {
+  // verify diagnostic "used type '<dependent type>' where arithmetic or pointer
+  // type is required" is not emitted.
+  (call() ? ptr : f); // expected-error {{too few arguments to function call}}
+}