[AST] Fix the CXXFoldExpr source range when parentheses range is invalid.

[hokein]

Summary

The CXXFoldExpr's range is invalid if the cxxfoldexpr is formed via the
Concept's TypeContraints (because the parentheses are not written in the
source code). We fallback to use the range from the pattern.

[nridge]

clang/include/clang/AST/ExprCXX.h

4589

Wouldn't EllipsisLoc be more accurate?

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

16

naming suggestion: variadic_concept?

[hokein]

address review comments.

clang/include/clang/AST/ExprCXX.h

4589

yeah, that sounds more reasonable.

[nridge]

clang/include/clang/AST/ExprCXX.h

4582

Can this case (left fold and no parenthesis) ever happen? It would be interesting to see an example.

[hokein]

clang/include/clang/AST/ExprCXX.h

4582

I think in theory it should not happen. Doing it here is for completeness, it seems a bit odd we only do the change for getEndLoc.

clang/include/clang/AST/ExprCXX.h

public:
   BinaryOperatorKind getOperator() const { return Opcode; }
 
   Optional<unsigned> getNumExpansions() const {
     if (NumExpansions)
       return NumExpansions - 1;
     return None;
   }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    if (LParenLoc.isValid())
+      return LParenLoc;
+    if (isLeftFold())
+      return getEllipsisLoc();
+    return getLHS()->getBeginLoc();
+  }
 
-  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    if (RParenLoc.isValid())
+      return RParenLoc;
+    if (isRightFold())
+      return getEllipsisLoc();
+    return getRHS()->getEndLoc();
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXFoldExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(SubExprs, SubExprs + SubExpr::Count);

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

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++2a -ast-dump -ast-dump-filter Foo %s | FileCheck -strict-whitespace %s
 
 // Test with serialization:
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown -emit-pch -o %t %s
 // RUN: %clang_cc1 -x c++ -std=c++20 -triple x86_64-unknown-unknown -include-pch %t \
 // RUN: -ast-dump-all -ast-dump-filter Foo /dev/null \
 // RUN: | FileCheck --strict-whitespace %s
 
 template <typename T>
 concept unary_concept = true;
 
 template <typename T, typename U>
 concept binary_concept = true;
 
+template <typename... Ts>
+concept variadic_concept = true;
+
 template <typename T>
 struct Foo {
   // CHECK:      TemplateTypeParmDecl {{.*}} referenced Concept {{.*}} 'binary_concept'
   // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} <col:13, col:31> 'bool' Concept {{.*}} 'binary_concept'
   // CHECK-NEXT:   |-TemplateArgument {{.*}} type 'R'
   // CHECK-NEXT:   | `-TemplateTypeParmType {{.*}} 'R'
   // CHECK-NEXT:   |   `-TemplateTypeParm {{.*}} 'R'
   // CHECK-NEXT:   `-TemplateArgument {{.*}} type 'int'
struct Foo {
   // CHECK:      FunctionTemplateDecl {{.*}} <line:[[@LINE+1]]:3, line:[[@LINE+2]]:39> {{.*}} Foo<T>
   template <typename R>
   Foo(R, int) requires unary_concept<R>;
 
   // CHECK:      FunctionTemplateDecl {{.*}} <line:[[@LINE+1]]:3, line:[[@LINE+3]]:3> {{.*}} Foo<T>
   template <typename R>
   Foo(R, char) requires unary_concept<R> {
   }
+
+  // CHECK: CXXFoldExpr {{.*}} <col:13, col:29>
+  template <variadic_concept... Ts>
+  Foo();
+
+  // CHECK: CXXFoldExpr {{.*}} <col:13, col:34>
+  template <variadic_concept<int>... Ts>
+  Foo();
 };