[AST] Add RecoveryExpr; produce it on overload resolution failure and missing member.

[sammccall]

Summary

In many places, Sema refuses to create an Expr if it encounters an error.
This means that broken code has no representation in the AST. As well as the broken node itself, child Exprs and parent Exprs are usually dropped.

This is terrible for tools that rely on the AST and see a lot of broken code (e.g. libclang-based IDEs and clangd).
In the expression foo(a, takes2args(b)), "go to definition" doesn't work on any of the subexpressions. And after takes2args(x)., member completion doesn't work, although in practice we almost always know the type.

This patch introduces RecoveryExpr. This AST node represents broken code, and has very weak semantics. It's part of the final AST (unlike TypoExpr) but can't produce code, as it's always accompanied by an error.
It captures valid subexpressions without checking or assigning them meaning.
Some RecoveryExprs have a known type (e.g. a broken non-overloaded call).
Where the type is unknown, it is modeled as the dependent RecoveryTy.
This allows us to reuse most existing behavior for suppressing further checks.
RecoveryTy is only used in C++, in C we don't recover unless the type is known.

Initiallly, RecoveryExpr is emitted in two common cases:

• a function call where overload resolution failed (most typically: wrong args) Callee is captured as an UnresolvedLookupExpr, and args are captured. Type is available if the "best" candidates have the same return type.
• access of a nonexistent member Base expression is captured, type is never available.

Test changes:

• SemaCXX/enable_if.cpp: we now emit more detailed diagnostics (the non-constexpr subexpression is inside a function call), which breaks the heuristic that tries to move the whole diagnostic to the subexpression location. This case (IMO) doesn't matter much: the subexpression is invalid, flagging it as non-constexpr isn't very useful to start with.
• SemaTemplate/instantiate-function-params.cpp: it looks like the testcase was minimized in an unrealistic way: the only version of if_ doesn't have type and the only version of requirement_ doesn't have failed, and it seems reasonable to diagnose this. If the precise invalid form is required, I can add another 17 expect-*s to the test, or remove -verify so we only fail on crashing. Original patch adding this test is very terse: https://github.com/llvm/llvm-project/commit/5112157958438005095aff805853f9b14ba974eb Testcase subsequently modified to test for a crash: https://github.com/llvm/llvm-project/commit/a02bb341552b2b91c93e708645c32d11cc4133d2

[sammccall]

Fix serialization maybe.

[sammccall]

This should work for real now: handle types properly, make tests pass, add some tests.

[erik.pilkington]

include/clang/AST/BuiltinTypes.def

265 ↗

