[Sema] Fix `ExtVectorElementExpr` tree transform for the `isArrow` case.

[michele.scandale]

Summary

Make sure we propagate the value for IsArrow to
RebuildExtVectorElementExpr in order to be able to handle correctly
vector component accesses where the base value is a pointer.

[michele.scandale]

Clang-format fixes

[michele.scandale]

Rebased

[michele.scandale]

Ping

[rjmccall]

LGTM

[michele.scandale]

Final rebase

[michele.scandale]

@rjmccall would you be able to land this on my behalf? Thanks in advance.

[michele.scandale]

In D131698#3848469, @michele.scandale wrote:

@rjmccall would you be able to land this on my behalf? Thanks in advance.

I got commit access. I will take care of landing the change. Thanks anyway.

clang/lib/Sema/TreeTransform.h

 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
 //
 // 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 implements a semantic tree transformation that takes a given
 //  AST and rebuilds it, possibly transforming some nodes in the process.
ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
     return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
                                               Init);
   }
 
   /// Build a new extended vector element access expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
-  ExprResult RebuildExtVectorElementExpr(Expr *Base,
-                                               SourceLocation OpLoc,
-                                               SourceLocation AccessorLoc,
-                                               IdentifierInfo &Accessor) {
+  ExprResult RebuildExtVectorElementExpr(Expr *Base, SourceLocation OpLoc,
+                                         bool IsArrow,
 
     CXXScopeSpec SS;
     DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
     return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
-                                              OpLoc, /*IsArrow*/ false,
+                                              OpLoc, IsArrow,
                                               SS, SourceLocation(),
                                               /*FirstQualifierInScope*/ nullptr,
                                               NameInfo,
                                               /* TemplateArgs */ nullptr,
                                               /*S*/ nullptr);
   }
 
   /// Build a new initializer list expression.
TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
 
   if (!getDerived().AlwaysRebuild() &&
       Base.get() == E->getBase())
     return E;
 
   // FIXME: Bad source location
   SourceLocation FakeOperatorLoc =
       SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
-  return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
-                                                  E->getAccessorLoc(),
-                                                  E->getAccessor());
+  return getDerived().RebuildExtVectorElementExpr(
+      Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(),
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
   if (InitListExpr *Syntactic = E->getSyntacticForm())
     E = Syntactic;
 

clang/test/SemaTemplate/instantiate-clang.cpp

struct ExtVectorAccess0 {
   void f(T v1, double4 v2) {
     v1.xy = v2.yx;
   }
 };
 
 template struct ExtVectorAccess0<double2>;
 template struct ExtVectorAccess0<double4>;
 
-typedef __attribute__(( ext_vector_type(2) )) double double2;
+template<typename T>
+struct ExtVectorAccess1 {
+  void f(T *v1, double4 *v2) {
+    v1->xy = v2->yx;
+  }
+};
+
+template struct ExtVectorAccess1<double2>;
+template struct ExtVectorAccess1<double4>;
 
 template<typename T, typename U, int N, int M>
 struct ShuffleVector0 {
   void f(T t, U u, double2 a, double2 b) {
     (void)__builtin_shufflevector(t, u, N, M); // expected-error{{index}}
     (void)__builtin_shufflevector(a, b, N, M); // expected-error{{index}}
     (void)__builtin_shufflevector(a, b, 2, 1);
   }
 };
 
 template struct ShuffleVector0<double2, double2, 2, 1>;
 template struct ShuffleVector0<double2, double2, 4, 3>; // expected-note{{instantiation}}