[AST] Always set dependent-type for the CallExpr for error-recovery in C.

[hokein]

Summary

When build CallExpr for error-recovery where we have any dependent
child nodes), we should set a dependent type for CallExpr to avoid
running into some unexpected following semantic analysis.

This also aligns with the C++ behavior.

This fixes the symptom crashes: https://github.com/llvm/llvm-project/issues/50244

[aaron.ballman]

LGTM, though please add a release note about the fix. Thank you!

[shafik]

Thank you for the quick fix!

[hokein]

add release note.

clang/docs/ReleaseNotes.rst

- Fix assertion and quality of diagnostic messages in a for loop
   containing multiple declarations and a range specifier
   (`#63010 <https://github.com/llvm/llvm-project/issues/63010>`_).
 - Fix rejects-valid when consteval operator appears inside of a template.
   (`#62886 <https://github.com/llvm/llvm-project/issues/62886>`_).
 - Fix crash for code using ``_Atomic`` types in C++
   (`See patch <https://reviews.llvm.org/D152303>`_).
 - Fix crash when passing a value larger then 64 bits to the aligned attribute.
   (`#50534 <https://github.com/llvm/llvm-project/issues/50534>`_).
+- CallExpr built for C error-recovery now is always type-dependent. Fixes a
+  crash when we encounter a unresolved TypoExpr during diagnostic emission.
+  (`#50244 <https://github.com/llvm/llvm-project/issues/50244>_`).
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed a bug where attribute annotations on type specifiers (enums, classes,
   structs, unions, and scoped enums) were not properly ignored, resulting in

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
 
   if (Context.isDependenceAllowed() &&
       (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs))) {
     assert(!getLangOpts().CPlusPlus);
     assert((Fn->containsErrors() ||
             llvm::any_of(ArgExprs,
                          [](clang::Expr *E) { return E->containsErrors(); })) &&
            "should only occur in error-recovery path.");
-    QualType ReturnType =
-        llvm::isa_and_nonnull<FunctionDecl>(NDecl)
-            ? cast<FunctionDecl>(NDecl)->getCallResultType()
-            : Context.DependentTy;
-    return CallExpr::Create(Context, Fn, ArgExprs, ReturnType,
-                            Expr::getValueKindForType(ReturnType), RParenLoc,
-                            CurFPFeatureOverrides());
+    return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
+                            VK_PRValue, RParenLoc, CurFPFeatureOverrides());
   }
   return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
                                ExecConfig, IsExecConfig);
 }
 
 /// BuildBuiltinCallExpr - Create a call to a builtin function specified by Id
 //  with the specified CallArgs
 Expr *Sema::BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,

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

void test3() {
   // CHECK:     CallExpr {{.*}} '<dependent type>' contains-errors
   // CHECK-NEXT: |-ParenExpr {{.*}} contains-errors lvalue
   // CHECK-NEXT: | `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT: |   `-DeclRefExpr {{.*}} '__builtin_classify_type'
   // CHECK-NEXT: `-IntegerLiteral {{.*}} 'int' 1
   (*__builtin_classify_type)(1);
 
   extern void ext();
-  // CHECK:     CallExpr {{.*}} 'void' contains-errors
+  // CHECK:     CallExpr {{.*}} '<dependent type>' contains-errors
   // CHECK-NEXT: |-DeclRefExpr {{.*}} 'ext'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} '<dependent type>'
   ext(undef_var);
 }
 
 // Verify no crash.
 void test4() {
   enum GH62446 {
     // CHECK:      RecoveryExpr {{.*}} '<dependent type>' contains-errors lvalue
     // CHECK-NEXT: |-StringLiteral {{.*}} "a"
     // CHECK-NEXT: `-IntegerLiteral {{.*}} 2
     invalid_enum_value = "a" * 2,
     b,
   };
 }
 
 // Verify no crash
 void test5_GH62711() {
   // CHECK:      VAArgExpr {{.*}} 'int' contains-errors
   // CHECK-NEXT: | `-ImplicitCastExpr {{.*}} '<dependent type>' contains-errors
   // CHECK-NEXT: |   `-RecoveryExpr {{.*}} '<dependent type>' contains-errors
   if (__builtin_va_arg(undef, int) << 1);
 }
+
+void test6_GH50244() {
+  double array[16];
+  // CHECK:      UnaryExprOrTypeTraitExpr {{.*}} 'unsigned long' contains-errors sizeof
+  // CHECK-NEXT: `-CallExpr {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT:   |-DeclRefExpr {{.*}} 'int ()'
+  // CHECK-NEXT:   `-RecoveryExpr {{.*}} '<dependent type>'
+  sizeof array / sizeof foo(undef);
+}