[Sema] Avoid using an invalid InsertPos

[Mordante]

Summary

The function Sema::CheckVarTemplateId tries to find a template specialization. If that fails it gets an InsertPos where the specialization should be added in a FoldingSet. Then it tries to resolve dependant arguments. This may add an item to the same FoldingSet. If this happens the set may be resized, which invalidates InsertPos.

It would be possible to send a nullptr to the call to BuildVarTemplateInstantiation, but that changes the behavior and fixing that seemed quite intrusive. Therefore the InsertPos is determined again before making the call.

Fixes PR43221: Assertion failure in translation unit with exactly 1 less than a power of 2 (starting at 127) operator== overloads combined with at least one operator== template with a substitution failure

[merge_guards_bot]

Unit tests: pass. 61175 tests passed, 0 failed and 729 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[Mordante]

Friendly ping.

[Mordante]

Friendly ping.

[Mordante]

Rebased the patch and updated the unit tests.

[shafik]

It looks like the original bug no longer reproduces: https://github.com/llvm/llvm-project/issues/42566

Is this PR still needed?

clang/lib/Sema/SemaTemplate.cpp

if (Matched.size() >= 1) {
       InstantiationArgs = Best->Args;
     } else {
       //   -- If no match is found, the instantiation is generated
       //      from the primary template.
       // InstantiationPattern = Template->getTemplatedDecl();
     }
   }
 
+  // The InsertPos needs to be reloaded:
+  // The call to TemplateSpecializationType::anyDependentTemplateArguments
+  // above may call ASTContext::getSubstTemplateTypeParmType. This function
+  // adds a new element in the FoldingSet InsertPos points at. If the
+  // FoldingSet resizes due to this insertion the 'iterator' is no longer
+  // valid.
+  VarTemplateSpecializationDecl *Spec =
+      Template->findSpecialization(Converted, InsertPos);
+  assert(!Spec && "Reloading InsertPos found a template specialization");
+  (void)Spec;
+
   // 2. Create the canonical declaration.
   // Note that we do not instantiate a definition until we see an odr-use
   // in DoMarkVarDeclReferenced().
   // FIXME: LateAttrs et al.?
   VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
       Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
       Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
   if (!Decl)

clang/test/SemaTemplate/instantiate-var-template.cpp

namespace NonDependent {
   static_assert(b<int> == 0, "");
 }
 
 namespace InstantiationDependent {
   int f(int);
   void f(char);
 
   template<int> constexpr int a = 1;
   template<typename T> constexpr T b = a<sizeof(sizeof(f(T())))>; // expected-error {{invalid application of 'sizeof' to an incomplete type 'void'}}
 
   static_assert(b<int> == 1, "");
   static_assert(b<char> == 1, ""); // expected-note {{in instantiation of}} expected-error {{not an integral constant}}
 
   template<typename T> void f() {
     static_assert(a<sizeof(sizeof(f(T())))> == 0, ""); // expected-error {{static_assert failed}}
   }
 }
 
 namespace PR24483 {
   template<typename> struct A;
   template<typename... T> A<T...> models;
   template<> struct B models<>; // expected-error {{incomplete type 'struct B'}} expected-note {{forward declaration}}
 }
+
+namespace PR43221 {
+// This test crashed before so the main reason for the test is to see that it
+// no longer will crash.
+
+template <bool>
+struct enable_if;
+
+template <>
+struct enable_if<true> { using type = void; };
+
+template <typename T, typename = void>
+constexpr bool always_false = false;
+
+// expected-note@+2 {{in instantiation of member function}}
+template <typename T>
+constexpr bool always_false<T, decltype(foo(T()))> = T() == T();
+
+template <typename T, typename = typename enable_if<always_false<T>>::type>
+bool operator==(T, T);
+
+// expected-note@+2 {{candidate template ignored: substitution failure}}
+template <typename T, typename = typename enable_if<always_false<T>>::type>
+void data(T);
+
+template <int>
+struct S {};
+template <int x>
+constexpr bool operator==(S<x>, S<x>) { return false; }
+
+template <int x>
+constexpr bool s = S<x>() == S<x>() and s<x - 1>;
+
+template <>
+constexpr bool s<0> = S<0>() == S<0>();
+
+void test() { s<127>; } // expected-warning {{expression result unused}}
+
+// expected-note@+2 {{while substituting deduced template arguments into function template}}
+template <typename T>
+struct wrapper {
+  wrapper() = default;
+  wrapper(wrapper &&) = default;
+
+  // expected-note@+2 {{during template argument deduction for variable template partial specialization}}
+  // expected-note@+2 {{in instantiation of default argument}}
+  template <typename U, typename = typename enable_if<always_false<U>>::type>
+  explicit wrapper(U);
+
+  // expected-error@+1 {{no matching function for call to 'data'}}
+  friend auto foo(wrapper w) { data(w.m); }
+
+  int m;
+};
+
+// expected-note@+1 {{while declaring the implicit copy constructor for}}
+struct wrapper2 {
+  wrapper<void> m;
+};
+
+} // namespace PR43221