[AST] Add API to iterate already loaded specializations

[Hahnfeld]

Summary

These new functions allow to look at specializations without triggering deserialization, which might be problematic in some contexts.

[Hahnfeld]

gentle ping :)

[aaron.ballman]

which might be problematic in some contexts.

I'd appreciate some more details on what those contexts are. It's a bit unpleasant to expose these APIs as part of the public interface because we typically *do* want deserialization. I'm not opposed to the changes, but we don't usually add APIs without any calls to the API. I assume you're planning to use these once they're in; are those uses from within Clang itself?

[Hahnfeld]

Right, it's not ideal to land APIs without usage in Clang itself... The context is, once again, ROOT and the Cling interpreter (where we are already using this API via downstream patches): When unloading a "transaction" (now PartialTranslationUnit in clang-repl) we need to "unload" all contained declarations, ie make the code generator forget that it had already emitted them. For templates, this is a bit tricky so we need to iterate specializations without triggering more deserialization. This will get important with D41416 where we only load needed specializations.

When playing a bit earlier this week, I learned that the problem related to "unloading" of template specializations can be observed upstream in clang-repl:

clang-repl> template <typename T> void f() {}
clang-repl> f<int>();
clang-repl> %undo
clang-repl> template <> void f<int>() {}
In file included from <<< inputs >>>:1:
input_line_3:1:18: error: explicit specialization of 'f<int>' after instantiation
    1 | template <> void f<int>() {}
      |                  ^
input_line_2:1:1: note: implicit instantiation first required here
    1 | f<int>();
      | ^
error: Parsing failed.

Let me see if I can come up a fix for that in clang-repl that would then need this API. But for now, it's also fine for us if the patch stays pending in review, still better than completely disconnected local commits...

[aaron.ballman]

In D154328#4542457, @Hahnfeld wrote:

Let me see if I can come up a fix for that in clang-repl that would then need this API. But for now, it's also fine for us if the patch stays pending in review, still better than completely disconnected local commits...

Thank you for the explanation! I think it makes sense to hold off on landing this until clang-reply needs to use the API. The code changes themselves look correct to me, so the review should hopefully sail through once there's test coverage exercising the functionality.

clang/include/clang/AST/DeclTemplate.h

public:
   spec_iterator spec_begin() const {
     return makeSpecIterator(getSpecializations(), false);
   }
 
   spec_iterator spec_end() const {
     return makeSpecIterator(getSpecializations(), true);
   }
 
+  /// All specializations that that have already been loaded, ie avoiding
+  /// deserialization of lazily registered specializations.
+  spec_range loaded_specializations() const {
+    return spec_range(loaded_spec_begin(), loaded_spec_end());
+  }
+
+  spec_iterator loaded_spec_begin() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, false);
+  }
+
+  spec_iterator loaded_spec_end() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, true);
+  }
+
   /// Return whether this function template is an abbreviated function template,
   /// e.g. `void foo(auto x)` or `template<typename T> void foo(auto x)`
   bool isAbbreviated() const {
     // Since the invented template parameters generated from 'auto' parameters
     // are either appended to the end of the explicit template parameter list or
     // form a new template parameter list, we can simply observe the last
     // parameter to determine if such a thing happened.
     const TemplateParameterList *TPL = getTemplateParameters();
public:
   spec_iterator spec_begin() const {
     return makeSpecIterator(getSpecializations(), false);
   }
 
   spec_iterator spec_end() const {
     return makeSpecIterator(getSpecializations(), true);
   }
 
+  /// All specializations that that have already been loaded, ie avoiding
+  /// deserialization of lazily registered specializations.
+  spec_range loaded_specializations() const {
+    return spec_range(loaded_spec_begin(), loaded_spec_end());
+  }
+
+  spec_iterator loaded_spec_begin() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, false);
+  }
+
+  spec_iterator loaded_spec_end() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, true);
+  }
+
   // Implement isa/cast/dyncast support
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ClassTemplate; }
 };
 
 /// Declaration of a friend template.
 ///
 /// For example:
public:
   spec_iterator spec_begin() const {
     return makeSpecIterator(getSpecializations(), false);
   }
 
   spec_iterator spec_end() const {
     return makeSpecIterator(getSpecializations(), true);
   }
 
+  /// All specializations that that have already been loaded, ie avoiding
+  /// deserialization of lazily registered specializations.
+  spec_range loaded_specializations() const {
+    return spec_range(loaded_spec_begin(), loaded_spec_end());
+  }
+
+  spec_iterator loaded_spec_begin() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, false);
+  }
+
+  spec_iterator loaded_spec_end() const {
+    return makeSpecIterator(getCommonPtr()->Specializations, true);
+  }
+
   // Implement isa/cast/dyncast support
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == VarTemplate; }
 };
 
 /// Declaration of a C++20 concept.
 class ConceptDecl : public TemplateDecl, public Mergeable<ConceptDecl> {
 protected: