Simulate template class instantiation

Author: robertoraggi

src/parser/cxx/ast_rewriter.cc

@@ -27,6 +27,7 @@
 #include <cxx/control.h>
 #include <cxx/decl.h>
 #include <cxx/decl_specs.h>
+#include <cxx/scope.h>
 #include <cxx/symbols.h>
 #include <cxx/translation_unit.h>
 #include <cxx/type_checker.h>
@@ -1055,9 +1056,24 @@ auto ASTRewriter::operator()(InitDeclaratorAST* ast, const DeclSpecs& declSpecs)
   auto copy = make_node<InitDeclaratorAST>(arena());
 
   copy->declarator = operator()(ast->declarator);
+
+  auto decl = Decl{declSpecs, copy->declarator};
+
+  auto type = getDeclaratorType(translationUnit(), copy->declarator,
+                                declSpecs.getType());
+
+  // ### fix scope
+  if (binder_.scope() && binder_.scope()->isClassScope()) {
+    auto symbol = binder_.declareMemberSymbol(ast->declarator, decl);
+    copy->symbol = symbol;
+  } else {
+    // ### TODO
+    copy->symbol = ast->symbol;
+  }
+
   copy->requiresClause = operator()(ast->requiresClause);
   copy->initializer = operator()(ast->initializer);
-  copy->symbol = ast->symbol;
+  // copy->symbol = ast->symbol; // TODO remove, done above
 
   return copy;
 }
@@ -3751,6 +3767,18 @@ auto ASTRewriter::SpecifierVisitor::operator()(ClassSpecifierAST* ast)
   copy->finalLoc = ast->finalLoc;
   copy->colonLoc = ast->colonLoc;
 
+  // ### TODO: use Binder::bind()
+  auto _ = Binder::ScopeGuard{binder()};
+  auto location = ast->symbol->location();
+  auto className = ast->symbol->name();
+  auto classSymbol = control()->newClassSymbol(binder()->scope(), location);
+  classSymbol->setName(className);
+  classSymbol->setIsUnion(ast->symbol->isUnion());
+  classSymbol->setFinal(ast->isFinal);
+  binder()->setScope(classSymbol);
+
+  copy->symbol = classSymbol;
+
   for (auto baseSpecifierList = &copy->baseSpecifierList;
        auto node : ListView{ast->baseSpecifierList}) {
     auto value = rewrite(node);
@@ -3769,7 +3797,7 @@ auto ASTRewriter::SpecifierVisitor::operator()(ClassSpecifierAST* ast)
 
   copy->rbraceLoc = ast->rbraceLoc;
   copy->classKey = ast->classKey;
-  copy->symbol = ast->symbol;
+  // copy->symbol = ast->symbol; // TODO: remove done by the binder
   copy->isFinal = ast->isFinal;
 
   return copy;

src/parser/cxx/binder.cc

@@ -161,7 +161,10 @@ void Binder::bind(ElaboratedTypeSpecifierAST* ast, DeclSpecs& declSpecs) {
     classSymbol->setIsUnion(isUnion);
     classSymbol->setName(className);
     classSymbol->setTemplateParameters(currentTemplateParameters());
+    classSymbol->setTemplateDeclaration(declSpecs.templateHead);
     declaringScope()->addSymbol(classSymbol);
+
+    classSymbol->setDeclaration(ast);
   }
 
   ast->symbol = classSymbol;
@@ -234,6 +237,12 @@ void Binder::bind(ClassSpecifierAST* ast, DeclSpecs& declSpecs) {
     }
   }
 
+  classSymbol->setDeclaration(ast);
+
+  if (declSpecs.templateHead) {
+    classSymbol->setTemplateDeclaration(declSpecs.templateHead);
+  }
+
   classSymbol->setFinal(ast->isFinal);
 
   ast->symbol = classSymbol;

src/parser/cxx/decl_specs.h

