[RecoveryExpr]WIP: Support dependence in C-only codepath

[hokein]

Summary

This is a large patch containing all required changes, want early
feedback.

what does this patch do?

• support dependent mechanisam (only for error-recovery) in C-only codepath;
• allows building RecoveryExpr for C;
• remove all early TypoCorrection technical debet in clang;

This will be split into different patches:

• build dependent binary operator for C: https://reviews.llvm.org/D84226
• build dependent callexpr in C for error-recovery: https://reviews.llvm.org/D84304
• suppress spurious "typecheck_cond_expect_scalar" diagnostic: https://reviews.llvm.org/D84322
• suppress spurious "err_typecheck_expect_scalar_operand" diagnostic : https://reviews.llvm.org/D84387
• adjust all existing tests when enabled recovery-expr for C: https://reviews.llvm.org/D84970

TESTED: ninja check-clang

[rsmith]

Looks reasonable to me. I expect you'll find more places that need to learn how to handle dependent types in C, but this looks like a solid start.

clang/lib/AST/Expr.cpp

3757–3758

This change appears to be redundant: we handled all containsErrors() cases before the switch.

clang/lib/Sema/SemaCast.cpp

2693

Do we care about value-dependence here? Very little of C cast semantics depends on the evaluated value of the expression -- I think this only matters for null pointer constants. If we care about the value-dependent cast to pointer case, maybe we should special-case that?

(It looks like the special-case handling for OpenCL event_t will also need a value-dependence check.)

clang/lib/Sema/SemaExpr.cpp

14245–14247

This function seems dangerous: in C++, we need to perform unqualified lookups from the template definition context when creating a dependent binary operator, and it's only correct to use this if such lookup found nothing.

Perhaps you could add something to the name of the function to indicate that it should only be used when there are no unqualified lookup results?

clang/test/Sema/error-dependence.c

10

clang/test/Sema/typo-correction.c

17

I assume we're getting a redefinition error for a now. If so, can you test that uses of a after line 13 don't produce errors?

[hokein]

In D85025#2201042, @rsmith wrote:

Looks reasonable to me. I expect you'll find more places that need to learn how to handle dependent types in C, but this looks like a solid start.

Thanks! Yeah, we'd need to a detailed plan to roll this out (similar to the recovery-ast in C++) to catch possibly-missing cases.

I'll address your comments in split patches. I think the next plan is be to move forward the code reviews, Sam agreed to review those and I'll add you in the Subscribers.

clang/lib/AST/Expr.cpp

3757–3758

oh, yeah, this is an oversight during the rebase.

clang/lib/Sema/SemaExpr.cpp

14245–14247

good point, thanks! I added some comments about this method, and make it private to make it less mis-unused.

[hokein]

Thanks for @rsmith's initial comments.

This is done, all related patches have been landed in upstream, and this feature is enabled by default for all languages.

clang/include/clang/Basic/LangOptions.def

 LANGOPT(Coroutines        , 1, 0, "C++20 coroutines")
 LANGOPT(DllExportInlines  , 1, 1, "dllexported classes dllexport inline methods")
 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
 
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 
 COMPATIBLE_LANGOPT(RecoveryAST, 1, 0, "Preserve expressions in AST when encountering errors")
 COMPATIBLE_LANGOPT(RecoveryASTType, 1, 0, "Preserve the type in recovery expressions")
+COMPATIBLE_LANGOPT(CDependence, 1, 0, "Build dependent AST nodes in C for better error recovery")
 
 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")
 LANGOPT(Blocks            , 1, 0, "blocks extension to C")
 BENIGN_LANGOPT(EmitAllDecls      , 1, 0, "emitting all declarations")
 LANGOPT(MathErrno         , 1, 1, "errno in math functions")
 BENIGN_LANGOPT(HeinousExtensions , 1, 0, "extensions that we really don't like and may be ripped out at any time")
 LANGOPT(Modules           , 1, 0, "modules semantics")

clang/include/clang/Driver/Options.td

def frecovery_ast : Flag<["-"], "frecovery-ast">,
   HelpText<"Preserve expressions in AST rather than dropping them when "
            "encountering semantic errors">;
 def fno_recovery_ast : Flag<["-"], "fno-recovery-ast">;
 def frecovery_ast_type : Flag<["-"], "frecovery-ast-type">,
   HelpText<"Preserve the type for recovery expressions when possible "
           "(experimental)">;
 def fno_recovery_ast_type : Flag<["-"], "fno-recovery-ast-type">;
 
+def fc_dependence : Flag<["-"], "fc-dependence">,
+  HelpText<"Build dependent AST nodes in C for error recovery">;
+def fno_c_dependence : Flag<["-"], "fno-c-dependence">;
+
 let Group = Action_Group in {
 
 def Eonly : Flag<["-"], "Eonly">,
   HelpText<"Just run preprocessor, no output (for timings)">;
 def dump_raw_tokens : Flag<["-"], "dump-raw-tokens">,
   HelpText<"Lex file in raw mode and dump raw tokens">;
 def analyze : Flag<["-"], "analyze">,
   HelpText<"Run static analysis engine">;

clang/include/clang/Sema/Sema.h

 
 public:
   ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
                         tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
   ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
                         BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
   ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
                                 Expr *LHSExpr, Expr *RHSExpr);
+  ExprResult CreateDependentBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
+                                  Expr *LHS, Expr *RHS);
 
   void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
 
   /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
   /// in the case of a the GNU conditional expr extension.
   ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
                                 SourceLocation ColonLoc,
                                 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);

clang/lib/AST/Expr.cpp

if (isValueDependent() &&
       (!Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().MSVCCompat)) {
     // Error-dependent expr should never be a null pointer.
     if (containsErrors())
       return NPCK_NotNull;
     switch (NPC) {
     case NPC_NeverValueDependent:
       llvm_unreachable("Unexpected value dependent expression!");
     case NPC_ValueDependentIsNull:
-      if (isTypeDependent() || getType()->isIntegralType(Ctx))
+      if ((!containsErrors() && isTypeDependent()) ||
+          getType()->isIntegralType(Ctx))
         return NPCK_ZeroExpression;
       else
         return NPCK_NotNull;
 
     case NPC_ValueDependentIsNotNull:
       return NPCK_NotNull;
     }
   }

clang/lib/Frontend/CompilerInvocation.cpp

if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
     Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
                                                  << A->getValue();
     Opts.NewAlignOverride = 0;
   }
   Opts.ConceptSatisfactionCaching =
       !Args.hasArg(OPT_fno_concept_satisfaction_caching);
   if (Args.hasArg(OPT_fconcepts_ts))
     Diags.Report(diag::warn_fe_concepts_ts_flag);
