diff --git a/src/parser/cxx/binder.cc b/src/parser/cxx/binder.cc
index 67ccadc8..94e0a463 100644
--- a/src/parser/cxx/binder.cc
+++ b/src/parser/cxx/binder.cc
@@ -272,10 +272,11 @@ void Binder::bind(ClassSpecifierAST* ast, DeclSpecs& declSpecs) {
           unit_, primaryTemplateSymbol->templateDeclaration(),
           templateId->templateArgumentList);
 
-      specialization =
-          primaryTemplateSymbol
-              ? primaryTemplateSymbol->findSpecialization(templateArguments)
-              : nullptr;
+      specialization = primaryTemplateSymbol
+                           ? symbol_cast<ClassSymbol>(
+                                 primaryTemplateSymbol->findSpecialization(
+                                     templateArguments))
+                           : nullptr;
 
       if (specialization) {
         error(location, std::format("redefinition of specialization '{}'",
@@ -518,6 +519,8 @@ void Binder::bind(UsingDeclaratorAST* ast, Symbol* target) {
 }
 
 void Binder::bind(BaseSpecifierAST* ast) {
+  const auto checkTemplates = unit_->config().checkTypes;
+
   Symbol* symbol = nullptr;
 
   if (auto decltypeId = ast_cast<DecltypeIdAST>(ast->unqualifiedId)) {
@@ -525,12 +528,12 @@ void Binder::bind(BaseSpecifierAST* ast) {
             control()->remove_cv(decltypeId->decltypeSpecifier->type))) {
       symbol = classType->symbol();
     }
+  } else {
+    symbol =
+        resolve(ast->nestedNameSpecifier, ast->unqualifiedId, checkTemplates);
   }
 
-  if (auto nameId = ast_cast<NameIdAST>(ast->unqualifiedId)) {
-    symbol = Lookup{scope_}(ast->nestedNameSpecifier, nameId->identifier);
-  }
-
+  // dealias
   if (auto typeAlias = symbol_cast<TypeAliasSymbol>(symbol)) {
     if (auto classType =
             type_cast<ClassType>(control()->remove_cv(typeAlias->type()))) {
@@ -538,32 +541,34 @@ void Binder::bind(BaseSpecifierAST* ast) {
     }
   }
 
-  if (symbol) {
-    auto location = ast->unqualifiedId->firstSourceLocation();
-    auto baseClassSymbol = control()->newBaseClassSymbol(scope(), location);
-    ast->symbol = baseClassSymbol;
+  if (!symbol || !symbol->isClass()) {
+    error(ast->unqualifiedId->firstSourceLocation(),
+          "base class specifier must be a class");
+    return;
+  }
+
+  auto location = ast->unqualifiedId->firstSourceLocation();
+  auto baseClassSymbol = control()->newBaseClassSymbol(scope(), location);
+  ast->symbol = baseClassSymbol;
 
-    baseClassSymbol->setVirtual(ast->isVirtual);
-    baseClassSymbol->setSymbol(symbol);
+  baseClassSymbol->setVirtual(ast->isVirtual);
+  baseClassSymbol->setSymbol(symbol);
 
-    if (symbol) {
-      baseClassSymbol->setName(symbol->name());
-    }
+  baseClassSymbol->setName(symbol->name());
 
-    switch (ast->accessSpecifier) {
-      case TokenKind::T_PRIVATE:
-        baseClassSymbol->setAccessSpecifier(AccessSpecifier::kPrivate);
-        break;
-      case TokenKind::T_PROTECTED:
-        baseClassSymbol->setAccessSpecifier(AccessSpecifier::kProtected);
-        break;
-      case TokenKind::T_PUBLIC:
-        baseClassSymbol->setAccessSpecifier(AccessSpecifier::kPublic);
-        break;
-      default:
-        break;
-    }  // switch
-  }
+  switch (ast->accessSpecifier) {
+    case TokenKind::T_PRIVATE:
+      baseClassSymbol->setAccessSpecifier(AccessSpecifier::kPrivate);
+      break;
+    case TokenKind::T_PROTECTED:
+      baseClassSymbol->setAccessSpecifier(AccessSpecifier::kProtected);
+      break;
+    case TokenKind::T_PUBLIC:
+      baseClassSymbol->setAccessSpecifier(AccessSpecifier::kPublic);
+      break;
+    default:
+      break;
+  }  // switch
 }
 
 void Binder::bind(NonTypeTemplateParameterAST* ast, int index, int depth) {
diff --git a/src/parser/cxx/symbol_printer.cc b/src/parser/cxx/symbol_printer.cc
index b9461d4c..17055289 100644
--- a/src/parser/cxx/symbol_printer.cc
+++ b/src/parser/cxx/symbol_printer.cc
@@ -63,9 +63,8 @@ struct DumpSymbols {
     --depth;
   }
 
-  template <typename S>
   void dumpSpecializations(
-      std::span<const TemplateSpecialization<S>> specializations) {
+      std::span<const TemplateSpecialization> specializations) {
     if (specializations.empty()) return;
     ++depth;
     indent();
diff --git a/src/parser/cxx/symbols.cc b/src/parser/cxx/symbols.cc
index 3fedef1c..bb49ef21 100644
--- a/src/parser/cxx/symbols.cc
+++ b/src/parser/cxx/symbols.cc
@@ -407,43 +407,6 @@ void ClassSymbol::addConversionFunction(FunctionSymbol* conversionFunction) {
   conversionFunctions_.push_back(conversionFunction);
 }
 
-auto ClassSymbol::declaration() const -> SpecifierAST* { return specifier_; }
-
-void ClassSymbol::setDeclaration(SpecifierAST* specifier) {
-  specifier_ = specifier;
-}
-
-auto ClassSymbol::templateDeclaration() const -> TemplateDeclarationAST* {
-  return templateDeclaration_;
-}
-
-void ClassSymbol::setTemplateDeclaration(
-    TemplateDeclarationAST* templateDeclaration) {
-  templateDeclaration_ = templateDeclaration;
-}
-
-auto ClassSymbol::specializations() const
-    -> std::span<const TemplateSpecialization<ClassSymbol>> {
-  if (!templateInfo_) return {};
-  return templateInfo_->specializations();
-}
-
-auto ClassSymbol::findSpecialization(
-    const std::vector<TemplateArgument>& arguments) const -> ClassSymbol* {
-  if (!templateInfo_) return {};
-  return templateInfo_->findSpecialization(arguments);
-}
-
-void ClassSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
-                                    ClassSymbol* specialization) {
-  if (!templateInfo_) {
-    templateInfo_ = std::make_unique<TemplateInfo<ClassSymbol>>(this);
-  }
-  auto index = templateInfo_->specializations().size();
-  specialization->setSpecializationInfo(this, index);
-  templateInfo_->addSpecialization(std::move(arguments), specialization);
-}
-
 auto ClassSymbol::buildClassLayout(Control* control)
     -> std::expected<bool, std::string> {
   int offset = 0;
@@ -726,7 +689,7 @@ void TypeAliasSymbol::setTemplateDeclaration(
 }
 
 auto TypeAliasSymbol::specializations() const
-    -> std::span<const TemplateSpecialization<TypeAliasSymbol>> {
+    -> std::span<const TemplateSpecialization> {
   if (!templateInfo_) return {};
   return templateInfo_->specializations();
 }
@@ -734,13 +697,14 @@ auto TypeAliasSymbol::specializations() const
 auto TypeAliasSymbol::findSpecialization(
     const std::vector<TemplateArgument>& arguments) const -> TypeAliasSymbol* {
   if (!templateInfo_) return {};
-  return templateInfo_->findSpecialization(arguments);
+  return symbol_cast<TypeAliasSymbol>(
+      templateInfo_->findSpecialization(arguments));
 }
 
 void TypeAliasSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
                                         TypeAliasSymbol* specialization) {
   if (!templateInfo_) {
-    templateInfo_ = std::make_unique<TemplateInfo<TypeAliasSymbol>>(this);
+    templateInfo_ = std::make_unique<TemplateInfo>(this);
   }
   auto index = templateInfo_->specializations().size();
   specialization->setSpecializationInfo(this, index);
@@ -792,7 +756,7 @@ void VariableSymbol::setTemplateDeclaration(
 }
 
 auto VariableSymbol::specializations() const
-    -> std::span<const TemplateSpecialization<VariableSymbol>> {
+    -> std::span<const TemplateSpecialization> {
   if (!templateInfo_) return {};
   return templateInfo_->specializations();
 }
@@ -800,13 +764,14 @@ auto VariableSymbol::specializations() const
 auto VariableSymbol::findSpecialization(
     const std::vector<TemplateArgument>& arguments) const -> VariableSymbol* {
   if (!templateInfo_) return {};
-  return templateInfo_->findSpecialization(arguments);
+  return symbol_cast<VariableSymbol>(
+      templateInfo_->findSpecialization(arguments));
 }
 
 void VariableSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
                                        VariableSymbol* specialization) {
   if (!templateInfo_) {
-    templateInfo_ = std::make_unique<TemplateInfo<VariableSymbol>>(this);
+    templateInfo_ = std::make_unique<TemplateInfo>(this);
   }
   auto index = templateInfo_->specializations().size();
   specialization->setSpecializationInfo(this, index);
diff --git a/src/parser/cxx/symbols.h b/src/parser/cxx/symbols.h
index ec732b5b..bea935be 100644
--- a/src/parser/cxx/symbols.h
+++ b/src/parser/cxx/symbols.h
@@ -41,29 +41,29 @@ namespace cxx {
 
 class SymbolChainView;
 
-template <typename S>
-struct TemplateSpecialization {
-  S* templateSymbol = nullptr;
+class TemplateSpecialization {
+ public:
+  Symbol* templateSymbol = nullptr;
   std::vector<TemplateArgument> arguments;
-  S* symbol = nullptr;
+  Symbol* symbol = nullptr;
 };
 
 [[nodiscard]] auto compare_args(const std::vector<TemplateArgument>& args1,
                                 const std::vector<TemplateArgument>& args2)
     -> bool;
 
-template <typename S>
 class TemplateInfo {
  public:
-  explicit TemplateInfo(S* templateSymbol) : templateSymbol_(templateSymbol) {}
+  explicit TemplateInfo(Symbol* templateSymbol)
+      : templateSymbol_(templateSymbol) {}
 
   [[nodiscard]] auto specializations() const
-      -> std::span<const TemplateSpecialization<S>> {
+      -> std::span<const TemplateSpecialization> {
     return specializations_;
   }
 
   [[nodiscard]] auto findSpecialization(
-      const std::vector<TemplateArgument>& arguments) const -> S* {
+      const std::vector<TemplateArgument>& arguments) const -> Symbol* {
     for (const auto& specialization : specializations_) {
       const std::vector<TemplateArgument>& args = specialization.arguments;
       if (args == arguments) return specialization.symbol;
@@ -77,14 +77,14 @@ class TemplateInfo {
   }
 
   void addSpecialization(std::vector<TemplateArgument> arguments,
-                         S* specialization) {
+                         Symbol* specialization) {
     specializations_.push_back(
         {templateSymbol_, std::move(arguments), specialization});
   }
 
  private:
-  S* templateSymbol_ = nullptr;
-  std::vector<TemplateSpecialization<S>> specializations_;
+  Symbol* templateSymbol_ = nullptr;
+  std::vector<TemplateSpecialization> specializations_;
 };
 
 class Symbol {
@@ -263,6 +263,15 @@ class BaseClassSymbol final : public Symbol {
   bool isVirtual_ = false;
 };
 
+class Template {
+ public:
+  std::unique_ptr<TemplateInfo> templateInfo_;
+  SpecifierAST* declaration_ = nullptr;
+  TemplateDeclarationAST* templateDeclaration_ = nullptr;
+  ClassSymbol* templateClass_ = nullptr;
+  int templateSepcializationIndex_ = 0;
+};
+
 class ClassSymbol final : public ScopeSymbol {
  public:
   constexpr static auto Kind = SymbolKind::kClass;
@@ -305,48 +314,95 @@ class ClassSymbol final : public ScopeSymbol {
   [[nodiscard]] auto flags() const -> std::uint32_t;
   void setFlags(std::uint32_t flags);
 
-  [[nodiscard]] auto declaration() const -> SpecifierAST*;
-  void setDeclaration(SpecifierAST* ast);
+  [[nodiscard]] auto declaration() const -> SpecifierAST* {
+    if (!template_) return nullptr;
+    return template_->declaration_;
+  }
+
+  void setDeclaration(SpecifierAST* ast) {
+    ensure_template();
+    template_->declaration_ = ast;
+  }
 
-  [[nodiscard]] auto templateDeclaration() const -> TemplateDeclarationAST*;
-  void setTemplateDeclaration(TemplateDeclarationAST* templateDeclaration);
+  [[nodiscard]] auto templateDeclaration() const -> TemplateDeclarationAST* {
+    if (!template_) return nullptr;
+    return template_->templateDeclaration_;
+  }
+
+  void setTemplateDeclaration(TemplateDeclarationAST* templateDeclaration) {
+    ensure_template();
+    template_->templateDeclaration_ = templateDeclaration;
+  }
 
   [[nodiscard]] auto specializations() const
-      -> std::span<const TemplateSpecialization<ClassSymbol>>;
+      -> std::span<const TemplateSpecialization> {
+    if (!template_) return {};
+    if (!template_->templateInfo_) return {};
+    return template_->templateInfo_->specializations();
+  }
 
   [[nodiscard]] auto findSpecialization(
-      const std::vector<TemplateArgument>& arguments) const -> ClassSymbol*;
+      const std::vector<TemplateArgument>& arguments) const -> Symbol* {
+    if (!template_) return {};
+    if (!template_->templateInfo_) return {};
+    return template_->templateInfo_->findSpecialization(arguments);
+  }
 
   void addSpecialization(std::vector<TemplateArgument> arguments,
-                         ClassSymbol* specialization);
+                         ClassSymbol* specialization) {
+    ensure_template();
+
+    if (!template_->templateInfo_) {
+      template_->templateInfo_ = std::make_unique<TemplateInfo>(this);
+    }
+
+    auto index = int(template_->templateInfo_->specializations().size());
+
+    specialization->setSpecializationInfo(this, index);
+
+    template_->templateInfo_->addSpecialization(std::move(arguments),
+                                                specialization);
+  }
 
   [[nodiscard]] auto isSpecialization() const -> bool {
-    return templateClass_ != nullptr;
+    if (!template_) return false;
+    return template_->templateClass_ != nullptr;
   }
 
   [[nodiscard]] auto templateArguments() const
       -> std::span<const TemplateArgument> {
-    if (!templateClass_) return {};
-    return templateClass_->specializations()[templateSepcializationIndex_]
+    if (!template_) return {};
+    if (!template_->templateClass_) return {};
+
+    return template_->templateClass_
+        ->specializations()[template_->templateSepcializationIndex_]
         .arguments;
   }
 
   void setSpecializationInfo(ClassSymbol* templateClass, std::size_t index) {
-    templateClass_ = templateClass;
-    templateSepcializationIndex_ = index;
+    ensure_template();
+    template_->templateClass_ = templateClass;
+    template_->templateSepcializationIndex_ = index;
   }
 
   [[nodiscard]] auto templateClass() const -> ClassSymbol* {
-    return templateClass_;
+    if (!template_) return nullptr;
+    return template_->templateClass_;
   }
 
   [[nodiscard]] auto templateSepcializationIndex() const -> std::size_t {
-    return templateSepcializationIndex_;
+    if (!template_) return 0;
+    return template_->templateSepcializationIndex_;
   }
 
   [[nodiscard]] auto buildClassLayout(Control* control)
       -> std::expected<bool, std::string>;
 
+  void ensure_template() {
+    if (template_) return;
+    template_ = std::make_unique<Template>();
+  }
+
  private:
   [[nodiscard]] auto hasBaseClass(Symbol* symbol,
                                   std::unordered_set<const ClassSymbol*>&) const
@@ -356,11 +412,7 @@ class ClassSymbol final : public ScopeSymbol {
   std::vector<BaseClassSymbol*> baseClasses_;
   std::vector<FunctionSymbol*> constructors_;
   std::vector<FunctionSymbol*> conversionFunctions_;
-  std::unique_ptr<TemplateInfo<ClassSymbol>> templateInfo_;
-  SpecifierAST* specifier_ = nullptr;
-  TemplateDeclarationAST* templateDeclaration_ = nullptr;
-  ClassSymbol* templateClass_ = nullptr;
-  std::size_t templateSepcializationIndex_ = 0;
+  std::unique_ptr<Template> template_;
   int sizeInBytes_ = 0;
   int alignment_ = 0;
   union {
@@ -564,7 +616,7 @@ class TypeAliasSymbol final : public Symbol {
   void setTemplateDeclaration(TemplateDeclarationAST* declaration);
 
   [[nodiscard]] auto specializations() const
-      -> std::span<const TemplateSpecialization<TypeAliasSymbol>>;
+      -> std::span<const TemplateSpecialization>;
 
   [[nodiscard]] auto findSpecialization(
       const std::vector<TemplateArgument>& arguments) const -> TypeAliasSymbol*;
@@ -587,7 +639,7 @@ class TypeAliasSymbol final : public Symbol {
 
  private:
   TemplateDeclarationAST* templateDeclaration_ = nullptr;
-  std::unique_ptr<TemplateInfo<TypeAliasSymbol>> templateInfo_;
+  std::unique_ptr<TemplateInfo> templateInfo_;
   TypeAliasSymbol* templateVariable_ = nullptr;
   std::size_t templateSepcializationIndex_ = 0;
 };
@@ -621,7 +673,7 @@ class VariableSymbol final : public Symbol {
   void setTemplateDeclaration(TemplateDeclarationAST* declaration);
 
   [[nodiscard]] auto specializations() const
-      -> std::span<const TemplateSpecialization<VariableSymbol>>;
+      -> std::span<const TemplateSpecialization>;
 
   [[nodiscard]] auto findSpecialization(
       const std::vector<TemplateArgument>& arguments) const -> VariableSymbol*;
@@ -652,7 +704,7 @@ class VariableSymbol final : public Symbol {
   TemplateDeclarationAST* templateDeclaration_ = nullptr;
   ExpressionAST* initializer_ = nullptr;
   std::optional<ConstValue> constValue_;
-  std::unique_ptr<TemplateInfo<VariableSymbol>> templateInfo_;
+  std::unique_ptr<TemplateInfo> templateInfo_;
   VariableSymbol* templateVariable_ = nullptr;
   std::size_t templateSepcializationIndex_ = 0;
 
diff --git a/src/parser/cxx/symbols_fwd.h b/src/parser/cxx/symbols_fwd.h
index 0709635f..b97fc0dc 100644
--- a/src/parser/cxx/symbols_fwd.h
+++ b/src/parser/cxx/symbols_fwd.h
@@ -55,10 +55,7 @@ class Symbol;
 class ScopeSymbol;
 class ScopeSymbol;
 
-template <typename S>
-struct TemplateSpecialization;
-
-template <typename S>
+class TemplateSpecialization;
 class TemplateInfo;
 
 #define PROCESS_SYMBOL(S) class S##Symbol;
diff --git a/tests/unit_tests/sema/template_class_06.cc b/tests/unit_tests/sema/template_class_06.cc
new file mode 100644
index 00000000..7f452388
--- /dev/null
+++ b/tests/unit_tests/sema/template_class_06.cc
@@ -0,0 +1,88 @@
+// RUN: %cxx -fcheck -dump-symbols %s | %filecheck %s
+
+template <typename X>
+struct A {
+  using T = X;
+  int v;
+};
+
+template <typename T>
+using B = const A<T>;
+
+struct D : B<A<void>> {
+  void f() {
+    T t;
+
+    this->v = 321;
+    static_assert(__is_same(T, A<void>));
+    static_assert(__is_same(decltype(t), A<void>));
+  }
+};
+
+template <typename T>
+struct D2 : B<double> {
+  auto f() -> T {
+    this->v = 42;
+    T t;
+    return t;
+  }
+
+  T t;
+};
+
+auto main() -> int {
+  D d1;
+  static_assert(__is_same(decltype(d1.f()), void));
+
+  D2<int> d2;
+
+  static_assert(__is_same(decltype(d2.f()), double));
+  static_assert(__is_same(decltype(d2.t), double));
+  static_assert(__is_same(decltype((d2.t)), double&));
+
+  d2.t = 123;
+
+  return 0;
+}
+
+// clang-format off
+//      CHECK:namespace
+// CHECK-NEXT:  template class A<type-param<0, 0>>
+// CHECK-NEXT:    parameter typename<0, 0> X
+// CHECK-NEXT:    typealias type-param<0, 0> T
+// CHECK-NEXT:    field int v
+// CHECK-NEXT:    [specializations]
+// CHECK-NEXT:      class A<void>
+// CHECK-NEXT:        typealias void T
+// CHECK-NEXT:        field int v
+// CHECK-NEXT:      class A<::A<void>>
+// CHECK-NEXT:        typealias ::A<void> T
+// CHECK-NEXT:        field int v
+// CHECK-NEXT:      class A<double>
+// CHECK-NEXT:        typealias double T
+// CHECK-NEXT:        field int v
+// CHECK-NEXT:  template typealias const ::A B
+// CHECK-NEXT:    parameter typename<0, 0> T
+// CHECK-NEXT:  class D
+// CHECK-NEXT:    base class A
+// CHECK-NEXT:    function void f()
+// CHECK-NEXT:      block
+// CHECK-NEXT:        variable ::A<void> t
+// CHECK-NEXT:  template class D2<type-param<0, 0>>
+// CHECK-NEXT:    parameter typename<0, 0> T
+// CHECK-NEXT:    base class A
+// CHECK-NEXT:    function double f()
+// CHECK-NEXT:      block
+// CHECK-NEXT:        variable double t
+// CHECK-NEXT:    field double t
+// CHECK-NEXT:    [specializations]
+// CHECK-NEXT:      class D2<int>
+// CHECK-NEXT:        base class A
+// CHECK-NEXT:        function double f()
+// CHECK-NEXT:          block
+// CHECK-NEXT:            variable double t
+// CHECK-NEXT:        field double t
+// CHECK-NEXT:  function int main()
+// CHECK-NEXT:    block
+// CHECK-NEXT:      variable ::D d1
+// CHECK-NEXT:      variable ::D2<int> d2