(On Diff #199678)

Why are you creating a new type as opposed to just using DependentTy (sorta like TypoExpr does)? It seems like if you want to recycle all the dependence-propagating code in Sema, then you need to fall back to DependentTy anyways, i.e. 1 + <recovery-expr> will have dependent type with this patch, right?

lib/Sema/SemaOverload.cpp

12167

Have you also considered handling this like delayed typos, where we try to TreeTransform into different possible recoveries later, in order to find out what the best fix is? You might be able to make a better guess as to what the right function to pick (or how to recover in general) is if you can see how the recovery would be used, but deciding here means you have a lot less information.

[rsmith]

I expect we'll want a ContainsErrors bit on Stmt, propagated similarly to the existing InstantiationDependent / ContainsUnexpandedParameterPack / ... bits. For example, the constant evaluator will want to quickly bail out of evaluating expressions and statements containing errors, and the error recovery TreeTransform that we perform to fix typos will want that too (and maybe could be able to fix other kinds of errors for which we build these error nodes eventually?).

include/clang/AST/BuiltinTypes.def

265 ↗

(On Diff #199678)

Using DependentTy for TypoExpr is a mistake; it leads to all sorts of bad follow-on diagnostics incorrectly claiming that constructs have dependent types.

Rather than calling this RecoveryTy, I'd prefer to call it something a bit more general like ErrorTy, with the intent being that we eventually use it for TypoExpr too.

include/clang/AST/Expr.h

5801–5809

Do we need this at all, if we have a properly-propagated ErrorTy anyway? Instead of using this, it would seem that we could model an ill-formed expression as the corresponding AST node but with its type set to ErrorTy. Presumably the latter is what we'll do when we find a subexpression containing an error, rather than creating a RecoveryExpr at every enclosing syntactic level, so AST clients will need to deal with that anyway.

include/clang/AST/Type.h

2423–2424 ↗

(On Diff #199678)

Experience with TypoExpr suggests that treating non-dependent constructs as dependent is a mistake in the long term.

[sammccall]

Thanks for the useful insights!

I'm going to work on a version of this patch that doesn't rely on type dependency and treats errors as a new concept instead.
I'm not convinced it's feasible to drop RecoveryExpr and reuse existing nodes, so I'll keep that at least for now. (I tried and failed, and don't have new ideas there - more detail below)

In D61722#1503863, @rsmith wrote:

I expect we'll want a ContainsErrors bit on Stmt, propagated similarly to the existing InstantiationDependent / ContainsUnexpandedParameterPack / ... bits.

This sounds good (as an alternative to using dependent bits for this).

Do you think we want a similar bit on Type (set on e.g. vector<ErrorTy>) , or should be ensure ErrorTy never gets used for compound types?

For example, the constant evaluator will want to quickly bail out of evaluating expressions and statements containing errors, and the error recovery TreeTransform that we perform to fix typos will want that too (and maybe could be able to fix other kinds of errors for which we build these error nodes eventually?).

Definitely possible, I don't know whether it's worth it or not:

1. errors that can be recovered eagerly: They are, and RecoveryExpr or equivalent never kicks in here. This seems ideal.
2. errors that can never be recovered: returned as RecoveryExpr or equivalent. This is a difference from current TypoExpr which never does this.
3. errors that must be recovered lazily: we could e.g. add TypoExpr-style recovery callbacks to RecoveryExpr and merge the two concepts. I don't have a clear idea of how large/important this category is compared to 1 though.

include/clang/AST/BuiltinTypes.def

265 ↗

(On Diff #199678)

Why are you creating a new type as opposed to just using DependentTy (sorta like TypoExpr does)?

Indeed it's probably redundant in this form of the patch. While I was still trying to get this to work in C mode, I was checking for RecoveryTy instead of isDependent() in various places. (Maybe that approach would always miss cases, as you suggest)

(Obviously if we *don't* reuse the concept of dependent types, then some new type/type concepts are needed.)

include/clang/AST/Expr.h

5801–5809

properly-propagated ErrorTy

An important part here (especially for code completion, but not only) is that there are RecoveryExprs where the real type is known. So ErrorTy doesn't mean "subexpression has errors".

The motivating case is:

string foo(param1, param2, param3, param4);
foo(param1, param2, param3);

Here foo has type string, not ErrorTy.

---

But we can certainly add a bit to Stmt for "subexpression has errors", so the question stands:

as the corresponding AST node but [with the HasError bit set]. Presumably the latter is what we'll do when we find a subexpression containing an error, rather than creating a RecoveryExpr at every enclosing syntactic level, so AST clients will need to deal with that anyway.

Yes. I did try this and we debated it a lot. Somehow I forgot to mention this central design question in the patch description :-(

It certainly preserves more information/structure, and allows existing code to work with broken nodes.
However:

• it breaks existing invariants, so a large fraction of consuming code needs to be modified but it's not obvious how. By comparison, most consumers are robust to adding a node type (or it'll break the compile in an obvious way with -Wswitch etc).
• every time we want to add more recovery, we break new invariants. Whereas code that handles RecoveryExpr/ErrorTy can be pretty generic.
• code tends to be partitioned by node type, so making errors a separate node type (mostly) isolates the complexity of error handling. Adding error conditions to many node types means this complexity is spread throughout consuming code.
• it's particularly important that error-recovery code be "correct by construction" because test coverage of all error-recovery situations is very hard. Using the type system helps here.

In practice with this approach I wasn't able to fix the crashes either in clang or client code in any principled way, and I didn't have any confidence that the code was going to be correct even if I got the tests to pass.

include/clang/AST/Type.h

2423–2424 ↗

(On Diff #199678)

Experience with TypoExpr suggests that treating non-dependent constructs as dependent is a mistake in the long term.

It's certainly a tradeoff. Reusing dependent types isn't quite accurate, but adding a separate concept complicates the model a lot I think. Could be that

• TypoExpr should have used a separate concept
• dependent types were the best option, the alternatives would have been even worse
• TypoExpr never should have happened, as both alternatives are too bad

Certainly this is a chance to try the other approach.

[rsmith]

In D61722#1504376, @sammccall wrote:

In D61722#1503863, @rsmith wrote:

I expect we'll want a ContainsErrors bit on Stmt, propagated similarly to the existing InstantiationDependent / ContainsUnexpandedParameterPack / ... bits.

This sounds good (as an alternative to using dependent bits for this).

Do you think we want a similar bit on Type (set on e.g. vector<ErrorTy>) , or should be ensure ErrorTy never gets used for compound types?

The simplest thing to do might be to ensure that vector<ErrorTy> is itself ErrorTy. There might be some cases where we can get better recovery by keeping a more precise type (eg, maybe we can infer something from an operation on ErrorTy* that we couldn't infer from merely ErrorTy), but I suspect the added complexity isn't worthwhile.

For example, the constant evaluator will want to quickly bail out of evaluating expressions and statements containing errors, and the error recovery TreeTransform that we perform to fix typos will want that too (and maybe could be able to fix other kinds of errors for which we build these error nodes eventually?).

Definitely possible, I don't know whether it's worth it or not:

1. errors that can be recovered eagerly: They are, and RecoveryExpr or equivalent never kicks in here. This seems ideal.
2. errors that can never be recovered: returned as RecoveryExpr or equivalent. This is a difference from current TypoExpr which never does this.
3. errors that must be recovered lazily: we could e.g. add TypoExpr-style recovery callbacks to RecoveryExpr and merge the two concepts. I don't have a clear idea of how large/important this category is compared to 1 though.

Well, typo correction would be in case 1: we can recover from typos eagerly, but we choose to defer them because we might be able to figure out a better recovery based on looking at context that we don't have yet. The same is probably true for a lot of our error recovery, but it's probably not worth it most of the time. So I think it's more of a question of balancing when it's worthwhile to save enough state to recover.

What kinds of cases are you thinking of that would be in your second category? The examples you give for RecoveryExpr (a call that can't be resolved and a member access that can't be resolved) are *already* in case 3 when the reason they can't be resolved is due to a typo within them. We model that today by treating them as dependent in the initial parse, but that's problematic and we will want to use whatever replacement mechanism we come up with here instead.

Looking at your current uses for RecoveryExpr, I'm not sure whether adding a new AST node is the right model:

a function call where overload resolution failed (most typically: wrong args) Callee is captured as an UnresolvedLookupExpr, and args are captured. Type is available if the "best" candidates have the same return type.

I would assume that we would represent a function call for which the callee or an argument contains an error as a CallExpr with the "contains error" flag set and with ErrorTy as its type. Could we use the same representation here? (That is, represent this case as a CallExpr whose type is ErrorTy with the "contains error" flag set, with no RecoveryExpr.)

access of a nonexistent member Base expression is captured, type is never available.

Using UnresolvedMemberExpr for this case might make sense. I think we should think about how we'd represent a member access that can't be fully analyzed because the object expression contains errors, and think about whether it makes sense to use that same representation for the case where the error is immediately in forming the member access itself. (And similarly across all other kinds of recovery expression we might create.)

If we want to enable (eg) AST matchers to operate on erroneous AST, using a homogeneous RecoveryExpr for all different syntaxes that originate errors seems like it would introduce complexity, especially if all consumers of the AST already need to deal with the case that some existing AST node is marked as being erroneous so don't get any benefit from having a concrete RecoveryExpr as a known stopping point. (If you get there, you've probably already gone too far.)

[sammccall]

In D61722#1508050, @rsmith wrote:

The simplest thing to do might be to ensure that vector<ErrorTy> is itself ErrorTy.

You're probably right, I'll try this.

For example, the constant evaluator will want to quickly bail out of evaluating expressions and statements containing errors

Thinking more - how important is this? These expressions are expected to be rare.
Discussing offline with @gribozavr, it seemed likely we could get away with the "errorness" of an expr being a local property, which would be simplifying. (Whereas the errorness of a type needs to be a transitive one).

What kinds of cases are you thinking of that would be in your second category?

Incomplete code, either new code or during refactoring

• not enough arguments
• symbol not found due to missing #include
• member not added yet
• function not defined yet

In an IDE context, it's *much* more important that diagnostics are useful and AST nodes aren't discarded, than that recovery correctly "fixes" the AST to have the intended semantics.

From that point of view, typo recovery/TypoExpr spends too much complexity budget on accurate recovery, rather than generality. RecoveryExpr is a different part of the design space for sure.

I would assume that we would represent a function call for which the callee or an argument contains an error as a CallExpr with the "contains error" flag set and with ErrorTy as its type.

Almost:

• if the argument has an error, but its type is still known, then overload resolution runs as normal and this CallExpr doesn't itself have an error. (If there's a transitive HasError bit on Expr, it would be set).
• if the argument has an error and has ErrorTy, overload resolution may still succeed (depending on the rules we choose for ErrorTy). In which case again, the CallExpr itself has no error.
• if the argument has an error and has ErrorTy, and this causes overload resolution to fail, but all (best) overloads have the same type, we get a RecoveryExpr/CallExpr-with-error with a real type
• if the argument has an error and has ErrorTy, and this causes overload resolution to fail, and the type is unknown, then we get a RecoveryExpr/CallExpr-with-error with ErrorTy.

Could we use the same representation here? (That is, represent this case as a CallExpr whose type is ErrorTy with the "contains error" flag set, with no RecoveryExpr.)

We can, but it breaks a lot of client code. These two cases are pretty different for clients:

• for an otherwise-valid CallExpr where one argument has errors, all the *local* invariants are preserved.
• for a CallExpr where callee is null, or the #args don't match the function, the client code often crashed or did the wrong thing.

My view is that we're fundamentally better having two types to keep the guarantees around CallExpr stronger. That we want matchers to "match through" RecoveryExpr, but callExpr shouldn't match here.
@ilya-biryukov disagreed and thought the main virtue of RecoveryExpr is backwards-compatibility.
Either way, I'm not optimistic about being able to get recovery changes to stick under this model. I'm willing to try if you feel strongly.

access of a nonexistent member Base expression is captured, type is never available.

Using UnresolvedMemberExpr for this case might make sense. I think we should think about how we'd represent a member access that can't be fully analyzed because the object expression contains errors, and think about whether it makes sense to use that same representation for the case where the error is immediately in forming the member access itself. (And similarly across all other kinds of recovery expression we might create.)

I agree it's important to be consistent here. It's hard work to be consistent and also precise!
Using RecoveryExpr for both cases seems sufficient to me, and one of its advantages is that it avoids having to make lots of hard decisions one-by-one, many of which will be wrong :-)

But that aside, I agree the best way to model that in the existing AST is make UnresolvedMemberExpr available in C, allow it to have no candidate decls, etc.
For the object expression, the error can be nested arbitrarily deep and I think we just have to apply whatever usual "subexpression-has-errors" strategy to UnresolvedMemberExpr and MemberExpr.

If we want to enable (eg) AST matchers to operate on erroneous AST, using a homogeneous RecoveryExpr for all different syntaxes that originate errors seems like it would introduce complexity, especially if all consumers of the AST already need to deal with the case that some existing AST node is marked as being erroneous so don't get any benefit from having a concrete RecoveryExpr as a known stopping point. (If you get there, you've probably already gone too far.)

Based on experiments, I think the desired behavior for ASTMatchers is that callExpr() wouldn't match a broken call, but descendant/ancestor matching would still traverse "through" broken calls.
This gets most of the possible benefit for little cost: matchers can "for free" match the rest of the expression tree that gets dropped today, but e.g. existing clang-tidy checks won't bind directly to the broken parts of the AST.
Matchers/options to opt-in can be added. e.g. brokenCallExpr(...) or recoveryExpr(attemptedExpr(CallExpr), ...) as the case may be.

I thought @klimek was on board with this approach, but he can correct me if not...

include/clang/AST/Expr.h

public:
   SourceLocation getBeginLoc() const LLVM_READONLY { return SourceLocation(); }
   SourceLocation getEndLoc() const LLVM_READONLY { return SourceLocation(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == TypoExprClass;
   }
 
 };
+
+class RecoveryExpr final : public Expr,
+                           private llvm::TrailingObjects<RecoveryExpr, Stmt *> {
+public:
+  static RecoveryExpr *Create(ASTContext &Ctx, QualType T, StmtClass Attempted,
+                              SourceLocation BeginLoc, SourceLocation EndLoc,
+                              ArrayRef<Stmt *> Stmts);
+
+  StmtClass attemptedStmtClass() const { return Attempted; }
+
+  child_range children() {
+    const_child_range CCR = const_cast<const RecoveryExpr *>(this)->children();
+    return child_range(cast_away_const(CCR.begin()),
+                       cast_away_const(CCR.end()));
+  }
+  const_child_range children() const {
+    Stmt *const *cs = const_cast<Stmt *const *>(
+        reinterpret_cast<const Stmt *const *>(getTrailingObjects<Stmt *>()));
+    return const_child_range(cs, cs + NumStmts);
+  }
+
+  SourceLocation getBeginLoc() const { return BeginLoc; }
+  SourceLocation getEndLoc() const { return EndLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == RecoveryExprClass;
+  }
+
+private:
+  RecoveryExpr(QualType T, StmtClass Attempted, SourceLocation BeginLoc,
+               SourceLocation EndLoc, ArrayRef<Stmt *> Stmts)
+      : Expr(RecoveryExprClass, T, VK_LValue, OK_Ordinary,
+             /*isTypeDependent*/ true,
+             /*isValueDependent*/ true,
+             /*isInstantiationDependent*/ true,
+             /*containsUnexpandedParameterPack*/ false),
+        BeginLoc(BeginLoc), EndLoc(EndLoc), Attempted(Attempted),
+        NumStmts(Stmts.size()) {
+    llvm::errs() << "Created RecoveryExpr with type " << T.getAsString() << "\n";
+    std::copy(Stmts.begin(), Stmts.end(), getTrailingObjects<Stmt *>());
+  }
+
+  size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumStmts; }
+
+  SourceLocation BeginLoc, EndLoc;
+  StmtClass Attempted;
+  unsigned NumStmts;
+  friend TrailingObjects;
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+};
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_EXPR_H

include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(SEHExceptStmt, {})
 DEF_TRAVERSE_STMT(SEHFinallyStmt, {})
 DEF_TRAVERSE_STMT(SEHLeaveStmt, {})
 DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); })
 
 DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {})
 DEF_TRAVERSE_STMT(OpaqueValueExpr, {})
 DEF_TRAVERSE_STMT(TypoExpr, {})
