chore: Expand unresolved type references during template instantiation

src/parser/cxx/parser.cc

@@ -5554,12 +5554,11 @@ auto Parser::instantiate(SimpleTemplateIdAST* templateId) -> Symbol* {
 
   auto needsInstantiation = [&]() -> bool {
     if (args.empty()) return true;
-    for (std::size_t i = 0; i < args.size(); ++i) {
-      auto typeArgument = std::get_if<const Type*>(&args[i]);
+    for (auto arg : args) {
+      auto typeArgument = std::get_if<const Type*>(&arg);
       if (!typeArgument) return true;
       auto ty = type_cast<TypeParameterType>(*typeArgument);
       if (!ty) return true;
-      if (ty->symbol()->index() != i) return true;
     }
     return false;
   };

src/parser/cxx/symbol_instantiation.cc

@@ -605,6 +605,21 @@ auto SymbolInstantiation::VisitType::operator()(const UnresolvedNameType* type)
         args.push_back(substitute(arg->typeId->type));
       }
     }
+
+    auto needsInstantiation = [&]() -> bool {
+      if (args.empty()) return true;
+
+      for (auto arg : args) {
+        auto typeArgument = std::get_if<const Type*>(&arg);
+        if (!typeArgument) return true;
+        auto ty = type_cast<TypeParameterType>(*typeArgument);
+        if (!ty) return true;
+      }
+      return false;
+    };
+
+    if (!needsInstantiation()) return type;
+
     auto symbol = self.control()->instantiate(type->translationUnit(),
                                               templateId->primaryTemplateSymbol,
                                               std::move(args));

src/parser/cxx/symbols.h

@@ -717,17 +717,20 @@ auto symbol_cast(Symbol* symbol) -> T* {
 struct GetTemplateParameters {
   auto operator()(Symbol* symbol) const -> TemplateParametersSymbol* {
     if (!symbol) return nullptr;
-    return visit(Visitor{*this}, symbol);
+    return visit(Visitor{}, symbol);
   }
 
  private:
   struct Visitor {
-    const GetTemplateParameters& getTemplateParameters;
-
     auto operator()(ConceptSymbol* symbol) const -> TemplateParametersSymbol* {
       return symbol->templateParameters();
     }
 
+    auto operator()(TemplateTypeParameterSymbol* symbol) const
+        -> TemplateParametersSymbol* {
+      return symbol->templateParameters();
+    }
+
     auto operator()(ClassSymbol* symbol) const -> TemplateParametersSymbol* {
       return symbol->templateParameters();
     }

tests/unit_tests/sema/template_class_03.cc

@@ -0,0 +1,45 @@
+// RUN: %cxx -verify -fcheck -ftemplates -dump-symbols %s | %filecheck %s
+
+namespace std {
+using size_t = decltype(sizeof(0));
+
+template <typename T>
+struct allocator {
+  template <typename U>
+  struct rebind {
+    typedef allocator<U> other;
+  };
+
+  auto allocate(size_t n) -> T*;
+  void deallocate(T* p, size_t n);
+};
+}  // namespace std
+
+std::allocator<int>::rebind<char> alloc8;
+std::allocator<int>::rebind<short> alloc16;
+
+// clang-format off
+//      CHECK:namespace
+// CHECK-NEXT:  namespace std
+// CHECK-NEXT:    typealias unsigned long size_t
+// CHECK-NEXT:    template class allocator
+// CHECK-NEXT:      parameter typename<0, 0> T
+// CHECK-NEXT:      template class rebind
+// CHECK-NEXT:        parameter typename<0, 1> U
+// CHECK-NEXT:        typealias allocator<U> other
+// CHECK-NEXT:      function T* allocate(unsigned long)
+// CHECK-NEXT:      function void deallocate(T*, unsigned long)
+// CHECK-NEXT:      [specializations]
+// CHECK-NEXT:        class allocator<int>
+// CHECK-NEXT:          template class rebind
+// CHECK-NEXT:            parameter typename<0, 1> U
+// CHECK-NEXT:            typealias allocator<U> other
+// CHECK-NEXT:            [specializations]
+// CHECK-NEXT:              class rebind<char>
+// CHECK-NEXT:                typealias allocator<U> other
+// CHECK-NEXT:              class rebind<short>
+// CHECK-NEXT:                typealias allocator<U> other
+// CHECK-NEXT:          function int* allocate(unsigned long)
+// CHECK-NEXT:          function void deallocate(int*, unsigned long)
+// CHECK-NEXT:  variable std::allocator<int>::rebind<char> alloc8
+// CHECK-NEXT:  variable std::allocator<int>::rebind<short> alloc16