[C89/C2x] Change the behavior of implicit int diagnostics

[aaron.ballman]

Summary

C89 allowed a type specifier to be elided with the resulting type being int, aka implicit int behavior. This feature was subsequently removed in C99 without a deprecation period, so implementations continued to support the feature. Now, as with implicit function declarations, is a good time to reevaluate the need for this support.

This patch allows -Wimplicit-int to issue warnings in C89 mode (off by default), defaults the warning to an error in C99 through C17, and disables support for the feature entirely in C2x. It also removes a warning about missing declaration specifiers that really was just an implicit int warning in disguise and other minor related cleanups.

[erichkeane]

Some quick comments... I didn't even bother opening the tests besides checking on functionality, so hopefully those are ok too :D

clang/docs/ReleaseNotes.rst

174

I find myself thinking that despite it being 'valid code' that -Wimplicit-int should be on-by-default in C89 mode. We often warn about 'valid, but non-future-proof' code, by default, particularly when they are code-breaking like this is.

clang/include/clang/Basic/LangOptions.h

534

This name seems inverse of what you mean to me? IDK if you're bike-shed-sniping me here, but:

prohibitsImplicitInt to be the reverse of above? It becomes SLIGHTLY ambiguous to me (in that we don't mean "the language standard prohibits", we mean "the compiler implementation prohibits"), but that can be fixed up with a comment.

If you want to keep the direction, perhaps implicitIntPermitted, at which point I might suggest the one above become implicitIntRequired.

clang/lib/Parse/Parser.cpp

1198

C90?

clang/lib/Sema/SemaDecl.cpp

14329

IMO there should be a warning here for C89. Warning for non-future-proof code is pretty typical.

[cor3ntin]

clang/include/clang/Basic/LangOptions.h

534

@erichkeane requiresImplicitInt is only used twice. Does it needs a name?

clang/lib/Sema/SemaDecl.cpp

14329

Isn't the counter argument that was made on similar changes that people specifically asking for C89 have peculiar expectations?
Otherwise i agree

14342–14343

Nitpick: whitespace only change

[erichkeane]

clang/include/clang/Basic/LangOptions.h

534

*shrug*, I tend to be of the feeling that if you have to say something this often, and functions are basically free, mind as well make one.

clang/lib/Sema/SemaDecl.cpp

14329

Yep, folks asking for C89 ARE peculiar :D However, warnings-not-as-error are, IMO, simply 'helpful'.

14342–14343

This might be a clang-format thing based on the previous line.

[aaron.ballman]

clang/docs/ReleaseNotes.rst

174

On the one hand, yes. On the other hand, this is only for people who specify -std=c89 explicitly (which is not the default language mode for C), and I think we've been taking the viewpoint that these folks are mostly trying to keep old, mostly unmaintained code working.

clang/include/clang/Basic/LangOptions.h

534

The idea here is that requiresImplicitInt() tells you when the support is mandatory per spec, and implicitIntEnabled() tells you when the support is either mandatory or an extension. I'm not strongly tied to the names, how do these sound?

isImplicitIntRequired() and isImplicitIntAllowed()?

(I could also add the word Support in there as in isImplicitIntSupportRequired() but then the function names start to get a bit longer than I think is reasonable.)

clang/lib/Parse/Parser.cpp

1198

I'll fix the comment up. This confusion exists all over the place. :-D

clang/lib/Sema/SemaDecl.cpp

14329

Same here as above -- we *could* warn, but I suspect it wouldn't be particularly helpful. The fact that we were warning with an extension warning was non-conforming though (we shouldn't fail -pedantic-errors in C89 over that).

14342–14343

Yeah, clang-format got a bit aggressive there, I'll be the formatting changes out, thanks!

[aaron.ballman]

Updated based on review feedback, fixed failing precommit CI issues.

[cor3ntin]

clang/include/clang/Basic/LangOptions.h

534

implicitIntEnabled makes sense to me. I guess my question is, is there precedence for options for language-mandated features?

[erichkeane]

clang/docs/ReleaseNotes.rst

174

I'm annoyed by how much I understand/agree with both sides of this argument.

clang/include/clang/Basic/LangOptions.h

534

The idea here is that requiresImplicitInt() tells you when the support is mandatory per spec, and implicitIntEnabled() tells you when the support is either mandatory or an extension. I'm not strongly tied to the names, how do these sound?

Well, as it is now, the latter tells you whether 'it is allowed as an extension'.

isImplicitIntRequired() and isImplicitIntAllowed()?

These seem pretty clear to me. I don't see 'Support' as being valuable.

clang/lib/Sema/SemaDecl.cpp

14329

*grumble grumble*.

[aaron.ballman]

clang/include/clang/Basic/LangOptions.h

534

I guess my question is, is there precedence for options for language-mandated features?

Sure, though many of them also have user-facing command line flags to set the options. (wchar_t support, digraphs, etc)

I added these as helper functions mostly because there's no way to have language options whose default value is dependent on other language options.

[aaron.ballman]

Updated based on review feedback; changes the names of the language option helper functions for clarity.

[erichkeane]

I'm happy enough. I see both sides of the C89 debate enough to 'disagree and commit' on that one.

[aaron.ballman]

Updated to fix more tests caught by precommit CI.

[rsmith]

clang/docs/ReleaseNotes.rst

173–174

Is there some fundamental reason why implicit int is harder to support in C2x (as there was for implicit function declarations, because unprototyped functions are gone), or are we merely taking the opportunity to do this because C2x is new? I find the former more easily defensible than the latter, but I suppose the fact that we removed implicit function declarations means that C2x is the first really properly breaking change that C has had, so maybe now is the time regardless.

[aaron.ballman]

clang/docs/ReleaseNotes.rst

173–174

Purely the latter -- C2x didn't make anything harder here. However, I'd like to position C23 as "not your grandfather's C" in Clang by strengthening diagnostics, especially ones related to safety or security vulnerabilities. Basically, I think it's time to cut ties with as many dangerous things that have been excised from C as possible. I think implicit int fits that goal in the same way that implicit function decls do (namely, the implicit choice can be wrong and you get surprising silent breakage at runtime if you're lucky).

(FWIW, I'm also hoping to get these sort of changes lumped into Clang 15 so that the pain of upgrading is more localized to just one release rather than strung out over several.)

[rsmith]

clang/docs/ReleaseNotes.rst

173–174

OK. I wonder our stricter interpretation of the rules in C23 onwards is something we should be calling out in our documentation as policy?

[aaron.ballman]

Precommit CI failures are down to just clang-format related ones. However, as with the implicit function declaration diagnostic, I expect there to be a long tail of failing tests which aren't caught by me locally or by the precommit CI bots. My plan is to track the bots closely whenever I do land this and fix up breakage as it's noticed. Hopefully it won't be too disruptive, but changing diagnostic behavior for ancient extensions like this turns out to be almost impossible to get a fully clean commit from in one go. (If someone wants to run this patch through their own configuration and report back failures before I land, I'm happy to make those fixes now.)

clang/docs/ReleaseNotes.rst

173–174

I'd be okay if we did that -- though, to be honest, we might want to review more of our developer policies regarding standards conformance in general, not just features removed from the language but kept as an extension. For example, I've been pretty sad about our inattention to documenting implementation-defined behaviors in Clang. "The source is our documentation" is cute for a while, but it does our users a disservice just the same, so it'd be nice to start setting policy that new implementation-defined stuff needs to be explicitly documented properly. I'm guessing we may find other such policy tweaks we'd like to make.

[aaron.ballman]

Ping for the other reviewers in case they have thoughts.

[tahonermann]

Ping for the other reviewers in case they have thoughts.

I took a gander and it all looks good to me. I added one comment regarding a test change.

clang/unittests/AST/SourceLocationTest.cpp

135–151

Perhaps preserve the prior tests (switched to Lang_C89) and then add these tests? That would ensure locations stay correct for both declaration forms.

[aaron.ballman]

Rebased and adjusted the source location AST unit test according to review feedback.

clang/unittests/AST/SourceLocationTest.cpp

135–151

Good suggestion! I've done that.

[aaron.ballman]

@rsmith -- do you have any lingering concerns about the severity of the diagnostic?

[aaron.ballman]

Assuming no further comments from reviewers, I plan to land this sometime tomorrow.

[aaron.ballman]

I've landed in 2cb2cd242ca08d0bbd2a51a41f1317442e5414fc and will keep my eyes on the bots for long tail issues from the diagnostic change.

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header("[[no_type_spec]]; // error-ok");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
-                  Diag(Main.range(), "in included file: C++ requires a "
-                                     "type specifier for all declarations"),
+                  Diag(Main.range(), "in included file: a type specifier is "
+                                     "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, DiagInTransitiveInclude) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "#include \"b.h\""},
                         {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
-                  Diag(Main.range(), "in included file: C++ requires a "
-                                     "type specifier for all declarations")));
+                  Diag(Main.range(), "in included file: a type specifier is "
+                                     "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, DiagInMultipleHeaders) {
   Annotations Main(R"cpp(
     #include $a[["a.h"]]
     #include $b[["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "no_type_spec; // error-ok"},
                         {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
-                  Diag(Main.range("a"), "in included file: C++ requires a type "
-                                        "specifier for all declarations"),
-                  Diag(Main.range("b"), "in included file: C++ requires a type "
-                                        "specifier for all declarations")));
+                  Diag(Main.range("a"), "in included file: a type specifier is "
+                                        "required for all declarations"),
+                  Diag(Main.range("b"), "in included file: a type specifier is "
+                                        "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocation) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"b.h\"\n"},
       {"b.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
-                                        "in included file: C++ requires a type "
-                                        "specifier for all declarations")));
+                                        "in included file: a type specifier is "
+                                        "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocationMacros) {
   Annotations Main(R"cpp(
     #define X
     #include "a.h"
     #undef X
     #include [["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"c.h\"\n"},
       {"b.h", "#include \"c.h\"\n"},
       {"c.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
-                  Diag(Main.range(), "in included file: C++ requires a "
-                                     "type specifier for all declarations")));
+                  Diag(Main.range(), "in included file: a type specifier is "
+                                     "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, LimitDiagsOutsideMainFile) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());

       no_type_spec_6;
       no_type_spec_7;
       no_type_spec_8;
       no_type_spec_9;
       no_type_spec_10;
       #endif)cpp"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
-                  Diag(Main.range(), "in included file: C++ requires a "
-                                     "type specifier for all declarations")));
+                  Diag(Main.range(), "in included file: a type specifier is "
+                                     "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, OnlyErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     [[no_type_spec]]; // error-ok
     int x = 5/0;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
-                  Diag(Main.range(), "in included file: C++ requires "
-                                     "a type specifier for all declarations"),
+                  Diag(Main.range(), "in included file: a type specifier is "
+                                     "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, OnlyDefaultErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]] // get unused "foo" warning when building preamble.
     )cpp");
   Annotations Header(R"cpp(

clang-tools-extra/test/clang-tidy/checkers/altera-struct-pack-align-invalid-decl-no-crash.cpp

 // RUN: %check_clang_tidy -expect-clang-tidy-error %s altera-struct-pack-align %t -- -header-filter=.*
 
 struct Foo {
   member; // no-crash
 };
-// CHECK-MESSAGES: :[[@LINE-2]]:3: error: C++ requires a type specifier for all declarations [clang-diagnostic-error]
+// CHECK-MESSAGES: :[[@LINE-2]]:3: error: a type specifier is required for all declarations [clang-diagnostic-error]

clang-tools-extra/test/clang-tidy/infrastructure/export-diagnostics.cpp

 // CHECK-MESSAGES: -input.cpp:2:1: warning: no previous prototype for function 'ff' [clang-diagnostic-missing-prototypes]
 // CHECK-MESSAGES: -input.cpp:1:19: note: expanded from macro 'X'
 // CHECK-MESSAGES: {{^}}note: expanded from here{{$}}
 // CHECK-MESSAGES: -input.cpp:2:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
 // CHECK-MESSAGES: -input.cpp:1:14: note: expanded from macro 'X'
 // CHECK-MESSAGES: -input.cpp:3:7: error: 'a' declared as an array with a negative size [clang-diagnostic-error]
 // CHECK-MESSAGES: -input.cpp:4:7: warning: zero size arrays are an extension [clang-diagnostic-zero-length-array]
 // CHECK-MESSAGES: -input.cpp:6:11: error: unknown type name 'x' [clang-diagnostic-error]
-// CHECK-MESSAGES: -input.cpp:8:3: error: C++ requires a type specifier for all declarations [clang-diagnostic-error]
+// CHECK-MESSAGES: -input.cpp:8:3: error: a type specifier is required for all declarations [clang-diagnostic-error]
 
 // CHECK-YAML: ---
 // CHECK-YAML-NEXT: MainSourceFile:  '{{.*}}-input.cpp'
 // CHECK-YAML-NEXT: Diagnostics:
 // CHECK-YAML-NEXT:   - DiagnosticName:  clang-diagnostic-missing-prototypes
 // CHECK-YAML-NEXT:     DiagnosticMessage:
 // CHECK-YAML-NEXT:       Message:         'no previous prototype for function ''ff'''
 // CHECK-YAML-NEXT:       FilePath:        '{{.*}}-input.cpp'

 // CHECK-YAML-NEXT:       Message:         'unknown type name ''x'''
 // CHECK-YAML-NEXT:       FilePath:        '{{.*}}-input.cpp'
 // CHECK-YAML-NEXT:       FileOffset:      67
 // CHECK-YAML-NEXT:       Replacements:    []
 // CHECK-YAML-NEXT:     Level:           Error
 // CHECK-YAML-NEXT:     BuildDirectory:  '{{.*}}'
 // CHECK-YAML-NEXT:   - DiagnosticName:  clang-diagnostic-error
 // CHECK-YAML-NEXT:     DiagnosticMessage:
-// CHECK-YAML-NEXT:       Message:         'C++ requires a type specifier for all declarations'
+// CHECK-YAML-NEXT:       Message:         a type specifier is required for all declarations
 // CHECK-YAML-NEXT:       FilePath:        '{{.*}}-input.cpp'
 // CHECK-YAML-NEXT:       FileOffset:      86
 // CHECK-YAML-NEXT:       Replacements:    []
 // CHECK-YAML-NEXT:     Level:           Error
 // CHECK-YAML-NEXT:     BuildDirectory:  '{{.*}}'
 // CHECK-YAML-NEXT: ...

clang/docs/ReleaseNotes.rst

- Clang now appropriately issues an error in C when a definition of a function
   function with a prototype. e.g., ``void f(int); void f() {}`` is now properly
   diagnosed.
 - The ``-Wimplicit-function-declaration`` warning diagnostic now defaults to
   an error in C99 and later. Prior to C2x, it may be downgraded to a warning
   with ``-Wno-error=implicit-function-declaration``, or disabled entirely with
   ``-Wno-implicit-function-declaration``. As of C2x, support for implicit
   function declarations has been removed, and the warning options will have no
   effect.
-
+- The ``-Wimplicit-int`` warning diagnostic now defaults to an error in C99 and
+  later. Prior to C2x, it may be downgraded to a warning with
+  ``-Wno-error=implicit-int``, or disabled entirely with ``-Wno-implicit-int``.
+  As of C2x, support for implicit int has been removed, and the warning options
+  will have no effect. Specifying ``-Wimplicit-int`` in C89 mode will now issue
+  warnings instead of being a noop.
+- No longer issue a "declaration specifiers missing, defaulting to int"
+  diagnostic in C89 mode because it is not an extension in C89, it was valid
+  code. The diagnostic has been removed entirely as it did not have a
+  diagnostic group to disable it, but it can be covered wholly by
+  ``-Wimplicit-int``.
 - ``-Wmisexpect`` warns when the branch weights collected during profiling
   conflict with those added by ``llvm.expect``.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - Improve __builtin_dump_struct:
   - Support bitfields in struct and union.
   - Improve the dump format, dump both bitwidth(if its a bitfield) and field value.

clang/include/clang/Basic/DiagnosticCommonKinds.td

def note_decl_hiding_tag_type : Note<
   "%1 %0 is hidden by a non-type declaration of %0 here">;
 def err_attribute_not_type_attr : Error<
   "%0 attribute cannot be applied to types">;
 def err_enum_template : Error<"enumeration cannot be a template">;
 
 def warn_cxx20_compat_consteval : Warning<
   "'consteval' specifier is incompatible with C++ standards before C++20">,
   InGroup<CXX20Compat>, DefaultIgnore;
-
+def warn_missing_type_specifier : Warning<
+  "type specifier missing, defaults to 'int'">,
+  InGroup<ImplicitInt>, DefaultIgnore;
 }
 
 let CategoryName = "Nullability Issue" in {
 
 def warn_nullability_duplicate : Warning<
   "duplicate nullability specifier %0">,
   InGroup<Nullability>;
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

 // Function Parameter Semantic Analysis.
 def err_param_with_void_type : Error<"argument may not have 'void' type">;
 def err_void_only_param : Error<
   "'void' must be the first and only parameter if specified">;
 def err_void_param_qualified : Error<
   "'void' as parameter must not have type qualifiers">;
 def err_ident_list_in_fn_declaration : Error<
   "a parameter list without types is only allowed in a function definition">;
-def ext_param_not_declared : Extension<
-  "parameter %0 was not declared, defaulting to type 'int'">;
+def ext_param_not_declared : ExtWarn<
+  "parameter %0 was not declared, defaults to 'int'; ISO C99 and later do not "
+  "support implicit int">, InGroup<ImplicitInt>, DefaultError;
 def err_param_default_argument : Error<
   "C does not support default arguments">;
 def err_param_default_argument_redefinition : Error<
   "redefinition of default argument">;
 def ext_param_default_argument_redefinition : ExtWarn<
   err_param_default_argument_redefinition.Text>,
   InGroup<MicrosoftDefaultArgRedefinition>;
 def err_param_default_argument_missing : Error<

 
 // Type
 def ext_wchar_t_sign_spec : ExtWarn<"'%0' cannot be signed or unsigned">,
   InGroup<DiagGroup<"signed-unsigned-wchar">>, DefaultError;
 def warn_receiver_forward_class : Warning<
   "receiver %0 is a forward class and corresponding @interface may not exist">,
   InGroup<ForwardClassReceiver>;
 def note_method_sent_forward_class : Note<"method %0 is used for the forward class">;
-def ext_missing_declspec : ExtWarn<
-  "declaration specifier missing, defaulting to 'int'">;
 def ext_missing_type_specifier : ExtWarn<
-  "type specifier missing, defaults to 'int'">,
-  InGroup<ImplicitInt>;
+  "type specifier missing, defaults to 'int'; ISO C99 and later do not support "
+  "implicit int">, InGroup<ImplicitInt>, DefaultError;
+def err_missing_type_specifier : Error<
+  "a type specifier is required for all declarations">;
 def err_decimal_unsupported : Error<
   "GNU decimal type extension not supported">;
-def err_missing_type_specifier : Error<
-  "C++ requires a type specifier for all declarations">;
 def err_objc_array_of_interfaces : Error<
   "array of interface %0 is invalid (probably should be an array of pointers)">;
 def ext_c99_array_usage : Extension<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature">, InGroup<C99>;
 def err_c99_array_usage_cxx : Error<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature, not permitted in C++">;

clang/include/clang/Basic/LangOptions.h

#include "clang/Basic/LangOptions.def"
   std::string getOpenCLVersionString() const;
 
   /// Returns true if functions without prototypes or functions with an
   /// identifier list (aka K&R C functions) are not allowed.
   bool requiresStrictPrototypes() const {
     return CPlusPlus || C2x || DisableKNRFunctions;
   }
 
+  /// Returns true if implicit int is part of the language requirements.
+  bool isImplicitIntRequired() const { return !CPlusPlus && !C99; }
+
+  /// Returns true if implicit int is supported at all.
+  bool isImplicitIntAllowed() const { return !CPlusPlus && !C2x; }
+
   /// Check if return address signing is enabled.
   bool hasSignReturnAddress() const {
     return getSignReturnAddressScope() != SignReturnAddressScopeKind::None;
   }
 
   /// Check if return address signing uses AKey.
   bool isSignReturnAddressWithAKey() const {
     return getSignReturnAddressKey() == SignReturnAddressKeyKind::AKey;

clang/include/clang/Basic/LangOptions.def

 LANGOPT(Char8             , 1, 0, "char8_t keyword")
 LANGOPT(IEEE128           , 1, 0, "__ieee128 keyword")
 LANGOPT(DeclSpecKeyword   , 1, 0, "__declspec keyword")
 BENIGN_LANGOPT(DollarIdents   , 1, 1, "'$' in identifiers")
 BENIGN_LANGOPT(AsmPreprocessor, 1, 0, "preprocessor in asm mode")
 LANGOPT(GNUMode           , 1, 1, "GNU extensions")
 LANGOPT(GNUKeywords       , 1, 1, "GNU keywords")
 VALUE_LANGOPT(GNUCVersion , 32, 0, "GNU C compatibility version")
-BENIGN_LANGOPT(ImplicitInt, 1, 0, "C89 implicit 'int'")
 LANGOPT(DisableKNRFunctions, 1, 0, "require function types to have a prototype")
 LANGOPT(Digraphs          , 1, 0, "digraphs")
 BENIGN_LANGOPT(HexFloats  , 1, 0, "C99 hexadecimal float constants")
 LANGOPT(CXXOperatorNames  , 1, 0, "C++ operator name keywords")
 LANGOPT(AppleKext         , 1, 0, "Apple kext support")
 BENIGN_LANGOPT(PascalStrings, 1, 0, "Pascal string support")
 LANGOPT(WritableStrings   , 1, 0, "writable string support")
 LANGOPT(ConstStrings      , 1, 0, "const-qualified string support")

clang/include/clang/Basic/LangStandard.h

enum LangFeatures {
   CPlusPlus11 = (1 << 6),
   CPlusPlus14 = (1 << 7),
   CPlusPlus17 = (1 << 8),
   CPlusPlus20 = (1 << 9),
   CPlusPlus2b = (1 << 10),
   Digraphs = (1 << 11),
   GNUMode = (1 << 12),
   HexFloat = (1 << 13),
-  ImplicitInt = (1 << 14),
-  OpenCL = (1 << 15),
-  HLSL = (1 << 16)
+  OpenCL = (1 << 14),
+  HLSL = (1 << 15)
 };
 
 /// LangStandard - Information about the properties of a particular language
 /// standard.
 struct LangStandard {
   enum Kind {
 #define LANGSTANDARD(id, name, lang, desc, features) \
     lang_##id,
public:
   bool hasDigraphs() const { return Flags & Digraphs; }
 
   /// isGNUMode - Language includes GNU extensions.
   bool isGNUMode() const { return Flags & GNUMode; }
 
   /// hasHexFloats - Language supports hexadecimal float constants.
   bool hasHexFloats() const { return Flags & HexFloat; }
 
-  /// hasImplicitInt - Language allows variables to be typed as int implicitly.
-  bool hasImplicitInt() const { return Flags & ImplicitInt; }
-
   /// isOpenCL - Language is a OpenCL variant.
   bool isOpenCL() const { return Flags & OpenCL; }
 
   static Kind getLangKind(StringRef Name);
   static const LangStandard &getLangStandardForKind(Kind K);
   static const LangStandard *getLangStandardForName(StringRef Name);
 };
 
 LangStandard::Kind getDefaultLanguageStandard(clang::Language Lang,
                                               const llvm::Triple &T);
 
 }  // end namespace clang
 
 #endif

clang/include/clang/Basic/LangStandards.def

 #endif
 
 #ifndef LANGSTANDARD_ALIAS_DEPR
 #define LANGSTANDARD_ALIAS_DEPR(IDENT, ALIAS) LANGSTANDARD_ALIAS(IDENT, ALIAS)
 #endif
 
 // C89-ish modes.
 LANGSTANDARD(c89, "c89",
-             C, "ISO C 1990",
-             ImplicitInt)
+             C, "ISO C 1990", 0)
 LANGSTANDARD_ALIAS(c89, "c90")
 LANGSTANDARD_ALIAS(c89, "iso9899:1990")
 
 LANGSTANDARD(c94, "iso9899:199409",
              C, "ISO C 1990 with amendment 1",
-             Digraphs | ImplicitInt)
+             Digraphs)
 
 LANGSTANDARD(gnu89, "gnu89",
              C, "ISO C 1990 with GNU extensions",
-             LineComment | Digraphs | GNUMode | ImplicitInt)
+             LineComment | Digraphs | GNUMode)
 LANGSTANDARD_ALIAS(gnu89, "gnu90")
 
 // C99-ish modes
 LANGSTANDARD(c99, "c99",
              C, "ISO C 1999",
              LineComment | C99 | Digraphs | HexFloat)
 LANGSTANDARD_ALIAS(c99, "iso9899:1999")
 LANGSTANDARD_ALIAS_DEPR(c99, "c9x")

