Fix missing initializer for inline static template member with auto caused by delayed template instantiation. #138122

dty2 · 2025-05-01T11:44:27Z

Try to fix missing initializer for inline static template member with auto caused by delayed template instantiation.

Bug Fix: Bug 135032
Problem Description:
Due to nested templates, when instantiating the outer layer (the template class), the inner layer (the template variable) uses delayed instantiation.
This causes the declaration (VarDecl) of the template variable to retain the type from the original template declaration (i.e., auto), and it loses the initializer.
Later, when instantiating the template variable, its VarTemplateSpecializationDecl type depends on the VarDecl type.
Thus, the VarTemplateSpecializationDecl also has no initializer, and its type remains auto.
Ultimately, when building the reference expression in Sema::BuildDeclarationNameExpr, the expression's type is auto and stays as auto until code generation, triggering llvm_unreachable in CodeGenTypes::ConvertType.

Reproduction Steps:
Test Code:

template <typename T> struct B {
  template <typename G> inline static auto var = 5;
};

int main() {
  int bb = B<int>::var<int>;
  return 0;
}

GDB Breakpoints for Debugging:
Annotations like #(1) mark the call order in a tree structure. For example, two #(3) entries mean Sema::CheckVarTemplateId calls Sema::BuildDeclarationNameExpr after its own execution.

#(1)
b Sema::BuildTemplateIdExpr
#(2)
b Sema::CheckVarTemplateId
#(3)
b Sema::CheckVarTemplateId
#(4)
b Sema::BuildVarTemplateInstantiation
#(5)
b TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl
#(6)
b VarTemplateSpecializationDecl::Create
#(7)
b VarTemplateSpecializationDecl::VarTemplateSpecializationDecl
#(8)
b VarDecl::VarDecl
#(6)
b Sema::BuildVariableInstantiation
#(7)
b Sema::InstantiateVariableInitializer
#(3)
b Sema::BuildDeclarationNameExpr
#(4)
b Sema::BuildDeclRefExpr

Key Observations:
While debugging, I generated the AST for the test code and noticed a contradiction:

The AST shows VarTemplateSpecializationDecl as int (correct), but GDB reveals its type is actually auto during execution.

Example from AST:

DeclRefExpr 0x598f651f5a60 <col:9, col:27> 'auto' lvalue VarTemplateSpecialization 0x598f651f5980 'var' 'int' (VarTemplate 0x598f651d1938 'var')
The DeclRefExpr has type auto, while its referenced VarTemplateSpecialization claims to be int—a clear inconsistency.

Solution:
Since I noticed that the deduction of auto type is caused by the initializer
I plan to do special processing for template variables of type auto, that is, to prevent their delayed instantiation
so that their initializers will not be lost when the outer template class is instantiated

…h auto caused by delayed template instantiation.

llvmbot · 2025-05-01T11:45:03Z

@llvm/pr-subscribers-clang

Author: 执着 (dty2)

Changes

Try to fix missing initializer for inline static template member with auto caused by delayed template instantiation.

Bug Fix: Bug 135032
Problem Description:
Due to nested templates, when instantiating the outer layer (the template class), the inner layer (the template variable) uses delayed instantiation.
This causes the declaration (VarDecl) of the template variable to retain the type from the original template declaration (i.e., auto), and it loses the initializer.
Later, when instantiating the template variable, its VarTemplateSpecializationDecl type depends on the VarDecl type.
Thus, the VarTemplateSpecializationDecl also has no initializer, and its type remains auto.
Ultimately, when building the reference expression in Sema::BuildDeclarationNameExpr, the expression's type is auto and stays as auto until code generation, triggering llvm_unreachable in CodeGenTypes::ConvertType.

Reproduction Steps:
Test Code:

template &lt;typename T&gt; struct B {
  template &lt;typename G&gt; inline static auto var = 5;
};

int main() {
  int bb = B&lt;int&gt;::var&lt;int&gt;;
  return 0;
}

GDB Breakpoints for Debugging:
Annotations like #(1) mark the call order in a tree structure. For example, two #(3) entries mean Sema::CheckVarTemplateId calls Sema::BuildDeclarationNameExpr after its own execution.

#(1)
b Sema::BuildTemplateIdExpr
#(2)
b Sema::CheckVarTemplateId
#(3)
b Sema::CheckVarTemplateId
#(4)
b Sema::BuildVarTemplateInstantiation
#(5)
b TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl
#(6)
b VarTemplateSpecializationDecl::Create
#(7)
b VarTemplateSpecializationDecl::VarTemplateSpecializationDecl
#(8)
b VarDecl::VarDecl
#(6)
b Sema::BuildVariableInstantiation
#(7)
b Sema::InstantiateVariableInitializer
#(3)
b Sema::BuildDeclarationNameExpr
#(4)
b Sema::BuildDeclRefExpr