+  Opts.CDependence =
+      Args.hasFlag(OPT_fc_dependence, OPT_fno_c_dependence, true);
   // Recovery AST still heavily relies on dependent-type machinery.
   Opts.RecoveryAST =
-      Args.hasFlag(OPT_frecovery_ast, OPT_fno_recovery_ast, Opts.CPlusPlus);
+      Args.hasFlag(OPT_frecovery_ast, OPT_fno_recovery_ast, true);
   Opts.RecoveryASTType =
       Args.hasFlag(OPT_frecovery_ast_type, OPT_fno_recovery_ast_type, false);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
   Opts.InstantiationDepth =
       getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);

clang/lib/Parse/ParseExpr.cpp

 //===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
if (!LHS.isInvalid()) {
           CondOp = Actions.CreateRecoveryExpr(LHS.get()->getBeginLoc(),
                                               RHS.get()->getEndLoc(), Args);
         }
 
         LHS = CondOp;
       }
       // In this case, ActOnBinOp or ActOnConditionalOp performed the
       // CorrectDelayedTyposInExpr check.
-      if (!getLangOpts().CPlusPlus)
+      if (!getLangOpts().CPlusPlus && !Actions.Context.getLangOpts().CDependence)
         continue;
     }
 
     // Ensure potential typos aren't left undiagnosed.
     if (LHS.isInvalid()) {
       Actions.CorrectDelayedTyposInExpr(OrigLHS);
       Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
       Actions.CorrectDelayedTyposInExpr(RHS);

clang/lib/Sema/SemaCast.cpp

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

clang/lib/Sema/SemaExpr.cpp

 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaFixItUtils.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/SaveAndRestore.h"
 using namespace clang;
 using namespace sema;
 using llvm::RoundingMode;
 
 /// Determine whether the use of this declaration is valid, without
 /// emitting diagnostics.
if (CallingNDeclIndirectly && !checkAddressOfFunctionIsAvailable(
       return ExprError();
 
     if (getLangOpts().OpenCL && checkOpenCLDisabledDecl(*FD, *Fn))
       return ExprError();
 
     checkDirectCallValidity(*this, Fn, FD, ArgExprs);
   }
 
+  if (getLangOpts().CDependence &&
+      (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs))) {
+    assert(!getLangOpts().CPlusPlus);
+    assert(Fn->containsErrors() ||
+           llvm::any_of(ArgExprs,
+                        [](clang::Expr *E) { return E->containsErrors(); }) &&
+               "should only occur in error-recovery path.");
+    return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
+                            VK_RValue, RParenLoc, CurFPFeatureOverrides());
+  }
+
   return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
                                ExecConfig, IsExecConfig);
 }
 
 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
 ///
 /// __builtin_astype( value, dst type )
 ///
TheCall = CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config),
                                          Args, ResultTy, VK_RValue, RParenLoc,
                                          CurFPFeatureOverrides(), NumParams);
   } else {
     TheCall =
         CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue, RParenLoc,
                          CurFPFeatureOverrides(), NumParams, UsesADL);
   }
 
-  if (!getLangOpts().CPlusPlus) {
+  if (!getLangOpts().CPlusPlus && !getLangOpts().CDependence) {
     // Forget about the nulled arguments since typo correction
     // do not handle them well.
     TheCall->shrinkNumArgs(Args.size());
     // C cannot always handle TypoExpr nodes in builtin calls and direct
     // function calls as their argument checking don't necessarily handle
     // dependent types properly, so make sure any TypoExprs have been
     // dealt with.
     ExprResult Result = CorrectDelayedTyposInExpr(TheCall);
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
 
   // C++ is sufficiently different to merit its own checker.
   if (getLangOpts().CPlusPlus)
     return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
 
   VK = VK_RValue;
   OK = OK_Ordinary;
 
+  if (getLangOpts().CDependence &&
+      (Cond.get()->isTypeDependent() || LHS.get()->isTypeDependent() ||
+       RHS.get()->isTypeDependent())) {
+    assert(!getLangOpts().CPlusPlus);
+    assert(Cond.get()->containsErrors() || LHS.get()->containsErrors() ||
+           RHS.get()->containsErrors() &&
+               "should only occur in error-recovery path.");
+    return Context.DependentTy;
+  }
+
   // The OpenCL operator with a vector condition is sufficiently
   // different to merit its own checker.
   if ((getLangOpts().OpenCL && Cond.get()->getType()->isVectorType()) ||
       Cond.get()->getType()->isExtVectorType())
     return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);
 
   // First, check the condition.
   Cond = UsualUnaryConversions(Cond.get());

 }
 
 /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
 /// in the case of a the GNU conditional expr extension.
 ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
                                     SourceLocation ColonLoc,
                                     Expr *CondExpr, Expr *LHSExpr,
                                     Expr *RHSExpr) {
-  if (!getLangOpts().CPlusPlus) {
+  if (!getLangOpts().CPlusPlus && !Context.getLangOpts().CDependence) {
     // C cannot handle TypoExpr nodes in the condition because it
     // doesn't handle dependent types properly, so make sure any TypoExprs have
     // been dealt with before checking the operands.
     ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr);
     ExprResult LHSResult = CorrectDelayedTyposInExpr(LHSExpr);
     ExprResult RHSResult = CorrectDelayedTyposInExpr(RHSExpr);
 
     if (!CondResult.isUsable())
auto *BO = BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc,
                                     BinOpResTy, VK, OK, OpLoc, FPFeatures);
   return convertVector(BO, ResultTy->castAs<VectorType>()->getElementType(), S);
 }
 
 static std::pair<ExprResult, ExprResult>
 CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr,
                            Expr *RHSExpr) {
   ExprResult LHS = LHSExpr, RHS = RHSExpr;
-  if (!S.getLangOpts().CPlusPlus) {
+  if (!S.getLangOpts().CPlusPlus && !S.getLangOpts().CDependence) {
     // C cannot handle TypoExpr nodes on either side of a binop because it
     // doesn't handle dependent types properly, so make sure any TypoExprs have
     // been dealt with before checking the operands.
     LHS = S.CorrectDelayedTyposInExpr(LHS);
     RHS = S.CorrectDelayedTyposInExpr(
         RHS, /*InitDecl=*/nullptr, /*RecoverUncorrectedTypos=*/false,
         [Opc, LHS](Expr *E) {
           if (Opc != BO_Assign)
if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(OverOp))
                                      RHS->getType(), Functions);
   }
 
   // Build the (potentially-overloaded, potentially-dependent)
   // binary operation.
   return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
 }
 
+ExprResult Sema::CreateDependentBinOp(SourceLocation OpLoc,
+                                      BinaryOperatorKind Opc, Expr *LHS,
+                                      Expr *RHS) {
+  assert(LHS->isTypeDependent() || RHS->isTypeDependent());
+  // If there are no functions to store, just build a dependent
+  // BinaryOperator or CompoundAssignment.
+  if (Opc <= BO_Assign || Opc > BO_OrAssign)
+    return BinaryOperator::Create(Context, LHS, RHS, Opc, Context.DependentTy,
+                                  VK_RValue, OK_Ordinary, OpLoc,
+                                  CurFPFeatureOverrides());
+  return CompoundAssignOperator::Create(
+      Context, LHS, RHS, Opc, Context.DependentTy, VK_LValue, OK_Ordinary,
+      OpLoc, CurFPFeatureOverrides(), Context.DependentTy, Context.DependentTy);
+}
+
 ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
                             BinaryOperatorKind Opc,
                             Expr *LHSExpr, Expr *RHSExpr) {
   ExprResult LHS, RHS;
   std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
   if (!LHS.isUsable() || !RHS.isUsable())
     return ExprError();
   LHSExpr = LHS.get();
if (getLangOpts().CPlusPlus) {
 
     // Otherwise, build an overloaded op if either expression has an
     // overloadable type.
     if (LHSExpr->getType()->isOverloadableType() ||
         RHSExpr->getType()->isOverloadableType())
       return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
   }
 
+  if (getLangOpts().CDependence &&
+      (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())) {
+    assert(!getLangOpts().CPlusPlus);
+    assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&
+           "Should only occur in error-recovery path.");
+    return CreateDependentBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
+  }
+
   // Build a built-in binary operation.
   return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
 }
 
 static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
   if (T.isNull() || T->isDependentType())
     return false;
 
