[AST][RecoveryExpr] Part4: Support dependent cast-expr in C for error-recovery.

[hokein]

Summary

Suppress spurious "typecheck_cond_expect_scalar_operand" diagnostic.

See whole context: https://reviews.llvm.org/D85025

[hokein]

clang/lib/Sema/SemaCast.cpp

2712

This is similar to the way how C++ codepath handles dependent code, https://github.com/llvm/llvm-project/blob/master/clang/lib/Sema/SemaCast.cpp#L2527-L2532.

[sammccall]

Sorry for losing track of this. Where is CDependence defined? Is this stacked on another patch?

[hokein]

In D84387#2220845, @sammccall wrote:

Sorry for losing track of this. Where is CDependence defined? Is this stacked on another patch?

yes. Sorry for not being clear here, this is stacked on another patch. I have renamed these patches (Part 1, 2, 3...). The review should go Part 1 first.

[sammccall]

I'm not sure I love having the assertion for contains-errors every place that handles dependent code in C.
We should certainly somehow document the reason dependence is possible, just as the possibility of overloads is documented.
But the assertion seems pretty heavyweight :-\

clang/lib/Sema/SemaCast.cpp

2712

also copy the comment?

[hokein]

rebase

[hokein]

I'm not sure I love having the assertion for contains-errors every place that handles dependent code in C.

My feeling is that the assertion would help for understanding the code (comparing with documenting it somewhere), and we don't have too many places.

clang/lib/Sema/SemaCast.cpp

if (DestType->isVoidType()) {
     if (SrcExpr.isInvalid())
       return;
 
     // Cast to void allows any expr type.
     Kind = CK_ToVoid;
     return;
   }
 
+  // If the type is dependent, we won't do any other semantic analysis now.
+  if (Self.getASTContext().isDependenceAllowed() &&
+      (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() ||
+       SrcExpr.get()->isValueDependent())) {
+    assert((DestType->containsErrors() || SrcExpr.get()->containsErrors() ||
+            SrcExpr.get()->containsErrors()) &&
+           "should only occur in error-recovery path.");
+    assert(Kind == CK_Dependent);
+    return;
+  }
+
   // Overloads are allowed with C extensions, so we need to support them.
   if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
     DeclAccessPair DAP;
     if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction(
             SrcExpr.get(), DestType, /*Complain=*/true, DAP))
       SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD);
     else
       return;

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

void test2() {
   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);
+
+  // CHECK:     CStyleCastExpr {{.*}} 'float' contains-errors <Dependent>
+  // CHECK-NEXT: `-RecoveryExpr {{.*}} '<dependent type>'
+  // CHECK-NEXT:   `-DeclRefExpr {{.*}} 'some_func'
+  (float)some_func();
 }

clang/test/Sema/error-dependence.c

 // RUN: %clang_cc1 -fsyntax-only -verify -frecovery-ast -fno-recovery-ast-type %s
 
 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}}
+
+  // verify diagnostic "operand of type '<dependent type>' where arithmetic or
+  // pointer type is required" is not emitted.
+  (float)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}}
 }