[AST] Fix recovery-AST crash: dependent overloaded call exprs are now possible.

[sammccall]

(Haha, I tried to send this 5 hours ago and found it waiting for me to confirm that clang-format could add a single space...)

[hokein]

Thanks!

clang/lib/AST/StmtProfile.cpp

static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
                                           BinaryOperatorKind &BinaryOp) {
   switch (S->getOperator()) {
   case OO_None:
   case OO_New:
   case OO_Delete:
   case OO_Array_New:
   case OO_Array_Delete:
   case OO_Arrow:
-  case OO_Call:
   case OO_Conditional:
   case NUM_OVERLOADED_OPERATORS:
     llvm_unreachable("Invalid operator call kind");
 
   case OO_Plus:
     if (S->getNumArgs() == 1) {
       UnaryOp = UO_Plus;
       return Stmt::UnaryOperatorClass;
static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
 
   case OO_ArrowStar:
     BinaryOp = BO_PtrMemI;
     return Stmt::BinaryOperatorClass;
 
   case OO_Subscript:
     return Stmt::ArraySubscriptExprClass;
 
+  case OO_Call:
+    return Stmt::CallExprClass;
+
   case OO_Coawait:
     UnaryOp = UO_Coawait;
     return Stmt::UnaryOperatorClass;
   }
 
   llvm_unreachable("Invalid overloaded operator expression");
 }
 
if (S->isTypeDependent()) {
     for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
       Visit(S->getArg(I));
     if (SC == Stmt::UnaryOperatorClass)
       ID.AddInteger(UnaryOp);
     else if (SC == Stmt::BinaryOperatorClass ||
              SC == Stmt::CompoundAssignOperatorClass)
       ID.AddInteger(BinaryOp);
     else
-      assert(SC == Stmt::ArraySubscriptExprClass);
+      assert(SC == Stmt::ArraySubscriptExprClass || SC == Stmt::CallExprClass);
 
     return;
   }
 
   VisitCallExpr(S);
   ID.AddInteger(S->getOperator());
 }
 

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

void InitializerForAuto() {
   auto b = some_func(invalid());
 
   decltype(ned);
   // very bad initailizer: there is an unresolved typo expr internally, we just
   // drop it.
   // CHECK: `-VarDecl {{.*}} invalid unresolved_typo 'auto'
   auto unresolved_typo = gned.*[] {};
 }
+
+// CHECK:      `-TypeAliasDecl {{.*}} Escape 'decltype([] {
+// CHECK-NEXT:   return <recovery-expr>(undef);
+// CHECK-NEXT: }())'
+// CHECK-NEXT:   `-DecltypeType {{.*}} 'decltype([] {
+// CHECK-NEXT:     return <recovery-expr>(undef);
+// CHECK-NEXT:   }())' dependent
+using Escape = decltype([] { return undef(); }());