Fix typos and cuda tests

Author: cor3ntin

clang/include/clang/Sema/Overload.h

@@ -1388,7 +1388,8 @@ class Sema;
 
   private:
     OverloadingResult ResultForBestCandidate(const iterator &Best);
-    void CudaExcludeWrongSideCandidates(Sema &S);
+    void CudaExcludeWrongSideCandidates(
+        Sema &S, SmallVectorImpl<OverloadCandidate *> &Candidates);
     OverloadingResult
     BestViableFunctionImpl(Sema &S, SourceLocation Loc,
                            OverloadCandidateSet::iterator &Best);
@@ -1447,10 +1448,17 @@ class Sema;
     return
         // For user defined conversion we need to check against different
         // combination of CV qualifiers and look at any expicit specifier, so
-        // always deduce template candidate.
+        // always deduce template candidates.
         Kind != CSK_InitByUserDefinedConversion &&
-        Kind != CSK_InitByConstructor && Kind != CSK_CodeCompletion &&
-        Opts.CPlusPlus && (!Opts.CUDA || Opts.GPUExcludeWrongSideOverloads);
+        Kind != CSK_InitByConstructor
+        // When doing code completion, we want to see all the
+        // viable candidates.
+        && Kind != CSK_CodeCompletion &&
+        Opts.CPlusPlus
+        // When -fgpu-exclude-wrong-side-overloads, CUDA needs
+        // to exclude templates from the overload sets after they
+        // have been instantiated. See CudaExcludeWrongSideCandidates.
+        && (!Opts.CUDA || !Opts.GPUExcludeWrongSideOverloads);
   }
 
 } // namespace clang

clang/lib/Sema/SemaInit.cpp

@@ -10031,7 +10031,7 @@ QualType Sema::DeduceTemplateSpecializationFromInitializer(
     if (TD) {
 
       // As template candidates are not deduced immediately,
-      // persist the arry in the overload set.
+      // persist the array in the overload set.
       MutableArrayRef<Expr *> TmpInits =
           Candidates.getPersistentArgsArray(Inits.size());
 

clang/lib/Sema/SemaOverload.cpp

@@ -8535,7 +8535,7 @@ void Sema::AddNonMemberOperatorCandidates(
       if (CandidateSet.getRewriteInfo().shouldAddReversed(*this, Args, FD)) {
 
         // As template candidates are not deduced immediately,
-        // persist the arry in the overload set.
+        // persist the array in the overload set.
         ArrayRef<Expr *> Reversed = CandidateSet.getPersistentArgsArray(
             FunctionArgs[1], FunctionArgs[0]);
         AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
@@ -10317,7 +10317,7 @@ Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
               *this, Args, FTD->getTemplatedDecl())) {
 
         // As template candidates are not deduced immediately,
-        // persist the arry in the overload set.
+        // persist the array in the overload set.
         if (ReversedArgs.empty())
           ReversedArgs = CandidateSet.getPersistentArgsArray(Args[1], Args[0]);
 
@@ -11091,7 +11091,8 @@ OverloadCandidateSet::ResultForBestCandidate(const iterator &Best) {
   return OR_Success;
 }
 
-void OverloadCandidateSet::CudaExcludeWrongSideCandidates(Sema &S) {
+void OverloadCandidateSet::CudaExcludeWrongSideCandidates(
+    Sema &S, SmallVectorImpl<OverloadCandidate *> &Candidates) {
   // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
   // are accepted by both clang and NVCC. However, during a particular
   // compilation mode only one call variant is viable. We need to
@@ -11108,26 +11109,23 @@ void OverloadCandidateSet::CudaExcludeWrongSideCandidates(Sema &S) {
   const FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true);
 
   bool ContainsSameSideCandidate =
-      llvm::any_of(Candidates, [&](const OverloadCandidate &Cand) {
+      llvm::any_of(Candidates, [&](const OverloadCandidate *Cand) {
         // Check viable function only.
-        return Cand.Viable && Cand.Function &&
-               S.CUDA().IdentifyPreference(Caller, Cand.Function) ==
+        return Cand->Viable && Cand->Function &&
+               S.CUDA().IdentifyPreference(Caller, Cand->Function) ==
                    SemaCUDA::CFP_SameSide;
       });
+
   if (!ContainsSameSideCandidate)
     return;
 
-  auto IsWrongSideCandidate = [&](const OverloadCandidate &Cand) {
+  auto IsWrongSideCandidate = [&](const OverloadCandidate *Cand) {
     // Check viable function only to avoid unnecessary data copying/moving.
-    return Cand.Viable && Cand.Function &&
-           S.CUDA().IdentifyPreference(Caller, Cand.Function) ==
+    return Cand->Viable && Cand->Function &&
+           S.CUDA().IdentifyPreference(Caller, Cand->Function) ==
                SemaCUDA::CFP_WrongSide;
   };
-
-  for (auto &Cand : Candidates) {
-    if (IsWrongSideCandidate(Cand))
-      Cand.Viable = false;
-  }
+  llvm::erase_if(Candidates, IsWrongSideCandidate);
 }
 
 /// Computes the best viable function (C++ 13.3.3)
@@ -11148,9 +11146,6 @@ OverloadingResult OverloadCandidateSet::BestViableFunction(Sema &S,
          DeferredCandidates.empty() &&
              "Unexpected deferred template candidate");
 
-  if (S.getLangOpts().CUDA)
-    CudaExcludeWrongSideCandidates(S);
-
   bool TwoPhaseResolution = !DeferredCandidates.empty();
 
   if (TwoPhaseResolution) {
@@ -11160,16 +11155,14 @@ OverloadingResult OverloadCandidateSet::BestViableFunction(Sema &S,
       return ResultForBestCandidate(Best);
 
     InjectNonDeducedTemplateCandidates(S);
-
-    if (S.getLangOpts().CUDA)
-      CudaExcludeWrongSideCandidates(S);
   }
 
   return BestViableFunctionImpl(S, Loc, Best);
 }
 
 void OverloadCandidateSet::PerfectViableFunction(
     Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best) {
+
   Best = end();
   for (auto It = begin(); It != end(); ++It) {
     if (It->isPerfectMatch(S.getASTContext())) {
@@ -11202,6 +11195,9 @@ OverloadingResult OverloadCandidateSet::BestViableFunctionImpl(
   std::transform(begin(), end(), std::back_inserter(Candidates),
                  [](OverloadCandidate &Cand) { return &Cand; });
 
+  if (S.getLangOpts().CUDA)
+    CudaExcludeWrongSideCandidates(S, Candidates);
+
   Best = end();
   for (auto *Cand : Candidates) {
     Cand->Best = false;
@@ -14954,7 +14950,7 @@ void Sema::LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
   AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
 
   // As template candidates are not deduced immediately,
-  // persist the arry in the overload set.
+  // persist the array in the overload set.
   ArrayRef<Expr *> ReversedArgs;
   if (CandidateSet.getRewriteInfo().allowsReversed(Op) ||
       CandidateSet.getRewriteInfo().allowsReversed(ExtraOp))