+DEF_TRAVERSE_STMT(RecoveryExpr, {}) // XXX
 DEF_TRAVERSE_STMT(CUDAKernelCallExpr, {})
 
 // These operators (all of them) do not need any action except
 // iterating over the children.
 DEF_TRAVERSE_STMT(BinaryConditionalOperator, {})
 DEF_TRAVERSE_STMT(ConditionalOperator, {})
 DEF_TRAVERSE_STMT(UnaryOperator, {})
 DEF_TRAVERSE_STMT(BinaryOperator, {})

include/clang/AST/Stmt.h

StmtClass getStmtClass() const {
     return static_cast<StmtClass>(StmtBits.sClass);
   }
 
   Stmt(const Stmt &) = delete;
   Stmt(Stmt &&) = delete;
   Stmt &operator=(const Stmt &) = delete;
   Stmt &operator=(Stmt &&) = delete;
 
-  const char *getStmtClassName() const;
+  static const char *getStmtClassName(StmtClass);
+  const char *getStmtClassName() const {
+    return getStmtClassName(getStmtClass());
+  }
 
   bool isOMPStructuredBlock() const { return StmtBits.IsOMPStructuredBlock; }
   void setIsOMPStructuredBlock(bool IsOMPStructuredBlock) {
     StmtBits.IsOMPStructuredBlock = IsOMPStructuredBlock;
   }
 
   /// SourceLocation tokens are not useful in isolation - they are low level
   /// value objects created/interpreted by SourceManager. We assume AST

include/clang/Basic/StmtNodes.td

 def CUDAKernelCallExpr : DStmt<CallExpr>;
 
 // Clang Extensions.
 def ShuffleVectorExpr : DStmt<Expr>;
 def ConvertVectorExpr : DStmt<Expr>;
 def BlockExpr : DStmt<Expr>;
 def OpaqueValueExpr : DStmt<Expr>;
 def TypoExpr : DStmt<Expr>;
+def RecoveryExpr : DStmt<Expr>;
 
 // Microsoft Extensions.
 def MSPropertyRefExpr : DStmt<Expr>;
 def MSPropertySubscriptExpr : DStmt<Expr>;
 def CXXUuidofExpr : DStmt<Expr>;
 def SEHTryStmt : Stmt;
 def SEHExceptStmt : Stmt;
 def SEHFinallyStmt : Stmt;

include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_GENERIC_SELECTION,
 
       /// A PseudoObjectExpr record.
       EXPR_PSEUDO_OBJECT,
 
       /// An AtomicExpr record.
       EXPR_ATOMIC,
 
