Introduce MaybeTemplate<S,D> to represent symbols that may be templates

src/parser/cxx/symbols.cc

@@ -522,14 +522,6 @@ FunctionSymbol::FunctionSymbol(ScopeSymbol* enclosingScope)
 
 FunctionSymbol::~FunctionSymbol() {}
 
-auto FunctionSymbol::declaration() const -> DeclarationAST* {
-  return declaration_;
-}
-
-void FunctionSymbol::setDeclaration(DeclarationAST* declaration) {
-  declaration_ = declaration;
-}
-
 auto FunctionSymbol::isDefined() const -> bool { return isDefined_; }
 
 void FunctionSymbol::setDefined(bool isDefined) { isDefined_ = isDefined; }
@@ -679,38 +671,6 @@ TypeAliasSymbol::TypeAliasSymbol(ScopeSymbol* enclosingScope)
 
 TypeAliasSymbol::~TypeAliasSymbol() {}
 
-auto TypeAliasSymbol::templateDeclaration() const -> TemplateDeclarationAST* {
-  return templateDeclaration_;
-}
-
-void TypeAliasSymbol::setTemplateDeclaration(
-    TemplateDeclarationAST* declaration) {
-  templateDeclaration_ = declaration;
-}
-
-auto TypeAliasSymbol::specializations() const
-    -> std::span<const TemplateSpecialization> {
-  if (!templateInfo_) return {};
-  return templateInfo_->specializations();
-}
-
-auto TypeAliasSymbol::findSpecialization(
-    const std::vector<TemplateArgument>& arguments) const -> TypeAliasSymbol* {
-  if (!templateInfo_) return {};
-  return symbol_cast<TypeAliasSymbol>(
-      templateInfo_->findSpecialization(arguments));
-}
-
-void TypeAliasSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
-                                        TypeAliasSymbol* specialization) {
-  if (!templateInfo_) {
-    templateInfo_ = std::make_unique<TemplateInfo>(this);
-  }
-  auto index = templateInfo_->specializations().size();
-  specialization->setSpecializationInfo(this, index);
-  templateInfo_->addSpecialization(std::move(arguments), specialization);
-}
-
 VariableSymbol::VariableSymbol(ScopeSymbol* enclosingScope)
     : Symbol(Kind, enclosingScope) {}
 
@@ -746,38 +706,6 @@ auto VariableSymbol::isInline() const -> bool { return isInline_; }
 
 void VariableSymbol::setInline(bool isInline) { isInline_ = isInline; }
 
-auto VariableSymbol::templateDeclaration() const -> TemplateDeclarationAST* {
-  return templateDeclaration_;
-}
-
-void VariableSymbol::setTemplateDeclaration(
-    TemplateDeclarationAST* declaration) {
-  templateDeclaration_ = declaration;
-}
-
-auto VariableSymbol::specializations() const
-    -> std::span<const TemplateSpecialization> {
-  if (!templateInfo_) return {};
-  return templateInfo_->specializations();
-}
-
-auto VariableSymbol::findSpecialization(
-    const std::vector<TemplateArgument>& arguments) const -> VariableSymbol* {
-  if (!templateInfo_) return {};
-  return symbol_cast<VariableSymbol>(
-      templateInfo_->findSpecialization(arguments));
-}
-
-void VariableSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
-                                       VariableSymbol* specialization) {
-  if (!templateInfo_) {
-    templateInfo_ = std::make_unique<TemplateInfo>(this);
-  }
-  auto index = templateInfo_->specializations().size();
-  specialization->setSpecializationInfo(this, index);
-  templateInfo_->addSpecialization(std::move(arguments), specialization);
-}
-
 auto VariableSymbol::initializer() const -> ExpressionAST* {
   return initializer_;
 }