Merge branch 'feature/extern_type' into development

Author: m-kurtenacker

include/artic/ast.h

@@ -1506,6 +1506,28 @@ struct TypeDecl : public NamedDecl {
     void print(Printer&) const override;
 };
 
+struct ExtTypeDecl : public NamedDecl {
+    Ptr<TypeParamList> type_params;
+    PtrVector<std::string> type_args;
+
+    ExtTypeDecl(
+        const Loc& loc,
+        Identifier&& id,
+        Ptr<TypeParamList>&& type_params,
+        PtrVector<std::string>&& type_args)
+        : NamedDecl(loc, std::move(id))
+        , type_params(std::move(type_params))
+        , type_args(std::move(type_args))
+    {}
+
+    const thorin::Def* emit(Emitter&) const override;
+    const artic::Type* infer(TypeChecker&) override;
+    void bind_head(NameBinder&) override;
+    void bind(NameBinder&) override;
+    void resolve_summons(Summoner&) override {};
+    void print(Printer&) const override;
+};
+
 /// Module definition.
 struct ModDecl : public NamedDecl {
     PtrVector<Decl> decls;

include/artic/parser.h

@@ -34,6 +34,7 @@ class Parser : public Logger {
     Ptr<ast::ImplicitDecl>  parse_implicit_decl();
     Ptr<ast::StaticDecl>    parse_static_decl();
     Ptr<ast::TypeDecl>      parse_type_decl();
+    Ptr<ast::ExtTypeDecl>   parse_ext_type_decl();
     Ptr<ast::TypeParam>     parse_type_param();
     Ptr<ast::TypeParamList> parse_type_params();
     Ptr<ast::ModDecl>       parse_mod_decl();

include/artic/token.h

@@ -30,6 +30,7 @@ namespace artic {
     f(Struct, "struct") \
     f(Enum, "enum") \
     f(Type, "type") \
+    f(TypeExt, "type_ext") \
     f(Static, "static") \
     f(Implicit, "implicit") \
     f(Summon, "summon") \

include/artic/types.h

@@ -582,6 +582,22 @@ struct TypeAlias : public PolyTypeFromDecl<UserType, ast::TypeDecl> {
     friend class TypeTable;
 };
 
+struct ExtType : public PolyTypeFromDecl<UserType, ast::ExtTypeDecl> {
+    void print(Printer&) const override;
+
+private:
+    ExtType(TypeTable& type_table, const ast::ExtTypeDecl& decl)
+        : PolyTypeFromDecl(type_table, decl)
+    {}
+
+    using UserType::convert;
+    const thorin::Type* convert(Emitter&, const Type*) const override;
+
+    std::string stringify(Emitter&) const override;
+
+    friend class TypeTable;
+};
+
 /// An application of a complex type with polymorphic parameters.
 struct TypeApp : public Type {
     const UserType* applied;
@@ -684,6 +700,7 @@ class TypeTable {
     const EnumType*          enum_type(const ast::EnumDecl&);
     const ModType*           mod_type(const ast::ModDecl&);
     const TypeAlias*         type_alias(const ast::TypeDecl&);
+    const ExtType*           ext_type(const ast::ExtTypeDecl&);
 
     /// Creates a type application for structures/enumeration types,
     /// or returns the type alias expanded with the given type arguments.

src/bind.cpp

@@ -509,13 +509,23 @@ void TypeDecl::bind_head(NameBinder& binder) {
     binder.insert_symbol(*this);
 }
 
+void ExtTypeDecl::bind_head(NameBinder& binder) {
+    binder.insert_symbol(*this);
+}
+
 void TypeDecl::bind(NameBinder& binder) {
     binder.push_scope();
     if (type_params) binder.bind(*type_params);
     binder.bind(*aliased_type);
     binder.pop_scope();
 }
 
+void ExtTypeDecl::bind(NameBinder& binder) {
+    binder.push_scope();
+    if (type_params) binder.bind(*type_params);
+    binder.pop_scope();
+}
+
 void ModDecl::bind_head(NameBinder& binder) {
     if (id.name != "")
         binder.insert_symbol(*this);

src/check.cpp

@@ -1816,6 +1816,11 @@ const artic::Type* TypeDecl::infer(TypeChecker& checker) {
     return type;
 }
 
+const artic::Type* ExtTypeDecl::infer(TypeChecker& checker) {
+    const artic::Type* type = checker.type_table.ext_type(*this);
+    return type;
+}
+
 const artic::Type* ModDecl::infer(TypeChecker& checker) {
     for (auto& decl : decls)
         checker.infer(*decl);

src/emit.cpp

@@ -1778,6 +1778,10 @@ const thorin::Def* TypeDecl::emit(Emitter&) const {
     return nullptr;
 }
 
+const thorin::Def* ExtTypeDecl::emit(Emitter&) const {
+    return nullptr;
+}
+
 const thorin::Def* ModDecl::emit(Emitter& emitter) const {
     for (auto& decl : decls) {
         // Do not emit polymorphic functions directly: Those will be emitted from
@@ -2054,6 +2058,26 @@ const thorin::Type* TypeApp::convert(Emitter& emitter) const {
     return result;
 }
 
+std::string ExtType::stringify(Emitter& emitter) const {
+    if (!type_params())
+        return decl.id.name;
+    return stringify_params(emitter, decl.id.name + "_", type_params()->params);
+}
+
+const thorin::Type* ExtType::convert(Emitter& emitter, const Type* parent) const {
+    if (auto it = emitter.types.find(this); !type_params() && it != emitter.types.end())
+        return it->second;
+
+    std::vector<std::string> args;
+    for (auto& arg : decl.type_args) {
+        args.emplace_back(*arg);
+    }
+
+    auto type = emitter.world.extern_type(decl.id.name, args);
+    emitter.types[parent] = type;
+    return type;
+}
+
 // A read-only buffer from memory, not performing any copy.
 struct MemBuf : public std::streambuf {
     MemBuf(const std::string& str) {

src/lexer.cpp

@@ -23,6 +23,7 @@ std::unordered_map<std::string, Token::Tag> Lexer::keywords{
     std::make_pair("struct",    Token::Struct),
     std::make_pair("enum",      Token::Enum),
     std::make_pair("type",      Token::Type),
+    std::make_pair("type_ext",  Token::TypeExt),
     std::make_pair("implicit",  Token::Implicit),
     std::make_pair("summon",    Token::Summon),
     std::make_pair("static",    Token::Static),

src/parser.cpp

@@ -42,6 +42,7 @@ Ptr<ast::Decl> Parser::parse_decl(bool is_top_level) {
         case Token::Struct:   decl = parse_struct_decl();   break;
         case Token::Enum:     decl = parse_enum_decl();     break;
         case Token::Type:     decl = parse_type_decl();     break;
+        case Token::TypeExt:  decl = parse_ext_type_decl(); break;
         case Token::Implicit: decl = parse_implicit_decl(); break;
         case Token::Static:   decl = parse_static_decl();   break;
         case Token::Mod:      decl = parse_mod_decl();      break;
@@ -200,6 +201,28 @@ Ptr<ast::TypeDecl> Parser::parse_type_decl() {
     return _arena.make_ptr<ast::TypeDecl>(tracker(), std::move(id), std::move(type_params), std::move(aliased_type));
 }
 
+Ptr<ast::ExtTypeDecl> Parser::parse_ext_type_decl() {
+    Tracker tracker(this);
+    eat(Token::TypeExt);
+    auto id = parse_id();
+
+    Ptr<ast::TypeParamList> type_params;
+    if (ahead().tag() == Token::LBracket)
+        type_params = parse_type_params();
+
+    PtrVector<std::string> type_args;
+    if (accept(Token::Eq)) {
+        expect(Token::LBrace);
+
+        parse_list(Token::RBrace, Token::Comma, [&] {
+            type_args.emplace_back(_arena.make_ptr<std::string>(parse_str()));
+        });
+    }
+
+    expect(Token::Semi);
+    return _arena.make_ptr<ast::ExtTypeDecl>(tracker(), std::move(id), std::move(type_params), std::move(type_args));
+}
+
 Ptr<ast::ImplicitDecl> Parser::parse_implicit_decl() {
     Tracker tracker(this);
     eat(Token::Implicit);

src/print.cpp

@@ -614,6 +614,17 @@ void TypeDecl::print(Printer& p) const {
     p << ';';
 }
 
+void ExtTypeDecl::print(Printer& p) const {
+    if (attrs) attrs->print(p);
+    p << log::keyword_style("type_ext") << ' ' <<  id.name;
+    if (type_params) type_params->print(p);
+    p << " = { ";
+    print_list(p, ',', type_args, [&] (auto& arg) {
+        p << *arg;
+    });
+    p << " };";
+}
+
 void ModDecl::print(Printer& p) const {
     if (attrs) attrs->print(p);
     bool anon = id.name == "";
@@ -825,6 +836,10 @@ void TypeAlias::print(Printer& p) const {
     p << decl.id.name;
 }
 
+void ExtType::print(Printer& p) const {
+    p << decl.id.name;
+}
+
 void TypeApp::print(Printer& p) const {
     applied->print(p);
     p << '[';