static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
 
   // Never recoverable.
   return ExprError();
 }
 
 /// Check for operands with placeholder types and complain if found.
 /// Returns ExprError() if there was an error and no recovery was possible.
 ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
-  if (!getLangOpts().CPlusPlus) {
+  if (!getLangOpts().CPlusPlus && !Context.getLangOpts().CDependence) {
     // C cannot handle TypoExpr nodes on either side of a binop because it
     // doesn't handle dependent types properly, so make sure any TypoExprs have
     // been dealt with before checking the operands.
     ExprResult Result = CorrectDelayedTyposInExpr(E);
     if (!Result.isUsable()) return ExprError();
     E = Result.get();
   }
 

clang/lib/Sema/SemaOverload.cpp

ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
   if (!getLangOpts().CPlusPlus20)
     AllowRewrittenCandidates = false;
 
   OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
 
   // If either side is type-dependent, create an appropriate dependent
   // expression.
   if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
-    if (Fns.empty()) {
-      // If there are no functions to store, just build a dependent
-      // BinaryOperator or CompoundAssignment.
-      if (Opc <= BO_Assign || Opc > BO_OrAssign)
-        return BinaryOperator::Create(
-            Context, Args[0], Args[1], Opc, Context.DependentTy, VK_RValue,
-            OK_Ordinary, OpLoc, CurFPFeatureOverrides());
-      return CompoundAssignOperator::Create(
-          Context, Args[0], Args[1], Opc, Context.DependentTy, VK_LValue,
-          OK_Ordinary, OpLoc, CurFPFeatureOverrides(), Context.DependentTy,
-          Context.DependentTy);
-    }
+    if (Fns.empty())
+      return CreateDependentBinOp(OpLoc, Opc, Args[0], Args[1]);
 
     // FIXME: save results of ADL from here?
     CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
     // TODO: provide better source location info in DNLoc component.
     DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
     DeclarationNameInfo OpNameInfo(OpName, OpLoc);
     UnresolvedLookupExpr *Fn = UnresolvedLookupExpr::Create(
         Context, NamingClass, NestedNameSpecifierLoc(), OpNameInfo,

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

-// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -frecovery-ast -fno-recovery-ast-type -ast-dump %s | FileCheck -strict-whitespace %s
+// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -frecovery-ast -fno-recovery-ast-type -fc-dependence -ast-dump %s | FileCheck -strict-whitespace %s
 
 int some_func(int);
 
 // CHECK:     VarDecl {{.*}} unmatch_arg_call 'int' cinit
 // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
 // CHECK-NEXT:   `-DeclRefExpr {{.*}} 'some_func'
 int unmatch_arg_call = some_func();
 

 // CHECK-NEXT:  `-ParenExpr {{.*}}
 // CHECK-NEXT:    `-BinaryOperator {{.*}} '+'
 // CHECK-NEXT:      |-ImplicitCastExpr
 // CHECK-NEXT:      | `-DeclRefExpr {{.*}} 'a'
 // CHECK-NEXT:      `-IntegerLiteral {{.*}} 'int'
 int unary_address = &(a + 1);
 
 // CHECK:       VarDecl {{.*}} ternary 'int' cinit
-// CHECK-NEXT:  `-RecoveryExpr {{.*}}
+// CHECK-NEXT:  `-ConditionalOperator {{.*}}
 // CHECK-NEXT:    |-DeclRefExpr {{.*}} 'a'
-// CHECK-NEXT:    |-TypoExpr {{.*}}
+// CHECK-NEXT:    |-RecoveryExpr {{.*}}
 // CHECK-NEXT:    `-DeclRefExpr {{.*}} 'a'
-// FIXME: The TypoExpr should never be print, and should be downgraded to
-// RecoveryExpr -- typo correction is performed too early in C-only codepath,
-// which makes no correction when clang finishes the full expr (Sema::Sema::ActOnFinishFullExpr).
-// this will be fixed when we support dependent mechanism and delayed typo correction for C.
 int ternary = a ? undef : a;
 
 void test1() {
   // CHECK:     `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-DeclRefExpr {{.*}} 'a' 'const int'
   static int foo = a++; // verify no crash on local static var decl.
 }
 
 void test2() {
   int* ptr;
-  // FIXME: the top-level expr should be a binary operator.
-  // CHECK:      ImplicitCastExpr {{.*}} contains-errors <LValueToRValue>
-  // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors lvalue
-  // CHECK-NEXT:   |-DeclRefExpr {{.*}} 'ptr' 'int *'
-  // CHECK-NEXT:   `-RecoveryExpr {{.*}}
-  // CHECK-NEXT:     `-DeclRefExpr {{.*}} 'some_func'
+  // CHECK:     BinaryOperator {{.*}} contains-errors '='
+  // CHECK-NEXT: |-DeclRefExpr {{.*}} 'ptr' 'int *'
+  // CHECK-NEXT: `-RecoveryExpr {{.*}}
+  // CHECK-NEXT:   `-DeclRefExpr {{.*}} 'some_func'
   ptr = some_func(); // should not crash
+
+  int compoundOp;
+  // CHECK:     CompoundAssignOperator {{.*}} '+='
+  // CHECK-NEXT: |-DeclRefExpr {{.*}} 'compoundOp'
+  // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
+  // CHECK-NEXT:   `-DeclRefExpr {{.*}} 'some_func'
+  compoundOp += some_func();
+}
+
+void test3() {
+  // CHECK:      CallExpr {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT:  |-ParenExpr {{.*}} contains-errors lvalue
+  // CHECK-NEXT:  | `-RecoveryExpr {{.*}} contains-errors
+  // CHECK-NEXT:  |   `-DeclRefExpr {{.*}} '__builtin_classify_type'
+  // CHECK-NEXT:  `-IntegerLiteral {{.*}} 'int' 1
+  (*__builtin_classify_type)(1);
+
+  extern void ext();
+  // FIXME: the broken AST will be preserved once we remove the early typo correction
+  // in Sema::CheckPlaceholderExpr.
+  // CHECK-NOT: DeclRefExpr {{.*}} 'ext' 'int (int)'
+  ext(undef_var);
 }

clang/test/CodeGen/builtins-ppc-error.c

void testXXSLDWI(int index) {
   vec_xxsldwi(vsi); //expected-error {{too few arguments to function call, expected 3, have 1}}
   vec_xxsldwi(vsi, vsi, 2, 4); //expected-error {{too many arguments to function call, expected 3, have 4}}
   vec_xxsldwi(vsi, vsi, index); //expected-error {{argument 3 to '__builtin_vsx_xxsldwi' must be a 2-bit unsigned literal (i.e. 0, 1, 2 or 3)}}
   vec_xxsldwi(1, 2, 3); //expected-error {{first two arguments to '__builtin_vsx_xxsldwi' must be vectors}}
   vec_xxsldwi(vsi, vuc, 2); //expected-error {{first two arguments to '__builtin_vsx_xxsldwi' must have the same type}}
 }
 
 void testCTF(int index) {
-  vec_ctf(vsi, index); //expected-error {{argument to '__builtin_altivec_vcfsx' must be a constant integer}}
-  vec_ctf(vui, index); //expected-error {{argument to '__builtin_altivec_vcfsx' must be a constant integer}}
+  vec_ctf(vsi, index); //expected-error {{argument to '__builtin_altivec_vcfsx' must be a constant integer}} expected-error {{argument to '__builtin_altivec_vcfux' must be a constant integer}}
+  vec_ctf(vui, index); //expected-error {{argument to '__builtin_altivec_vcfsx' must be a constant integer}} expected-error {{argument to '__builtin_altivec_vcfux' must be a constant integer}}
 }
 
 void testVCFSX(int index) {
   vec_vcfsx(vsi, index); //expected-error {{argument to '__builtin_altivec_vcfsx' must be a constant integer}}
 }
 
 void testVCFUX(int index) {
   vec_vcfux(vui, index); //expected-error {{argument to '__builtin_altivec_vcfux' must be a constant integer}}

clang/test/CodeGen/builtins-systemz-zvector-error.c

len = __lcbb(cptr, idx);   // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
   len = __lcbb(cptr, 200);   // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
   len = __lcbb(cptr, 32);    // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
   len = __lcbb(cptr, 8192);  // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
 
-  vsl = vec_permi(vsl, vsl, idx); // expected-error {{no matching function}}
+  vsl = vec_permi(vsl, vsl, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vpdi' must be a constant integer}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
   vsl = vec_permi(vsl, vsl, -1);  // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
   vsl = vec_permi(vsl, vsl, 4);   // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vul = vec_permi(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_permi(vul, vul, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vpdi' must be a constant integer}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
   vul = vec_permi(vul, vul, -1);  // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
   vul = vec_permi(vul, vul, 4);   // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
-  vbl = vec_permi(vbl, vbl, idx); // expected-error {{no matching function}}
+  vbl = vec_permi(vbl, vbl, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vpdi' must be a constant integer}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
   vbl = vec_permi(vbl, vbl, -1);  // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
   vbl = vec_permi(vbl, vbl, 4);   // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 2 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
-  vd = vec_permi(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_permi(vd, vd, idx);    // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vpdi' must be a constant integer}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
   vd = vec_permi(vd, vd, -1);     // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
   vd = vec_permi(vd, vd, 4);      // expected-error {{no matching function}}
                                   // expected-note@vecintrin.h:* 3 {{candidate function not viable}}
                                   // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
vec_scatter_element(vd, vul, ptrd, idx);   // expected-error {{no matching function}}
                                              // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
   vec_scatter_element(vd, vul, ptrd, -1);    // expected-error {{no matching function}}
                                              // expected-note@vecintrin.h:* 6 {{candidate function not viable}}
                                              // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
   vec_scatter_element(vd, vul, ptrd, 2);     // expected-error {{no matching function}}
                                              // expected-note@vecintrin.h:* 6 {{candidate function not viable}}
                                              // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
 
-  vsc = vec_load_bndry(cptrsc, idx);   // expected-error {{no matching function}}
+  vsc = vec_load_bndry(cptrsc, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vsc = vec_load_bndry(cptrsc, 200);   // expected-error {{no matching function}}
+  vsc = vec_load_bndry(cptrsc, 200);   // expected-error {{no matching function}} expected-error {{argument value -1 is outside the valid range [0, 15]}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vsc = vec_load_bndry(cptrsc, 32);    // expected-error {{no matching function}}
+  vsc = vec_load_bndry(cptrsc, 32);    // expected-error {{no matching function}} expected-error {{argument value -1 is outside the valid range [0, 15]}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vsc = vec_load_bndry(cptrsc, 8192);  // expected-error {{no matching function}}
+  vsc = vec_load_bndry(cptrsc, 8192);  // expected-error {{no matching function}} expected-error {{argument value -1 is outside the valid range [0, 15]}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vuc = vec_load_bndry(cptruc, idx);   // expected-error {{no matching function}}
+  vuc = vec_load_bndry(cptruc, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vss = vec_load_bndry(cptrss, idx);   // expected-error {{no matching function}}
+  vss = vec_load_bndry(cptrss, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vus = vec_load_bndry(cptrus, idx);   // expected-error {{no matching function}}
+  vus = vec_load_bndry(cptrus, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vsi = vec_load_bndry(cptrsi, idx);   // expected-error {{no matching function}}
+  vsi = vec_load_bndry(cptrsi, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vui = vec_load_bndry(cptrui, idx);   // expected-error {{no matching function}}
+  vui = vec_load_bndry(cptrui, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vsl = vec_load_bndry(cptrsl, idx);   // expected-error {{no matching function}}
+  vsl = vec_load_bndry(cptrsl, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
-  vul = vec_load_bndry(cptrul, idx);   // expected-error {{no matching function}}
+  vul = vec_load_bndry(cptrul, idx);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vlbb' must be a constant integer}}
                                        // expected-note@vecintrin.h:* 9 {{must be a constant power of 2 from 64 to 4096}}
 
   vuc = vec_genmask(idx);  // expected-error {{no matching function}}
                            // expected-note@vecintrin.h:* {{must be a constant integer}}
 
   vuc = vec_genmasks_8(0, idx);    // expected-error {{no matching function}}
                                    // expected-note@vecintrin.h:* {{must be a constant integer}}
   vuc = vec_genmasks_8(idx, 0);    // expected-error {{no matching function}}
vui = vec_splat_u32(idx); // expected-error {{no matching function}}
                             // expected-note@vecintrin.h:* {{must be a constant integer}}
   vsl = vec_splat_s64(idx); // expected-error {{no matching function}}
                             // expected-note@vecintrin.h:* {{must be a constant integer}}
   vul = vec_splat_u64(idx); // expected-error {{no matching function}}
                             // expected-note@vecintrin.h:* {{must be a constant integer}}
 }
 
 void test_integer(void) {
-  vsc = vec_rl_mask(vsc, vuc, idx); // expected-error {{no matching function}}
+  vsc = vec_rl_mask(vsc, vuc, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vuc = vec_rl_mask(vuc, vuc, idx); // expected-error {{no matching function}}
+  vuc = vec_rl_mask(vuc, vuc, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vss = vec_rl_mask(vss, vus, idx); // expected-error {{no matching function}}
+  vss = vec_rl_mask(vss, vus, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vus = vec_rl_mask(vus, vus, idx); // expected-error {{no matching function}}
+  vus = vec_rl_mask(vus, vus, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vsi = vec_rl_mask(vsi, vui, idx); // expected-error {{no matching function}}
+  vsi = vec_rl_mask(vsi, vui, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vui = vec_rl_mask(vui, vui, idx); // expected-error {{no matching function}}
+  vui = vec_rl_mask(vui, vui, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vsl = vec_rl_mask(vsl, vul, idx); // expected-error {{no matching function}}
+  vsl = vec_rl_mask(vsl, vul, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
-  vul = vec_rl_mask(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_rl_mask(vul, vul, idx); // expected-error {{no matching function}} \
+                                    // expected-error {{argument to '__builtin_s390_verimb' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimh' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimf' must be a constant integer}} \
+                                    // expected-error {{argument to '__builtin_s390_verimg' must be a constant integer}}
                                     // expected-note@vecintrin.h:* 7 {{candidate function not viable}}
                                     // expected-note@vecintrin.h:* 1 {{must be a constant integer}}
 
-  vsc = vec_sld(vsc, vsc, idx); // expected-error {{no matching function}}
+  vsc = vec_sld(vsc, vsc, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vsc = vec_sld(vsc, vsc, -1);  // expected-error {{no matching function}}
+  vsc = vec_sld(vsc, vsc, -1);  // expected-error {{no matching function}} expected-error {{argument value -1 is outside the valid range [0, 15]}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vsc = vec_sld(vsc, vsc, 16);  // expected-error {{no matching function}}
+  vsc = vec_sld(vsc, vsc, 16);  // expected-error {{no matching function}} expected-error {{argument value 16 is outside the valid range [0, 15]}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vuc = vec_sld(vuc, vuc, idx); // expected-error {{no matching function}}
+  vuc = vec_sld(vuc, vuc, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vuc = vec_sld(vuc, vuc, -1);  // expected-error {{no matching function}}
+  vuc = vec_sld(vuc, vuc, -1);  // expected-error {{no matching function}} expected-error {{argument value -1 is outside the valid range [0, 15]}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vuc = vec_sld(vuc, vuc, 16);  // expected-error {{no matching function}}
+  vuc = vec_sld(vuc, vuc, 16);  // expected-error {{no matching function}} expected-error {{argument value 16 is outside the valid range [0, 15]}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vss = vec_sld(vss, vss, idx); // expected-error {{no matching function}}
+  vss = vec_sld(vss, vss, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vus = vec_sld(vus, vus, idx); // expected-error {{no matching function}}
+  vus = vec_sld(vus, vus, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vsi = vec_sld(vsi, vsi, idx); // expected-error {{no matching function}}
+  vsi = vec_sld(vsi, vsi, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vui = vec_sld(vui, vui, idx); // expected-error {{no matching function}}
+  vui = vec_sld(vui, vui, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vsl = vec_sld(vsl, vsl, idx); // expected-error {{no matching function}}
+  vsl = vec_sld(vsl, vsl, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vul = vec_sld(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_sld(vul, vul, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 11 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
-  vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 12 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
 
-  vsc = vec_sldw(vsc, vsc, idx); // expected-error {{no matching function}}
+  vsc = vec_sldw(vsc, vsc, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vsc = vec_sldw(vsc, vsc, -1);  // expected-error {{no matching function}}
+  vsc = vec_sldw(vsc, vsc, -1);  // expected-error {{no matching function}} expected-error {{argument value -4 is outside the valid range [0, 15]}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vsc = vec_sldw(vsc, vsc, 4);   // expected-error {{no matching function}}
+  vsc = vec_sldw(vsc, vsc, 4);   // expected-error {{no matching function}} expected-error {{argument value 16 is outside the valid range [0, 15]}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vuc = vec_sldw(vuc, vuc, idx); // expected-error {{no matching function}}
+  vuc = vec_sldw(vuc, vuc, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vuc = vec_sldw(vuc, vuc, -1);  // expected-error {{no matching function}}
+  vuc = vec_sldw(vuc, vuc, -1);  // expected-error {{no matching function}} expected-error {{argument value -4 is outside the valid range [0, 15]}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vuc = vec_sldw(vuc, vuc, 4);   // expected-error {{no matching function}}
+  vuc = vec_sldw(vuc, vuc, 4);   // expected-error {{no matching function}} expected-error {{argument value 16 is outside the valid range [0, 15]}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vss = vec_sldw(vss, vss, idx); // expected-error {{no matching function}}
+  vss = vec_sldw(vss, vss, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vus = vec_sldw(vus, vus, idx); // expected-error {{no matching function}}
+  vus = vec_sldw(vus, vus, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vsi = vec_sldw(vsi, vsi, idx); // expected-error {{no matching function}}
+  vsi = vec_sldw(vsi, vsi, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vui = vec_sldw(vui, vui, idx); // expected-error {{no matching function}}
+  vui = vec_sldw(vui, vui, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vsl = vec_sldw(vsl, vsl, idx); // expected-error {{no matching function}}
+  vsl = vec_sldw(vsl, vsl, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vul = vec_sldw(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_sldw(vul, vul, idx); // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
-  vd = vec_sldw(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_sldw(vd, vd, idx);    // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 8 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
 }
 
 void test_float(void) {
   vd = vec_ctd(vsl, idx); // expected-error {{no matching function}}
                           // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                           // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

clang/test/CodeGen/builtins-systemz-zvector2-error.c

vd = vec_splat(vd, -1);    // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                              // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
   vd = vec_splat(vd, 2);     // expected-error {{no matching function}}
                              // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                              // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
 }
 
 void test_integer(void) {
-  vf = vec_sld(vf, vf, idx);    // expected-error {{no matching function}}
+  vf = vec_sld(vf, vf, idx);    // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
-  vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vsldb' must be a constant integer}}
                                 // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
 
   vuc = vec_msum_u128(vul, vul, vuc, idx);  // expected-error {{must be a constant integer}}
   vuc = vec_msum_u128(vul, vul, vuc, -1);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vuc = vec_msum_u128(vul, vul, vuc, 16);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_float(void) {
-  vbi = vec_fp_test_data_class(vf, idx, &cc);   // expected-error {{no matching function}}
+  vbi = vec_fp_test_data_class(vf, idx, &cc);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vftcisb' must be a constant integer}} expected-error {{argument to '__builtin_s390_vftcidb' must be a constant integer}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
-  vbi = vec_fp_test_data_class(vf, -1, &cc);    // expected-error {{no matching function}}
+  vbi = vec_fp_test_data_class(vf, -1, &cc);    // expected-error {{no matching function}} expected-error 2{{argument value -1 is outside the valid range [0, 4095]}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
-  vbi = vec_fp_test_data_class(vf, 4096, &cc);  // expected-error {{no matching function}}
+  vbi = vec_fp_test_data_class(vf, 4096, &cc);  // expected-error {{no matching function}} expected-error 2{{argument value 4096 is outside the valid range [0, 4095]}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
-  vbl = vec_fp_test_data_class(vd, idx, &cc);   // expected-error {{no matching function}}
+  vbl = vec_fp_test_data_class(vd, idx, &cc);   // expected-error {{no matching function}} expected-error {{argument to '__builtin_s390_vftcisb' must be a constant integer}} expected-error {{argument to '__builtin_s390_vftcidb' must be a constant integer}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
-  vbl = vec_fp_test_data_class(vd, -1, &cc);    // expected-error {{no matching function}}
+  vbl = vec_fp_test_data_class(vd, -1, &cc);    // expected-error {{no matching function}} expected-error 2{{argument value -1 is outside the valid range [0, 4095]}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
-  vbl = vec_fp_test_data_class(vd, 4096, &cc);  // expected-error {{no matching function}}
+  vbl = vec_fp_test_data_class(vd, 4096, &cc);  // expected-error {{no matching function}} expected-error 2{{argument value 4096 is outside the valid range [0, 4095]}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
 }

clang/test/CodeGen/builtins-systemz-zvector3-error.c

 float * volatile ptrf;
 double * volatile ptrd;
 
 volatile unsigned int len;
 volatile int idx;
 int cc;
 
 void test_integer(void) {
-  vsc = vec_sldb(vsc, vsc, idx); // expected-error {{no matching function}}
+  vsc = vec_sldb(vsc, vsc, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vuc = vec_sldb(vuc, vuc, idx); // expected-error {{no matching function}}
+  vuc = vec_sldb(vuc, vuc, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vss = vec_sldb(vss, vss, idx); // expected-error {{no matching function}}
+  vss = vec_sldb(vss, vss, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vus = vec_sldb(vus, vus, idx); // expected-error {{no matching function}}
+  vus = vec_sldb(vus, vus, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vsi = vec_sldb(vsi, vsi, idx); // expected-error {{no matching function}}
+  vsi = vec_sldb(vsi, vsi, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vui = vec_sldb(vui, vui, idx); // expected-error {{no matching function}}
+  vui = vec_sldb(vui, vui, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vsl = vec_sldb(vsl, vsl, idx); // expected-error {{no matching function}}
+  vsl = vec_sldb(vsl, vsl, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vul = vec_sldb(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_sldb(vul, vul, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vf = vec_sldb(vf, vf, idx);    // expected-error {{no matching function}}
+  vf = vec_sldb(vf, vf, idx);    // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vd = vec_sldb(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_sldb(vd, vd, idx);    // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsld' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
 
-  vsc = vec_srdb(vsc, vsc, idx); // expected-error {{no matching function}}
+  vsc = vec_srdb(vsc, vsc, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vuc = vec_srdb(vuc, vuc, idx); // expected-error {{no matching function}}
+  vuc = vec_srdb(vuc, vuc, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vss = vec_srdb(vss, vss, idx); // expected-error {{no matching function}}
+  vss = vec_srdb(vss, vss, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vus = vec_srdb(vus, vus, idx); // expected-error {{no matching function}}
+  vus = vec_srdb(vus, vus, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vsi = vec_srdb(vsi, vsi, idx); // expected-error {{no matching function}}
+  vsi = vec_srdb(vsi, vsi, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vui = vec_srdb(vui, vui, idx); // expected-error {{no matching function}}
+  vui = vec_srdb(vui, vui, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vsl = vec_srdb(vsl, vsl, idx); // expected-error {{no matching function}}
+  vsl = vec_srdb(vsl, vsl, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vul = vec_srdb(vul, vul, idx); // expected-error {{no matching function}}
+  vul = vec_srdb(vul, vul, idx); // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vf = vec_srdb(vf, vf, idx);    // expected-error {{no matching function}}
+  vf = vec_srdb(vf, vf, idx);    // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
-  vd = vec_srdb(vd, vd, idx);    // expected-error {{no matching function}}
+  vd = vec_srdb(vd, vd, idx);    // expected-error {{no matching function}} \
+                                 // expected-error {{argument to '__builtin_s390_vsrd' must be a constant integer}}
                                  // expected-note@vecintrin.h:* 9 {{candidate function not viable}}
                                  // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
 }
 

clang/test/Index/complete-switch.c

 void f() {
   auto foo = bar;
   switch(foo) {
     case x:
       break;
   }
 }
 
-// RUN: not %clang_cc1 -fsyntax-only -code-completion-at=%s:4:10 %s | FileCheck %s -allow-empty
+// RUN: not %clang_cc1 -fsyntax-only -Xclang -fno-recovery-ast -code-completion-at=%s:4:10 %s | FileCheck %s -allow-empty
 // CHECK-NOT: COMPLETION: foo

clang/test/OpenMP/begin_declare_variant_messages.c

 #pragma omp begin declare variant match(device={kind}) // expected-warning {{the context selector 'kind' in context set 'device' requires a context property defined in parentheses; selector ignored}} expected-note {{the ignored selector spans until here}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(}) // expected-error {{expected ')'}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind()}) // expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(score cpu)}) // expected-error {{expected '(' after 'score'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<invalid>'); score ignored}}
 #pragma omp end declare variant
-#pragma omp begin declare variant match(device={kind(score( ibm)}) // expected-error {{use of undeclared identifier 'ibm'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<invalid>'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
+#pragma omp begin declare variant match(device={kind(score( ibm)}) // expected-error {{use of undeclared identifier 'ibm'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<recovery-expr>()'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(score(2 gpu)}) // expected-error {{expected ')'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('2'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{to match this '('}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(score(foo()) ibm)}) // expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('foo()'); score ignored}} expected-warning {{'ibm' is not a valid context property for the context selector 'kind' and the context set 'device'; property ignored}} expected-note {{try 'match(implementation={vendor(ibm)})'}} expected-note {{the ignored property spans until here}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(score(5): host), kind(llvm)}) // expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('5'); score ignored}} expected-warning {{the context selector 'kind' was used already in the same 'omp declare variant' directive; selector ignored}} expected-note {{the previous context selector 'kind' used here}} expected-note {{the ignored selector spans until here}}
 #pragma omp end declare variant
 #pragma omp begin declare variant match(device={kind(score(5): nohost), vendor(llvm)}) // expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('5'); score ignored}} expected-warning {{the context selector 'vendor' is not valid for the context set 'device'; selector ignored}} expected-note {{the context selector 'vendor' can be nested in the context set 'implementation'; try 'match(implementation={vendor(property)})'}} expected-note {{the ignored selector spans until here}}

clang/test/OpenMP/declare_variant_messages.c

 // RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp -x c -std=c99 -fms-extensions -Wno-pragma-pack %s
 
 // RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp-simd -x c -std=c99 -fms-extensions -Wno-pragma-pack %s
 
 
 #pragma omp declare // expected-error {{expected an OpenMP directive}}
 
 int foo(void);
 
 #pragma omp declare variant // expected-error {{expected '(' after 'declare variant'}}
 #pragma omp declare variant( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
 #pragma omp declare variant(foo // expected-error {{expected ')'}} expected-error {{expected 'match' clause on 'omp declare variant' directive}} expected-note {{to match this '('}}
-#pragma omp declare variant(x) // expected-error {{use of undeclared identifier 'x'}}
+#pragma omp declare variant(x) // expected-error {{use of undeclared identifier 'x'}} expected-error {{expected 'match' clause on}}
 #pragma omp declare variant(foo) // expected-error {{expected 'match' clause on 'omp declare variant' directive}}
 #pragma omp declare variant(foo) // expected-error {{expected 'match' clause on 'omp declare variant' directive}}
 #pragma omp declare variant(foo) xxx // expected-error {{expected 'match' clause on 'omp declare variant' directive}}
 #pragma omp declare variant(foo) match // expected-error {{expected '(' after 'match'}}
 #pragma omp declare variant(foo) match( // expected-error {{expected ')'}} expected-warning {{expected identifier or string literal describing a context set; set skipped}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}} expected-note {{to match this '('}}
 #pragma omp declare variant(foo) match() // expected-warning {{expected identifier or string literal describing a context set; set skipped}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}
 #pragma omp declare variant(foo) match(xxx) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}
 #pragma omp declare variant(foo) match(xxx=) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}

 #pragma omp declare variant(foo) match(implementation={vendor(score(foo()) ibm)}) // expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{score expressions in the OpenMP context selector need to be constant; foo() is not and will be ignored}}
 #pragma omp declare variant(foo) match(implementation={vendor(score(5): ibm), vendor(llvm)}) // expected-warning {{the context selector 'vendor' was used already in the same 'omp declare variant' directive; selector ignored}} expected-note {{the previous context selector 'vendor' used here}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(implementation={vendor(score(5): ibm), kind(cpu)}) // expected-warning {{the context selector 'kind' is not valid for the context set 'implementation'; selector ignored}} expected-note {{the context selector 'kind' can be nested in the context set 'device'; try 'match(device={kind(property)})'}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(device={xxx}) // expected-warning {{'xxx' is not a valid context selector for the context set 'device'; selector ignored}} expected-note {{context selector options are: 'kind' 'isa' 'arch'}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(device={kind}) // expected-warning {{the context selector 'kind' in context set 'device' requires a context property defined in parentheses; selector ignored}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(device={kind(}) // expected-error {{expected ')'}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp declare variant(foo) match(device={kind()}) // expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}}
 #pragma omp declare variant(foo) match(device={kind(score cpu)}) // expected-error {{expected '(' after 'score'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<invalid>'); score ignored}}
-#pragma omp declare variant(foo) match(device={kind(score( ibm)}) // expected-error {{use of undeclared identifier 'ibm'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<invalid>'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
+#pragma omp declare variant(foo) match(device={kind(score( ibm)}) // expected-error {{use of undeclared identifier 'ibm'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('<recovery-expr>()'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp declare variant(foo) match(device={kind(score(2 gpu)}) // expected-error {{expected ')'}} expected-error {{expected ')'}} expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('2'); score ignored}} expected-warning {{expected identifier or string literal describing a context property; property skipped}} expected-note {{to match this '('}} expected-note {{context property options are: 'host' 'nohost' 'cpu' 'gpu' 'fpga' 'any'}} expected-note {{to match this '('}}
 #pragma omp declare variant(foo) match(device={kind(score(foo()) ibm)}) // expected-warning {{expected '':'' after the score expression; '':'' assumed}} expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('foo()'); score ignored}} expected-warning {{'ibm' is not a valid context property for the context selector 'kind' and the context set 'device'; property ignored}} expected-note {{try 'match(implementation={vendor(ibm)})'}} expected-note {{the ignored property spans until here}}
 #pragma omp declare variant(foo) match(device={kind(score(5): host), kind(llvm)}) // expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('5'); score ignored}} expected-warning {{the context selector 'kind' was used already in the same 'omp declare variant' directive; selector ignored}} expected-note {{the previous context selector 'kind' used here}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(device={kind(score(5): nohost), vendor(llvm)}) // expected-warning {{the context selector 'kind' in the context set 'device' cannot have a score ('5'); score ignored}} expected-warning {{the context selector 'vendor' is not valid for the context set 'device'; selector ignored}} expected-note {{the context selector 'vendor' can be nested in the context set 'implementation'; try 'match(implementation={vendor(property)})'}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(foo) match(implementation={extension("aaa")}) // expected-warning {{'aaa' is not a valid context property for the context selector 'extension' and the context set 'implementation'; property ignored}} expected-note {{context property options are: 'match_all' 'match_any' 'match_none'}} expected-note {{the ignored property spans until here}}
 int bar(void);
 
 #pragma omp declare variant(foo) match(implementation = {vendor(score(foo) :llvm)}) // expected-warning {{score expressions in the OpenMP context selector need to be constant; foo is not and will be ignored}}

clang/test/Parser/objc-foreach-syntax.m

 MyList * el; 
      for (el in @"foo") 
     { LOOP(); }
 }
 @end
 
 
 static int test7(id keys) {
-  for (id key; in keys) ;  // expected-error {{use of undeclared identifier 'in'}}
+  // FIXME: would be nice to suppress the secondary diagnostics.
+  for (id key; in keys) ;  // expected-error {{use of undeclared identifier 'in'}} \
+                           // expected-error {{expected ';' in 'for' statement specifier}} \
+                           // expected-warning {{expression result unused}}
 }

clang/test/Sema/__try.c

 void TEST() {
   __try {
 
   }
 }  // expected-error{{expected '__except' or '__finally' block}}
 
 void TEST() {
   __except ( FilterExpression() ) { // expected-warning{{implicit declaration of function '__except' is invalid in C99}} \
-    // expected-error{{too few arguments to function call, expected 1, have 0}}
-
+    // expected-error{{too few arguments to function call, expected 1, have 0}} \
+    // expected-error{{expected ';' after expression}}
   }
 }
 
 void TEST() {
   __finally { } // expected-error{{}}
 }
 
 void TEST() {

clang/test/Sema/enum.c

 
 // PR4515
 enum PR4515 {PR4515a=1u,PR4515b=(PR4515a-2)/2};
 int CheckPR4515[PR4515b==0?1:-1];
 
 // PR7911
 extern enum PR7911T PR7911V; // expected-warning{{ISO C forbids forward references to 'enum' types}}
 void PR7911F() {
-  switch (PR7911V); // expected-error {{statement requires expression of integer type}}
+  switch (PR7911V); // expected-error {{statement requires expression of integer type}} \
+                    // expected-warning {{switch statement has empty body}} expected-note {{put the semicolon on a separate line to silence this warning}}
 }
 
 char test5[__has_feature(enumerator_attributes) ? 1 : -1];
 
 // PR8694
 // rdar://8707031
 void PR8694(int* e) // expected-note {{passing argument to parameter 'e' here}}
 {

clang/test/Sema/error-dependence.c

+// RUN: %clang_cc1 -fsyntax-only -verify -frecovery-ast -fno-recovery-ast-type -fc-dependence %s
+
+int call(int); // expected-note 2{{'call' declared here}}
+
+void test1(int s) {
+  // verify "assigning to 'int' from incompatible type '<dependent type>'" is
+  // not emitted.
+  s = call(); // expected-error {{too few arguments to function call}}
+
+  // verify disgnostic "called object type '<dependent type>' is not a function
+  // or function pointer" is not emitted.
+  (*__builtin_classify_type)(1); // expected-error {{builtin functions must be directly called}}
+}
+
+void test2(int *ptr, float f) {
+  // verify diagnostic "used type '<dependent type>' where arithmetic or pointer
+  // type is required" is not emitted.
+  ptr > f ? ptr : f; // expected-error {{invalid operands to binary expression}}
+}
+
+void test3(float f) {
+  // verify diagnostic "operand of type '<dependent type>' where arithmetic or
+  // pointer type is required" is not emitted.
+  f = (float)call(); // expected-error {{too few arguments to function call}}
+}

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() {
   float x;
   x = (float)arst;  // expected-error-re {{use of undeclared identifier 'arst'{{$}}}}
 }
 
 a = b ? : 0;  // expected-warning {{type specifier missing, defaults to 'int'}} \
               // expected-error {{use of undeclared identifier 'b'}}
 
 int foobar;  // expected-note {{'foobar' declared here}}
-a = goobar ?: 4;  // expected-warning {{type specifier missing, defaults to 'int'}} \
+new_a = goobar ?: 4;  // expected-warning {{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) {
void f(long *a, long b) {
       __atomic_or_fetch(a, b, c);  // expected-error {{use of undeclared identifier 'c'}}
 }
 
 extern double cabs(_Complex double z);
 void fn1() {
   cabs(errij);  // expected-error {{use of undeclared identifier 'errij'}}
 }
 
-extern long afunction(int); // expected-note {{'afunction' declared here}}
+extern long afunction(int);
 void fn2() {
   f(THIS_IS_AN_ERROR, // expected-error {{use of undeclared identifier 'THIS_IS_AN_ERROR'}}
-    afunction(afunction_));  // expected-error {{use of undeclared identifier 'afunction_'; did you mean 'afunction'?}}
+    afunction(afunction_));  // expected-error {{use of undeclared identifier 'afunction_'}}
 }
 
 int d = X ? d : L; // expected-error 2 {{use of undeclared identifier}}
 
 int fn_with_ids() { ID = ID == ID >= ID ; } // expected-error 4 {{use of undeclared identifier}}
 
 int fn_with_rs(int r) { r = TYPO + r * TYPO; } // expected-error 2 {{use of undeclared identifier}}