+      /// A RecoveryExpr record.
+      EXPR_RECOVERY,
+
       // Objective-C
 
       /// An ObjCStringLiteral record.
       EXPR_OBJC_STRING_LITERAL,
 
       EXPR_OBJC_BOXED_EXPRESSION,
       EXPR_OBJC_ARRAY_LITERAL,
       EXPR_OBJC_DICTIONARY_LITERAL,

lib/AST/Expr.cpp

bool Expr::HasSideEffects(const ASTContext &Ctx,
   case CXXUnresolvedConstructExprClass:
   case CXXDependentScopeMemberExprClass:
   case UnresolvedLookupExprClass:
   case UnresolvedMemberExprClass:
   case PackExpansionExprClass:
   case SubstNonTypeTemplateParmPackExprClass:
   case FunctionParmPackExprClass:
   case TypoExprClass:
+  case RecoveryExprClass:
   case CXXFoldExprClass:
     llvm_unreachable("shouldn't see dependent / unresolved nodes here");
 
   case DeclRefExprClass:
   case ObjCIvarRefExprClass:
   case PredefinedExprClass:
   case IntegerLiteralClass:
   case FixedPointLiteralClass:
if (OriginalTy->isAnyPointerType())
       OriginalTy = OriginalTy->getPointeeType();
     else {
       assert (OriginalTy->isArrayType());
       OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
     }
   }
   return OriginalTy;
 }
+
+RecoveryExpr *RecoveryExpr::Create(ASTContext &Ctx, QualType T,
+                                   StmtClass Attempted, SourceLocation BeginLoc,
+                                   SourceLocation EndLoc,
+                                   ArrayRef<Stmt *> Stmts) {
+  void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()),
+                           alignof(CallExpr));
+  return new (Mem) RecoveryExpr(T, Attempted, BeginLoc, EndLoc, Stmts);
+}

lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ObjCIndirectCopyRestoreExprClass:
   case Expr::AtomicExprClass:
   case Expr::CXXFoldExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
     return Cl::CL_PRValue;
+  case Expr::RecoveryExprClass:
+    return Cl::CL_LValue; // XXX
 
   case Expr::ConstantExprClass:
     return ClassifyInternal(Ctx, cast<ConstantExpr>(E)->getSubExpr());
 
     // Next come the complicated cases.
   case Expr::SubstNonTypeTemplateParmExprClass:
     return ClassifyInternal(Ctx,
                  cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());

lib/AST/ExprConstant.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::UserDefinedLiteralClass:
   case Expr::CXXThisExprClass:
   case Expr::CXXThrowExprClass:
   case Expr::CXXNewExprClass:
   case Expr::CXXDeleteExprClass:
   case Expr::CXXPseudoDestructorExprClass:
   case Expr::UnresolvedLookupExprClass:
   case Expr::TypoExprClass:
+  case Expr::RecoveryExprClass:
   case Expr::DependentScopeDeclRefExprClass:
   case Expr::CXXConstructExprClass:
   case Expr::CXXInheritedCtorInitExprClass:
   case Expr::CXXStdInitializerListExprClass:
   case Expr::CXXBindTemporaryExprClass:
   case Expr::ExprWithCleanupsClass:
   case Expr::CXXTemporaryObjectExprClass:
   case Expr::CXXUnresolvedConstructExprClass:

lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::FixedPointLiteralClass:
+  case Expr::RecoveryExprClass:
   {
     if (!NullOut) {
       // As bad as this diagnostic is, it's better than crashing.
       DiagnosticsEngine &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                        "cannot yet mangle expression type %0");
       Diags.Report(E->getExprLoc(), DiagID)
         << E->getStmtClassName() << E->getSourceRange();

lib/AST/Stmt.cpp

#include "clang/AST/StmtNodes.inc"
   return StmtClassInfo[E];
 }
 
 void *Stmt::operator new(size_t bytes, const ASTContext& C,
                          unsigned alignment) {
   return ::operator new(bytes, C, alignment);
 }
 
-const char *Stmt::getStmtClassName() const {
-  return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
+const char *Stmt::getStmtClassName(StmtClass C) {
+  return getStmtInfoTableEntry(C).Name;
 }
 
 // Check that no statement / expression class is polymorphic. LLVM style RTTI
 // should be used instead. If absolutely needed an exception can still be added
 // here by defining the appropriate macro (but please don't do this).
 #define STMT(CLASS, PARENT) \
   static_assert(!std::is_polymorphic<CLASS>::value, \
                 #CLASS " should not be polymorphic!");

lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
   PrintExpr(Node->getSourceExpr());
 }
 
 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
   // TODO: Print something reasonable for a TypoExpr, if necessary.
   llvm_unreachable("Cannot print TypoExpr nodes");
 }
 
+void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) {
+  OS << "<invalid " << Stmt::getStmtClassName(Node->attemptedStmtClass())
+     << ">{";
+  for (Stmt *S : Node->children())
+    PrintStmt(S);
+  OS << '}';
+}
+
 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
   OS << "__builtin_astype(";
   PrintExpr(Node->getSrcExpr());
   OS << ", ";
   Node->getType().print(OS, Policy);
   OS << ")";
 }
 

lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
   VisitExpr(E);
 }
 
 void StmtProfiler::VisitTypoExpr(const TypoExpr *E) {
   VisitExpr(E);
 }
 
+void StmtProfiler::VisitRecoveryExpr(const RecoveryExpr *E) {
+  VisitExpr(E);
+}
+
 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
   VisitExpr(E);
 }
 

lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Expr *E) {
   case Expr::PseudoObjectExprClass:
   case Expr::SubstNonTypeTemplateParmExprClass:
   case Expr::SubstNonTypeTemplateParmPackExprClass:
   case Expr::FunctionParmPackExprClass:
   case Expr::UnaryExprOrTypeTraitExprClass:
   case Expr::UnresolvedLookupExprClass:
   case Expr::UnresolvedMemberExprClass:
   case Expr::TypoExprClass:
+  case Expr::RecoveryExprClass:
     // FIXME: Can any of the above throw?  If so, when?
     return CT_Cannot;
 
   case Expr::AddrLabelExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::AtomicExprClass:
   case Expr::TypeTraitExprClass:
   case Expr::CXXBoolLiteralExprClass:

lib/Sema/SemaExpr.cpp

if (!getLangOpts().CPlusPlus) {
     // 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();
   }
 
+  if (isa<RecoveryExpr>(E))
+    return E;
+
   const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
   if (!placeholderType) return E;
 
   switch (placeholderType->getKind()) {
 
   // Overloaded expressions.
   case BuiltinType::Overload: {
     // Try to resolve a single function template specialization.

lib/Sema/SemaOverload.cpp

 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides Sema routines for C++ overloading.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/Type.h"
 #include "clang/Sema/Overload.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/TypeOrdering.h"
case OR_Deleted: {
     Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
   }
   }
 
   // Overload resolution failed.
+  if (!AllowTypoCorrection)
     return ExprError();
+
+  // Try to find the common return type.
+  QualType Type;
+  for (const auto& Candidate : *CandidateSet) {
+    QualType CandidateType;
+    if (Candidate.Function)
+      CandidateType = Candidate.Function->getCallResultType();
+    if (!CandidateType.isNull()) {
+      if (!Type.isNull() && CandidateType != Type) {
+        Type = QualType(); // Different types, give up.
+        break;
+      }
+      Type = CandidateType;
+    }
+  }
+  if (Type.isNull())
+    Type = SemaRef.Context.IntTy;
+
+  SmallVector<Stmt*, 8> SubExprs = {Fn};
+  SubExprs.append(Args.begin(), Args.end());
+  return RecoveryExpr::Create(SemaRef.Context, Type, Stmt::CallExprClass,
+                              Fn->getBeginLoc(), RParenLoc, SubExprs);
 }
 
 static void markUnaddressableCandidatesUnviable(Sema &S,
                                                 OverloadCandidateSet &CS) {
   for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
     if (I->Viable &&
         !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
       I->Viable = false;

lib/Sema/TreeTransform.h

 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
   return E;
 }
 
 template<typename Derived>
 ExprResult
+TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) {
+  return E;
+}
+
+template<typename Derived>
+ExprResult
 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
   // Rebuild the syntactic form.  The original syntactic form has
   // opaque-value expressions in it, so strip those away and rebuild
   // the result.  This is a really awful way of doing this, but the
   // better solution (rebuilding the semantic expressions and
   // rebinding OVEs as necessary) doesn't work; we'd need
   // TreeTransform to not strip away implicit conversions.
   Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);

lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   E->OpaqueValueExprBits.Loc = ReadSourceLocation();
   E->setIsUnique(Record.readInt());
 }
 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
+void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
+  VisitExpr(E);
+  E->BeginLoc = ReadSourceLocation();
+  E->EndLoc = ReadSourceLocation();
+  E->Attempted = (Stmt::StmtClass)Record.readInt();
+  unsigned NumArgs = Record.readInt();
+  assert(
+      (NumArgs == std::distance(E->children().begin(), E->children().end())) &&
+      "Wrong NumArgs!");
+  for (Stmt*& Child : E->children())
+    Child = Record.readSubStmt();
+}
+
 //===----------------------------------------------------------------------===//
 // Microsoft Expressions and Statements
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
   VisitExpr(E);
   E->IsArrow = (Record.readInt() != 0);
   E->BaseExpr = Record.readSubExpr();
   E->QualifierLoc = Record.readNestedNameSpecifierLoc();

lib/Serialization/ASTWriterStmt.cpp

 }
 
 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
   VisitExpr(E);
   // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
   llvm_unreachable("Cannot write TypoExpr nodes");
 }
 
+void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
+  VisitExpr(E);
+  llvm_unreachable("Cannot write RecoveryExpr nodes"); // XXX
+}
+
 //===----------------------------------------------------------------------===//
 // CUDA Expressions and Statements.
 //===----------------------------------------------------------------------===//
 
 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
   VisitCallExpr(E);
   Record.AddStmt(E->getConfig());
   Code = serialization::EXPR_CUDA_KERNEL_CALL;

lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::MSPropertySubscriptExprClass:
     case Stmt::CXXUnresolvedConstructExprClass:
     case Stmt::DependentScopeDeclRefExprClass:
     case Stmt::ArrayTypeTraitExprClass:
     case Stmt::ExpressionTraitExprClass:
     case Stmt::UnresolvedLookupExprClass:
     case Stmt::UnresolvedMemberExprClass:
     case Stmt::TypoExprClass:
+    case Stmt::RecoveryExprClass:
     case Stmt::CXXNoexceptExprClass:
     case Stmt::PackExpansionExprClass:
     case Stmt::SubstNonTypeTemplateParmPackExprClass:
     case Stmt::FunctionParmPackExprClass:
     case Stmt::CoroutineBodyStmtClass:
     case Stmt::CoawaitExprClass:
     case Stmt::DependentCoawaitExprClass:
     case Stmt::CoreturnStmtClass:

