[Clang] Handle ellipsises in abiguous cast expressions.

[cor3ntin]

Summary

(T())(foo) is a cast expression because T()
is treated as a type-id, and the expression is valid.

However, (T())(foo...) is not a valid cast-expression,
because (type-id)(foo...) is invalid.
Yet, it is a valid postfix expression, ie,
T().operator()(foo...)

We previously would uncontitionally consider the whole thing
a cast expression and complained about expecting a
right parenthesis after foo.

We do keep track of whether we are in a context where the
type-id is ambiguous to keep the existing diagnostics for
the non ambiguous case (ie (void)(foo...)).

Fixes #64926

[cor3ntin]

As described here, clang is actually conforming, there is an open core issue with unclear resolution and that ""fix"" doesn't cover all the ambiguous use cases
https://github.com/llvm/llvm-project/issues/64926

clang/docs/ReleaseNotes.rst

 
 - Clang emits an error on substitution failure within lambda body inside a
   requires-expression. This fixes:
   (`#64138 <https://github.com/llvm/llvm-project/issues/64138>`_).
 
 - Update ``FunctionDeclBitfields.NumFunctionDeclBits``. This fixes:
   (`#64171 <https://github.com/llvm/llvm-project/issues/64171>`_).
 
+- Correctly parse ``(T())(pack...)`` as a call to ``T::operator()``
+  instead of an invalid cast expression.
+  (`#64926 <https://github.com/llvm/llvm-project/issues/64926>`_)
+
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed an import failure of recursive friend class template.
   `Issue 64169 <https://github.com/llvm/llvm-project/issues/64169>`_
 - Remove unnecessary RecordLayout computation when importing UnaryOperator. The
   computed RecordLayout is incorrect if fields are not completely imported and
   should not be cached.
   `Issue 64170 <https://github.com/llvm/llvm-project/issues/64170>`_

clang/include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
 
   /// When true, we are directly inside an Objective-C message
   /// send expression.
   ///
   /// This is managed by the \c InMessageExpressionRAIIObject class, and
   /// should not be set directly.
   bool InMessageExpression;
 
+  /// Track whether we are currently trying to parse an ambiguous
+  /// paren expression after a cast expression.
+  bool InAmbiguousCXXParenExprParsing;
+
   /// Gets set to true after calling ProduceSignatureHelp, it is for a
   /// workaround to make sure ProduceSignatureHelp is only called at the deepest
   /// function call.
   bool CalledSignatureHelp = false;
 
   Sema::OffsetOfKind OffsetOfState = Sema::OffsetOfKind::OOK_Outside;
 
   /// The "depth" of the template parameters currently being parsed.

clang/lib/Parse/ParseExpr.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/SmallVector.h"
 #include <optional>
 using namespace clang;
 
 /// Simple precedence-based parser for binary/ternary operators.
if (!ParseSimpleExpressionList(ArgExprs)) {
       // FIXME: If we ever support comma expressions as operands to
       // fold-expressions, we'll need to allow multiple ArgExprs here.
       if (ExprType >= FoldExpr && ArgExprs.size() == 1 &&
           isFoldOperator(Tok.getKind()) && NextToken().is(tok::ellipsis)) {
         ExprType = FoldExpr;
         return ParseFoldExpression(ArgExprs[0], T);
       }
 
+      // If we find an ellipsis, this cannot be part of a cast expression,
+      // stop there and try to parse a simple expression instead.
+      // This handles `(T())(expr...)`.
+      if(InAmbiguousCXXParenExprParsing && isTypeCast && Tok.is(tok::ellipsis)
+          && ExprType == Parser::CastExpr && getLangOpts().CPlusPlus) {
+        return ExprError();
+      }
+
       ExprType = SimpleExpr;
       Result = Actions.ActOnParenListExpr(OpenLoc, Tok.getLocation(),
                                           ArgExprs);
     }
   } else if (getLangOpts().OpenMP >= 50 && OpenMPDirectiveParsing &&
              ExprType == CastExpr && Tok.is(tok::l_square) &&
              tryParseOpenMPArrayShapingCastPart()) {
     bool ErrorFound = false;

clang/lib/Parse/ParseExprCXX.cpp

if (Tok.is(tok::l_brace)) {
     bool NotCastExpr;
     if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
       NotCastExpr = true;
     } else {
       // Try parsing the cast-expression that may follow.
       // If it is not a cast-expression, NotCastExpr will be true and no token
       // will be consumed.
       ColonProt.restore();
+      SaveAndRestore AmbiguousParenRAII(InAmbiguousCXXParenExprParsing, true);
       Result = ParseCastExpression(AnyCastExpr,
                                    false/*isAddressofOperand*/,
                                    NotCastExpr,
                                    // type-id has priority.
                                    IsTypeCast);
     }
 
     // If we parsed a cast-expression, it's really a type-id, otherwise it's

clang/lib/Parse/Parser.cpp

IdentifierInfo *Parser::getSEHExceptKeyword() {
 
   return Ident__except;
 }
 
 Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
     : PP(pp), PreferredType(pp.isCodeCompletionEnabled()), Actions(actions),
       Diags(PP.getDiagnostics()), GreaterThanIsOperator(true),
       ColonIsSacred(false), InMessageExpression(false),
+      InAmbiguousCXXParenExprParsing(false),
       TemplateParameterDepth(0), ParsingInObjCContainer(false) {
   SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies;
   Tok.startToken();
   Tok.setKind(tok::eof);
   Actions.CurScope = nullptr;
   NumCachedScopes = 0;
   CurParsedObjCImpl = nullptr;
 

clang/test/Parser/cxx-ambig-paren-expr.cpp

void test(int i) {
 
   if (result((ns::rec) i).check())
     return;
 
   if (result((::rec) i).check())
     return;
 }
 
+namespace GH64926 {
+template<typename T, typename... Args>
+void PackInAmbiguousCastExpression(Args... args) {
+    (void) (Args::foo()...); // expected-error {{expression contains unexpanded parameter pack 'Args'}} \
+                            // expected-error {{expected ')'}} expected-note {{to match this '('}}
+
+    (void) (args...);  // expected-error {{expression contains unexpanded parameter pack 'args'}} \
+                       // expected-error {{expected ')'}} expected-note {{to match this '('}}
+
+    (void) (((args))...);  // expected-error {{expression contains unexpanded parameter pack 'args'}} \
+                           // expected-error {{expected ')'}} expected-note {{to match this '('}}
+
+    (void) (((args...)));  // expected-error {{expression contains unexpanded parameter pack 'args'}} \
+                           // expected-error {{expected ')'}} expected-note {{to match this '('}}
+    (T()) (Args::foo()...);
+    (T()) (args...);
+    (T()) (((args))...);
+    (T()) (((args...))); // expected-error {{expression contains unexpanded parameter pack 'args'}} \
+                         // expected-error {{expected ')'}} expected-note {{to match this '('}}
+}
+}