clang/lib/Basic/LangOptions.cpp

void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang,
   Opts.CPlusPlus11 = Std.isCPlusPlus11();
   Opts.CPlusPlus14 = Std.isCPlusPlus14();
   Opts.CPlusPlus17 = Std.isCPlusPlus17();
   Opts.CPlusPlus20 = Std.isCPlusPlus20();
   Opts.CPlusPlus2b = Std.isCPlusPlus2b();
   Opts.GNUMode = Std.isGNUMode();
   Opts.GNUCVersion = 0;
   Opts.HexFloats = Std.hasHexFloats();
-  Opts.ImplicitInt = Std.hasImplicitInt();
   Opts.WChar = Std.isCPlusPlus();
   Opts.Digraphs = Std.hasDigraphs();
 
   Opts.HLSL = Lang == Language::HLSL;
 
   // Set OpenCL Version.
   Opts.OpenCL = Std.isOpenCL();
   if (LangStd == LangStandard::lang_opencl10)

clang/lib/Parse/ParseDecl.cpp

   // next token is obviously invalid for a type.  Parse these as a case
   // with an invalid type specifier.
   assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
 
   // Since we know that this either implicit int (which is rare) or an
   // error, do lookahead to try to do better recovery. This never applies
   // within a type specifier. Outside of C++, we allow this even if the
   // language doesn't "officially" support implicit int -- we support
-  // implicit int as an extension in C99 and C11.
-  if (!isTypeSpecifier(DSC) && !getLangOpts().CPlusPlus &&
+  // implicit int as an extension in some language modes.
+  if (!isTypeSpecifier(DSC) && getLangOpts().isImplicitIntAllowed() &&
       isValidAfterIdentifierInDeclarator(NextToken())) {
     // If this token is valid for implicit int, e.g. "static x = 4", then
     // we just avoid eating the identifier, so it will be parsed as the
     // identifier in the declarator.
     return false;
   }
 
   // Early exit as Sema has a dedicated missing_actual_pipe_type diagnostic

clang/lib/Parse/Parser.cpp

 Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D,
                                       const ParsedTemplateInfo &TemplateInfo,
                                       LateParsedAttrList *LateParsedAttrs) {
   // Poison SEH identifiers so they are flagged as illegal in function bodies.
   PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true);
   const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
 
-  // If this is C90 and the declspecs were completely missing, fudge in an
+  // If this is C89 and the declspecs were completely missing, fudge in an
   // implicit int.  We do this here because this is the only place where
   // declaration-specifiers are completely optional in the grammar.
-  if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) {
+  if (getLangOpts().isImplicitIntRequired() && D.getDeclSpec().isEmpty()) {
+    Diag(D.getIdentifierLoc(), diag::warn_missing_type_specifier)
+        << D.getDeclSpec().getSourceRange();
     const char *PrevSpec;
     unsigned DiagID;
     const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
     D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int,
                                            D.getIdentifierLoc(),
                                            PrevSpec, DiagID,
                                            Policy);
     D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin());