test/SemaCXX/enable_if.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
-typedef int (*fp)(int);
-int surrogate(int);
-struct Incomplete;  // expected-note{{forward declaration of 'Incomplete'}} \
-                    // expected-note {{forward declaration of 'Incomplete'}}
-
-struct X {
-  X() = default;  // expected-note{{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
-  X(const X&) = default;  // expected-note{{candidate constructor not viable: no known conversion from 'bool' to 'const X' for 1st argument}}
-  X(bool b) __attribute__((enable_if(b, "chosen when 'b' is true")));  // expected-note{{candidate disabled: chosen when 'b' is true}}
-
-  void f(int n) __attribute__((enable_if(n == 0, "chosen when 'n' is zero")));
-  void f(int n) __attribute__((enable_if(n == 1, "chosen when 'n' is one")));  // expected-note{{member declaration nearly matches}} expected-note 2{{candidate disabled: chosen when 'n' is one}}
-
-  void g(int n) __attribute__((enable_if(n == 0, "chosen when 'n' is zero")));  // expected-note{{candidate disabled: chosen when 'n' is zero}}
-
-  void h(int n, int m = 0) __attribute__((enable_if(m == 0, "chosen when 'm' is zero")));  // expected-note{{candidate disabled: chosen when 'm' is zero}}
-
-  static void s(int n) __attribute__((enable_if(n == 0, "chosen when 'n' is zero")));  // expected-note2{{candidate disabled: chosen when 'n' is zero}}
-
-  void conflict(int n) __attribute__((enable_if(n+n == 10, "chosen when 'n' is five")));  // expected-note{{candidate function}}
-  void conflict(int n) __attribute__((enable_if(n*2 == 10, "chosen when 'n' is five")));  // expected-note{{candidate function}}
-
-  void hidden_by_argument_conversion(Incomplete n, int m = 0) __attribute__((enable_if(m == 10, "chosen when 'm' is ten")));
-  Incomplete hidden_by_incomplete_return_value(int n = 0) __attribute__((enable_if(n == 10, "chosen when 'n' is ten"))); // expected-note{{'hidden_by_incomplete_return_value' declared here}}
-
-  operator long() __attribute__((enable_if(true, "chosen on your platform")));
-  operator int() __attribute__((enable_if(false, "chosen on other platform")));
-
-  operator fp() __attribute__((enable_if(false, "never enabled"))) { return surrogate; }  // expected-note{{conversion candidate of type 'int (*)(int)'}}  // FIXME: the message is not displayed
-};
-
-void X::f(int n) __attribute__((enable_if(n == 0, "chosen when 'n' is zero")))  // expected-note{{member declaration nearly matches}} expected-note 2{{candidate disabled: chosen when 'n' is zero}}
-{
-}
-
-void X::f(int n) __attribute__((enable_if(n == 2, "chosen when 'n' is two")))  // expected-error{{out-of-line definition of 'f' does not match any declaration in 'X'}}
-{
-}
-
-X x1(true);
-X x2(false); // expected-error{{no matching constructor for initialization of 'X'}}
-
-__attribute__((deprecated)) constexpr int old() { return 0; }  // expected-note2{{'old' has been explicitly marked deprecated here}}
-void deprec1(int i) __attribute__((enable_if(old() == 0, "chosen when old() is zero")));  // expected-warning{{'old' is deprecated}}
-void deprec2(int i) __attribute__((enable_if(old() == 0, "chosen when old() is zero")));  // expected-warning{{'old' is deprecated}}
-
-void overloaded(int);
-void overloaded(long);
-
-struct Int {
-  constexpr Int(int i) : i(i) { }
-  constexpr operator int() const { return i; }
-  int i;
-};
-
-void default_argument(int n, int m = 0) __attribute__((enable_if(m == 0, "chosen when 'm' is zero")));  // expected-note{{candidate disabled: chosen when 'm' is zero}}
-void default_argument_promotion(int n, int m = Int(0)) __attribute__((enable_if(m == 0, "chosen when 'm' is zero")));  // expected-note{{candidate disabled: chosen when 'm' is zero}}
-
-struct Nothing { };
-template<typename T> void typedep(T t) __attribute__((enable_if(t, "")));  // expected-note{{candidate disabled:}}  expected-error{{value of type 'Nothing' is not contextually convertible to 'bool'}}
-template<int N> void valuedep() __attribute__((enable_if(N == 1, "")));
-
-// FIXME: we skip potential constant expression evaluation on value dependent
-// enable-if expressions
-int not_constexpr();
-template<int N> void valuedep() __attribute__((enable_if(N == not_constexpr(), "")));
-
-template <typename T> void instantiationdep() __attribute__((enable_if(sizeof(sizeof(T)) != 0, "")));
-
-void test() {
-  X x;
-  x.f(0);
-  x.f(1);
-  x.f(2);  // expected-error{{no matching member function for call to 'f'}}
-  x.f(3);  // expected-error{{no matching member function for call to 'f'}}
-
-  x.g(0);
-  x.g(1);  // expected-error{{no matching member function for call to 'g'}}
-
-  x.h(0);
-  x.h(1, 2);  // expected-error{{no matching member function for call to 'h'}}
-
-  x.s(0);
-  x.s(1);  // expected-error{{no matching member function for call to 's'}}
-
-  X::s(0);
-  X::s(1);  // expected-error{{no matching member function for call to 's'}}
-
-  x.conflict(5);  // expected-error{{call to member function 'conflict' is ambiguous}}
-
-  x.hidden_by_argument_conversion(10);  // expected-error{{argument type 'Incomplete' is incomplete}}
-  x.hidden_by_incomplete_return_value(10);  // expected-error{{calling 'hidden_by_incomplete_return_value' with incomplete return type 'Incomplete'}}
-
-  deprec2(0);
-
-  overloaded(x);
-
-  default_argument(0);
-  default_argument(1, 2);  // expected-error{{no matching function for call to 'default_argument'}}
-
-  default_argument_promotion(0);
-  default_argument_promotion(1, 2);  // expected-error{{no matching function for call to 'default_argument_promotion'}}
-
-  int i = x(1);  // expected-error{{no matching function for call to object of type 'X'}}
-
-  Nothing n;
-  typedep(0);  // expected-error{{no matching function for call to 'typedep'}}
-  typedep(1);
-  typedep(n);  // expected-note{{in instantiation of function template specialization 'typedep<Nothing>' requested here}}
-}
-
-template <typename T> class C {
-  void f() __attribute__((enable_if(T::expr == 0, ""))) {}
-  void g() { f(); }
-};
-
-int fn3(bool b) __attribute__((enable_if(b, ""))); // FIXME: This test should net 0 error messages.
-template <class T> void test3() {
-  fn3(sizeof(T) == 1); // expected-error{{no matching function for call to 'fn3'}} expected-note@-2{{candidate disabled}}
-}
-
-template <typename T>
-struct Y {
-  T h(int n, int m = 0) __attribute__((enable_if(m == 0, "chosen when 'm' is zero")));  // expected-note{{candidate disabled: chosen when 'm' is zero}}
-};
-
-void test4() {
-  Y<int> y;
-
-  int t0 = y.h(0);
-  int t1 = y.h(1, 2);  // expected-error{{no matching member function for call to 'h'}}
-}
-
-// FIXME: issue an error (without instantiation) because ::h(T()) is not
-// convertible to bool, because return types aren't overloadable.
-void h(int);
-template <typename T> void outer() {
-  void local_function() __attribute__((enable_if(::h(T()), "")));
-  local_function(); // expected-error{{no matching function for call to 'local_function'}} expected-note@-1{{candidate disabled}}
-};
-
-namespace PR20988 {
-  struct Integer {
-    Integer(int);
-  };
-
-  int fn1(const Integer &) __attribute__((enable_if(true, "")));
-  template <class T> void test1() {
-    int &expr = T::expr();
-    fn1(expr);
-  }
-
-  int fn2(const Integer &) __attribute__((enable_if(false, "")));  // expected-note{{candidate disabled}}
-  template <class T> void test2() {
-    int &expr = T::expr();
-    fn2(expr);  // expected-error{{no matching function for call to 'fn2'}}
-  }
-
-  int fn3(bool b) __attribute__((enable_if(b, ""))); // FIXME: This test should net 0 error messages.
-  template <class T> void test3() {
-    fn3(sizeof(T) == 1); // expected-error{{no matching function for call to 'fn3'}} expected-note@-2{{candidate disabled}}
-  }
-}
-
-namespace FnPtrs {
-  int ovlFoo(int m) __attribute__((enable_if(m > 0, "")));
-  int ovlFoo(int m);
-
-  void test() {
-    // Assignment gives us a different code path than declarations, and `&foo`
-    // gives us a different code path than `foo`
-    int (*p)(int) = ovlFoo;
-    int (*p2)(int) = &ovlFoo;
-    int (*a)(int);
-    a = ovlFoo;
-    a = &ovlFoo;
-  }
-
-  int ovlBar(int) __attribute__((enable_if(true, "")));
-  int ovlBar(int m) __attribute__((enable_if(false, "")));
-  void test2() {
-    int (*p)(int) = ovlBar;
-    int (*p2)(int) = &ovlBar;
-    int (*a)(int);
-    a = ovlBar;
-    a = &ovlBar;
-  }
-
-  int ovlConflict(int m) __attribute__((enable_if(true, "")));
-  int ovlConflict(int m) __attribute__((enable_if(1, "")));
-  void test3() {
-    int (*p)(int) = ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-    int (*p2)(int) = &ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-    int (*a)(int);
-    a = ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-    a = &ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-  }
-
-  template <typename T>
-  T templated(T m) __attribute__((enable_if(true, ""))) { return T(); }
-  template <typename T>
-  T templated(T m) __attribute__((enable_if(false, ""))) { return T(); }
-  void test4() {
-    int (*p)(int) = templated<int>;
-    int (*p2)(int) = &templated<int>;
-    int (*a)(int);
-    a = templated<int>;
-    a = &templated<int>;
-  }
-
-  template <typename T>
-  T templatedBar(T m) __attribute__((enable_if(m > 0, ""))) { return T(); }
-  void test5() {
-    int (*p)(int) = templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@214{{candidate function made ineligible by enable_if}}
-    int (*p2)(int) = &templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@214{{candidate function made ineligible by enable_if}}
-    int (*a)(int);
-    a = templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@214{{candidate function made ineligible by enable_if}}
-    a = &templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@214{{candidate function made ineligible by enable_if}}
-  }
-
-  template <typename T>
-  T templatedConflict(T m) __attribute__((enable_if(false, ""))) { return T(); }
-  template <typename T>
-  T templatedConflict(T m) __attribute__((enable_if(true, ""))) { return T(); }
-  template <typename T>
-  T templatedConflict(T m) __attribute__((enable_if(1, ""))) { return T(); }
-  void test6() {
-    int (*p)(int) = templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@224{{candidate function made ineligible by enable_if}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-    int (*p0)(int) = &templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@224{{candidate function made ineligible by enable_if}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-    int (*a)(int);
-    a = templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-    a = &templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-  }
-
-  int ovlNoCandidate(int m) __attribute__((enable_if(false, "")));
-  int ovlNoCandidate(int m) __attribute__((enable_if(0, "")));
-  void test7() {
-    int (*p)(int) = ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-    int (*p2)(int) = &ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-    int (*a)(int);
-    a = ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-    a = &ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-  }
-
-  int noOvlNoCandidate(int m) __attribute__((enable_if(false, "")));
-  void test8() {
-    int (*p)(int) = noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' because it has one or more non-tautological enable_if conditions}}
-    int (*p2)(int) = &noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' because it has one or more non-tautological enable_if conditions}}
-    int (*a)(int);
-    a = noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' because it has one or more non-tautological enable_if conditions}}
-    a = &noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' because it has one or more non-tautological enable_if conditions}}
-  }
-}
-
-namespace casting {
-using VoidFnTy = void (*)();
-
-void foo(void *c) __attribute__((enable_if(0, "")));
-void foo(int *c) __attribute__((enable_if(c, "")));
-void foo(char *c) __attribute__((enable_if(1, "")));
-
-void testIt() {
-  auto A = reinterpret_cast<VoidFnTy>(foo);
-  auto AAmp = reinterpret_cast<VoidFnTy>(&foo);
-
-  using VoidFooTy = void (*)(void *);
-  auto B = reinterpret_cast<VoidFooTy>(foo);
-  auto BAmp = reinterpret_cast<VoidFooTy>(&foo);
-
-  using IntFooTy = void (*)(int *);
-  auto C = reinterpret_cast<IntFooTy>(foo);
-  auto CAmp = reinterpret_cast<IntFooTy>(&foo);
-
-  using CharFooTy = void (*)(void *);
-  auto D = reinterpret_cast<CharFooTy>(foo);
-  auto DAmp = reinterpret_cast<CharFooTy>(&foo);
-}
-
-void testItCStyle() {
-  auto A = (VoidFnTy)foo;
-  auto AAmp = (VoidFnTy)&foo;
-
-  using VoidFooTy = void (*)(void *);
-  auto B = (VoidFooTy)foo;
-  auto BAmp = (VoidFooTy)&foo;
-
-  using IntFooTy = void (*)(int *);
-  auto C = (IntFooTy)foo;
-  auto CAmp = (IntFooTy)&foo;
-
-  using CharFooTy = void (*)(void *);
-  auto D = (CharFooTy)foo;
-  auto DAmp = (CharFooTy)&foo;
-}
-}
-
-namespace casting_templates {
-template <typename T> void foo(T) {} // expected-note 4 {{candidate function}}
-
-void foo(int *c) __attribute__((enable_if(c, ""))); //expected-note 4 {{candidate function}}
-void foo(char *c) __attribute__((enable_if(c, ""))); //expected-note 4 {{candidate function}}
-
-void testIt() {
-  using IntFooTy = void (*)(int *);
-  auto A = reinterpret_cast<IntFooTy>(foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-  auto ARef = reinterpret_cast<IntFooTy>(&foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-  auto AExplicit = reinterpret_cast<IntFooTy>(foo<int*>);
-
-  using CharFooTy = void (*)(char *);
-  auto B = reinterpret_cast<CharFooTy>(foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-  auto BRef = reinterpret_cast<CharFooTy>(&foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-  auto BExplicit = reinterpret_cast<CharFooTy>(foo<char*>);
-}
-
-void testItCStyle() {
-  // constexpr is usable here because all of these should become static_casts.
-  using IntFooTy = void (*)(int *);
-  constexpr auto A = (IntFooTy)foo;
-  constexpr auto ARef = (IntFooTy)&foo;
-  constexpr auto AExplicit = (IntFooTy)foo<int*>;
-
-  using CharFooTy = void (*)(char *);
-  constexpr auto B = (CharFooTy)foo;
-  constexpr auto BRef = (CharFooTy)&foo;
-  constexpr auto BExplicit = (CharFooTy)foo<char*>;
-
-  static_assert(A == ARef && ARef == AExplicit, "");
-  static_assert(B == BRef && BRef == BExplicit, "");
-}
-}
-
-namespace multiple_matches {
-using NoMatchTy = void (*)();
-
-void foo(float *c); //expected-note 4 {{candidate function}}
-void foo(int *c) __attribute__((enable_if(1, ""))); //expected-note 4 {{candidate function}}
-void foo(char *c) __attribute__((enable_if(1, ""))); //expected-note 4 {{candidate function}}
-
-void testIt() {
-  auto A = reinterpret_cast<NoMatchTy>(foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-  auto ARef = reinterpret_cast<NoMatchTy>(&foo); // expected-error{{reinterpret_cast cannot resolve overloaded function 'foo' to type}}
-
-  auto C = (NoMatchTy)foo; // expected-error{{address of overloaded function 'foo' does not match required type 'void ()'}}
-  auto CRef = (NoMatchTy)&foo; // expected-error{{address of overloaded function 'foo' does not match required type 'void ()'}}
-}
-}
-
-namespace PR27122 {
-// (slightly reduced) code that motivated the bug...
-namespace ns {
-void Function(int num)
-  __attribute__((enable_if(num != 0, "")));
-void Function(int num, int a0)
-  __attribute__((enable_if(num != 1, "")));
-}  // namespace ns
-
-using ns::Function; // expected-note 3{{declared here}}
-void Run() {
-  Functioon(0); // expected-error{{use of undeclared identifier}} expected-error{{too few arguments}}
-  Functioon(0, 1); // expected-error{{use of undeclared identifier}}
-  Functioon(0, 1, 2); // expected-error{{use of undeclared identifier}}
-}
-
-// Extra tests
-void regularEnableIf(int a) __attribute__((enable_if(a, ""))); // expected-note 3{{declared here}} expected-note 3{{candidate function not viable}}
-void runRegularEnableIf() {
-  regularEnableIf(0, 2); // expected-error{{no matching function}}
-  regularEnableIf(1, 2); // expected-error{{no matching function}}
-  regularEnableIf(); // expected-error{{no matching function}}
-
-  // Test without getting overload resolution involved
-  ::PR27122::regularEnableIf(0, 2); // expected-error{{too many arguments}}
-  ::PR27122::regularEnableIf(1, 2); // expected-error{{too many arguments}}
-  ::PR27122::regularEnableIf(); // expected-error{{too few arguments}}
-}
-
-struct Foo {
-  void bar(int i) __attribute__((enable_if(i, ""))); // expected-note 2{{declared here}}
-};
-
-void runFoo() {
-  Foo f;
-  f.bar(); // expected-error{{too few arguments}}
-  f.bar(1, 2); // expected-error{{too many arguments}}
-}
-}
-
-// Ideally, we should be able to handle value-dependent expressions sanely.
-// Sadly, that isn't the case at the moment.
-namespace dependent {
-int error(int N) __attribute__((enable_if(N, ""))); // expected-note{{candidate disabled}}
-int error(int N) __attribute__((enable_if(!N, ""))); // expected-note{{candidate disabled}}
-template <int N> int callUnavailable() {
-  return error(N); // expected-error{{no matching function for call to 'error'}}
-}
-
-constexpr int noError(int N) __attribute__((enable_if(N, ""))) { return -1; }
-constexpr int noError(int N) __attribute__((enable_if(!N, ""))) { return -1; }
-constexpr int noError(int N) { return 0; }
-
-template <int N>
-constexpr int callNoError() { return noError(N); }
-static_assert(callNoError<0>() == 0, "");
-static_assert(callNoError<1>() == 0, "");
-
 template <int N> constexpr int templated() __attribute__((enable_if(N, ""))) {
   return 1;
 }
-
-constexpr int A = templated<0>(); // expected-error{{no matching function for call to 'templated'}} expected-note@-4{{candidate disabled}}
-static_assert(templated<1>() == 1, "");
-
 template <int N> constexpr int callTemplated() { return templated<N>(); }
-
 constexpr int B = 10 + // the carat for the error should be pointing to the problematic call (on the next line), not here.
-    callTemplated<0>(); // expected-error{{initialized by a constant expression}} expected-error@-3{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-10{{candidate disabled}}
-static_assert(callTemplated<1>() == 1, "");
-}
-
-namespace variadic {
-void foo(int a, int b = 0, ...) __attribute__((enable_if(a && b, ""))); // expected-note 6{{disabled}}
-
-void testFoo() {
-  foo(1, 1);
-  foo(1, 1, 2);
-  foo(1, 1, 2, 3);
-
-  foo(1, 0); // expected-error{{no matching}}
-  foo(1, 0, 2); // expected-error{{no matching}}
-  foo(1, 0, 2, 3); // expected-error{{no matching}}
-
-  int m;
-  foo(1, 1);
-  foo(1, 1, m);
-  foo(1, 1, m, 3);
-
-  foo(1, 0); // expected-error{{no matching}}
-  foo(1, 0, m); // expected-error{{no matching}}
-  foo(1, 0, m, 3); // expected-error{{no matching}}
-}
-}
-
-// Tests that we emit errors at the point of the method call, rather than the
-// beginning of the expression that happens to be a member call.
-namespace member_loc {
-  struct Foo { void bar() __attribute__((enable_if(0, ""))); }; // expected-note{{disabled}}
-  void testFoo() {
-    Foo()
-      .bar(); // expected-error{{no matching member function}}
-  }
-}
-
-// Prior bug: we wouldn't properly convert conditions to bools when
-// instantiating templates in some cases.
-namespace template_instantiation {
-template <typename T>
-struct Foo {
-  void bar(int a) __attribute__((enable_if(a, ""))); // expected-note{{disabled}}
-};
-
-void runFoo() {
-  Foo<double>().bar(0); // expected-error{{no matching}}
-  Foo<double>().bar(1);
-}
-}
-
-namespace instantiate_constexpr_in_enable_if {
-  template<typename T> struct X {
-    static constexpr bool ok() { return true; }
-    void f() __attribute__((enable_if(ok(), "")));
-  };
-  void g() { X<int>().f(); }
-}
-
-namespace PR31934 {
-int foo(int a) __attribute__((enable_if(a, "")));
-int runFn(int (&)(int));
-
-void run() {
-  {
-    int (&bar)(int) = foo; // expected-error{{cannot take address of function 'foo'}}
-    int baz = runFn(foo); // expected-error{{cannot take address of function 'foo'}}
-  }
-
-  {
-    int (&bar)(int) = (foo); // expected-error{{cannot take address of function 'foo'}}
-    int baz = runFn((foo)); // expected-error{{cannot take address of function 'foo'}}
-  }
-
-  {
-    int (&bar)(int) = static_cast<int (&)(int)>(foo); // expected-error{{cannot take address of function 'foo'}}
-    int baz = runFn(static_cast<int (&)(int)>(foo)); // expected-error{{cannot take address of function 'foo'}}
-  }
-
-  {
-    int (&bar)(int) = static_cast<int (&)(int)>((foo)); // expected-error{{cannot take address of function 'foo'}}
-    int baz = runFn(static_cast<int (&)(int)>((foo))); // expected-error{{cannot take address of function 'foo'}}
-  }
-}
-}
-
-namespace TypeOfFn {
-  template <typename T, typename U>
-  struct is_same;
-
-  template <typename T> struct is_same<T, T> {
-    enum { value = 1 };
-  };
-
-  void foo(int a) __attribute__((enable_if(a, "")));
-  void foo(float a) __attribute__((enable_if(1, "")));
-
-  static_assert(is_same<__typeof__(foo)*, decltype(&foo)>::value, "");
-}
-
-namespace InConstantContext {
-void foo(const char *s) __attribute__((enable_if(((void)__builtin_constant_p(*s), true), "trap"))) {}
-
-void test() {
-  InConstantContext::foo("abc");
-}
-} // namespace InConstantContext
-
-namespace StringLiteralDetector {
-  void need_string_literal(const char *p) __attribute__((enable_if(__builtin_constant_p(p), "argument is not a string literal"))); // expected-note 2{{not a string literal}}
-  void test(const char *unknown) {
-    need_string_literal("foo");
-    need_string_literal(unknown); // expected-error {{no matching function}}
-    constexpr char str[] = "bar";
-    need_string_literal(str); // expected-error {{no matching function}}
-  }
-}
+    callTemplated<0>(); // expected-error{{initialized by a constant expression}} expected-error@-2{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-5{{candidate disabled}}
 

test/SemaTemplate/instantiate-init.cpp

namespace PR7985 {
 
   template<>
   const Data<float*> Description<float*>::data[];
 
   void test() {
     integral_c<1> ic1 = array_lengthof(Description<int>::data);
     (void)sizeof(array_lengthof(Description<float>::data));
 
-    sizeof(array_lengthof( // expected-error{{no matching function for call to 'array_lengthof'}}
-                          Description<int*>::data // expected-note{{in instantiation of static data member 'PR7985::Description<int *>::data' requested here}}
-                          ));
+    (void)sizeof(array_lengthof( // expected-error{{no matching function for call to 'array_lengthof'}}
+        Description<int *>::data // expected-note{{in instantiation of static data member 'PR7985::Description<int *>::data' requested here}}
 
     array_lengthof(Description<float*>::data); // expected-error{{no matching function for call to 'array_lengthof'}}
   }
 }
 
 namespace PR13064 {
   // Ensure that in-class direct-initialization is instantiated as
   // direct-initialization and likewise copy-initialization is instantiated as

tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::PredefinedExprClass:
   case Stmt::ShuffleVectorExprClass:
   case Stmt::ConvertVectorExprClass:
   case Stmt::VAArgExprClass:
   case Stmt::ObjCArrayLiteralClass:
   case Stmt::ObjCDictionaryLiteralClass:
   case Stmt::ObjCBoxedExprClass:
   case Stmt::ObjCSubscriptRefExprClass:
+  case Stmt::RecoveryExprClass:
     K = CXCursor_UnexposedExpr;
     break;
 
   case Stmt::OpaqueValueExprClass:
     if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
       return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
     K = CXCursor_UnexposedExpr;
     break;