[clang][AST] Handle variable declaration with unknown typedef in C

[urazoff]

Summary

With this patch, declarations containing unknown types are parsed
like declarations, not like expressions. This leads to better
diagnostics and yields InvalidDecl in AST (thus DeclRefExpr's to
them) which is good for compiler users and AST consumers.

[urazoff]

https://github.com/llvm/llvm-project/issues/58355 corresponding github issue with current clang behavior.

[shafik]

CC @aaron.ballman

[aaron.ballman]

Thank you for the changes! One thing you should add is a release note so users know there's been a diagnostic improvement.

clang/lib/Parse/ParseDecl.cpp

5384–5385 ↗

(On Diff #471751)

This is a pretty unsafe function to call from arbitrary parsing contexts. We should be asserting that the parser is in a reasonable state to even ask this question; alternatively, we could make this a static function that accepts a Parser& object.

5388 ↗

(On Diff #471751)

Why only __attribute__ and not __declspec? [[]] attributes as well?

5392–5394 ↗

(On Diff #471751)

Looking for *, &, and && will help catch some cases... but it's not really going to help for situations like unknown const * or other qualifiers...

5425 ↗

(On Diff #471751)

Why is ObjC exempted from this?

I need to think about this a whole lot more. On the one hand, I like the changes happening in the test cases; those look like good changes to me. But on the other hand, this function is called in a fair number of places to make parsing decisions and I'm not convinced that speculative answers are the best way to go from this interface. I need to see if I can find any situations where this is called and we'd get worse parsing behavior (or incorrect parsing behavior!).

clang/test/SemaOpenCL/invalid-pipes-cl1.2.cl

28–29

[urazoff]

clang/lib/Parse/ParseDecl.cpp

5392–5394 ↗

(On Diff #471751)

Actually, this Parser::isDeclarationSpecifier is never called in case of C++. So I am not sure if we need to cover C++ specific constructs or not. But unknown const * is a good catch, I missed it for some reason. I will update the patch soon.

5425 ↗

(On Diff #471751)

There is weird behavior in case of ObjC range-based for loop. For example, in for (NSString* key in xyz) token for in keyword is of type Identifier by the call of Parser::isDeclarationSpecifier. So I decided to exempt it in first version and discuss it in review.

[sammccall]

I admire the goals of this patch, but I think it needs some explanation "why we expect this to be roughly correct/safe", rather than just trying to think of cases that might go wrong and patch them.

The test coverage for incorrect code is not good, I'd expect to need to add some new cases here. (And if there are benefits to the AST, we'd want to test those).

clang/lib/Parse/ParseDecl.cpp

5425 ↗

(On Diff #471751)

This looks very suspicious to me, for example in a * b;. isDeclarationSpecifier() is going to return true when pointing at a. In fact a may be either a type or an expression here.

Even if this right now this function never gets called for that case, it's not obvious why it wouldn't be in the future, or wouldn't be called for similar cases.

[urazoff]

clang/lib/Parse/ParseDecl.cpp

5425 ↗

(On Diff #471751)

The property I relied on is that token a in a * b; gets annotated before and default branch works. But I understand your concern, I am gonna update the patch soon.

[urazoff]

Added test to show the advantage in AST dump.
Missing keywords are added in 'IsUnknownTypedefName', the function is static now.
'DisambiguatingWithExpression' check is added to narrow down the effect of the changes.

[urazoff]

• Added test for AST dump of invalid C code
• Added testcase for diagnostics
• Some minor fixes

[sammccall]

Not sure this is ready for review again, ignore me if not...

I'm still not sure why this is correct in principle. Without that, if someone finds a misparse 6 months from now I don't know how we determine where to fix it.

For example, this path is called from Parser::isKnownToBeDeclarationSpecifier() whose contract is Return true if we know that we are definitely looking at a decl-specifier... Return false if it's no a decl-specifier, or we're not sure. There doesn't seem to be any room for heuristics, unless we're going to change that contract and audit all the callers. If this *isn't* a heuristic (it sure looks like one) it needs some comments on why it's correct.

clang/test/Parser/recovery.c

105

this diagnostic is worse than the old one (less accurate).

(I think it's OK to trade off diagnostics quality if it's better on balance, maybe leave a comment?)

[aaron.ballman]

In D137020#3940523, @sammccall wrote:

Not sure this is ready for review again, ignore me if not...

I'm still not sure why this is correct in principle. Without that, if someone finds a misparse 6 months from now I don't know how we determine where to fix it.

For example, this path is called from Parser::isKnownToBeDeclarationSpecifier() whose contract is Return true if we know that we are definitely looking at a decl-specifier... Return false if it's no a decl-specifier, or we're not sure. There doesn't seem to be any room for heuristics, unless we're going to change that contract and audit all the callers. If this *isn't* a heuristic (it sure looks like one) it needs some comments on why it's correct.

FWIW, I agree with the concerns here; I touched on the same thing with my earlier comments.

[urazoff]

clang/test/Parser/recovery.c

105

Just to mention, this is exact behavior of clang for C++.

[urazoff]

Reasoning about invalid code is made now in specific parsing path not in general decision-making method.

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

177–178

What about other qualifiers? _Nullable and restrict and whatnot?

184–185

Why are these pinned to C++? __declspec is used in C and shows up in the same syntactic locations as in C++, and [ seems like you're looking for [[]]-style attributes (perhaps?) but those also exist in C.

What about parens? e.g.,

_BitNit(12) foo; // Oops, meant to type _BitInt(12)

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

8–11

I'd also like to see a test where the qualifier comes before the unknown type name:

const unknown_t e;

and for typos with multi-keyword types:

unsinged long g;
unsigned lnog h;

and for situations that are just utter nonsense rather than types:

unknown_t[12] i;
unknown_t&&& j;

ohhh.... and GNU statement expressions make this a bit interesting because that's a place where a declaration and an expression get a bit mixed up:

({ int val = 0, i = 12; vla * i; }) // Typo: vla should be val, but this is *not* a declaration, it's the expression determining the value of the statement expression.
({ int val = 0, i = 12; vla & i; }) // Similar but an interesting case for C++

clang/test/Parser/recovery.c

105

this diagnostic is worse than the old one (less accurate).

Less accurate how? It went from use of undeclared identifier 'unknown_t' to unknown type name 'unknown_t' and that seems accurate to me given that the undeclared identifier is written in a type position.

109

There is a behavioral difference here that is plausibly a regression: we used to get use of undeclared identifier 'a' here as well but because we recover as-if a was declared as type int, that diagnostic has gone away. I think that's reasonable as the user was already told about the issue with the declaration of a.

[sammccall]

clang/test/Parser/recovery.c

105

It *could* be a type position, or it could be an operand of multiplication - because the identifier is unresolved, we don't know.

(We could discount the possibility it's a multiplication expression because the result would be discarded, but AFAICT that's not actually what's happening and it'll fire in other cases).

Regardless, this seems OK to me (especially given we already make this guess for C++!)

[aaron.ballman]

clang/test/Parser/recovery.c

105

Ahhh okay, I see what you mean, thanks! I guess I've never seen a discarded multiplication in real world code, so my assumption was there's very little chance this diagnostic is less accurate instead of more accurate. Same goes for Foo & Bar which could be a bitwise AND or a declaration of reference in C++.

[urazoff]

clang/lib/Parse/ParseStmt.cpp

177–178

I think restrict can not go just after type name.

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

177–178

It can when you consider typedefs, as in: https://godbolt.org/z/hjK9f3xEc

[urazoff]

clang/lib/Parse/ParseStmt.cpp

184–185

For _BitNit(12) foo; clang gives diagnostics about implicit declaration of function _BitNit'. This patch preserves the behaviour. I think it's OK, wdyt?

[urazoff]

@sammccall @aaron.ballman I am thinking about another solution with tentative parsing as implemented for C++ in Parser::isCXXSimpleDeclaration (which is eventually called from isDeclarationStatement()). This approach works well for C++. So I want to update this patch with this approach.

clang/lib/Parse/ParseStmt.cpp

std::unique_ptr<CorrectionCandidateCallback> clone() override {
     return std::make_unique<StatementFilterCCC>(*this);
   }
 
 private:
   Token NextToken;
 };
 }
 
+static bool IsUnknownTypedefName(Parser &P) {
+  if (P.getCurToken().isNot(tok::identifier))
+    return false;
+
+  // Handle things like "unknown *bar;" as declaration for better
+  // diagnostics. Also it leads to creation of invalid declaration
+  // node in AST for such cases which is good for AST consumers.
+  switch (P.NextToken().getKind()) {
+  default:
+    return false;
+  case tok::kw___attribute:
+  case tok::kw_const:
+  case tok::kw_volatile:
+  case tok::star:
+  case tok::identifier:
+    return !P.getLangOpts().ObjC;
+  case tok::amp:
+  case tok::ampamp:
+  case tok::kw___declspec:
+  case tok::l_square:
+    return P.getLangOpts().CPlusPlus;
+  }
+}
+
 StmtResult Parser::ParseStatementOrDeclarationAfterAttributes(
     StmtVector &Stmts, ParsedStmtContext StmtCtx,
     SourceLocation *TrailingElseLoc, ParsedAttributes &CXX11Attrs,
     ParsedAttributes &GNUAttrs) {
   const char *SemiError = nullptr;
   StmtResult Res;
   SourceLocation GNUAttributeLoc;
 
default: {
     bool HaveAttrs = !CXX11Attrs.empty() || !GNUAttrs.empty();
     auto IsStmtAttr = [](ParsedAttr &Attr) { return Attr.isStmtAttr(); };
     bool AllAttrsAreStmtAttrs = llvm::all_of(CXX11Attrs, IsStmtAttr) &&
                                 llvm::all_of(GNUAttrs, IsStmtAttr);
     if ((getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt ||
          (StmtCtx & ParsedStmtContext::AllowDeclarationsInC) !=
              ParsedStmtContext()) &&
         ((GNUAttributeLoc.isValid() && !(HaveAttrs && AllAttrsAreStmtAttrs)) ||
-         isDeclarationStatement())) {
+         isDeclarationStatement() || IsUnknownTypedefName(*this))) {
       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
       DeclGroupPtrTy Decl;
       if (GNUAttributeLoc.isValid()) {
         DeclStart = GNUAttributeLoc;
         Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,
                                 GNUAttrs, &GNUAttributeLoc);
       } else {
         Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,

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

+// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -frecovery-ast -fno-recovery-ast-type -ast-dump %s | FileCheck -strict-whitespace %s
+
+void test1() {
+  unknown_t a;
+  // CHECK:      VarDecl{{.*}} invalid a 'int'
+  unknown_t *b;
+  // CHECK:      VarDecl{{.*}} invalid b 'int *'
+  unknown_t const *c;
+  // CHECK:      VarDecl{{.*}} invalid c 'const int *'
+  unknown_t volatile *d;
+  // CHECK:      VarDecl{{.*}} invalid d 'volatile int *'
+  unknown_t __attribute__ ((aligned (16))) f;
+  // CHECK:      VarDecl{{.*}} invalid f 'int'
+}

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

void test3() {
   (*__builtin_classify_type)(1);
 
   extern void ext();
   // CHECK:     CallExpr {{.*}} 'void' contains-errors
   // CHECK-NEXT: |-DeclRefExpr {{.*}} 'ext'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} '<dependent type>'
   ext(undef_var);
 }
+
+void RecoverToAnInvalidDecl() {
+  Unknown* foo; // invalid decl
+  foo;
+  // Verify that RecoveryExpr has an inner DeclRefExpr.
+  // CHECK:      RecoveryExpr {{.*}} '<dependent type>' contains-errors lvalue
+  // CHECK-NEXT: `-DeclRefExpr {{.*}} 'foo' 'int *'
+}

clang/test/Driver/types.c

 // RUN: %clang -c --target=powerpc64-ibm-aix -fsyntax-only %s \
 // RUN: 2>&1
 
 void a(void) {
   __int128_t s;
   __uint128_t t;
 }
 
-// CHECK: error: use of undeclared identifier '__int128_t'
-// CHECK: error: use of undeclared identifier '__uint128_t'
+// CHECK: error: unknown type name '__int128_t'
+// CHECK: error: unknown type name '__uint128_t'

clang/test/Parser/CompoundStmtScope.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void foo(void) {
   {
     typedef float X;
   }
-  X Y;  // expected-error {{use of undeclared identifier}}
+  X Y;  // expected-error {{unknown type name 'X'}}
 }

clang/test/Parser/opencl-atomics-cl20.cl

 // OpenCL v2.0 s6.13.11.6 defines supported atomic types.
 
 // Non-optional types
   atomic_int i;
   atomic_uint ui;
   atomic_float f;
   atomic_flag fl;
 #if !defined(LANG_VER_OK)
-// expected-error@-5 {{use of undeclared identifier 'atomic_int'}}
-// expected-error@-5 {{use of undeclared identifier 'atomic_uint'}}
-// expected-error@-5 {{use of undeclared identifier 'atomic_float'}}
-// expected-error@-5 {{use of undeclared identifier 'atomic_flag'}}
+// expected-error@-5 {{unknown type name 'atomic_int'}}
+// expected-error@-5 {{unknown type name 'atomic_uint'}}
+// expected-error@-5 {{unknown type name 'atomic_float'}}
+// expected-error@-5 {{unknown type name 'atomic_flag'}}
 #endif
 
 // Optional types
   atomic_long l;
   atomic_ulong ul;
   atomic_double d;
   atomic_size_t s;
   atomic_intptr_t ip;
   atomic_uintptr_t uip;
   atomic_ptrdiff_t pd;
 // Optional type identifiers are not added in earlier version or if at least
 // one of the extensions is not supported. Here we check with
 // `cl_khr_int64_base_atomics` only.
 #if !defined(LANG_VER_OK) || !defined(cl_khr_int64_base_atomics)
-// expected-error@-11 {{use of undeclared identifier 'atomic_long'}}
-// expected-error@-11 {{use of undeclared identifier 'atomic_ulong'}}
-// expected-error@-11 {{use of undeclared identifier 'atomic_double'}}
-#if defined(LANG_VER_OK)
-// expected-error@-15 {{expected ';' after expression}}
-// expected-error@-16 {{use of undeclared identifier 'l'}}
-// expected-error@-16 {{expected ';' after expression}}
-// expected-error@-17 {{use of undeclared identifier 'ul'}}
-#endif
+// expected-error@-11 {{unknown type name 'atomic_long'}}
+// expected-error@-11 {{unknown type name 'atomic_ulong'}}
+// expected-error@-11 {{unknown type name 'atomic_double'}}
 #if !defined(LANG_VER_OK) || defined(__SPIR64__)
-// expected-error@-18 {{use of undeclared identifier 'atomic_size_t'}}
-// expected-error@-16 {{use of undeclared identifier 'atomic_ptrdiff_t'}}
-#if !defined(LANG_VER_OK)
-// expected-error@-20 {{use of undeclared identifier 'atomic_intptr_t'}}
-// expected-error@-20 {{use of undeclared identifier 'atomic_uintptr_t'}}
+// expected-error@-12 {{unknown type name 'atomic_size_t'}}
+// expected-error@-12 {{unknown type name 'atomic_intptr_t'}}
+#if !defined(LANG_VER_OK) && defined(__SPIR64__)
+// expected-error@-14 {{unknown type name 'atomic_intptr_t'; did you mean 'atomic_int'?}}
+// expected-note@* {{'atomic_int' declared here}}
+// expected-error@-16 {{unknown type name 'atomic_uintptr_t'}}
+// expected-error@-16 {{unknown type name 'atomic_ptrdiff_t'}}
 #else
-// expected-error@-24 {{expected ';' after expression}}
-// expected-error@-25 {{use of undeclared identifier 's'}}
-// expected-error@-25 {{unknown type name 'atomic_intptr_t'; did you mean 'atomic_int'?}}
+#if defined(LANG_VER_OK)
 // expected-note@* {{'atomic_int' declared here}}
-// expected-error@-26 {{unknown type name 'atomic_uintptr_t'; did you mean 'atomic_uint'?}}
+// expected-error@-20 {{unknown type name 'atomic_uintptr_t'; did you mean 'atomic_uint'?}}
 // expected-note@* {{'atomic_uint' declared here}}
+#else
+// expected-error@-23 {{unknown type name 'atomic_uintptr_t'}}
+#endif
+// expected-error@-24 {{unknown type name 'atomic_ptrdiff_t'}}
 #endif
 #endif
 #endif
 
 // OpenCL v2.0 s6.13.11.8, _Atomic type specifier and _Atomic type qualifier
 // are not supported by OpenCL.
   _Atomic int i;
 #ifdef __OPENCL_C_VERSION__

clang/test/Parser/recovery.c

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fblocks %s
 
 // PR2241
 float test2241[2] = { 
   1e,            // expected-error {{exponent}}
   1ee0           // expected-error {{exponent}}
 };
 
 
 // Testcase derived from PR2692
 static void f (char * (*g) (char **, int), char **p, ...) {
   char *s;
-  va_list v;                              // expected-error {{identifier}}
-  s = g (p, __builtin_va_arg(v, int));    // expected-error {{identifier}}
+  va_list v;                              // expected-error {{unknown type name 'va_list'}}
+  s = g (p, __builtin_va_arg(v, int));
 }
 
 
 // PR3172
 } // expected-error {{extraneous closing brace ('}')}}
 
 
 // rdar://6094870

 void test2(int x) {
 #define VALUE2 VALUE+VALUE
 #define VALUE3 VALUE+0
 #define VALUE4(x) x+0
   x = VALUE2 // expected-error{{expected ';' after expression}}
   x = VALUE3 // expected-error{{expected ';' after expression}}
   x = VALUE4(0) // expected-error{{expected ';' after expression}}
 }
+
+void test3(void) {
+  unknown_t a; // expected-error {{unknown type name 'unknown_t'}}
+  unknown_t *b; // expected-error {{unknown type name 'unknown_t'}}
+  unknown_t const *c; // expected-error {{unknown type name 'unknown_t'}}
+  unknown_t volatile *d; // expected-error {{unknown type name 'unknown_t'}}
+  unknown_t __attribute__ ((aligned (16))) f; // expected-error {{unknown type name 'unknown_t'}}
+  int g = unknown_t * a; // expected-error {{use of undeclared identifier 'unknown_t'}}
+}

clang/test/SemaOpenCL/intel-subgroup-avc-ext-types.cl

 // expected-error@-14 {{initializing '__private intel_sub_group_avc_ref_result_t' with an expression of incompatible type '__private float'}}
 // expected-error@-14 {{initializing '__private intel_sub_group_avc_sic_result_t' with an expression of incompatible type '__private struct st'}}
 // expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_result_single_reference_streamout_t' with an expression of incompatible type '__private void *__private'}}
 // expected-warning@-14 {{excess elements in struct initializer}}
 // expected-error@-14 {{scalar initializer cannot be empty}}
 // expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_single_reference_streamin_t' with an expression of incompatible type '__private char'}}
 // expected-error@-14 {{initializing '__private intel_sub_group_avc_ime_dual_reference_streamin_t' with an expression of incompatible type 'int'}}
 #else
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_mce_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ref_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_sic_payload_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_mce_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ref_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_sic_result_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_single_reference_streamout_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_dual_reference_streamout_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_single_reference_streamin_t'}}
-// expected-error@-28 {{use of undeclared identifier 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_mce_payload_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_payload_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ref_payload_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_sic_payload_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_mce_result_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_result_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ref_result_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_sic_result_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_result_single_reference_streamout_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_result_dual_reference_streamout_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_single_reference_streamin_t'}}
+// expected-error@-28 {{unknown type name 'intel_sub_group_avc_ime_dual_reference_streamin_t'}}
 #endif
 }
 
 // negative tests for initializers and assignment
 void far() {
   intel_sub_group_avc_mce_payload_t payload_mce;
   intel_sub_group_avc_mce_payload_t payload_mce2 = payload_mce;
   intel_sub_group_avc_ime_payload_t payload_ime;
   intel_sub_group_avc_ref_payload_t payload_ref = payload_ime;
   intel_sub_group_avc_sic_result_t result_sic;
   intel_sub_group_avc_ime_result_t result_ime;
   result_sic = result_ime;
 #ifdef EXT
 // expected-error@-5 {{initializing '__private intel_sub_group_avc_ref_payload_t' with an expression of incompatible type '__private intel_sub_group_avc_ime_payload_t'}}
 // expected-error@-3 {{assigning to '__private intel_sub_group_avc_sic_result_t' from incompatible type '__private intel_sub_group_avc_ime_result_t'}}
 #else
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_mce_payload_t'}}
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_mce_payload_t'}}
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_ime_payload_t'}}
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_ref_payload_t'}}
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_sic_result_t'}}
-// expected-error@-11 {{use of undeclared identifier 'intel_sub_group_avc_ime_result_t'}}
-// expected-error@-11 {{use of undeclared identifier 'result_sic'}} expected-error@-11 {{use of undeclared identifier 'result_ime'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_mce_payload_t'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_mce_payload_t'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_ime_payload_t'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_ref_payload_t'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_sic_result_t'}}
+// expected-error@-11 {{unknown type name 'intel_sub_group_avc_ime_result_t'}}
 #endif
 }
 
 // Using 0x0 directly allows us not to include opencl-c.h header and not to
 // redefine all of these CLK_AVC_*_INTITIALIZE_INTEL macro. '0x0' value must
 // be in sync with ones defined in opencl-c.h
 
 #ifdef EXT

clang/test/SemaOpenCL/invalid-device-enqueue-types-cl3.0.cl

 // RUN: %clang_cc1 -verify -fblocks -cl-std=CL3.0 -cl-ext=-all,+__opencl_c_device_enqueue,+__opencl_c_generic_address_space,+__opencl_c_program_scope_global_variables %s
 // RUN: %clang_cc1 -verify -fblocks -cl-std=CL3.0 -cl-ext=-__opencl_c_device_enqueue %s
 
 void f() {
   clk_event_t e;
   queue_t q;
 #ifndef __opencl_c_device_enqueue
-// expected-error@-3 {{use of undeclared identifier 'clk_event_t'}}
-// expected-error@-3 {{use of undeclared identifier 'queue_t'}}
+// expected-error@-3 {{unknown type name 'clk_event_t'}}
+// expected-error@-3 {{unknown type name 'queue_t'}}
 #else
 // expected-no-diagnostics
 #endif
 }

clang/test/SemaOpenCL/invalid-pipes-cl1.2.cl

 #if __OPENCL_C_VERSION__ > 120
 // expected-error@-2 {{OpenCL C version 3.0 does not support the 'pipe' type qualifier}}
 // expected-warning@-3 {{typedef requires a name}}
 #elif defined(__OPENCL_CPP_VERSION__)
 // expected-error@-5 {{C++ for OpenCL version 2021 does not support the 'pipe' type qualifier}}
 // expected-warning@-6 {{typedef requires a name}}
 #endif
 
 void bar(void) {
- reserve_id_t r;
-#if defined(__OPENCL_C_VERSION__)
-// expected-error@-2 {{use of undeclared identifier 'reserve_id_t'}}
-#else
-// expected-error@-4 {{unknown type name 'reserve_id_t'}}
-#endif
+ reserve_id_t r; // expected-error {{unknown type name 'reserve_id_t'}}
 }