@@ -49,6 +49,7 @@ class DeclSpecs {
 
   ASTRewriter* rewriter = nullptr;
   TranslationUnit* unit = nullptr;
+  TemplateDeclarationAST* templateHead = nullptr;
   const Type* type = nullptr;
   SpecifierAST* typeSpecifier = nullptr;
 

src/parser/cxx/parser.cc

@@ -4024,6 +4024,7 @@ auto Parser::parse_simple_declaration(DeclarationAST*& yyast,
   if (parse_notypespec_function_definition(yyast, attributes, ctx)) return true;
 
   DeclSpecs specs{unit};
+  specs.templateHead = templateHead;
   List<SpecifierAST*>* declSpecifierList = nullptr;
 
   auto lookat_decl_specifiers = [&] {

src/parser/cxx/symbols.cc

@@ -215,6 +215,21 @@ auto ClassSymbol::hasBaseClass(
   return false;
 }
 
+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::templateParameters() const -> TemplateParametersSymbol* {
   return templateInfo_ ? templateInfo_->templateParameters() : nullptr;
 }

src/parser/cxx/symbols.h

@@ -136,7 +136,7 @@ class Symbol {
   [[nodiscard]] auto next() const -> Symbol*;
 
 #define PROCESS_SYMBOL(S) \
-  [[nodiscard]] auto is##S() const->bool { return kind_ == SymbolKind::k##S; }
+  [[nodiscard]] auto is##S() const -> bool { return kind_ == SymbolKind::k##S; }
   CXX_FOR_EACH_SYMBOL(PROCESS_SYMBOL)
 #undef PROCESS_SYMBOL
 
@@ -263,6 +263,12 @@ class ClassSymbol final : public ScopedSymbol {
   [[nodiscard]] auto flags() const -> std::uint32_t;
   void setFlags(std::uint32_t flags);
 
+  [[nodiscard]] auto declaration() const -> SpecifierAST*;
+  void setDeclaration(SpecifierAST* ast);
+
+  [[nodiscard]] auto templateDeclaration() const -> TemplateDeclarationAST*;
+  void setTemplateDeclaration(TemplateDeclarationAST* templateDeclaration);
+
   [[nodiscard]] auto templateParameters() const -> TemplateParametersSymbol*;
   void setTemplateParameters(TemplateParametersSymbol* templateParameters);
 
@@ -311,6 +317,8 @@ class ClassSymbol final : public ScopedSymbol {
   std::vector<BaseClassSymbol*> baseClasses_;
   std::vector<FunctionSymbol*> constructors_;
   std::unique_ptr<TemplateInfo<ClassSymbol>> templateInfo_;
+  SpecifierAST* specifier_ = nullptr;
+  TemplateDeclarationAST* templateDeclaration_ = nullptr;
   ClassSymbol* templateClass_ = nullptr;
   std::size_t templateSepcializationIndex_ = 0;
   int sizeInBytes_ = 0;
@@ -784,7 +792,7 @@ auto visit(Visitor&& visitor, Symbol* symbol) {
 }
 
 #define PROCESS_SYMBOL(S)                                \
-  inline auto is##S##Symbol(Symbol* symbol)->bool {      \
+  inline auto is##S##Symbol(Symbol* symbol) -> bool {    \
     return symbol && symbol->kind() == SymbolKind::k##S; \
   }
 

tests/api_tests/test_rewriter.cc

@@ -255,4 +255,62 @@ const auto N = S<0, 1, 2>;
   const auto value = interp.evaluate(eq->expression);
   ASSERT_TRUE(value.has_value());
   ASSERT_EQ(std::visit(ArithmeticCast<int>{}, *value), 0 * 0 + 1 * 1 + 2 * 2);
+}
+
+TEST(Rewriter, Class) {
+  auto source = R"(
+template <typename T1, typename T2>
+struct Pair {
+  T1 first;
+  T2 second;
+  auto operator=(const Pair& other) -> Pair&;
+};
+
+using Pair1 = Pair<int, float*>;
+
+)"_cxx_no_templates;
+
+  auto control = source.control();
+
+  auto pair = source.getAs<ClassSymbol>("Pair");
+  ASSERT_TRUE(pair != nullptr);
+
+  ASSERT_TRUE(pair->declaration() != nullptr);
+
+  auto classDecl = ast_cast<ClassSpecifierAST>(pair->declaration());
+  ASSERT_TRUE(classDecl != nullptr);
+
+  auto templateDecl = pair->templateDeclaration();
+  ASSERT_TRUE(templateDecl != nullptr);
+
+  auto pair1 = source.getAs<TypeAliasSymbol>("Pair1");
+  ASSERT_TRUE(pair1 != nullptr);
+
+  auto pair1Type = type_cast<UnresolvedNameType>(pair1->type());
+  ASSERT_TRUE(pair1Type != nullptr);
+
+  auto templateId = ast_cast<SimpleTemplateIdAST>(pair1Type->unqualifiedId());
+  ASSERT_TRUE(templateId != nullptr);
+
+  auto templateArguments = make_substitution(&source.unit, templateDecl,
+                                             templateId->templateArgumentList);
+
+  auto instance = substitute(source, classDecl, templateArguments);
+  ASSERT_TRUE(instance != nullptr);
+
+  auto classDeclInstance = ast_cast<ClassSpecifierAST>(instance);
+  ASSERT_TRUE(classDeclInstance != nullptr);
+
+  auto classInstance = classDeclInstance->symbol;
+
+  ASSERT_TRUE(classInstance != nullptr);
+
+  std::ostringstream os;
+  dump(os, classDeclInstance->symbol);
+
+  ASSERT_EQ(os.str(), R"(class Pair
+  field int first
+  field float* second
+  function ::Pair& operator =(const ::Pair&)
+)");
 }

tests/api_tests/test_utils.h

@@ -22,6 +22,7 @@
 
 #include <cxx/ast.h>
 #include <cxx/control.h>
+#include <cxx/memory_layout.h>
 #include <cxx/names.h>
 #include <cxx/scope.h>
 #include <cxx/symbols.h>
@@ -40,10 +41,16 @@ inline auto dump_symbol(Symbol* symbol) -> std::string {
 }
 
 struct Source {
+  std::unique_ptr<MemoryLayout> memoryLayout;
   DiagnosticsClient diagnosticsClient;
   TranslationUnit unit{&diagnosticsClient};
 
   explicit Source(std::string_view source, bool templateInstantiation = true) {
+    // default to wasm32 memory layout
+    auto memoryLayout = std::make_unique<MemoryLayout>(32);
+
+    unit.control()->setMemoryLayout(memoryLayout.get());
+
     unit.setSource(std::string(source), "<test>");
 
     unit.parse({