clang/lib/Sema/SemaDecl.cpp

 
   return New;
 }
 
 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
                                            SourceLocation LocAfterDecls) {
   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
 
-  // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
-  // for a K&R function.
+  // C99 6.9.1p6 "If a declarator includes an identifier list, each declaration
+  // in the declaration list shall have at least one declarator, those
+  // declarators shall only declare identifiers from the identifier list, and
+  // every identifier in the identifier list shall be declared.
+  //
+  // C89 3.7.1p5 "If a declarator includes an identifier list, only the
+  // identifiers it names shall be declared in the declaration list."
+  //
+  // This is why we only diagnose in C99 and later. Note, the other conditions
+  // listed are checked elsewhere.
   if (!FTI.hasPrototype) {
     for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
       --i;
       if (FTI.Params[i].Param == nullptr) {
-        SmallString<256> Code;
-        llvm::raw_svector_ostream(Code)
-            << "  int " << FTI.Params[i].Ident->getName() << ";\n";
-        Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
-            << FTI.Params[i].Ident
-            << FixItHint::CreateInsertion(LocAfterDecls, Code);
+        if (getLangOpts().C99) {
+          SmallString<256> Code;
+          llvm::raw_svector_ostream(Code)
+              << "  int " << FTI.Params[i].Ident->getName() << ";\n";
+          Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
+              << FTI.Params[i].Ident
+              << FixItHint::CreateInsertion(LocAfterDecls, Code);
+        }
 
         // Implicitly declare the argument as type 'int' for lack of a better
         // type.
         AttributeFactory attrs;
         DeclSpec DS(attrs);
         const char* PrevSpec; // unused
         unsigned DiagID; // unused
         DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
                            DiagID, Context.getPrintingPolicy());
         // Use the identifier location for the type source range.
         DS.SetRangeStart(FTI.Params[i].IdentLoc);
         DS.SetRangeEnd(FTI.Params[i].IdentLoc);
         Declarator ParamD(DS, DeclaratorContext::KNRTypeList);
         ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
         FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);

clang/lib/Sema/SemaType.cpp

 
     // Unspecified typespec defaults to int in C90.  However, the C90 grammar
     // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
     // type-qualifier, or storage-class-specifier.  If not, emit an extwarn.
     // Note that the one exception to this is function definitions, which are
     // allowed to be completely missing a declspec.  This is handled in the
     // parser already though by it pretending to have seen an 'int' in this
     // case.
-    if (S.getLangOpts().ImplicitInt) {
-      // In C89 mode, we only warn if there is a completely missing declspec
-      // when one is not allowed.
-      if (DS.isEmpty()) {
-        S.Diag(DeclLoc, diag::ext_missing_declspec)
-            << DS.getSourceRange()
-            << FixItHint::CreateInsertion(DS.getBeginLoc(), "int");
-      }
+    if (S.getLangOpts().isImplicitIntRequired()) {
+      S.Diag(DeclLoc, diag::warn_missing_type_specifier)
+          << DS.getSourceRange()
+          << FixItHint::CreateInsertion(DS.getBeginLoc(), "int");
     } else if (!DS.hasTypeSpecifier()) {
       // C99 and C++ require a type specifier.  For example, C99 6.7.2p2 says:
       // "At least one type specifier shall be given in the declaration
       // specifiers in each declaration, and in the specifier-qualifier list in
       // each struct declaration and type name."
-      if (S.getLangOpts().CPlusPlus && !DS.isTypeSpecPipe()) {
+      if (!S.getLangOpts().isImplicitIntAllowed() && !DS.isTypeSpecPipe()) {
         S.Diag(DeclLoc, diag::err_missing_type_specifier)
             << DS.getSourceRange();
 
-        // When this occurs in C++ code, often something is very broken with the
-        // value being declared, poison it as invalid so we don't get chains of
+        // When this occurs, often something is very broken with the value
+        // being declared, poison it as invalid so we don't get chains of
         // errors.
         declarator.setInvalidType(true);
       } else if (S.getLangOpts().getOpenCLCompatibleVersion() >= 200 &&
                  DS.isTypeSpecPipe()) {
         S.Diag(DeclLoc, diag::err_missing_actual_pipe_type)
             << DS.getSourceRange();
         declarator.setInvalidType(true);
       } else {
+        assert(S.getLangOpts().isImplicitIntAllowed() &&
+               "implicit int is disabled?");
         S.Diag(DeclLoc, diag::ext_missing_type_specifier)
-          << DS.getSourceRange();
+            << DS.getSourceRange()
+            << FixItHint::CreateInsertion(DS.getBeginLoc(), "int");
       }
     }
 
     LLVM_FALLTHROUGH;
   case DeclSpec::TST_int: {
     if (DS.getTypeSpecSign() != TypeSpecifierSign::Unsigned) {
       switch (DS.getTypeSpecWidth()) {
       case TypeSpecifierWidth::Unspecified:

clang/test/Analysis/PR49642.c

-// RUN: %clang_analyze_cc1 -Wno-implicit-function-declaration -w -verify %s \
+// RUN: %clang_analyze_cc1 -Wno-implicit-function-declaration -Wno-implicit-int -w -verify %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=apiModeling.StdCLibraryFunctions
 
 // expected-no-diagnostics
 
 typedef ssize_t;
 b;
 

clang/test/Analysis/inline-unique-reports.c

-// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -o %t > /dev/null 2>&1
+// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference -analyzer-output=plist -Wno-error=implicit-int -o %t > /dev/null 2>&1
 // RUN: %normalize_plist <%t | diff -ub %S/Inputs/expected-plists/inline-unique-reports.c.plist -
 
 static inline bug(int *p) {
   *p = 0xDEADBEEF;
 }
 
 void test_bug_1(void) {
   int *p = 0;

clang/test/Analysis/malloc.c

-// RUN: %clang_analyze_cc1 -Wno-strict-prototypes -analyzer-store=region -verify %s \
+// RUN: %clang_analyze_cc1 -Wno-strict-prototypes -Wno-error=implicit-int -analyzer-store=region -verify %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=alpha.deadcode.UnreachableCode \
 // RUN:   -analyzer-checker=alpha.core.CastSize \
 // RUN:   -analyzer-checker=unix \
 // RUN:   -analyzer-checker=debug.ExprInspection
 
 #include "Inputs/system-header-simulator.h"
 

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p2.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s -std=c++11
 
 struct S {
   virtual ~S();
 
   void g() throw (auto(*)()->int);
 
   // Note, this is not permitted: conversion-declarator cannot have a trailing return type.
   // FIXME: don't issue the second diagnostic for this.
-  operator auto(*)()->int(); // expected-error{{'auto' not allowed in conversion function type}} expected-error {{C++ requires a type specifier}}
+  operator auto(*)()->int(); // expected-error{{'auto' not allowed in conversion function type}} expected-error {{a type specifier is required}}
 };
 
 typedef auto Fun(int a) -> decltype(a + a);
 typedef auto (*PFun)(int a) -> decltype(a + a);
 
 void g(auto (*f)() -> int) {
   try { }
   catch (auto (&f)() -> int) { }

clang/test/CXX/drs/dr2xx.cpp

   A::type i1;
   B::type i2;
   C::type i3;
 
   struct A a;
   struct B b; // expected-error {{typedef 'B' cannot be referenced with a struct specifier}}
   struct C c; // expected-error {{typedef 'C' cannot be referenced with a struct specifier}}
 
-  B::B() {} // expected-error {{requires a type specifier}}
+  B::B() {} // expected-error {{a type specifier is required}}
   B::A() {} // ok
   C::~C() {} // expected-error {{destructor cannot be declared using a typedef 'dr298::C' (aka 'const dr298::A') of the class name}}
 
   typedef struct D E; // expected-note {{here}}
   struct E {}; // expected-error {{conflicts with typedef}}
 
   struct F {
     ~F();

clang/test/CXX/drs/dr4xx.cpp

 
   namespace N {
     struct D;
     typedef D DT; // expected-note {{here}}
   }
   struct N::DT {}; // expected-error {{conflicts with typedef}}
 
   typedef struct {
-    S(); // expected-error {{requires a type}}
+    S(); // expected-error {{a type specifier is required}}
   } S;
 }
 
 namespace dr485 { // dr485: yes
   namespace N {
     struct S {};
     int operator+(S, S);
     template<typename T> int f(S);

clang/test/CXX/drs/dr5xx.cpp

namespace dr522 { // dr522: yes
   template<typename T> void b2a(volatile T *S::* const *); // expected-note {{candidate template ignored: deduced type 'volatile int *dr522::S::*const *' of 1st parameter does not match adjusted type 'int *dr522::S::**' of argument}}
 
   template<typename T> struct Base {};
   struct Derived : Base<int> {};
   template<typename T> void b3(Base<T>);
   template<typename T> void b3(Base<T> *);
 
   void test(int n, const int cn, int **p, int *S::*pm) {
-    int *a[3], *S::*am[3]; 
+    int *a[3], *S::*am[3];
     const Derived cd = Derived();
     Derived d[3];
 
     b1(n);
     b1(cn);
     b2(p);
     b2(pm);
     b2(a);
#if __cplusplus >= 201103L
   constexpr C x = c();
 #endif
 }
 
 // dr537: na
 // dr538: na
 
 // dr539: yes
-const dr539( // expected-error {{requires a type specifier}}
+const dr539( // expected-error {{a type specifier is required}}
     const a) { // expected-error {{unknown type name 'a'}}
-  const b; // expected-error {{requires a type specifier}}
+  const b; // expected-error {{a type specifier is required}}
   new const; // expected-error {{expected a type}}
   try {} catch (const n) {} // expected-error {{unknown type name 'n'}}
   try {} catch (const) {} // expected-error {{expected a type}}
-  if (const n = 0) {} // expected-error {{requires a type specifier}}
-  switch (const n = 0) {} // expected-error {{requires a type specifier}}
-  while (const n = 0) {} // expected-error {{requires a type specifier}}
-  for (const n = 0; // expected-error {{requires a type specifier}}
-       const m = 0; ) {} // expected-error {{requires a type specifier}}
-  sizeof(const); // expected-error {{requires a type specifier}}
+  if (const n = 0) {} // expected-error {{a type specifier is required}}
+  switch (const n = 0) {} // expected-error {{a type specifier is required}}
+  while (const n = 0) {} // expected-error {{a type specifier is required}}
+  for (const n = 0; // expected-error {{a type specifier is required}}
+       const m = 0; ) {} // expected-error {{a type specifier is required}}
+  sizeof(const); // expected-error {{a type specifier is required}}
   struct S {
-    const n; // expected-error {{requires a type specifier}}
+    const n; // expected-error {{a type specifier is required}}
     operator const(); // expected-error {{expected a type}}
   };
 #if __cplusplus >= 201103L
   int arr[3];
   // FIXME: The extra braces here are to avoid the parser getting too
   // badly confused when recovering here. We should fix this recovery.
   { for (const n // expected-error {{unknown type name 'n'}} expected-note {{}}
          : arr) ; {} } // expected-error +{{}}
-  (void) [](const) {}; // expected-error {{requires a type specifier}}
+  (void) [](const) {}; // expected-error {{a type specifier is required}}
   (void) [](const n) {}; // expected-error {{unknown type name 'n'}}
   enum E : const {}; // expected-error {{expected a type}}
   using T = const; // expected-error {{expected a type}}
   auto f() -> const; // expected-error {{expected a type}}
 #endif
 }
 
 namespace dr540 { // dr540: yes

 
 // dr584: na
 
 namespace dr585 { // dr585: yes
   template<typename> struct T;
   struct A {
     friend T;
 #if __cplusplus <= 201402L
-    // expected-error@-2 {{requires a type specifier}} expected-error@-2 {{can only be classes or functions}}
+    // expected-error@-2 {{a type specifier is required}} expected-error@-2 {{can only be classes or functions}}
 #else
     // expected-error@-4 {{use of class template 'T' requires template arguments; argument deduction not allowed in friend declaration}}
     // expected-note@-7 {{here}}
 #endif
     // FIXME: It's not clear whether the standard allows this or what it means,
     // but the DR585 writeup suggests it as an alternative.
     template<typename U> friend T<U>; // expected-error {{must use an elaborated type}}
   };
   template<template<typename> class T> struct B {
     friend T;
 #if __cplusplus <= 201402L
-    // expected-error@-2 {{requires a type specifier}} expected-error@-2 {{can only be classes or functions}}
+    // expected-error@-2 {{a type specifier is required}} expected-error@-2 {{can only be classes or functions}}
 #else
     // expected-error@-4 {{use of template template parameter 'T' requires template arguments; argument deduction not allowed in friend declaration}}
     // expected-note@-6 {{here}}
 #endif
     template<typename U> friend T<U>; // expected-error {{must use an elaborated type}}
   };
 }
 

clang/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp

 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
 // RUN:            -DTEST=10 -DEXPORT=export -DMODULE_NAME='z [[maybe_unused]]'
 
 EXPORT module MODULE_NAME;
 #if TEST == 4
 // expected-error@-2 {{redefinition of module 'x'}}
 // [e-mail]:* {{loaded from '{{.*[/\\]}}x.pcm'}}
 #elif TEST == 7
-// expected-error@-5 {{expected ';'}} expected-error@-5 {{requires a type specifier}}
+// expected-error@-5 {{expected ';'}} expected-error@-5 {{a type specifier is required}}
 #elif TEST == 9
 // expected-warning@-7 {{unknown attribute 'fancy' ignored}}
 #elif TEST == 10
 // expected-error-re@-9 {{'maybe_unused' attribute cannot be applied to a module{{$}}}}
 #elif TEST == 1
 // expected-error@-11 {{definition of module 'z' is not available}}
 #else
 // expected-no-diagnostics
 #endif

clang/test/CXX/temp/p3.cpp

 // RUN: %clang_cc1 -verify %s
 
 template<typename T> struct S {
   static int a, b;
 };
 
 template<typename T> int S<T>::a, S<T>::b; // expected-error {{can only declare a single entity}}
 
 template<typename T> struct A { static A a; } A<T>::a; // expected-error {{expected ';' after struct}} \
                                                           expected-error {{use of undeclared identifier 'T'}}
 
 template<typename T> struct B { } f(); // expected-error {{expected ';' after struct}} \
-                                          expected-error {{requires a type specifier}}
+                                          expected-error {{a type specifier is required}}
 
 template<typename T> struct C { } // expected-error {{expected ';' after struct}}
 
 A<int> c;

clang/test/CXX/temp/temp.deduct.guide/p3.cpp

 A(long) -> A<int>;
 template<typename T = int> A(long) -> A<char>; // ok, non-template beats template as usual
 
 // (Pending DR) The template-name shall name a class template.
 template<typename T> using B = A<T>; // expected-note {{template}}
 B() -> B<int>; // expected-error {{cannot specify deduction guide for alias template 'B'}}
 // FIXME: expected-error@-1 {{declarator requires an identifier}}
 template<typename T> int C;
-C() -> int; // expected-error {{requires a type specifier}}
+C() -> int; // expected-error {{a type specifier is required}}
 template<typename T> void D();
-D() -> int; // expected-error {{requires a type specifier}}
+D() -> int; // expected-error {{a type specifier is required}}
 template<template<typename> typename TT> struct E { // expected-note 2{{template}}
   // FIXME: Should only diagnose this once!
   TT(int) -> TT<int>; // expected-error 2{{cannot specify deduction guide for template template parameter 'TT'}} expected-error {{requires an identifier}}
 };
 
 A(int) -> int; // expected-error {{deduced type 'int' of deduction guide is not a specialization of template 'A'}}
 template<typename T> A(T) -> B<T>; // expected-error {{deduced type 'B<T>' (aka 'A<type-parameter-0-0>') of deduction guide is not written as a specialization of template 'A'}}
 template<typename T> A(T*) -> const A<T>; // expected-error {{deduced type 'const A<T>' of deduction guide is not a specialization of template 'A'}}

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

 // RUN: %clang_cc1 -verify %s
 
 template <class T> struct Base {
   // expected-note@-1 2{{member type 'Base<int>' found by ambiguous name lookup}}
   // expected-note@-2 2{{member type 'Base<char>' found by ambiguous name lookup}}
   static void f();
-}; 
+};
 
 struct X0 { };
 
 template <class T> struct Derived: Base<int>, Base<char> {
   typename Derived::Base b;  // expected-error{{member 'Base' found in multiple base classes of different types}}
   typename Derived::Base<double> d;  // OK
 
   void g(X0 *t) {
     t->Derived::Base<T>::f();
     t->Base<T>::f();
     t->Base::f(); // expected-error{{member 'Base' found in multiple base classes of different types}} \
     // expected-error{{no member named 'f' in 'X0'}}
   }
 };
 
 namespace PR6717 {
   template <typename T>
   class WebVector {
   } // expected-error {{expected ';' after class}}
 
     WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \
-                                                expected-error{{requires a type specifier}}
+                                                expected-error{{a type specifier is required}}
 
   template <typename C>
   WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}}
 }

clang/test/CodeGen/2002-07-14-MiscTests2.c

 // RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
 
 
 // Test ?: in function calls
-extern fp(int, char*);
+extern void fp(int, char*);
 char *Ext;
 void
 __bb_exit_func (void)
 {
   fp (12, Ext ? Ext : "<none>");
 }
 
 

clang/test/CodeGen/2003-08-20-vfork-bug.c

 // RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
 
 extern int vfork(void);
-test() {
+void test() {
   vfork();
 }

clang/test/CodeGen/2007-04-24-bit-not-expr.c

 // PR 1346
 // RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
-extern bar(void *);
+extern void bar(void *);
 
 void f(void *cd) {
   bar(((void *)((unsigned long)(cd) ^ -1)));
 }

clang/test/CodeGen/2007-09-26-Alignment.c

 // RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
-extern p(int *);
+extern void p(int *);
 int q(void) {
   // CHECK: alloca i32, align 16
   int x __attribute__ ((aligned (16)));
   p(&x);
   return x;
 }

clang/test/CodeGen/2010-07-14-ref-off-end.c

 // RUN: %clang_cc1 -no-opaque-pointers %s -emit-llvm -triple i386-apple-darwin -o - | FileCheck %s
 extern void abort(void);
 extern void exit(int);
 struct T
 {
 unsigned i:8;
 unsigned c:24;
 };
-f(struct T t)
+int f(struct T t)
 {
 struct T s[1];
 s[0]=t;
 return(char)s->c;
 }
-main(void)
+int main(void)
 {
 // CHECK:  getelementptr inbounds [1 x %struct.T], [1 x %struct.T]* %s, i32 0, i32 0
 // CHECK:  getelementptr inbounds [1 x %struct.T], [1 x %struct.T]* %s, i32 0, i32 0
 struct T t;
 t.i=0xff;
 t.c=0xffff11;
 if(f(t)!=0x11)abort();
 exit(0);
 }

clang/test/CodeGen/mips-clobber-reg.c

 // RUN: %clang -target mipsel-unknown-linux -S -o - -emit-llvm %s
 
 /*
     This checks that the frontend will accept both
     enumerated and symbolic Mips register names.
 
     Includes:
     - GPR
     - FPU
     - MSA
 
     Any bad names will make the frontend choke.
  */
 
-main(void)
+int main(void)
 {
 
     __asm__ __volatile__ (".set noat \n\t addi $7,$at,77":::"at");
     __asm__ __volatile__ ("addi $7,$v0,77":::"v0");
     __asm__ __volatile__ ("addi $7,$v1,77":::"v1");
     __asm__ __volatile__ ("addi $7,$a0,77":::"a0");
     __asm__ __volatile__ ("addi $7,$a1,77":::"a1");
     __asm__ __volatile__ ("addi $7,$a2,77":::"a2");

clang/test/CodeGen/mips-vector-arg.c

 // RUN: %clang_cc1 -triple mipsel-unknown-linux -O3 -S -o - -emit-llvm %s | FileCheck %s -check-prefix=O32
 // RUN: %clang_cc1 -triple mips64el-unknown-linux -O3 -S -target-abi n64 -o - -emit-llvm %s | FileCheck %s -check-prefix=N64
 
 // check that
 // 1. vector arguments are passed in integer registers
 // 2. argument alignment is no larger than 8-byte for O32 and 16-byte for N64.
 
 typedef float  v4sf __attribute__ ((__vector_size__ (16)));
 typedef int v4i32 __attribute__ ((__vector_size__ (16)));
 
 // O32: define{{.*}} void @test_v4sf(i32 inreg noundef %a1.coerce0, i32 inreg noundef %a1.coerce1, i32 inreg noundef %a1.coerce2, i32 inreg noundef %a1.coerce3, i32 noundef signext %a2, i32 %0, i32 inreg noundef %a3.coerce0, i32 inreg noundef %a3.coerce1, i32 inreg noundef %a3.coerce2, i32 inreg noundef %a3.coerce3) local_unnamed_addr [[NUW:#[0-9]+]]
-// O32: declare i32 @test_v4sf_2(i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 noundef signext, i32, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef)
+// O32: declare void @test_v4sf_2(i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 noundef signext, i32, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef)
 // N64: define{{.*}} void @test_v4sf(i64 inreg noundef %a1.coerce0, i64 inreg noundef %a1.coerce1, i32 noundef signext %a2, i64 %0, i64 inreg noundef %a3.coerce0, i64 inreg noundef %a3.coerce1) local_unnamed_addr [[NUW:#[0-9]+]]
-// N64: declare signext i32 @test_v4sf_2(i64 inreg noundef, i64 inreg noundef, i32 noundef signext, i64, i64 inreg noundef, i64 inreg noundef)
-extern test_v4sf_2(v4sf, int, v4sf);
+// N64: declare void @test_v4sf_2(i64 inreg noundef, i64 inreg noundef, i32 noundef signext, i64, i64 inreg noundef, i64 inreg noundef)
+extern void test_v4sf_2(v4sf, int, v4sf);
 void test_v4sf(v4sf a1, int a2, v4sf a3) {
   test_v4sf_2(a3, a2, a1);
 }
 
 // O32: define{{.*}} void @test_v4i32(i32 inreg noundef %a1.coerce0, i32 inreg noundef %a1.coerce1, i32 inreg noundef %a1.coerce2, i32 inreg noundef %a1.coerce3, i32 noundef signext %a2, i32 %0, i32 inreg noundef %a3.coerce0, i32 inreg noundef %a3.coerce1, i32 inreg noundef %a3.coerce2, i32 inreg noundef %a3.coerce3) local_unnamed_addr [[NUW]]
-// O32: declare i32 @test_v4i32_2(i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 noundef signext, i32, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef)
+// O32: declare void @test_v4i32_2(i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 noundef signext, i32, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef, i32 inreg noundef)
 // N64: define{{.*}} void @test_v4i32(i64 inreg noundef %a1.coerce0, i64 inreg noundef %a1.coerce1, i32 noundef signext %a2, i64 %0, i64 inreg noundef %a3.coerce0, i64 inreg noundef %a3.coerce1) local_unnamed_addr [[NUW]]
-// N64: declare signext i32 @test_v4i32_2(i64 inreg noundef, i64 inreg noundef, i32 noundef signext, i64, i64 inreg noundef, i64 inreg noundef)
-extern test_v4i32_2(v4i32, int, v4i32);
+// N64: declare void @test_v4i32_2(i64 inreg noundef, i64 inreg noundef, i32 noundef signext, i64, i64 inreg noundef, i64 inreg noundef)
+extern void test_v4i32_2(v4i32, int, v4i32);
 void test_v4i32(v4i32 a1, int a2, v4i32 a3) {
   test_v4i32_2(a3, a2, a1);
 }
 
 // O32: attributes [[NUW]] = { nounwind{{.*}} }
 
 // N64: attributes [[NUW]] = { nounwind{{.*}} }

clang/test/Driver/cxx_for_opencl.clcpp

 // RUN: %clang %s -Xclang -verify -fsyntax-only
 // RUN: %clang %s -cl-std=clc++ -Xclang -verify -fsyntax-only
 // RUN: %clang %s -cl-std=cl2.0 -Xclang -verify -fsyntax-only
 // RUN: %clang %s -### 2>&1 | FileCheck %s
 
 // CHECK: "-x" "clcpp"
 
 #ifdef __OPENCL_CPP_VERSION__
 //expected-no-diagnostics
 #endif
 
 kernel void k(){
   auto a = get_local_id(1);
 #ifndef __OPENCL_CPP_VERSION__
 //expected-error@-2{{OpenCL C version 2.0 does not support the 'auto' storage class specifier}}
-//expected-warning@-3{{type specifier missing, defaults to 'int'}}
+//expected-error@-3{{type specifier missing, defaults to 'int'}}
 #endif
 }

clang/test/FixIt/fixit.c

 // CHECK: struct s s0 = { .y = 5 };
 struct s s0 = { y: 5 }; // expected-warning {{GNU old-style}}
 
 // CHECK: int array0[5] = { [3] = 3 };
 int array0[5] = { [3] 3 }; // expected-warning {{GNU 'missing ='}}
 
 // CHECK: int x
 // CHECK: int y
-void f1(x, y) // expected-warning 2{{defaulting to type 'int'}}
+void f1(x, y) // expected-error 2{{was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
 {
 }
 
 int i0 = { 17 };
 
 #define ONE 1
 #define TWO 2
 
 int test_cond(int y, int fooBar) { // expected-note {{here}}
 // CHECK: int x = y ? 1 : 4+fooBar;
   int x = y ? 1 4+foobar; // expected-error {{expected ':'}} expected-error {{undeclared identifier}} expected-note {{to match}}
 // CHECK: x = y ? ONE : TWO;
   x = y ? ONE TWO; // expected-error {{':'}} expected-note {{to match}}
   return x;
 }
 
 // CHECK: const typedef int int_t;
 const typedef typedef int int_t; // expected-warning {{duplicate 'typedef'}}
 
 // <rdar://problem/7159693>
-enum Color { 
+enum Color {
   Red // expected-error{{missing ',' between enumerators}}
   Green = 17 // expected-error{{missing ',' between enumerators}}
   Blue,
 };
 
 // rdar://9295072
 struct test_struct {
   // CHECK: struct test_struct *struct_ptr;

clang/test/Frontend/fixed_point_errors.c

void CheckSuffixOnIntegerLiterals(void) {
   long_fract_int = 0x10lr;  // expected-error{{invalid suffix 'lr' on integer constant}}
 
   u_short_fract_int = 0x10uhr; // expected-error{{invalid suffix 'uhr' on integer constant}}
   u_fract_int = 0x10ur;        // expected-error{{invalid suffix 'ur' on integer constant}}
   u_long_fract_int = 0x10ulr;  // expected-error{{invalid suffix 'ulr' on integer constant}}
 
   // Using auto
   auto auto_fract = 0r;  // expected-error{{invalid suffix 'r' on integer constant}}
-                         // expected-warning@-1{{type specifier missing, defaults to 'int'}}
+                         // expected-error@-1{{type specifier missing, defaults to 'int'}}
   auto auto_accum = 0k;  // expected-error{{invalid suffix 'k' on integer constant}}
-                         // expected-warning@-1{{type specifier missing, defaults to 'int'}}
+                         // expected-error@-1{{type specifier missing, defaults to 'int'}}
 }
 
 // Ok conversions
 int i_const = -2.5hk;
 _Sat short _Accum sat_sa_const2 = 256.0k;
 _Sat unsigned short _Accum sat_usa_const = -1.0hk;
 short _Accum sa_const3 = 2;
 short _Accum sa_const4 = -2;

clang/test/Frontend/fixed_point_not_enabled.c

 // RUN: %clang_cc1 -x c -verify %s
 
 // Primary fixed point types
 signed short _Accum s_short_accum;    // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 signed _Accum s_accum;                // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 signed long _Accum s_long_accum;      // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned short _Accum u_short_accum;  // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned _Accum u_accum;              // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned long _Accum u_long_accum;    // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 
 // Aliased fixed point types
 short _Accum short_accum;             // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 _Accum accum;                         // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
-                                      // expected-warning@-1{{type specifier missing, defaults to 'int'}}
+                                      // expected-error@-1{{type specifier missing, defaults to 'int'}}
 long _Accum long_accum;               // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 
 // Cannot use fixed point suffixes
 int accum_int = 10k;     // expected-error{{invalid suffix 'k' on integer constant}}
 int fract_int = 10r;     // expected-error{{invalid suffix 'r' on integer constant}}
 float accum_flt = 10.0k; // expected-error{{invalid suffix 'k' on floating constant}}
 float fract_flt = 10.0r; // expected-error{{invalid suffix 'r' on floating constant}}

clang/test/Frontend/system-header-line-directive.c

 // RUN: %clang_cc1 -Wall %s -I %S/Inputs -isystem %S/Inputs/SystemHeaderPrefix -verify
 // RUN: %clang_cc1 %s -E -o - -I %S/Inputs -isystem %S/Inputs/SystemHeaderPrefix | FileCheck %s
 #include <noline.h>
 #include <line-directive-in-system.h>
 
-// expected-warning@line-directive.h:* {{type specifier missing, defaults to 'int'}}
+// expected-error@line-directive.h:* {{type specifier missing, defaults to 'int'}}
 #include "line-directive.h"
 
 // This tests that "#line" directives in system headers preserve system
 // header-ness just like GNU line markers that don't have filenames.  This was
 // PR30752.
 
 // CHECK: # {{[0-9]+}} "{{.*}}system-header-line-directive.c" 2
 // CHECK: # 1 "{{.*}}noline.h" 1 3

clang/test/Index/reparsed-live-issue.cpp

 // RUN: env CINDEXTEST_EDITING=1 LIBCLANG_DISABLE_CRASH_RECOVERY=1 c-index-test -test-load-source-reparse 2 none -remap-file-0=%S/Inputs/reparse-issue.h,%S/Inputs/reparse-issue.h-0 -remap-file-1=%S/Inputs/reparse-issue.h,%S/Inputs/reparse-issue.h-1 -- %s 2>&1 | FileCheck %s
 #include "Inputs/reparse-issue.h"
 
-// CHECK: reparse-issue.h:4:1:{1:1-1:1}: error: C++ requires a type specifier for all declarations
+// CHECK: reparse-issue.h:4:1:{1:1-1:1}: error: a type specifier is required for all declarations

clang/test/Misc/warning-flags.c

(2) It prevents us adding new warnings to Clang that have no -W flag.  All
     new warnings should have -W flags.
 
     If you add a new warning without a flag, this test will fail.  To fix
     this test, simply add a warning group to that warning.
 
 
 The list of warnings below should NEVER grow.  It should gradually shrink to 0.
 
-CHECK: Warnings without flags (67):
+CHECK: Warnings without flags (66):
 
 CHECK-NEXT:   ext_expected_semi_decl_list
 CHECK-NEXT:   ext_explicit_specialization_storage_class
-CHECK-NEXT:   ext_missing_declspec
 CHECK-NEXT:   ext_missing_whitespace_after_macro_name
 CHECK-NEXT:   ext_new_paren_array_nonconst
 CHECK-NEXT:   ext_plain_complex
 CHECK-NEXT:   ext_template_arg_extra_parens
 CHECK-NEXT:   ext_typecheck_cond_incompatible_operands
 CHECK-NEXT:   ext_typecheck_ordered_comparison_of_pointer_integer
 CHECK-NEXT:   ext_using_undefined_std
 CHECK-NEXT:   pp_invalid_string_literal

 CHECK-NEXT:   warn_undef_interface
 CHECK-NEXT:   warn_undef_interface_suggest
 CHECK-NEXT:   warn_undef_protocolref
 CHECK-NEXT:   warn_weak_identifier_undeclared
 CHECK-NEXT:   warn_weak_import
 
 The list of warnings in -Wpedantic should NEVER grow.
 
-CHECK: Number in -Wpedantic (not covered by other -W flags): 27
+CHECK: Number in -Wpedantic (not covered by other -W flags): 26

clang/test/Modules/malformed-overload.m

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fsyntax-only -I%S/Inputs/malformed-overload -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Wno-strict-prototypes -verify %s
-NSLog(@"%@", path); // expected-error {{expected parameter declarator}} expected-error {{expected ')'}} expected-warning {{type specifier missing}} expected-warning {{incompatible redeclaration}} expected-note {{to match this '('}} expected-note {{'NSLog' is a builtin with type}}
+NSLog(@"%@", path); // expected-error {{expected parameter declarator}} expected-error {{expected ')'}} expected-error {{type specifier missing}} expected-warning {{incompatible redeclaration}} expected-note {{to match this '('}} expected-note {{'NSLog' is a builtin with type}}
 #import "X.h"
 
 @class NSString;
 void f(NSString *a) {
  NSLog(@"***** failed to get URL for %@", a);
 }

clang/test/Modules/va_list.m

 // REQUIRES: x86-registered-target
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
-// RUN:     -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \
+// RUN:     -fmodules-ignore-macro=PREFIX -DPREFIX -Wno-error=implicit-int -I %S/Inputs/va_list \
 // RUN:     -x objective-c-header %s -o %t.pch -emit-pch
 
 // Include the pch, as a basic correctness check.
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
-// RUN:     -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \
+// RUN:     -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -Wno-error=implicit-int -include-pch %t.pch \
 // RUN:     -x objective-c %s -fsyntax-only
 
 // Repeat the previous emit-pch, but not we will have a global module index.
 // For some reason, this results in an identifier for __va_list_tag being
 // emitted into the pch.
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
-// RUN:     -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \
+// RUN:     -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list -Wno-error=implicit-int \
 // RUN:     -x objective-c-header %s -o %t.pch -emit-pch
 
 // Include the pch, which now has __va_list_tag in it, which needs to be merged.
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
-// RUN:     -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \
+// RUN:     -fmodules-ignore-macro=PREFIX -Wno-error=implicit-int -I %S/Inputs/va_list -include-pch %t.pch \
 // RUN:     -x objective-c %s -fsyntax-only
 
 // rdar://18039719
 
 #ifdef PREFIX
 @import va_list_b;
 #endif

clang/test/PCH/decl-in-prototype.c

 // Test that we serialize the enum decl in the function prototype somehow.
 // These decls aren't serialized quite the same way as parameters.
 
 // Test this without pch.
 // RUN: %clang_cc1 -include %s -emit-llvm -o - %s | FileCheck %s
 
 // Test with pch.
 // RUN: %clang_cc1 -emit-pch -o %t %s
 // RUN: %clang_cc1 -include-pch %t -emit-llvm -o - %s | FileCheck %s
 
 // CHECK-LABEL: define {{.*}}i32 @main()
 // CHECK:   ret i32 1
 
 #ifndef HEADER
 #define HEADER
 
-static inline __attribute__((always_inline)) f(enum { x, y } p) {
+static inline __attribute__((always_inline)) int f(enum { x, y } p) {
   return y;
 }
 
 #else
 
 int main(void) {
   return f(0);
 }
 
 #endif

clang/test/Parser/altivec.c

vector signed long int v_sli;       // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // novsx-error@-2 {{cannot use 'long' with '__vector'}}
 vector unsigned long int v_uli;     // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // aix-error@-1 {{cannot use 'long' with '__vector'}}
                                     // novsx-error@-2 {{cannot use 'long' with '__vector'}}
 
 // These should have warnings.
 __vector long double  vv_ld;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld;           // expected-error {{cannot use 'long double' with '__vector'}}
-vector bool v_b;                    // expected-warning {{type specifier missing, defaults to 'int'}}
-vector __bool v___b;                // expected-warning {{type specifier missing, defaults to 'int'}}
+vector bool v_b;                    // expected-error {{type specifier missing, defaults to 'int'}}
+vector __bool v___b;                // expected-error {{type specifier missing, defaults to 'int'}}
 
 // These should have errors.
 #ifndef __VSX__
 __vector double vv_d1;               // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 vector double v_d2;                  // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 __vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 __vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}

clang/test/Parser/attributes.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s -pedantic -std=c99 -Wno-strict-prototypes
 
 int __attribute__(()) x;
 
 __inline void __attribute__((__always_inline__, __nodebug__))
 foo(void) {
 }
 
 
-__attribute__(()) y;   // expected-warning {{defaults to 'int'}}
+__attribute__(()) y;   // expected-error {{type specifier missing, defaults to 'int'}}
 
 // PR2796
 int (__attribute__(()) *z)(long y);
 
 
 void f1(__attribute__(()) int x);
 
 int f2(y, __attribute__(()) x);     // expected-error {{expected identifier}}
 
 // This is parsed as a normal argument list (with two args that are implicit
 // int) because the __attribute__ is a declspec.
-void f3(__attribute__(()) x,  // expected-warning {{defaults to 'int'}}
-        y);               // expected-warning {{defaults to 'int'}}
+void f3(__attribute__(()) x,  // expected-error {{type specifier missing, defaults to 'int'}}
+        y);               // expected-error {{type specifier missing, defaults to 'int'}}
 
 void f4(__attribute__(()));   // expected-error {{expected parameter declarator}}
 
 
 // This is ok, the __attribute__ applies to the pointer.
 int baz(int (__attribute__(()) *x)(long y));
 
 void g1(void (*f1)(__attribute__(()) int x));
 void g2(int (*f2)(y, __attribute__(()) x));    // expected-error {{expected identifier}}
-void g3(void (*f3)(__attribute__(()) x, int y));  // expected-warning {{defaults to 'int'}}
+void g3(void (*f3)(__attribute__(()) x, int y));  // expected-error {{type specifier missing, defaults to 'int'}}
 void g4(void (*f4)(__attribute__(())));  // expected-error {{expected parameter declarator}}
 
 
 void (*h1)(void (*f1)(__attribute__(()) int x));
 void (*h2)(int (*f2)(y, __attribute__(()) x));    // expected-error {{expected identifier}}
 
-void (*h3)(void (*f3)(__attribute__(()) x));   // expected-warning {{defaults to 'int'}}
+void (*h3)(void (*f3)(__attribute__(()) x));   // expected-error {{type specifier missing, defaults to 'int'}}
 void (*h4)(void (*f4)(__attribute__(())));  // expected-error {{expected parameter declarator}}
 
 
 
 // rdar://6131260
 int foo42(void) {
   int x, __attribute__((unused)) y, z;
   return 0;

clang/test/Parser/backtrack-off-by-one.cpp

 template <typename T> class A {};
 
 // expected-error@+1 {{expected '{' after base class list}}
 template <typename T> class B : T // not ',' or '{'
 #if __cplusplus < 201103L
 // expected-error@+8 {{expected ';' after top level declarator}}
 #endif
 #if __cplusplus <= 201402L
-// expected-error@+5 {{C++ requires a type specifier for all declarations}}
+// expected-error@+5 {{a type specifier is required for all declarations}}
 #else
 // expected-error@+3 {{expected unqualified-id}}
 #endif
 // expected-error@+1 {{expected ';' after class}}
 A<int> {
 };

clang/test/Parser/c2x-attributes.c

 [[]] void f1(void);
 void [[]] f2(void);
 void f3 [[]] (void);
 void f4(void) [[]];
 
 void f5(int i [[]], [[]] int j, int [[]] k);
 
 void f6(a, b) [[]] int a; int b; { // notc2x-error {{an attribute list cannot appear here}} \
-                                      c2x-warning 2 {{type specifier missing, defaults to 'int'}} \
+                                      c2x-error {{unknown type name 'a'}} \
+                                      c2x-error {{unknown type name 'b'}} \
                                       c2x-error {{expected ';' after top level declarator}} \
                                       c2x-error {{expected identifier or '('}}
 }
 
 // FIXME: technically, an attribute list cannot appear here, but we currently
 // parse it as part of the return type of the function, which is reasonable
 // behavior given that we *don't* want to parse it as part of the K&R parameter
 // declarations. It is disallowed to avoid a parsing ambiguity we already
 // handle well.
-int (*f7(a, b))(int, int) [[]] int a; int b; { // c2x-warning 2 {{type specifier missing, defaults to 'int'}} \
+int (*f7(a, b))(int, int) [[]] int a; int b; { // c2x-error {{unknown type name 'a'}} \
+                                                  c2x-error {{unknown type name 'b'}} \
                                                   c2x-error {{expected ';' after top level declarator}} \
                                                   c2x-error {{expected identifier or '('}}
 
   return 0;
 }
 
 [[]] int a, b;
 int c [[]], d [[]];

clang/test/Parser/c2x-func-prototype.c

 // RUN: %clang_cc1 -fsyntax-only -verify=c2x -std=c2x %s
 // RUN: %clang_cc1 -Wno-strict-prototypes -fsyntax-only -verify -std=c17 %s
 // expected-no-diagnostics
 
 // Functions with an identifier list are not supported in C2x.
 void ident_list(a) // c2x-error {{expected ';' after top level declarator}} \
-                      c2x-warning {{type specifier missing, defaults to 'int'}}
+                      c2x-error {{unknown type name 'a'}}
   int a;
 {}                 // c2x-error {{expected identifier or '('}}
 
 // Functions with an empty parameter list are supported as though the function
 // was declared with a parameter list of (void). Ensure they still parse.
 void no_param_decl();
 void no_param_defn() {}
 void (*var_of_type_with_no_param)();
 typedef void fn();

clang/test/Parser/colon-colon-parentheses.cpp

void foo() {
   a = ::(g);  // expected-error{{expected unqualified-id}}
   a = ::(h;  // expected-error{{expected unqualified-id}}
   a = ::i;
 }
 
 // The following tests used to be crash bugs.
 
 // PR21815
-// expected-error@+2{{C++ requires a type specifier for all declarations}}
+// expected-error@+2{{a type specifier is required for all declarations}}
 // expected-error@+1{{expected unqualified-id}}
 a (::( ));
 
 ::((c )); // expected-error{{expected unqualified-id}}
 
 // PR26623
 int f1(::(B) p); // expected-error {{expected unqualified-id}} expected-error {{use of undeclared identifier 'B'}}
 
 int f2(::S::(C) p); // expected-error {{expected unqualified-id}} expected-error {{use of undeclared identifier 'C'}}

clang/test/Parser/cxx-altivec.cpp

 vector double v_d2;                  // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 __vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 __vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 vector __bool long long v_bll4;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 #endif
 __vector long double  vv_ld3;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld4;           // expected-error {{cannot use 'long double' with '__vector'}}
-vector bool v_b;                     // expected-error {{C++ requires a type specifier for all declarations}}
+// FIXME: why is this diagnostic different from the others?
+vector bool v_b;                     // expected-error {{a type specifier is required for all declarations}}
 vector bool float v_bf;              // expected-error {{cannot use 'float' with '__vector bool'}}
 vector bool double v_bd;             // expected-error {{cannot use 'double' with '__vector bool'}}
 vector bool pixel v_bp;              // expected-error {{cannot use '__pixel' with '__vector bool'}}
 vector bool signed char v_bsc;       // expected-error {{cannot use 'signed' with '__vector bool'}}
 vector bool unsigned int v_bsc2;     // expected-error {{cannot use 'unsigned' with '__vector bool'}}
 vector bool long v_bl;               // expected-error {{cannot use 'long' with '__vector bool'}}
 vector __bool float v___bf;          // expected-error {{cannot use 'float' with '__vector bool'}}
 vector __bool double v___bd;         // expected-error {{cannot use 'double' with '__vector bool'}}

clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp

 // RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 // Test parsing of constraint-expressions in cases where the grammar is
 // ambiguous with the expectation that the longest token sequence which matches
 // the syntax is consumed without backtracking.
 
 // type-specifier-seq in conversion-type-id
 template <typename T> requires T::operator short
-unsigned int foo(); // expected-error {{C++ requires a type specifier for all declarations}}
+unsigned int foo(); // expected-error {{a type specifier is required for all declarations}}
 No newline at end of file

clang/test/Parser/cxx-decl.cpp

 y::a a1;
 y:a a2;  // expected-error {{unexpected ':' in nested name specifier}}
 y::a a3 = a2;
 
 // Some valid colons:
 void foo() {
 y:  // label
   y::a s;
-  
   int a = 4;
   a = a ? a : a+1;
 }
 
 struct b : y::a {};
 
 template <typename T>
 class someclass {
-  
   int bar() {
     T *P;
     return 1 ? P->x : P->y;
   }
 };
 
 class asm_class_test {
   void foo() __asm__("baz");
 };
 
 enum { fooenum = 1, };
 #if __cplusplus <= 199711L
 // expected-error@-2 {{commas at the end of enumerator lists are a C++11 extension}}
 #endif
 
 struct a {
   int Type : fooenum;
 };
 
 void test(struct Type *P) {
   int Type;
   Type = 1 ? P->Type : Type;
-  
   Type = (y:b) 4;   // expected-error {{unexpected ':' in nested name specifier}}
   Type = 1 ? (
               (y:b)  // expected-error {{unexpected ':' in nested name specifier}}
               4) : 5;
 }
 
 struct test4 {
   int x  // expected-error {{expected ';' at end of declaration list}}

 
 typedef Class1<Class2> Type1;
 
 // rdar : // 8307865
 struct CodeCompleteConsumer {
 };
 
 void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}}
-} 
+}
 
 ;
 
 // PR4111
 void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}}
 
 // PR9903
 struct S {

 
 namespace rdar37099386 {
   class A typename A; // expected-error {{expected a qualified name after 'typename'}}
   // expected-error@-1 {{cannot combine with previous 'class' declaration specifier}}
 }
 
 // PR8380
 extern ""      // expected-error {{unknown linkage language}}
-test6a { ;// expected-error {{C++ requires a type specifier for all declarations}}
+test6a { ;// expected-error {{a type specifier is required for all declarations}}
 #if __cplusplus <= 199711L
 // expected-error@-2 {{expected ';' after top level declarator}}
 #else
 // expected-error@-4 {{expected expression}}
 // expected-note@-5 {{to match this}}
 #endif
-  
   int test6b;
 #if __cplusplus >= 201103L
 // expected-error@+3 {{expected}}
 // expected-error@-3 {{expected ';' after top level declarator}}
 #endif
 

clang/test/Parser/cxx-keyword-identifiers.cpp

 void test() {
   // FIXME: we shoud improve the dianostics for the following cases.
   int case; // expected-error {{expected unqualified-id}}
   struct X {
     int case; // expected-error {{expected member name or ';'}}
   };
 }
 struct Foo {
-  void bar(*decltype(1) aux); // expected-error {{C++ requires a type specifier for all declarations}}. \
+  void bar(*decltype(1) aux); // expected-error {{a type specifier is required for all declarations}}. \
                                  // expected-error {{expected ')'}} expected-note {{to match this '('}}
 };

clang/test/Parser/cxx-template-decl.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp17 -std=gnu++1z %s
 
 
 
 // Errors
 export class foo { };   // expected-error {{expected template}}
-template  x;            // expected-error {{C++ requires a type specifier for all declarations}} \
+template  x;            // expected-error {{a type specifier is required for all declarations}} \
                         // expected-error {{does not refer}}
 export template x;      // expected-error {{expected '<' after 'template'}}
 export template<class T> class x0; // expected-warning {{exported templates are unsupported}}
 template < ;            // expected-error {{expected template parameter}} \
 // expected-error{{expected ',' or '>' in template-parameter-list}} \
 // expected-error {{declaration does not declare anything}}
 template <int +> struct x1; // expected-error {{expected ',' or '>' in template-parameter-list}}
 

 template <template <typename> class = foo> class TTP3; // expected-error{{must be a class template}}
 template <template <typename X, typename Y> class T> class TTP5;
 
 // Forward declarations with non-type params
 template <int> class NTP0;
 template <int N> class NTP1;
 template <int N = 5> class NTP2;
 template <int = 10> class NTP3;
-template <unsigned int N = 12u> class NTP4; 
+template <unsigned int N = 12u> class NTP4;
 template <unsigned int = 12u> class NTP5;
 template <unsigned = 15u> class NTP6;
 template <typename T, T Obj> class NTP7;
 
 // Template class declarations
 template <typename T> struct A { };
 template <typename T, typename U> struct B { };
 

 void shadow7();
 
 // PR8302
 template<template<typename> class T> struct shadow8 { // expected-note{{template parameter is declared here}}
   template<template<typename> class T> struct inner; // expected-error{{declaration of 'T' shadows template parameter}}
 };
 
 // Non-type template parameters in scope
-template<int Size> 
+template<int Size>
 void f(int& i) {
   i = Size;
  #ifdef DELAYED_TEMPLATE_PARSING
-  Size = i; 
+  Size = i;
  #else
   Size = i; // expected-error{{expression is not assignable}}
  #endif
 }
 
 template<typename T>
 const T& min(const T&, const T&);
 

 template <> struct SS<int> { }; // expected-error{{explicit specialization of non-template struct 'SS'}}
 template <> union UU<int> { }; // expected-error{{explicit specialization of non-template union 'UU'}}
 
 namespace PR6184 {
   namespace N {
     template <typename T>
     void bar(typename T::x);
   }
-  
   template <typename T>
   void N::bar(typename T::x) { }
 }
 
 // This PR occurred only in template parsing mode.
 namespace PR17637 {
 template <int>
 struct L {

 
 
 template <int>
 struct L {
   template <typename T>
   struct O {
     template <typename U>
     static oneT Fun(U);
-    
   };
 };
 template <int k>
 template <typename T>
 template <typename U>
 oneT L<k>::O<T>::Fun(U) { return one; }
 
 template<>
 template<>
 template<typename U>
 oneT L<0>::O<char>::Fun(U) { return one; }
 
 
-void Instantiate() { 
-  sassert(sizeof(L<0>::O<int>::Fun(0)) == sizeof(one)); 
+void Instantiate() {
+  sassert(sizeof(L<0>::O<int>::Fun(0)) == sizeof(one));
   sassert(sizeof(L<0>::O<char>::Fun(0)) == sizeof(one));
 }
 
 }
 
 namespace func_tmpl_spec_def_in_func {
 // We failed to diagnose function template specialization definitions inside
 // functions during recovery previously.

clang/test/Parser/cxx-undeclared-identifier.cpp

 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
 
 namespace ImplicitInt {
-  static a(4); // expected-error {{requires a type specifier}}
-  b(int n); // expected-error {{requires a type specifier}}
+  static a(4); // expected-error {{a type specifier is required}}
+  b(int n); // expected-error {{a type specifier is required}}
   c (*p)[]; // expected-error {{unknown type name 'c'}}
-  itn f(char *p, *q); // expected-error {{unknown type name 'itn'}} expected-error {{requires a type specifier}}
+  itn f(char *p, *q); // expected-error {{unknown type name 'itn'}} expected-error {{a type specifier is required}}
 
   struct S {
     void f();
   };
-  S::f() {} // expected-error {{requires a type specifier}}
+  S::f() {} // expected-error {{a type specifier is required}}
 }
 
 // PR7180
 int f(a::b::c); // expected-error {{use of undeclared identifier 'a'}}
 
 class Foo::Bar { // expected-error {{use of undeclared identifier 'Foo'}} \
                  // expected-error {{expected ';' after class}}

clang/test/Parser/cxx2b-lambdas.cpp

 auto L15 = []<auto> requires true noexcept {};
 auto L16 = [] [[maybe_unused]]{};
 
 auto XL0 = [] mutable constexpr mutable {};    // expected-error{{cannot appear multiple times}}
 auto XL1 = [] constexpr mutable constexpr {};  // expected-error{{cannot appear multiple times}}
 auto XL2 = []) constexpr mutable constexpr {}; // expected-error{{expected body of lambda expression}}
 auto XL3 = []( constexpr mutable constexpr {}; // expected-error{{invalid storage class specifier}} \
                                                // expected-error{{function parameter cannot be constexpr}} \
-                                               // expected-error{{C++ requires}} \
+                                               // expected-error{{a type specifier is required}} \
                                                // expected-error{{expected ')'}} \
                                                // expected-note{{to match this '('}} \
                                                // expected-error{{expected body}} \
                                                // expected-warning{{duplicate 'constexpr'}}
 
 // http://llvm.org/PR49736
 auto XL4 = [] requires true {}; // expected-error{{expected body}}
 auto XL5 = []<auto> requires true requires true {}; // expected-error{{expected body}}
 auto XL6 = []<auto> requires true noexcept requires true {}; // expected-error{{expected body}}

clang/test/Parser/declarators.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -std=c99
 
 extern int a1[];
 
 void f0(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
 void f1(int [*]);
 void f2(int [const *]);
 void f3(int [volatile const*]);
-int f4(*XX)(void); /* expected-error {{cannot return}} expected-warning {{type specifier missing, defaults to 'int'}} */
+int f4(*XX)(void); /* expected-error {{cannot return}} expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} */
 int f5(int [static]); /* expected-error {{'static' may not be used without an array size}} */
 
 char ((((*X))));
 
 void (*signal(int, void (*)(int)))(int);
 
 int aaaa, ***C, * const D, B(int);
 
float *test7(void) {
   // allows us to diagnose other bad things done with y, such as this.
   return &b.y;   // expected-warning {{incompatible pointer types returning 'int *' from a function with result type 'float *'}}
 }
 
 struct xyz test8(void) { return a; }  // a should be be marked invalid, no diag.
 
 
 // Verify that implicit int still works.
-static f;      // expected-warning {{type specifier missing, defaults to 'int'}}
-static g = 4;  // expected-warning {{type specifier missing, defaults to 'int'}}
-static h        // expected-warning {{type specifier missing, defaults to 'int'}} 
+static f;      // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+static g = 4;  // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+static h        // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
       __asm__("foo");
 
 
 struct test9 {
   int x  // expected-error {{expected ';' at end of declaration list}}
   int y;
   int z  // expected-warning {{expected ';' at end of declaration list}}
 };

clang/test/Parser/explicit-bool.cpp

struct B {
   // cxx20-warning@#3 {{incompatible with C++ standards before C++20}}
 
   // Looks like a 'constructor' of C. Actually a constructor of B.
   explicit (C)(B)(A); // #4
   // cxx17-warning@#4 {{C++20 extension}}
   // cxx20-warning@#4 {{incompatible with C++ standards before C++20}}
 
   explicit (operator+(A())) operator int(); // #5
-  // cxx17-error@#5 {{requires a type specifier}} cxx17-error@#5 {{expected ';'}}
+  // cxx17-error@#5 {{a type specifier is required}} cxx17-error@#5 {{expected ';'}}
   // cxx17-warning@#5 {{will be parsed as explicit(bool)}}
   // cxx20-warning@#5 {{incompatible with C++ standards before C++20}}
 };
 
 }

clang/test/Parser/ext-int.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // expected-error@+5{{expected ')'}}
 // expected-note@+4{{to match this '('}}
 // expected-error@+3{{expected unqualified-id}}
 // expected-error@+2{{extraneous closing brace}}
-// expected-error@+1{{C++ requires a type specifier for all declarations}}
+// expected-error@+1{{a type specifier is required for all declarations}}
 _BitInt(32} a;
 // expected-error@+2{{expected expression}}
-// expected-error@+1{{C++ requires a type specifier for all declarations}}
+// expected-error@+1{{a type specifier is required for all declarations}}
 _BitInt(32* ) b;
 // expected-error@+3{{expected '('}}
 // expected-error@+2{{expected unqualified-id}}
-// expected-error@+1{{C++ requires a type specifier for all declarations}}
+// expected-error@+1{{a type specifier is required for all declarations}}
 _BitInt{32} c;

clang/test/Parser/objc-forcollection-neg-2.m

 @end
 
 @interface MyList (BasicTest)
 - (void)compilerTestAgainst;
 @end
 
 @implementation MyList (BasicTest)
 - (void)compilerTestAgainst {
-    static i;// expected-warning {{type specifier missing, defaults to 'int'}}
+    static i;// expected-error {{type specifier missing, defaults to 'int'}}
         for (id el, elem in self)  // expected-error {{only one element declaration is allowed}}
            ++i;
         for (id el in self) 
            ++i;
   MyList<P> ***p;
         for (p in self)  // expected-error {{selector element type 'MyList<P> ***' is not a valid object}}
            ++i;
 
 }
 @end
 

clang/test/Parser/static_assert.c

 
 #ifdef TEST_SPELLING
 // Only test the C++ spelling in C mode in some of the tests, to reduce the
 // amount of diagnostics to have to check. This spelling is allowed in MS-
 // compatibility mode in C, but otherwise produces errors.
 static_assert(1, ""); // c2x-error {{expected parameter declarator}} \
                       // c2x-error {{expected ')'}} \
                       // c2x-note {{to match this '('}} \
-                      // c2x-warning {{type specifier missing, defaults to 'int'}} \
+                      // c2x-error {{a type specifier is required for all declarations}} \
                       // c2x-ms-warning {{use of 'static_assert' without inclusion of <assert.h> is a Microsoft extension}}
 #endif
 
 // We support _Static_assert as an extension in older C modes and in all C++
 // modes, but only as a pedantic warning.
 _Static_assert(1, ""); // c99-pedantic-warning {{'_Static_assert' is a C11 extension}} \
                        // cxx17-pedantic-warning {{'_Static_assert' is a C11 extension}} \
                        // cxx98-pedantic-warning {{'_Static_assert' is a C11 extension}}

clang/test/Preprocessor/macro_paste_msextensions.c

 
 // CHECK: int baz
 // CHECK: ;
 
 
 // rdar://8197149 - VC++ allows invalid token pastes: (##baz
 #define foo(x) abc(x)
 #define bar(y) foo(##baz(y))
-bar(q) // expected-warning {{type specifier missing}} expected-error {{invalid preprocessing token}} expected-error {{parameter list without types}}
+bar(q) // expected-error {{type specifier missing}} expected-error {{invalid preprocessing token}} expected-error {{parameter list without types}}
 
 // CHECK: abc(baz(q))
 
 
 #define str(x) #x
 #define collapse_spaces(a, b, c, d) str(a ## - ## b ## - ## c ## d)
 collapse_spaces(1a, b2, 3c, d4) // expected-error 4 {{invalid preprocessing token}} expected-error {{expected function body}}
 
 // CHECK: "1a-b2-3cd4"

clang/test/Sema/address_spaces.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 
 #define _AS1 __attribute__((address_space(1)))
 #define _AS2 __attribute__((address_space(2)))
 #define _AS3 __attribute__((address_space(3)))
 
 void bar(_AS2 int a); // expected-error {{parameter may not be qualified with an address space}}
 
 void foo(_AS3 float *a,
          _AS1 float b) // expected-error {{parameter may not be qualified with an address space}}
 {
-  _AS2 *x;// expected-warning {{type specifier missing, defaults to 'int'}}
+  _AS2 *x;// expected-error {{type specifier missing, defaults to 'int'}}
   _AS1 float * _AS2 *B;
 
   int _AS1 _AS2 *Y;   // expected-error {{multiple address spaces specified for type}}
   int *_AS1 _AS2 *Z;  // expected-error {{multiple address spaces specified for type}}
   int *_AS1 _AS1 *M;  // expected-warning {{multiple identical address spaces specified for type}}
 
   _AS1 int local;     // expected-error {{automatic variable qualified with an address space}}
   _AS1 int array[5];  // expected-error {{automatic variable qualified with an address space}}

clang/test/Sema/auto-type.c

void Issue53652(void) {
   volatile __auto_type vat = a;
   volatile __auto_type pvat = &a;
   restrict __auto_type rat = &a;
   _Atomic __auto_type aat1 = a;
   _Atomic __auto_type paat = &a;
 
   // GCC does not accept this either, for the same reason.
   _Atomic(__auto_type) aat2 = a; // expected-error {{'__auto_type' not allowed here}} \
-                                 // expected-warning {{type specifier missing, defaults to 'int'}}
+                                 // expected-error {{type specifier missing, defaults to 'int'}}
 
   // Ensure the types are what we expect them to be, regardless of order we
   // pass the types.
   _Static_assert(__builtin_types_compatible_p(__typeof(cat), const int), "");
   _Static_assert(__builtin_types_compatible_p(const int, __typeof(cat)), "");
   _Static_assert(__builtin_types_compatible_p(__typeof(pcat), int *const), "");
   _Static_assert(__builtin_types_compatible_p(int *const, __typeof(pcat)), "");
   _Static_assert(__builtin_types_compatible_p(__typeof(vat), volatile int), "");

clang/test/Sema/block-args.c

 // radar 7528255
 void f0(void) {
   ^(int, double d, char) {}(1, 1.34, 'a'); // expected-warning {{omitting the parameter name in a function definition is a C2x extension}} \
                                            // expected-warning {{omitting the parameter name in a function definition is a C2x extension}}
 }
 
 // rdar://problem/8962770
 void test4(void) {
-  int (^f)(void) = ^((x)) { }; // expected-warning {{type specifier missing}} expected-error {{type-id cannot have a name}}
+  int (^f)(void) = ^((x)) { }; // expected-error {{type specifier missing}} expected-error {{type-id cannot have a name}}
 }
 
 // rdar://problem/9170609
 void test5_helper(void (^)(int, int[*]));
 void test5(void) {
   test5_helper(^(int n, int array[n]) {});
 }
 

clang/test/Sema/block-literal.c

T somefunction(void) {
   return ^{printf("\nClosure\n"); };
 }
 void test2(void) {
   int x = 4;
 
   takeblock(^{ printf("%d\n", x); });
 
   while (1) {
-    takeblock(^{ 
+    takeblock(^{
         break;  // expected-error {{'break' statement not in loop or switch statement}}
         continue; // expected-error {{'continue' statement not in loop statement}}
         while(1) break;  // ok
         goto foo; // expected-error {{use of undeclared label 'foo'}}
         a: goto a;       // ok
       });
     break;
   }
 
   foo:
   takeblock(^{ x = 4; });  // expected-error {{variable is not assignable (missing __block type specifier)}}
-  __block y = 7;    // expected-warning {{type specifier missing, defaults to 'int'}}
+  __block y = 7;    // expected-error {{type specifier missing, defaults to 'int'}}
   takeblock(^{ y = 8; });
 }
 
 
-void (^test3(void))(void) { 
+void (^test3(void))(void) {
   return ^{};
 }
 
 void test4(void) {
   void (^noop)(void) = ^{};
   void (*noop2)(void) = 0;
 }
 

 
 static int global_x = 10;
 void (^global_block)(void) = ^{ printf("global x is %d\n", global_x); };
 
 typedef void (^void_block_t)(void);
 
 static const void_block_t myBlock = ^{ };
 
-static const void_block_t myBlock2 = ^ void(void) { }; 
+static const void_block_t myBlock2 = ^ void(void) { };

clang/test/Sema/c89.c

 int *restrict;
 int *__restrict;  /* expected-error {{expected identifier}} */
 
 
 /* Implicit int, always ok */
 test6(void) { return 0; }
 
 /* PR2012 */
-test7;  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */
+test7;
 
-void test8(int, x);  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */
+void test8(int, x);
 
 typedef int sometype;
-int a(sometype, y) {return 0;}  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} \
-                                   expected-warning {{omitting the parameter name in a function definition is a C2x extension}}*/
-
-
-
+int a(sometype, y) {return 0;}  /* expected-warning {{omitting the parameter name in a function definition is a C2x extension}}*/
 
-void bar (void *); 
+void bar (void *);
 void f11 (z)       /* expected-error {{may not have 'void' type}} */
-void z; 
+void z;
 { bar (&z); }
 
 typedef void T;
 void foo(T); /* typedef for void is allowed */
 
 void foo(void) {}
 
 /* PR2759 */

clang/test/Sema/crash-invalid-builtin.c

 // RUN: %clang_cc1 -triple=x86_64-apple-darwin -fsyntax-only -verify %s
 // PR23086
 
-__builtin_isinf(...); // expected-warning {{type specifier missing, defaults to 'int'}} expected-error {{ISO C requires a named parameter before '...'}} // expected-error {{cannot redeclare builtin function '__builtin_isinf'}} // expected-note {{'__builtin_isinf' is a builtin with type 'int ()'}}
+__builtin_isinf(...); // expected-error {{type specifier missing, defaults to 'int'}} expected-error {{ISO C requires a named parameter before '...'}} // expected-error {{cannot redeclare builtin function '__builtin_isinf'}} // expected-note {{'__builtin_isinf' is a builtin with type 'int ()'}}

clang/test/Sema/darwin-tls.c

 // RUN: not %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.6 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.7 %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple x86_64-apple-macosx10.7 %s 2>&1 | FileCheck %s --check-prefix TLS
 
 // RUN: not %clang_cc1 -fsyntax-only -triple arm64-apple-ios7.1 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-ios8.0 %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple arm64-apple-ios8.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: not %clang_cc1 -fsyntax-only -triple thumbv7s-apple-ios8.3 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple thumbv7s-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
-// RUN: %clang_cc1 -fsyntax-only -triple armv7-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple thumbv7s-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple armv7-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: not %clang_cc1 -fsyntax-only -triple i386-apple-ios9.0-simulator %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple i386-apple-ios10.0-simulator %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple i386-apple-ios10.0-simulator %s 2>&1 | FileCheck %s --check-prefix TLS
 
 // RUN: not %clang_cc1 -fsyntax-only -triple thumbv7k-apple-watchos1.0 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple thumbv7k-apple-watchos2.0 %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple thumbv7k-apple-watchos2.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: not %clang_cc1 -fsyntax-only -triple i386-apple-watchos2.0-simulator %s 2>&1 | FileCheck %s --check-prefix NO-TLS
-// RUN: %clang_cc1 -fsyntax-only -triple i386-apple-watchos3.0-simulator %s 2>&1 | FileCheck %s --check-prefix TLS
+// RUN: %clang_cc1 -fsyntax-only -Wno-error=implicit-int -triple i386-apple-watchos3.0-simulator %s 2>&1 | FileCheck %s --check-prefix TLS
 
 
 __thread int a;
 
 // NO-TLS: thread-local storage is not supported for the current target
 // TLS-NOT: thread-local storage is not supported for the current target
 
 wibble;

clang/test/Sema/function.c

 void g(int (*compar)()) {
 }
 
 void h();  // expected-note {{previous declaration is here}}
 void h (const char *fmt, ...) {} // expected-error{{conflicting types for 'h'}}
 
 // PR1965
 int t5(b);          // expected-error {{parameter list without types}}
-int t6(int x, g);   // expected-warning {{type specifier missing, defaults to 'int'}}
+int t6(int x, g);   // expected-error {{type specifier missing, defaults to 'int'}}
 
 int t7(, );       // expected-error {{expected parameter declarator}} expected-error {{expected parameter declarator}}
 int t8(, int a);  // expected-error {{expected parameter declarator}}
 int t9(int a, );  // expected-error {{expected parameter declarator}}
 
 
 // PR2042
 void t10(){}
 void t11(){t10(1);} // expected-warning{{too many arguments}}
 
 // PR3208
 void t12(int) {}  // c2x-warning{{omitting the parameter name in a function definition is a C2x extension}}
 
 // PR2790
 void t13() {
   return 0; // expected-error {{void function 't13' should not return a value}}
 }
 int t14() {
   return; // expected-error {{non-void function 't14' should return a value}}
 }
 
 // <rdar://problem/6097326>
-y(y) { return y; } // expected-warning{{parameter 'y' was not declared, defaulting to type 'int'}} \
-                   // expected-warning{{type specifier missing, defaults to 'int'}}
+y(y) { return y; } // expected-error{{parameter 'y' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                   // expected-error{{type specifier missing, defaults to 'int'}}
 
 
 // PR3137, <rdar://problem/6127293>
 extern int g0_3137(void);
 void f0_3137() {
   int g0_3137(void);
 }
 void f1_3137() {

clang/test/Sema/implicit-int.c

-// RUN: %clang_cc1 -fsyntax-only %s -verify -pedantic -Wno-strict-prototypes
-
-foo(void) { // expected-warning {{type specifier missing, defaults to 'int'}}
+/* RUN: %clang_cc1 -fsyntax-only -std=c89 -Wimplicit-int %s -verify -Wno-strict-prototypes
+   RUN: %clang_cc1 -fsyntax-only -std=c99 %s -verify=ext -Wno-strict-prototypes
+   RUN: %clang_cc1 -fsyntax-only -std=c2x %s -verify=unsupported
+*/
+
+foo(void) { /* expected-warning {{type specifier missing, defaults to 'int'}} \
+               ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+               unsupported-error {{a type specifier is required for all declarations}} */
   return 0;
 }
 
-y;  // expected-warning {{type specifier missing, defaults to 'int'}}
-
-// rdar://6131634
-void f((x));  // expected-warning {{type specifier missing, defaults to 'int'}}
-
+y;  /* expected-warning {{type specifier missing, defaults to 'int'}} \
+       ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+       unsupported-error {{a type specifier is required for all declarations}} */
+
+/* rdar://6131634 */
+void f((x));  /* expected-warning {{type specifier missing, defaults to 'int'}} \
+                 ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                 unsupported-error {{a type specifier is required for all declarations}} */
 
-// PR3702
+/* PR3702 */
 #define PAD(ms10) { \
     register i;     \
 }
 
 #define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */
 
 void
-h19_insline(n)  // expected-warning {{parameter 'n' was not declared, defaulting to type 'int'}}
+h19_insline(n)  /* ext-error {{parameter 'n' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                   unsupported-error {{unknown type name 'n'}} */
 {
-  ILPAD();  // expected-warning {{type specifier missing, defaults to 'int'}}
+  ILPAD();  /* expected-warning {{type specifier missing, defaults to 'int'}} \
+               ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+               unsupported-error {{a type specifier is required for all declarations}} */
+
 }
 
 struct foo {
- __extension__ __attribute__((packed)) x : 4; // expected-warning {{type specifier missing, defaults to 'int'}}
+ __extension__ __attribute__((packed)) x : 4; /* expected-warning {{type specifier missing, defaults to 'int'}} \
+                                                 ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                                                 unsupported-error {{unknown type name 'x'}} */
+
 };

clang/test/Sema/invalid-decl.c

 // RUN: %clang_cc1 %s -fsyntax-only -Wno-strict-prototypes -verify
 
 void test(void) {
     char = 4;  // expected-error {{expected identifier}}
 }
 
 
 // PR2400
-typedef xtype (*x)(void* handle); // expected-error {{function cannot return function type}} expected-warning {{type specifier missing, defaults to 'int'}} expected-warning {{type specifier missing, defaults to 'int'}}
+typedef xtype (*x)(void* handle); // expected-error {{function cannot return function type}} expected-error 2{{type specifier missing, defaults to 'int'}}
 
 typedef void ytype();
 
 
 typedef struct _zend_module_entry zend_module_entry;
 struct _zend_module_entry {
     ytype globals_size; // expected-error {{field 'globals_size' declared as a function}}
 };

clang/test/Sema/invalid-struct-init.c

 // RUN: %clang_cc1 %s -verify -fsyntax-only
 
 typedef struct _zend_module_entry zend_module_entry;
 struct _zend_module_entry {
   _efree((p)); // expected-error{{type name requires a specifier or qualifier}} \
-                  expected-warning {{type specifier missing, defaults to 'int'}}
-  
+                  expected-error {{type specifier missing, defaults to 'int'}}
 };
 typedef struct _zend_function_entry { } zend_function_entry;
 typedef struct _zend_pcre_globals { } zend_pcre_globals;
 zend_pcre_globals pcre_globals;
 
 static void zm_globals_ctor_pcre(zend_pcre_globals *pcre_globals ) { }
 static void zm_globals_dtor_pcre(zend_pcre_globals *pcre_globals ) { }
 static void zm_info_pcre(zend_module_entry *zend_module ) { }
 static int zm_startup_pcre(int type, int module_number ) { }
 
 static int zm_shutdown_pcre(int type, int module_number ) {
   zend_function_entry pcre_functions[] = {{ }; // expected-error{{expected '}'}} expected-note {{to match this '{'}}
   zend_module_entry pcre_module_entry = {
-    sizeof(zend_module_entry), 20071006, 0, 0, ((void *)0), ((void *)0),    
-    "pcre",  pcre_functions,  zm_startup_pcre,  zm_shutdown_pcre,  ((void *)0),  
-    ((void *)0),  zm_info_pcre,  ((void *)0),  sizeof(zend_pcre_globals), &pcre_globals,  
-    ((void (*)(void* ))(zm_globals_ctor_pcre)),  ((void (*)(void* ))(zm_globals_dtor_pcre)),  
-    ((void *)0),  0, 0, ((void *)0), 0 
+    sizeof(zend_module_entry), 20071006, 0, 0, ((void *)0), ((void *)0),
+    "pcre",  pcre_functions,  zm_startup_pcre,  zm_shutdown_pcre,  ((void *)0),
+    ((void *)0),  zm_info_pcre,  ((void *)0),  sizeof(zend_pcre_globals), &pcre_globals,
+    ((void (*)(void* ))(zm_globals_ctor_pcre)),  ((void (*)(void* ))(zm_globals_dtor_pcre)),
+    ((void *)0),  0, 0, ((void *)0), 0
   };
 }

clang/test/Sema/redefinition.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -Wno-strict-prototypes
 int f(int a) { return 0; } // expected-note {{previous definition is here}}
 int f(int);
 int f(int a) { return 0; } // expected-error {{redefinition of 'f'}}
 
 // <rdar://problem/6097326>
-int foo(x) {
+int foo(x) { // expected-error {{parameter 'x' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
   return 0;
 }
 int x = 1;
 
 // <rdar://problem/6880464>
 extern inline int g(void) { return 0; } // expected-note{{previous definition}}
 int g(void) { return 0; } // expected-error{{redefinition of a 'extern inline' function 'g' is not supported in C99 mode}}

clang/test/Sema/return.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wno-unreachable-code -Wno-unused-value -Wno-strict-prototypes
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -Wno-error=implicit-int -verify -fblocks -Wno-unreachable-code -Wno-unused-value -Wno-strict-prototypes
 
 // clang emits the following warning by default.
-// With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the 
+// With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the
 // following warning.
 int t14(void) {
   return; // expected-warning {{non-void function 't14' should return a value}}
 }
 
 void t15(void) {
   return 1; // expected-warning {{void function 't15' should not return a value}}
 }
case 2:
     for (;;) ;
     break;
   case 3:
     for (;1;) ;
     for (;0;) {
       goto done;
     }
     return 1;
-  case 4:    
+  case 4:
     while (0) { goto done; }
     return 1;
   case 5:
     while (1) { return 1; }
     break;
   case 6:
     fptr();
     break;
   default:
     return 1;
   }
   done: ;
 }
 
 // PR4624
 void test28() __attribute__((noreturn));
-void test28(x) { while (1) { } }
+void test28(x) { while (1) { } } // expected-warning {{parameter 'x' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
 
 void exit(int);
 int test29(void) {
   exit(1);
 }
 
 // Include these declarations here explicitly so we don't depend on system headers.
 typedef struct __jmp_buf_tag{} jmp_buf[1];

clang/test/Sema/typo-correction.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 //
 // This file contains typo correction tests which hit different code paths in C
 // than in C++ and may exhibit different behavior as a result.
 
 __typeof__(struct F*) var[invalid];  // expected-error-re {{use of undeclared identifier 'invalid'{{$}}}}
 
 void PR21656(void) {
   float x;
   x = (float)arst;  // expected-error-re {{use of undeclared identifier 'arst'{{$}}}}
 }
 
-a = b ? : 0;  // expected-warning {{type specifier missing, defaults to 'int'}} \
+a = b ? : 0;  // expected-error {{type specifier missing, defaults to 'int'}} \
               // expected-error {{use of undeclared identifier 'b'}}
 
 int foobar;  // expected-note {{'foobar' declared here}}
-new_a = goobar ?: 4; // expected-warning {{type specifier missing, defaults to 'int'}} \
+new_a = goobar ?: 4; // expected-error {{type specifier missing, defaults to 'int'}} \
                       // expected-error {{use of undeclared identifier 'goobar'; did you mean 'foobar'?}} \
                       // expected-error {{initializer element is not a compile-time constant}}
 
 struct ContainerStuct {
   enum { SOME_ENUM }; // expected-note {{'SOME_ENUM' declared here}}
 };
 
 void func(int arg) {

clang/test/Sema/warn-strict-prototypes.c

-// RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -Wno-implicit-function-declaration -verify %s
-// RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -Wno-implicit-function-declaration -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -Wno-implicit-function-declaration -Wno-error=implicit-int -verify %s
+// RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -Wno-implicit-function-declaration -Wno-error=implicit-int -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 // function definition with 0 params, no prototype, no preceding declaration.
 void foo0() {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
 // function declaration with unspecified params
 void foo1(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
              // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:11-[[@LINE-1]]:11}:"void"
 // function declaration with 0 params
int foo9(a, b) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
   return a + b;
 }
 
 // Function declaration with no types
 void foo10(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
                  expected-note {{a function declaration without a prototype is not supported in C2x}}
               // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"void"
 // K&R function definition with incomplete param list declared
-void foo10(p, p2) void *p; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void foo10(p, p2) void *p; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
+                                 expected-warning {{parameter 'p2' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
 
 void foo11(int p, int p2);
 void foo11(p, p2) int p; int p2; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 // PR31020
 void __attribute__((cdecl)) foo12(d) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
   short d;
 {}

clang/test/SemaCXX/MicrosoftSuper.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -fms-extensions -std=c++11 -verify
 
 struct Errors {
   using __super::foo; // expected-error {{'__super' cannot be used with a using declaration}}
   __super::XXX x; // expected-error {{invalid use of '__super', Errors has no base classes}} expected-error {{expected}}
 
   void foo() {
     // expected-note@+4 {{replace parentheses with an initializer to declare a variable}}
     // expected-warning@+3 {{empty parentheses interpreted as a function declaration}}
-    // expected-error@+2 {{C++ requires a type specifier for all declarations}}
+    // expected-error@+2 {{a type specifier is required for all declarations}}
     // expected-error@+1 {{use of '__super' inside a lambda is unsupported}}
     auto lambda = []{ __super::foo(); };
   }
 };
 
 struct Base1 {
   void foo(int) {}
 

clang/test/SemaCXX/PR9459.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Don't crash.
 
 template<typename>struct ae_same; // expected-note {{}}
-template<typename>struct ts{}ap() // expected-error {{expected ';' after struct}} expected-error {{requires a type specifier}}
+template<typename>struct ts{}ap() // expected-error {{expected ';' after struct}} expected-error {{a type specifier is required}}
 {ts<a>::ap<ae_same<int>::&ae_same<>>::p(a); }; // expected-error {{use of undeclared identifier 'a'}} expected-error 5{{}}

clang/test/SemaCXX/PR9460.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Don't crash.
 
 template<typename aT>
 struct basic_string{
-  a; // expected-error {{requires a type specifier}}
+  a; // expected-error {{a type specifier is required}}
   basic_string(aT*);
 };
 
 struct runtime_error{
   runtime_error(
 basic_string<char> struct{ // expected-error {{cannot combine with previous 'type-name' declaration specifier}}
-a(){ // expected-error {{requires a type specifier}}
+a(){ // expected-error {{a type specifier is required}}
   runtime_error(0);
 }
 }
 );
 };

clang/test/SemaCXX/PR9461.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Don't crash.
 
 template<typename,typename=int,typename=int>struct basic_string;
 
 typedef basic_string<char> string;
 
 
 
 template<typename aT,typename,typename oc>
 struct basic_string
 {
 int us;
 basic_string(const aT*,const oc&a=int());
 
 int _S_construct();
 
 int _S_construct(int);
 
-_S_construct(); // expected-error {{requires}}
+_S_construct(); // expected-error {{a type specifier is required}}
 };
 
 template<typename _CharT,typename _Traits,typename _Alloc>
 basic_string<_CharT,_Traits,_Alloc>::basic_string(const _CharT* c,const _Alloc&)
 :us(_S_construct)
 {string a(c);}
 
 struct runtime_error{runtime_error(string);};
 
 struct system_error:runtime_error{ // expected-note {{to match}}
 system_error():time_error("" // expected-error 3 {{expected}} expected-note {{to match}}

clang/test/SemaCXX/crashes.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // <rdar://problem/8124080>
 template<typename _Alloc> class allocator;
 template<class _CharT> struct char_traits;
-template<typename _CharT, typename _Traits = char_traits<_CharT>,            
+template<typename _CharT, typename _Traits = char_traits<_CharT>,
          typename _Alloc = allocator<_CharT> >
 class basic_string;
 template<typename _CharT, typename _Traits, typename _Alloc>
-const typename basic_string<_CharT, _Traits, _Alloc>::size_type   
+const typename basic_string<_CharT, _Traits, _Alloc>::size_type
 basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_max_size // expected-error{{no member named '_Rep' in 'basic_string<_CharT, _Traits, _Alloc>'}}
-  = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; 
+  = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
 
 // PR7118
 template<typename T>
 class Foo {
   class Bar;
   void f() {
     Bar i;
   }
void ParseBoxCornerRadii(int y) {
     int& x = dimenX.*sides;
   }
 }
 
 namespace pr16964 {
   template<typename> struct bs {
     bs();
     static int* member(); // expected-note{{possible target}}
-    member();  // expected-error{{C++ requires a type specifier for all declarations}}
-    static member();  // expected-error{{C++ requires a type specifier for all declarations}}
+    member();  // expected-error{{a type specifier is required for all declarations}}
+    static member();  // expected-error{{a type specifier is required for all declarations}}
     static int* member(int); // expected-note{{possible target}}
   };
 
   template<typename T> bs<T>::bs() { member; }  // expected-error{{did you mean to call it}}
 
   bs<int> test() {
     return bs<int>(); // expected-note{{in instantiation}}
   }
namespace pr16989 {
   };
   class C2 {
     void f();
   };
   void C2::f() {}
 }
 
 namespace pr20660 {
- appendList(int[]...);     // expected-error {{C++ requires a type specifier for all declarations}}
- appendList(int[]...) { }  // expected-error {{C++ requires a type specifier for all declarations}}
+ appendList(int[]...);     // expected-error {{a type specifier is required for all declarations}}
+ appendList(int[]...) { }  // expected-error {{a type specifier is required for all declarations}}
 }
 

clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp

 // RUN: %clang_cc1 -std=c++98 -verify -fsyntax-only -Wno-c++11-extensions -Wno-c++1y-extensions %s -DPRECXX11
 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
 
 #ifdef PRECXX11
   #define CONST const
 #else
   #define CONST constexpr
 #endif
 
-template<typename T> 
+template<typename T>
 T pi = T(3.1415926535897932385); // expected-note 2{{declared here}}
 
-template<typename T> 
+template<typename T>
 CONST T cpi = T(3.1415926535897932385); // expected-note {{template is declared here}}
 
 template<typename T> extern CONST T vc;
 #ifndef PRECXX11
 // expected-error@-2 {{constexpr variable declaration must be a definition}}
 #endif
 
 namespace use_in_top_level_funcs {
 
   void good() {
     int ipi = pi<int>;
     int icpi = cpi<int>;
     double dpi = pi<double>;
     double dcpi = cpi<double>;
   }
 
   void no_deduce() {
     // template arguments are not deduced for uses of variable templates.
     int ipi = pi; // expected-error {{use of variable template 'pi' requires template arguments}}
     int icpi = cpi; // expected-error {{use of variable template 'cpi' requires template arguments}}
   }
-  
   template<typename T>
   T circular_area(T r) {
     return pi<T> * r * r;
   }
 
   template<typename T>
   CONST T const_circular_area(T r) {
     return cpi<T> * r * r;
namespace pvt_cv {
     int v;   // expected-error {{redefinition of 'v' as different kind of symbol}}
   }
   namespace pvt_cvt {
     template<typename T> T v0; // expected-note {{previous definition is here}}
     template<typename T> T v0; // expected-error {{redefinition of 'v0'}}
 
     template<typename T> T v; // expected-note {{previous definition is here}}
     template<typename T> int v; // expected-error {{redefinition of 'v'}}
-    
     template<typename T> extern int v1; // expected-note {{previous template declaration is here}}
     template<int I> int v1;      // expected-error {{template parameter has a different kind in template redeclaration}}
   }
   namespace pvt_use {
     template<typename T> T v;
-    v = 10;  // expected-error {{C++ requires a type specifier for all declarations}}
+    v = 10;  // expected-error {{a type specifier is required for all declarations}}
   }
 
   namespace pvt_diff_params {
     template<typename T, typename> T v;   // expected-note 2{{previous template declaration is here}}
     template<typename T> T v;   // expected-error {{too few template parameters in template redeclaration}}
     template<typename T, typename, typename> T v; // expected-error {{too many template parameters in template redeclaration}}
   }
 
namespace pvt_auto {
     template<typename T> auto v2 = T();  // expected-note {{previous definition is here}}
     template<typename T> T v2;   // expected-error {{redefinition of 'v2'}}
     template<typename T> auto v3 = T();   // expected-note {{previous definition is here}}
     template<typename T> extern T v3;     // expected-error {{redeclaration of 'v3' with a different type: 'T' vs 'auto'}}
     template<typename T> auto v4 = T();
     template<typename T> extern auto v4;   // expected-error {{declaration of variable 'v4' with deduced type 'auto' requires an initializer}}
   }
 #endif
-  
 }
 
 namespace explicit_instantiation {
-  template<typename T> 
+  template<typename T>
   T pi0a = T(3.1415926535897932385);  // expected-note {{variable template 'pi0a' declared here}}
   template float pi0a<int>; // expected-error {{type 'float' of explicit instantiation of 'pi0a' does not match expected type 'int'}}
 
-  template<typename T> 
+  template<typename T>
   T pi0b = T(3.1415926535897932385);  // expected-note {{variable template 'pi0b' declared here}}
   template CONST int pi0b<int>; // expected-error {{type 'const int' of explicit instantiation of 'pi0b' does not match expected type 'int'}}
 
-  template<typename T> 
+  template<typename T>
   T pi0c = T(3.1415926535897932385);  // expected-note {{variable template 'pi0c' declared here}}
   template int pi0c<const int>;  // expected-error {{type 'int' of explicit instantiation of 'pi0c' does not match expected type 'const int'}}
 
-  template<typename T> 
+  template<typename T>
   T pi0 = T(3.1415926535897932385);
   template int pi0<int>;   // expected-note {{previous explicit instantiation is here}}
   template int pi0<int>;   // expected-error {{duplicate explicit instantiation of 'pi0<int>'}}
 
-  template<typename T> 
+  template<typename T>
   CONST T pi1a = T(3.1415926535897932385);  // expected-note {{variable template 'pi1a' declared here}}
   template int pi1a<int>; // expected-error {{type 'int' of explicit instantiation of 'pi1a' does not match expected type 'const int'}}
 
-  template<typename T> 
+  template<typename T>
   CONST T pi1b = T(3.1415926535897932385);  // expected-note {{variable template 'pi1b' declared here}}
   template int pi1b<const int>;  // expected-error {{type 'int' of explicit instantiation of 'pi1b' does not match expected type 'const const int'}}
 
-  template<typename T> 
+  template<typename T>
   CONST T pi1 = T(3.1415926535897932385);
   template CONST int pi1<int>;   // expected-note {{previous explicit instantiation is here}}
   template CONST int pi1<int>;   // expected-error {{duplicate explicit instantiation of 'pi1<int>'}}
 
 #ifndef PRECXX11
   namespace auto_var {
     template<typename T> auto var0 = T();
     template auto var0<int>;    // expected-error {{'auto' variable template instantiation is not allowed}}
-    
     template<typename T> auto var = T();
     template int var<int>;
   }
 #endif
 
   template<typename=int> int missing_args; // expected-note {{here}}
   template int missing_args; // expected-error {{must specify a template argument list}}
 
namespace good {
     template<typename T>
     CONST int pi2<T,int> = 2;
 
     template<typename T>
     CONST int pi2<int,T> = 3;
 
     template<> CONST int pi2<int,int> = 4;
 
-#ifndef PRECXX11   
+#ifndef PRECXX11
     void foo() {
       static_assert(pi2<int,int> == 4, "");
       static_assert(pi2<float,int> == 2, "");
       static_assert(pi2<int,float> == 3, "");
       static_assert(pi2<int,float> == pi2<int,double>, "");
       static_assert(pi2<float,float> == 1, "");
       static_assert(pi2<float,float> == pi2<float,double>, "");
     }
 #endif
   }
 
   namespace ambiguous {
 
     template<typename T1, typename T2>
     CONST int pi2 = 1;
 
     template<typename T>
     CONST int pi2<T,int> = 2; // expected-note {{partial specialization matches [with T = int]}}
 
     template<typename T>
     CONST int pi2<int,T> = 3; // expected-note {{partial specialization matches [with T = int]}}
-    
     void foo() {
       int a = pi2<int,int>;  // expected-error {{ambiguous partial specializations of 'pi2<int, int>'}}
     }
   }
-  
   namespace type_changes {
 
-    template<typename T> 
+    template<typename T>
     T pi0 = T(3.1415926535897932385);
 
     template<> float pi0<int> = 10;
     template<> int pi0<const int> = 10;
 
     template<typename T>
     T pi1 = T(3.1415926535897932385);
     template<> CONST int pi1<int> = 10;
#endif
     template<> int pi0<int> = 10;   // expected-error {{redefinition of 'pi0<int>'}}
     template<> CONST int pi0<int> = 10; // expected-error {{redefinition of 'pi0' with a different type: 'const int' vs 'int'}}
     template<> float pi0<int> = 10; // expected-error {{redefinition of 'pi0' with a different type: 'float' vs 'int'}}
 #ifndef PRECXX11
     template<> auto pi0<int> = 10;  // expected-error {{redefinition of 'pi0<int>'}}
 #endif
 
 
-    template<typename T> 
+    template<typename T>
     CONST T pi1 = T(3.1415926535897932385);
 
     template<> CONST int pi1<int> = 10;   // expected-note {{previous definition is here}}
     template<> CONST int pi1<int> = 10;   // expected-error {{redefinition of 'pi1<int>'}}
   }
-  
   namespace before_instantiation {
-    template<typename T> 
+    template<typename T>
     T pi0 = T(3.1415926535897932385);   // expected-note {{variable template 'pi0' declared here}}
 
     template<> int pi0<int> = 10; // expected-note 2{{previous template specialization is here}}
     template int pi0<int>;        // expected-warning {{has no effect}}
     template float pi0<int>;      // expected-error {{type 'float' of explicit instantiation of 'pi0' does not match expected type}} expected-warning {{has no effect}}
 
     template<typename T1, typename T2>
     CONST int pi2 = 1;
 
     template<typename T> CONST int pi2<T,int> = 2;
     template CONST int pi2<int,int>;
   }
   namespace after_instantiation {
-    template<typename T> 
+    template<typename T>
     T pi0 = T(3.1415926535897932385);
 
     template int pi0<int>;   // expected-note 2{{explicit instantiation first required here}}
     template<> int pi0<int> = 10; // expected-error {{explicit specialization of 'pi0' after instantiation}}
     template<> float pi0<int>;    // expected-error {{explicit specialization of 'pi0' after instantiation}}
 
     template<typename T1, typename T2>
     CONST int pi2 = 1;
namespace auto_var {
     template<> int var<int,int> = 7;
 
     void foo() {
       int i0 = var0<int,int>;
       int b = var<int,int>;
     }
   }
 #endif
-  
   namespace extern_var {
     // TODO:
   }
-  
   namespace diff_type {
     // TODO:
     template<typename T> T* var = new T();
 #ifndef PRECXX11
     template<typename T> auto var<T*> = T();  // expected-note {{previous definition is here}}
     template<typename T> T var<T*> = T();     // expected-error {{redefinition of 'var' with a different type: 'T' vs 'auto'}}
 #endif
   }

 
 #ifndef PRECXX11
 namespace arrays {
   template<typename T>
   T* arr = new T[10]{T(10), T(23)};
 
   float f = 10.5;
   template<> float* arr<float> = &f;
-  
   void bar() {
     int *iarr = arr<int>;
     iarr[0] = 1;
     iarr[2] = 3;
     iarr[6] = -2;
 
     float ff = *arr<float>;
     float nof = arr<float>[3];  // No bounds-check in C++
   }
 }
 #endif
 
 namespace nested {
-  
   namespace n0a {
-    template<typename T> 
+    template<typename T>
     T pi0a = T(3.1415926535897932385);
   }
-  
   using namespace n0a;
   int i0a = pi0a<int>;
-  
   template float pi0a<float>;
   float f0a = pi0a<float>;
-  
   template<> double pi0a<double> = 5.2;
   double d0a = pi0a<double>;
 
   namespace n0b {
-    template<typename T> 
+    template<typename T>
     T pi0b = T(3.1415926535897932385);
   }
-  
   int i0b = n0b::pi0b<int>;
-  
   template float n0b::pi0b<float>;
   float f0b = n0b::pi0b<float>;
-  
   template<> double n0b::pi0b<double> = 5.2;
   double d0b = n0b::pi0b<double>;
-  
   namespace n1 {
-    template<typename T> 
+    template<typename T>
     T pi1a = T(3.1415926535897932385); // expected-note {{explicitly specialized declaration is here}}
 #ifndef PRECXX11
 // expected-note@-2 {{explicit instantiation refers here}}
 #endif
 
-    template<typename T> 
+    template<typename T>
     T pi1b = T(3.1415926535897932385); // expected-note {{explicitly specialized declaration is here}}
 #ifndef PRECXX11
 // expected-note@-2 {{explicit instantiation refers here}}
 #endif
   }
-  
   namespace use_n1a {
     using namespace n1;
     int i1 = pi1a<int>;
 
     template float pi1a<float>;
 #ifndef PRECXX11
 // expected-error@-2 {{explicit instantiation of 'pi1a<float>' not in a namespace enclosing 'n1'}}
 #endif
     float f1 = pi1a<float>;
-    
     template<> double pi1a<double> = 5.2; // expected-error {{not in a namespace enclosing 'n1'}}
     double d1 = pi1a<double>;
   }
-  
   namespace use_n1b {
     int i1 = n1::pi1b<int>;
-    
     template float n1::pi1b<float>;
 #ifndef PRECXX11
 // expected-error@-2 {{explicit instantiation of 'pi1b<float>' not in a namespace enclosing 'n1'}}
 #endif
     float f1 = n1::pi1b<float>;
-    
     template<> double n1::pi1b<double> = 5.2;  // expected-error {{not in a namespace enclosing 'n1'}}
     double d1 = n1::pi1b<double>;
   }
 }
 
 namespace nested_name {
   template<typename T> int a; // expected-note {{variable template 'a' declared here}}
   a<int>::b c; // expected-error {{qualified name refers into a specialization of variable template 'a'}}
#ifndef PRECXX11
   static_assert(x<int> == 1, "");
 #endif
 }
 
 namespace PR19169 {
   template <typename T> int* f();
   template <typename T> void f();
   template<> int f<double>; // expected-error {{no variable template matches specialization; did you mean to use 'f' as function template instead?}}
-  
   template <typename T> void g();
   template<> int g<double>; // expected-error {{no variable template matches specialization; did you mean to use 'g' as function template instead?}}
 }
 
 #ifndef PRECXX11
 template <typename... Args> struct Variadic_t { };
 template <typename... Args> Variadic_t<Args...> Variadic;
 auto variadic1 = Variadic<>;
 auto variadic2 = Variadic<int, int>;
 #endif
 
 namespace VexingParse {
   template <typename> int var; // expected-note {{declared here}}
   int x(var); // expected-error {{use of variable template 'var' requires template arguments}}
 }

clang/test/SemaCXX/for-range-crash.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s
 
 // Ensure that we don't crash if errors are suppressed by an error limit.
 // RUN: not %clang_cc1 -fsyntax-only -std=c++17 -ferror-limit=1 %s
 
 error e; // expected-error {{unknown type name}}
 
 template <typename>
 class Bar {
   Bar<int> *variables_to_modify;
-  foo() { // expected-error {{C++ requires a type specifier for all declarations}}
+  foo() { // expected-error {{a type specifier is required for all declarations}}
     for (auto *c : *variables_to_modify)
       delete c;
   }
 };
 
 void foo() {
   int a;
   struct X; // expected-note {{forward declaration}}

clang/test/SemaCXX/implicit-int.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-x; // expected-error{{C++ requires a type specifier for all declarations}}
+x; // expected-error{{a type specifier is required for all declarations}}
 
-f(int y) { return y; } // expected-error{{C++ requires a type specifier for all declarations}}
+f(int y) { return y; } // expected-error{{a type specifier is required for all declarations}}

clang/test/SemaCXX/lambda-invalid-capture.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // Don't crash.
 
 struct g {
-  j; // expected-error {{C++ requires a type specifier for all declarations}}
+  j; // expected-error {{a type specifier is required for all declarations}}
 };
 
 void captures_invalid_type() {
   g child;
   auto q = [child]{};
   const int n = sizeof(q);
 }
 

clang/test/SemaCXX/pr18284-crash-on-invalid.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // Don't crash (PR18284).
 
 namespace n1 {
 class A { };
 class C { A a; };
 
-A::RunTest() {} // expected-error {{C++ requires a type specifier for all declarations}}
+A::RunTest() {} // expected-error {{a type specifier is required for all declarations}}
 
 void f() {
   new C;
 }
 } // namespace n1
 
 namespace n2 {
 class A { };
 class C : public A { };
 
-A::RunTest() {} // expected-error {{C++ requires a type specifier for all declarations}}
+A::RunTest() {} // expected-error {{a type specifier is required for all declarations}}
 
 void f() {
   new C;
 }
 } // namespace n2

clang/test/SemaCXX/typo-correction-delayed.cpp

 }
 
 namespace PR21947 {
 int blue;  // expected-note {{'blue' declared here}}
 __typeof blur y;  // expected-error {{use of undeclared identifier 'blur'; did you mean 'blue'?}}
 }
 
 namespace PR22092 {
-a = b ? : 0;  // expected-error {{C++ requires a type specifier for all declarations}} \
+a = b ? : 0;  // expected-error {{a type specifier is required for all declarations}} \
               // expected-error-re {{use of undeclared identifier 'b'{{$}}}}
 }
 
 extern long clock (void);
 struct Pointer {
   void set_xpos(int);
   void set_ypos(int);
 };

clang/test/SemaCXX/typo-correction.cpp

 };
 
 // Note the space before "::PR18213" is intended and needed, as it highlights
 // the actual typo, which is the leading "::".
 // TODO: Suggest removing the "::" from "::PR18213" (the right correction)
 // instead of incorrectly suggesting dropping "PR18213::WrapperInfo::".
 template <>
 PR18213::WrapperInfo ::PR18213::Wrappable<int>::kWrapperInfo = { 0 };  // expected-error {{no member named 'PR18213' in 'PR18213::WrapperInfo'; did you mean simply 'PR18213'?}} \
-                                                                       // expected-error {{C++ requires a type specifier for all declarations}}
+                                                                       // expected-error {{a type specifier is required for all declarations}}
 }
 
 namespace PR18651 {
 struct {
   int x;
 } a, b;
 
 int y = x;  // expected-error-re {{use of undeclared identifier 'x'{{$}}}}

clang/test/SemaCXX/unknown-type-name.cpp

 #if __cplusplus <= 201103L
 // expected-warning@-2 {{variable templates are a C++14 extension}}
 #endif
 
 
 // FIXME: We know which type specifier should have been specified here. Provide
 //        a fix-it to add 'typename A<T>::type'
 template<typename T>
-A<T>::g() { } // expected-error{{requires a type specifier}}
+A<T>::g() { } // expected-error{{a type specifier is required}}

clang/test/SemaObjC/protocols.m

 @protocol C < B > // expected-note{{previous definition is here}}
 @end
 @protocol A < C > 
 @end
 @protocol B < A > // expected-error{{protocol has circular dependency}}
 @end
 
 @protocol P
-- (int)test:(int)param, ..; // expected-warning{{type specifier missing}} \
+- (int)test:(int)param, ..; // expected-error{{type specifier missing}} \
                       // expected-error{{expected ';' after method prototype}}
 @end

clang/test/SemaObjCXX/crash.mm

 };
 
 @protocol InvalidProperties
 
 @property (nonatomic) (OuterType::InnerType) invalidTypeParens;
 // expected-error@-1 {{type name requires a specifier or qualifier}}
 // expected-error@-2 {{property requires fields to be named}}
 // expected-error@-3 {{expected ';' at end of declaration list}}
-// expected-error@-4 {{C++ requires a type specifier for all declarations}}
+// expected-error@-4 {{a type specifier is required for all declarations}}
 // expected-error@-5 {{cannot declare variable inside @interface or @protocol}}
 
 @property (nonatomic) (ns::InnerType) invalidTypeParens2;
 // expected-error@-1 {{type name requires a specifier or qualifier}}
 // expected-error@-2 {{property requires fields to be named}}
 // expected-error@-3 {{expected ';' at end of declaration list}}
-// expected-error@-4 {{C++ requires a type specifier for all declarations}}
+// expected-error@-4 {{a type specifier is required for all declarations}}
 // expected-error@-5 {{cannot declare variable inside @interface or @protocol}}
 
 @property (nonatomic) int OuterType::InnerType; // expected-error {{property requires fields to be named}}
 
 @property (nonatomic) int OuterType::InnerType foo; // expected-error {{property requires fields to be named}}
 // expected-error@-1 {{expected ';' at end of declaration list}}
-// expected-error@-2 {{C++ requires a type specifier for all declarations}}
+// expected-error@-2 {{a type specifier is required for all declarations}}
 // expected-error@-3 {{cannot declare variable inside @interface or @protocol}}
 
 @end

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

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all
 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all
 
 void foo(read_only pipe int p);
 #if __OPENCL_C_VERSION__ > 120
 // expected-error@-2 {{OpenCL C version 3.0 does not support the 'pipe' type qualifier}}
 // expected-error@-3 {{access qualifier can only be used for pipe and image type}}
 #elif defined(__OPENCL_CPP_VERSION__)
 // expected-error@-5 {{C++ for OpenCL version 2021 does not support the 'pipe' type qualifier}}
 // expected-error@-6 {{access qualifier can only be used for pipe and image type}}
 #else
-// expected-warning@-8 {{type specifier missing, defaults to 'int'}}
+// expected-error@-8 {{type specifier missing, defaults to 'int'}}
 // expected-error@-9 {{access qualifier can only be used for pipe and image type}}
 // expected-error@-10 {{expected ')'}} expected-note@-10 {{to match this '('}}
 #endif
 
 // 'pipe' should be accepted as an identifier.
 typedef int pipe;
 #if __OPENCL_C_VERSION__ > 120
 // expected-error@-2 {{OpenCL C version 3.0 does not support the 'pipe' type qualifier}}

clang/test/SemaTemplate/address_space-dependent.cpp

 // RUN: %clang_cc1 -x c++ -std=c++14 -fsyntax-only -verify %s
 
 template <int I, int J, int K>
 void car() {
   int __attribute__((address_space(I))) __attribute__((address_space(J))) * Y;  // expected-error {{multiple address spaces specified for type}}
   int *__attribute__((address_space(I))) __attribute__((address_space(J))) * Z; // expected-error {{multiple address spaces specified for type}}
 
   __attribute__((address_space(I))) int local;        // expected-error {{automatic variable qualified with an address space}}
   __attribute__((address_space(J))) int array[5];     // expected-error {{automatic variable qualified with an address space}}
   __attribute__((address_space(I))) int arrarr[5][5]; // expected-error {{automatic variable qualified with an address space}}
 
-  __attribute__((address_space(J))) * x; // expected-error {{C++ requires a type specifier for all declarations}}
+  __attribute__((address_space(J))) * x; // expected-error {{a type specifier is required for all declarations}}
 
   __attribute__((address_space(I))) float *B;
 
   typedef __attribute__((address_space(J))) int AS2Int;
   struct HasASFields {
     AS2Int typedef_as_field; // expected-error {{field may not be qualified with an address space}}
   };
 

 template <unsigned B> int __attribute__((address_space(B))) *same_template();
 void test_same_template() { (void) same_template<0>(); }
 
 template <unsigned A> int __attribute__((address_space(A))) *different_template(); // expected-note {{candidate function [with A = 0]}}
 template <unsigned B> int __attribute__((address_space(B+1))) *different_template(); // expected-note {{candidate function [with B = 0]}}
 void test_different_template() { (void) different_template<0>(); } // expected-error {{call to 'different_template' is ambiguous}}
 
 template <typename T> struct partial_spec_deduce_as;
-template <typename T, unsigned AS> 
+template <typename T, unsigned AS>
 struct partial_spec_deduce_as <__attribute__((address_space(AS))) T *> {
-   static const unsigned value = AS;  
-}; 
+   static const unsigned value = AS;
+};
 
-int main() {  
+int main() {
   int __attribute__((address_space(1))) * p1;
   int p = GetAddressSpaceValue(p1);
 
   car<1, 2, 3>(); // expected-note {{in instantiation of function template specialization 'car<1, 2, 3>' requested here}}
   HasASTemplateFields<1> HASTF;
   neg<-1>(); // expected-note {{in instantiation of function template specialization 'neg<-1>' requested here}}
   correct<0x7FFFEB>();
   tooBig<8388650>(); // expected-note {{in instantiation of function template specialization 'tooBig<8388650L>' requested here}}
 
   __attribute__((address_space(1))) char *x;
   __attribute__((address_space(2))) char *y;
   cmp<1, 2>(x, y); // expected-note {{in instantiation of function template specialization 'cmp<1, 2>' requested here}}
 
   fooFunction<1> ff;
   ff.get_0(); // expected-note {{in instantiation of member function 'fooFunction<1>::get_0' requested here}}
   ff.qf();
   ff.test3(); // expected-note {{in instantiation of member function 'fooFunction<1>::test3' requested here}}
-  
-  static_assert(partial_spec_deduce_as<int __attribute__((address_space(3))) *>::value == 3, "address space value has been incorrectly deduced"); 
+  static_assert(partial_spec_deduce_as<int __attribute__((address_space(3))) *>::value == 3, "address space value has been incorrectly deduced");
 
   return 0;
 }

clang/test/SemaTemplate/derived.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<typename T> class vector2 {};
 template<typename T> class vector : vector2<T> {};
 
 template<typename T> void Foo2(vector2<const T*> V) {}  // expected-note{{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'int'}}
 template<typename T> void Foo(vector<const T*> V) {} // expected-note {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'int'}}
 
 void test() {
   Foo2(vector2<int*>());  // expected-error{{no matching function for call to 'Foo2'}}
   Foo(vector<int*>());  // expected-error{{no matching function for call to 'Foo'}}
 }
 
 namespace rdar13267210 {
   template < typename T > class A {
-    BaseTy; // expected-error{{C++ requires a type specifier for all declarations}}
+    BaseTy; // expected-error{{a type specifier is required for all declarations}}
   };
 
   template < typename T, int N > class C: A < T > {};
 
   class B {
     C<long, 16> ExternalDefinitions;
     C<long, 64> &Record;
 

clang/test/SemaTemplate/temp_arg_template.cpp

 template<const int &N> struct Yref; // expected-note{{template non-type parameter has a different type 'const int &' in template argument}}
 
 namespace N {
   template<class> struct Z;
 }
 template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}}
 
 
-A<X> *a1; 
+A<X> *a1;
 A<N::Z> *a2;
 A< ::N::Z> *a3;
 
 A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 C<Y> *a7;
 C<Ylong> *a8; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 C<Yref> *a9; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 
 template<typename T> void f(int);
 
 A<f> *a9; // expected-error{{must be a class template}}
 
 // Evil digraph '<:' is parsed as '[', expect error.
 A<::N::Z> *a10;
 #if __cplusplus <= 199711L
 // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
 #endif
 
 // Do not do a digraph correction here.
 A<: :N::Z> *a11;  // expected-error{{expected expression}} \
-          expected-error{{C++ requires a type specifier for all declarations}}
+                     expected-error{{a type specifier is required for all declarations}}
 
 // PR7807
 namespace N {
-  template <typename, typename = int> 
+  template <typename, typename = int>
   struct X
   { };
 
-  template <typename ,int> 
+  template <typename ,int>
   struct Y
   { X<int> const_ref(); };
 
-  template <template<typename,int> class TT, typename T, int N> 
+  template <template<typename,int> class TT, typename T, int N>
   int operator<<(int, TT<T, N> a) { // expected-note{{candidate template ignored}}
     0 << a.const_ref(); // expected-error{{invalid operands to binary expression ('int' and 'X<int>')}}
   }
 
   void f0( Y<int,1> y){ 1 << y; } // expected-note{{in instantiation of function template specialization 'N::operator<<<N::Y, int, 1>' requested here}}
 }
 
 // PR12179

clang/test/Tooling/auto-detect-from-source-parent-of-cwd.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t/abc/def/ijk/qwe
 // RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %t/abc/def/ijk/qwe/test.cpp\",\"file\":\"%t/abc/def/ijk/qwe/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/abc/def/ijk/qwe/test.cpp"
 // RUN: ln -sf %t/abc/def %t/abc/def2
 // RUN: cd %t/abc/def2
 // RUN: env PWD="%t/abc/def" not clang-check "ijk/qwe/test.cpp" 2>&1 | FileCheck %s
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 // CHECK: /abc/def/ijk/qwe/test.cpp
 invalid;
 
 // REQUIRES: shell

clang/test/Tooling/auto-detect-from-source-parent.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t/abc/def/ijk/qwe
 // RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/abc/def/ijk/qwe/test.cpp\",\"file\":\"%/t/abc/def/ijk/qwe/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/abc/def/ijk/qwe/test.cpp"
 // RUN: not clang-check "%t/abc/def/ijk/qwe/test.cpp" 2>&1 | FileCheck %s
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-args.cpp

 // RUN: not clang-check "%s" -- -c 2>&1 | FileCheck %s
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-autodetect-dir.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t/abc/def
 // RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/test.cpp\",\"file\":\"%/t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: not clang-check -p "%t/abc/def" "%t/test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-builtin-headers.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // Add a path that doesn't exist as argv[0] for the compile command line:
 // RUN: echo '[{"directory":".","command":"/random/tool -c %t/test.cpp","file":"%t/test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: not clang-check -p "%t" "%t/test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
 #include <stddef.h>
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-chdir.cpp

 // Verifies that paths are resolved relatively to the directory specified in the
 // compilation database.
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "[{\"directory\":\"%t\",\"command\":\"clang -c test.cpp -I.\",\"file\":\"%t/test.cpp\"}]" | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: touch "%t/clang-check-test.h"
 // RUN: not clang-check -p "%t" "%t/test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
 #include "clang-check-test.h"
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-pwd.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %t/test.cpp\",\"file\":\"%t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: ln -sf %t %t.foobar
 // RUN: cd %t
 // RUN: env PWD="%t.foobar" not clang-check -p "%t" "test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 // CHECK: .foobar/test.cpp
 invalid;
 
 // REQUIRES: shell

clang/test/Tooling/clang-check-rel-path.cpp

 // This block test a compilation database with files relative to the directory
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo '[{"directory":"%t","command":"clang++ -c test.cpp","file":"test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: not clang-check -p "%t" "%t/test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check-strip-o.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo '[{"directory":".","command":"clang++ -c %t/test.cpp -o foo -ofoo","file":"%t/test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: not clang-check -p "%t" "%t/test.cpp" -extra-arg=-v 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
 // CHECK: Invocation
 // CHECK-NOT: {{ -v}}
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/clang-check.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo '[{"directory":".","command":"clang++ -c %t/test.cpp","file":"%t/test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: not clang-check -p "%t" "%t/test.cpp" 2>&1|FileCheck %s
 // FIXME: Make the above easier.
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/test/Tooling/multi-jobs.cpp

 // RUN: not clang-check "%s" -- -no-integrated-as -c 2>&1 | FileCheck %s
 // The following test uses multiple time the same '-no-integrated-as' flag in order to make sure those flags are really skipped, and not just overwritten by luck :
 // RUN: not clang-check "%s" -- -target x86_64-win32 -c -no-integrated-as -no-integrated-as -no-integrated-as 2>&1 | FileCheck %s
 
-// CHECK: C++ requires
+// CHECK: a type specifier is required
 invalid;

clang/unittests/AST/SourceLocationTest.cpp

 }
 
 TEST(LabelStmt, Range) {
   RangeVerifier<LabelStmt> Verifier;
   Verifier.expectRange(1, 12, 1, 15);
   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
 }
 
 TEST(ParmVarDecl, KNRLocation) {
   LocationVerifier<ParmVarDecl> Verifier;
   Verifier.expectLocation(1, 8);
-  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C99));
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C89));
+
+  Verifier.expectLocation(1, 15);
+  EXPECT_TRUE(Verifier.match("void f(i) int i; {}", varDecl(), Lang_C99));
 }
 
 TEST(ParmVarDecl, KNRRange) {
   RangeVerifier<ParmVarDecl> Verifier;
   Verifier.expectRange(1, 8, 1, 8);
-  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C99));
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C89));
+
+  Verifier.expectRange(1, 11, 1, 15);
+  EXPECT_TRUE(Verifier.match("void f(i) int i; {}", varDecl(), Lang_C99));
 }
 
 TEST(CXXNewExpr, ArrayRange) {
   RangeVerifier<CXXNewExpr> Verifier;
   Verifier.expectRange(1, 12, 1, 22);
   EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
 }
 
 TEST(CXXNewExpr, ParenRange) {