diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -186,6 +186,9 @@
   by prioritizing ``-Wunreachable-code-fallthrough``.
 - Clang now correctly diagnoses statement attributes ``[[clang::always_inine]]`` and
   ``[[clang::noinline]]`` when used on a statement with dependent call expressions.
+- Clang now checks for completeness of the second and third arguments in the
+  conditional operator.
+  (`#59718 <https://github.com/llvm/llvm-project/issues/59718>`_)
 
 Bug Fixes in This Version
 -------------------------
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -14396,6 +14396,9 @@
 static void CheckConditionalOperand(Sema &S, Expr *E, QualType T,
                                     SourceLocation CC, bool &ICContext) {
   E = E->IgnoreParenImpCasts();
+  // Diagnose incomplete type for second or third operand in C.
+  if (!S.getLangOpts().CPlusPlus && E->getType()->isRecordType())
+    S.RequireCompleteExprType(E, diag::err_incomplete_type);
 
   if (auto *CO = dyn_cast<AbstractConditionalOperator>(E))
     return CheckConditionalOperator(S, CO, CC, T);
diff --git a/clang/test/Sema/incomplete-decl.c b/clang/test/Sema/incomplete-decl.c
--- a/clang/test/Sema/incomplete-decl.c
+++ b/clang/test/Sema/incomplete-decl.c
@@ -1,31 +1,51 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c,expected %s
+// RUN: %clang_cc1 -x c++ -fsyntax-only -verify=cxx,expected %s
 
-struct foo; // expected-note 5 {{forward declaration of 'struct foo'}}
+
+
+struct foo; // c-note 5 {{forward declaration of 'struct foo'}} \
+               cxx-note 3 {{forward declaration of 'foo'}}
 
 void b;  // expected-error {{variable has incomplete type 'void'}}
-struct foo f; // expected-error{{tentative definition has type 'struct foo' that is never completed}}
+struct foo f; // c-error {{tentative definition has type 'struct foo' that is never completed}} \
+                 cxx-error {{variable has incomplete type 'struct foo'}}
 
 static void c; // expected-error {{variable has incomplete type 'void'}}
-static struct foo g;  // expected-warning {{tentative definition of variable with internal linkage has incomplete non-array type 'struct foo'}} \
-    expected-error{{tentative definition has type 'struct foo' that is never completed}}
+static struct foo g;  // c-warning {{tentative definition of variable with internal linkage has incomplete non-array type 'struct foo'}} \
+                         c-error {{tentative definition has type 'struct foo' that is never completed}} \
+                         cxx-error {{variable has incomplete type 'struct foo'}}
 
-extern void d;
+extern void d; // cxx-error {{variable has incomplete type 'void'}}
 extern struct foo e;
 
-int ary[]; // expected-warning {{tentative array definition assumed to have one element}}
-struct foo bary[]; // expected-error {{array has incomplete element type 'struct foo'}}
+int ary[]; // c-warning {{tentative array definition assumed to have one element}} \
+              cxx-error {{definition of variable with array type needs an explicit size or an initializer}}
+struct foo bary[]; // c-error {{array has incomplete element type 'struct foo'}} \
+                      cxx-error {{definition of variable with array type needs an explicit size or an initializer}}
 
 void func(void) {
-  int ary[]; // expected-error{{definition of variable with array type needs an explicit size or an initializer}}
+  int ary[]; // expected-error {{definition of variable with array type needs an explicit size or an initializer}}
   void b; // expected-error {{variable has incomplete type 'void'}}
   struct foo f; // expected-error {{variable has incomplete type 'struct foo'}}
 }
 
-int h[]; // expected-warning {{tentative array definition assumed to have one element}}
-int (*i)[] = &h+1; // expected-error {{arithmetic on a pointer to an incomplete type 'int[]'}}
+int h[]; // c-warning {{tentative array definition assumed to have one element}} \
+            cxx-error {{definition of variable with array type needs an explicit size or an initializer}}
+int (*i)[] = &h+1; // c-error {{arithmetic on a pointer to an incomplete type 'int[]'}}
 
 struct bar j = {1}; // expected-error {{variable has incomplete type 'struct bar'}} \
-    expected-note {{forward declaration of 'struct bar'}}
-struct bar k;
+                       c-note {{forward declaration of 'struct bar'}} \
+                       cxx-note 2 {{forward declaration of 'bar'}}
+
+struct bar k; // cxx-error {{variable has incomplete type 'struct bar'}}
 struct bar { int a; };
 
+struct x y; //c-note 2 {{forward declaration of 'struct x'}} \
+              cxx-error {{variable has incomplete type 'struct x'}} \
+              cxx-note {{forward declaration of 'x'}}
+void foo() {
+  (void)(1 ? y : y); // c-error 2 {{incomplete type 'struct x' where a complete type is required}}
+}
+struct x{
+  int a;
+};