Implement default instances of typeclasses.

.gitignore

@@ -14,3 +14,4 @@ tags
 build*
 *.vprm
 *.tmp
+compile_flags.txt

CMakeLists.txt

@@ -60,3 +60,4 @@ add_subdirectory(lib)
 add_subdirectory(src)
 add_subdirectory(runtime)
 add_subdirectory(tests EXCLUDE_FROM_ALL)
+

include/reaver/vapor/analyzer/expressions/binary.h

@@ -36,7 +36,9 @@ inline namespace _v1
         binary_expression(ast_node parse,
             lexer::token op,
             std::unique_ptr<expression> lhs,
-            std::unique_ptr<expression> rhs);
+            std::unique_ptr<expression> rhs,
+            scope * lex_scope,
+            std::optional<std::u32string> name);
 
         virtual void print(std::ostream & os, print_context ctx) const override;
 
@@ -100,6 +102,7 @@ inline namespace _v1
     struct precontext;
     std::unique_ptr<binary_expression> preanalyze_binary_expression(precontext & ctx,
         const parser::binary_expression & parse,
-        scope * lex_scope);
+        scope * lex_scope,
+        std::optional<std::u32string> name);
 }
 }

include/reaver/vapor/analyzer/expressions/boolean.h

@@ -34,8 +34,11 @@ inline namespace _v1
     class boolean_constant : public constant
     {
     public:
-        boolean_constant(bool value, ast_node parse = {})
-            : constant{ builtin_types().boolean.get() }, _value{ std::move(value) }
+        boolean_constant(bool value,
+            scope * lex_scope,
+            std::optional<std::u32string> name,
+            ast_node parse = {})
+            : constant{ builtin_types().boolean, lex_scope, std::move(name) }, _value{ std::move(value) }
         {
             _set_ast_info(parse);
         }
@@ -60,7 +63,8 @@ inline namespace _v1
 
         virtual std::unique_ptr<expression> _clone_expr(replacements & repl) const override
         {
-            return std::make_unique<boolean_constant>(_value, get_ast_info().value());
+            return std::make_unique<boolean_constant>(
+                _value, get_scope(), get_name(), get_ast_info().value());
         }
 
         virtual future<expression *> _simplify_expr(recursive_context) override
@@ -84,9 +88,12 @@ inline namespace _v1
         bool _value;
     };
 
-    inline std::unique_ptr<boolean_constant> make_boolean_constant(const parser::boolean_literal & parse)
+    inline std::unique_ptr<boolean_constant> make_boolean_constant(const parser::boolean_literal & parse,
+        scope * lex_scope,
+        std::optional<std::u32string> name)
     {
-        return std::make_unique<boolean_constant>(parse.value.string == U"true", make_node(parse));
+        return std::make_unique<boolean_constant>(
+            parse.value.string == U"true", lex_scope, std::move(name), make_node(parse));
     }
 }
 }

include/reaver/vapor/analyzer/expressions/call.h