Key Observations:
While debugging, I generated the AST for the test code and noticed a contradiction:

The AST shows VarTemplateSpecializationDecl as int (correct), but GDB reveals its type is actually auto during execution.

Example from AST:

DeclRefExpr 0x598f651f5a60 <col:9, col:27> 'auto' lvalue VarTemplateSpecialization 0x598f651f5980 'var' 'int' (VarTemplate 0x598f651d1938 'var')
The DeclRefExpr has type auto, while its referenced VarTemplateSpecialization claims to be int—a clear inconsistency.

Solution:
Since I noticed that the deduction of auto type is caused by the initializer
I plan to do special processing for template variables of type auto, that is, to prevent their delayed instantiation
so that their initializers will not be lost when the outer template class is instantiated

Full diff: https://github.com/llvm/llvm-project/pull/138122.diff

3 Files Affected:

(modified) clang/lib/Sema/SemaTemplateInstantiateDecl.cpp (+7-1)
(modified) clang/test/CodeGenCXX/cxx1z-inline-variables.cpp (+8)
(modified) clang/test/SemaTemplate/cxx17-inline-variables.cpp (+6)

diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 76c055d28f091..eb66ec34a956f 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -6027,8 +6027,14 @@ void Sema::BuildVariableInstantiation(
   Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
   Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
 
+  bool VarTemplateWithAutoType = false;
+  QualType VarSourceType = OldVar->getTypeSourceInfo()->getType();
+  if (VarSourceType->getAs<AutoType>()) {
+    VarTemplateWithAutoType = true;
+  }
+
   // Figure out whether to eagerly instantiate the initializer.
-  if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
+  if ((InstantiatingVarTemplate && !VarTemplateWithAutoType) || InstantiatingVarTemplatePartialSpec) {
     // We're producing a template. Don't instantiate the initializer yet.
   } else if (NewVar->getType()->isUndeducedType()) {
     // We need the type to complete the declaration of the variable.
diff --git a/clang/test/CodeGenCXX/cxx1z-inline-variables.cpp b/clang/test/CodeGenCXX/cxx1z-inline-variables.cpp
index 812e438f30c9a..b1d8e376b826f 100644
--- a/clang/test/CodeGenCXX/cxx1z-inline-variables.cpp
+++ b/clang/test/CodeGenCXX/cxx1z-inline-variables.cpp
@@ -1,5 +1,13 @@
 // RUN: %clang_cc1 -std=c++1z %s -emit-llvm -o - -triple x86_64-linux-gnu | FileCheck %s
 
+template <typename T> struct B {
+  template <typename G> inline static auto var = 5;
+};
+
+int inlinevartemplate = B<int>::var<int>;
+// CHECK: @_ZN1BIiE3varIiEE = {{.*}}global i32 5{{.*}}comdat
+// CHECK-NOT: @_ZN1BIiE3varIfEE
+
 struct Q {
   // CHECK: @_ZN1Q1kE = linkonce_odr constant i32 5, comdat
   static constexpr int k = 5;
diff --git a/clang/test/SemaTemplate/cxx17-inline-variables.cpp b/clang/test/SemaTemplate/cxx17-inline-variables.cpp
index 7fc0aa8eeeb0c..27067c8e1b5e4 100644
--- a/clang/test/SemaTemplate/cxx17-inline-variables.cpp
+++ b/clang/test/SemaTemplate/cxx17-inline-variables.cpp
@@ -27,3 +27,9 @@ template <typename T> constexpr int A<T>::n = sizeof(A) + sizeof(T);
 template <typename T> inline constexpr int A<T>::m = sizeof(A) + sizeof(T);
 static_assert(A<int>().f() == 5);
 static_assert(A<int>().g() == 5);
+
+template <typename T> struct B {
+  template <typename G> inline static auto var = 5;
+};
+
+int b = B<int>::var<int>;

github-actions · 2025-05-01T11:46:40Z

✅ With the latest revision this PR passed the C/C++ code formatter.

…h auto caused by delayed template instantiation.

zyn0217 · 2025-05-01T12:12:49Z

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

+  bool VarTemplateWithAutoType = false;
+  QualType VarSourceType = OldVar->getTypeSourceInfo()->getType();
+  if (VarSourceType->getAs<AutoType>()) {
+    VarTemplateWithAutoType = true;
+  }
+


Suggested change

bool VarTemplateWithAutoType = false;

QualType VarSourceType = OldVar->getTypeSourceInfo()->getType();

if (VarSourceType->getAs<AutoType>()) {

VarTemplateWithAutoType = true;

}

bool VarTemplateWithAutoType = OldVar->getTypeSourceInfo()->getType()->getAs<AutoType>();

Can we avoid getTypeSourceInfo?

Your suggestion is correct, I will adopt it.

zyn0217 · 2025-05-01T12:25:42Z

Also, can you help me test if this fixes #134526? Thanks

dty2 · 2025-05-01T13:20:37Z

Also, can you help me test if this fixes #134526? Thanks

sure, no problem.

dty2 · 2025-05-01T13:28:32Z

@zyn0217
I can compile it successfuly, and the output is 1.

#include <iostream>
template <class T>
struct S {
  template <class U> static const auto var = T();
  template <class U> static const auto foo = var<T>;
};

int main() {
  const int p = S<int>::var<int> + S<int>::foo<int> + 1;
  std::cout << p;
  return 0;
}

zwuis

Please add a release note in clang/docs/ReleaseNotes.rst .

zwuis · 2025-05-01T13:38:20Z

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -6027,8 +6027,15 @@ void Sema::BuildVariableInstantiation(
  Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
  Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));

+  bool VarTemplateWithAutoType = false;
+  QualType VarSourceType = OldVar->getTypeSourceInfo()->getType();
+  if (VarSourceType->getAs<AutoType>()) {


Can we use ->isUndeducedType() to handle this case

template <typename T> struct S { S(T); }; template <typename T> struct B { template <typename G> inline static S var = 5; };

?

Update: And we need to change OldVar-> to NewVar->.

zwuis · 2025-05-02T14:40:44Z

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

+  if ((InstantiatingVarTemplate && !VarTemplateWithAutoType) ||
+      InstantiatingVarTemplatePartialSpec) {
    // We're producing a template. Don't instantiate the initializer yet.
  } else if (NewVar->getType()->isUndeducedType()) {
    // We need the type to complete the declaration of the variable.


It seems that we can just swap these two if statements. We need to handle partial specializations as well. E.g.

template <typename> struct B { template <typename, typrname> inline static auto var = 6; template <typename T> inline static auto var<int, T> = 7; }; int b = B<int>::var<int, int>;

[clang] Fix missing initializer for inline static template member wit…

f9bdf07

…h auto caused by delayed template instantiation.

llvmbot added clang Clang issues not falling into any other category clang:frontend Language frontend issues, e.g. anything involving "Sema" labels May 1, 2025

dty2 mentioned this pull request May 1, 2025

[clang] Crash instantiating static variable template specialization member of class template #135032

Open

[Clang] Fix missing initializer for inline static template member wit…

3c21bee

…h auto caused by delayed template instantiation.

zyn0217 reviewed May 1, 2025

View reviewed changes

zwuis reviewed May 1, 2025

View reviewed changes

zwuis reviewed May 2, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Fix missing initializer for inline static template member with auto caused by delayed template instantiation. #138122

Fix missing initializer for inline static template member with auto caused by delayed template instantiation. #138122

dty2 commented May 1, 2025

llvmbot commented May 1, 2025

github-actions bot commented May 1, 2025 •

edited

Loading

zyn0217 May 1, 2025

dty2 May 1, 2025

zyn0217 commented May 1, 2025

dty2 commented May 1, 2025

dty2 commented May 1, 2025

zwuis left a comment

zwuis May 1, 2025 •

edited

Loading

zwuis May 2, 2025

Fix missing initializer for inline static template member with auto caused by delayed template instantiation. #138122

Are you sure you want to change the base?

Fix missing initializer for inline static template member with auto caused by delayed template instantiation. #138122

Conversation

dty2 commented May 1, 2025

llvmbot commented May 1, 2025

github-actions bot commented May 1, 2025 • edited Loading

zyn0217 May 1, 2025

Choose a reason for hiding this comment

dty2 May 1, 2025

Choose a reason for hiding this comment

zyn0217 commented May 1, 2025

dty2 commented May 1, 2025

dty2 commented May 1, 2025

zwuis left a comment

Choose a reason for hiding this comment

zwuis May 1, 2025 • edited Loading

Choose a reason for hiding this comment

zwuis May 2, 2025

Choose a reason for hiding this comment

github-actions bot commented May 1, 2025 •

edited

Loading

zwuis May 1, 2025 •

edited

Loading