@@ -1,7 +1,7 @@
 /**
  * Vapor Compiler Licence
  *
- * Copyright © 2017-2019 Michał "Griwes" Dominiak
+ * Copyright © 2017-2020 Michał "Griwes" Dominiak
  *
  * This software is provided 'as-is', without any express or implied
  * warranty. In no event will the authors be held liable for any damages
@@ -35,8 +35,13 @@ inline namespace _v1
     public:
         call_expression(function * fun,
             std::unique_ptr<expression> vtable_arg,
-            std::vector<expression *> args)
-            : _function{ fun }, _vtable_arg{ std::move(vtable_arg) }, _args{ std::move(args) }
+            std::vector<expression *> args,
+            scope * lex_scope,
+            std::optional<std::u32string> name)
+            : expression{ lex_scope, std::move(name) },
+              _function{ fun },
+              _vtable_arg{ std::move(vtable_arg) },
+              _args{ std::move(args) }
         {
         }
 
@@ -53,7 +58,7 @@ inline namespace _v1
             }
         }
 
-        const range_type & get_range() const
+        range_type get_range() const
         {
             return get_ast_info().value().range;
         }
@@ -104,10 +109,14 @@ inline namespace _v1
     public:
         owning_call_expression(function * fun,
             std::unique_ptr<expression> vtable_arg,
-            std::vector<std::unique_ptr<expression>> args)
+            std::vector<std::unique_ptr<expression>> args,
+            scope * lex_scope,
+            std::optional<std::u32string> name)
             : call_expression{ fun,
                   std::move(vtable_arg),
-                  fmap(args, [](auto && arg) { return arg.get(); }) },
+                  fmap(args, [](auto && arg) { return arg.get(); }),
+                  lex_scope,
+                  std::move(name) },
               _var_exprs{ std::move(args) }
         {
         }
@@ -118,11 +127,15 @@ inline namespace _v1
         std::vector<std::unique_ptr<expression>> _var_exprs;
     };
 
-    inline auto make_call_expression(function * fun, expression * vtable_arg, std::vector<expression *> args)
+    inline auto make_call_expression(function * fun,
+        expression * vtable_arg,
+        std::vector<expression *> args,
+        scope * lex_scope,
+        std::optional<std::u32string> name)
     {
         replacements repl;
         return std::make_unique<call_expression>(
-            fun, fun->vtable_slot() ? repl.claim(vtable_arg) : nullptr, args);
+            fun, fun->vtable_slot() ? repl.claim(vtable_arg) : nullptr, args, lex_scope, std::move(name));
     }
 }
 }

include/reaver/vapor/analyzer/expressions/closure.h

@@ -42,7 +42,9 @@ inline namespace _v1
             std::unique_ptr<scope> sc,
             parameter_list params,
             std::unique_ptr<block> body,
-            std::optional<std::unique_ptr<expression>> return_type);
+            std::optional<std::unique_ptr<expression>> return_type,
+            scope * lex_scope,
+            std::optional<std::u32string> name);
 
         virtual void print(std::ostream & os, print_context ctx) const override;
 
@@ -85,6 +87,7 @@ inline namespace _v1
     struct precontex;
     std::unique_ptr<closure> preanalyze_closure(precontext & ctx,
         const parser::lambda_expression & parse,
-        scope * lex_scope);
+        scope * lex_scope,
+        std::optional<std::u32string> name);
 }
 }

include/reaver/vapor/analyzer/expressions/conversion.h

@@ -28,12 +28,19 @@ namespace reaver::vapor::analyzer
 {
 inline namespace _v1
 {
-    std::unique_ptr<expression> make_conversion_expression(std::unique_ptr<expression> expr, type * target);
+    inline std::unique_ptr<expression> make_conversion_expression(std::unique_ptr<expression> expr,
+        type * conv,
+        scope * lex_scope,
+        std::optional<std::u32string> name);
 
     class conversion_expression : public expression
     {
     public:
-        conversion_expression(expression * expr, type * conv) : expression{ conv }, _base{ expr }
+        conversion_expression(expression * expr,
+            type * conv,
+            scope * lex_scope,
+            std::optional<std::u32string> name)
+            : expression{ conv, lex_scope, std::move(name) }, _base{ expr }
         {
         }
 
@@ -82,7 +89,7 @@ inline namespace _v1
     private:
         virtual std::unique_ptr<expression> _clone_expr(replacements & repl) const override
         {
-            return make_conversion_expression(repl.copy_claim(_base), get_type());
+            return make_conversion_expression(repl.copy_claim(_base), get_type(), get_scope(), get_name());
         }
 
         virtual statement_ir _codegen_ir(ir_generation_context &) const override
@@ -106,8 +113,12 @@ inline namespace _v1
     class owning_conversion_expression : public conversion_expression
     {
     public:
-        owning_conversion_expression(std::unique_ptr<expression> expr, type * target)
-            : conversion_expression{ expr.get(), target }, _owned{ std::move(expr) }
+        owning_conversion_expression(std::unique_ptr<expression> expr,
+            type * target,
+            scope * lex_scope,
+            std::optional<std::u32string> name)
+            : conversion_expression{ expr.get(), target, lex_scope, std::move(name) },
+              _owned{ std::move(expr) }
         {
         }
 
@@ -130,21 +141,27 @@ inline namespace _v1
 
         virtual std::unique_ptr<expression> _clone_expr(replacements & repl) const override
         {
-            return make_conversion_expression(repl.claim(_owned.get()), get_type());
+            return make_conversion_expression(repl.claim(_owned.get()), get_type(), get_scope(), get_name());
         }
 
         std::unique_ptr<expression> _owned;
     };
 
-    inline auto make_conversion_expression(expression * expr, type * conv)
+    inline auto make_conversion_expression(expression * expr,
+        type * conv,
+        scope * lex_scope,
+        std::optional<std::u32string> name)
     {
-        return std::make_unique<conversion_expression>(expr, conv);
+        return std::make_unique<conversion_expression>(expr, conv, lex_scope, std::move(name));
     }
 
     inline std::unique_ptr<expression> make_conversion_expression(std::unique_ptr<expression> expr,
-        type * conv)
+        type * conv,
+        scope * lex_scope,
+        std::optional<std::u32string> name)
     {
-        return std::make_unique<owning_conversion_expression>(std::move(expr), conv);
+        return std::make_unique<owning_conversion_expression>(
+            std::move(expr), conv, lex_scope, std::move(name));
     }
 }
 }

include/reaver/vapor/analyzer/expressions/entity.h

@@ -32,9 +32,12 @@ inline namespace _v1
     class entity : public expression
     {
     public:
-        entity(type *, std::unique_ptr<expression> value = nullptr);
-        entity(std::unique_ptr<type>, std::unique_ptr<expression> value = nullptr);
-        entity(std::shared_ptr<unresolved_type>, std::unique_ptr<expression> value = nullptr);
+        entity(type *, scope *, std::u32string, std::unique_ptr<expression> = nullptr);
+        entity(std::unique_ptr<type>, scope *, std::u32string, std::unique_ptr<expression> = nullptr);
+        entity(std::shared_ptr<unresolved_type>,
+            scope *,
+            std::u32string,
+            std::unique_ptr<expression> = nullptr);
 
         virtual void print(std::ostream &, print_context) const override;
 
@@ -131,15 +134,18 @@ inline namespace _v1
         symbol * _symbol = nullptr;
     };
 
-    inline std::unique_ptr<entity> make_entity(imported_type imported)
+    inline std::unique_ptr<entity> make_entity(imported_type imported, scope * lex_scope, std::u32string name)
     {
-        return std::get<0>(
-            fmap(imported, [](auto && imported) { return std::make_unique<entity>(std::move(imported)); }));
+        return std::get<0>(fmap(imported, [&](auto && imported) {
+            return std::make_unique<entity>(std::move(imported), lex_scope, std::move(name));
+        }));
     }
 
-    inline std::unique_ptr<entity> make_entity(std::unique_ptr<type> owned)
+    inline std::unique_ptr<entity> make_entity(std::unique_ptr<type> owned,
+        scope * lex_scope,
+        std::u32string name)
     {
-        return std::make_unique<entity>(std::move(owned));
+        return std::make_unique<entity>(std::move(owned), lex_scope, std::move(name));
     }
 
     std::unique_ptr<entity> get_entity(precontext &, const proto::entity &);