nixir

diff --git a/src/irc/serializer.cpp b/src/irc/serializer.cppindex cc6cdc8..7a83e55 100644--- a/src/irc/serializer.cpp+++ b/src/irc/serializer.cpp@@ -43,6 +43,7 @@ struct Serializer::Impl {         if (node.holds<UnaryOpNode>()) return NodeType::UNARY_OP;         if (node.holds<AttrsetNode>()) return NodeType::ATTRSET;         if (node.holds<SelectNode>()) return NodeType::SELECT;+        if (node.holds<HasAttrNode>()) return NodeType::HAS_ATTR;         if (node.holds<WithNode>()) return NodeType::WITH;         if (node.holds<IfNode>()) return NodeType::IF;         if (node.holds<LetNode>()) return NodeType::LET;@@ -100,6 +101,9 @@ struct Serializer::Impl {             } else {                 write_u8(0);             }+        } else if (auto* n = node.get_if<HasAttrNode>()) {+            if (n->expr) write_node(*n->expr);+            if (n->attr) write_node(*n->attr);         } else if (auto* n = node.get_if<WithNode>()) {             if (n->attrs) write_node(*n->attrs);             if (n->body) write_node(*n->body);@@ -204,6 +208,122 @@ struct Deserializer::Impl {         pos += len;         return str;     }++    std::shared_ptr<Node> read_node() {+        NodeType type = static_cast<NodeType>(read_u8());+        uint32_t line = read_u32();++        switch (type) {+            case NodeType::CONST_INT: {+                int64_t val = static_cast<int64_t>(read_u64());+                return std::make_shared<Node>(ConstIntNode(val, line));+            }+            case NodeType::CONST_STRING: {+                std::string val = read_string();+                return std::make_shared<Node>(ConstStringNode(val, line));+            }+            case NodeType::CONST_PATH: {+                std::string val = read_string();+                return std::make_shared<Node>(ConstPathNode(val, line));+            }+            case NodeType::CONST_BOOL: {+                bool val = read_u8() != 0;+                return std::make_shared<Node>(ConstBoolNode(val, line));+            }+            case NodeType::CONST_NULL:+                return std::make_shared<Node>(ConstNullNode(line));+            case NodeType::VAR: {+                uint32_t index = read_u32();+                return std::make_shared<Node>(VarNode(index, "", line));+            }+            case NodeType::LAMBDA: {+                uint32_t arity = read_u32();+                auto body = read_node();+                return std::make_shared<Node>(LambdaNode(arity, body, line));+            }+            case NodeType::APP: {+                auto func = read_node();+                auto arg = read_node();+                return std::make_shared<Node>(AppNode(func, arg, line));+            }+            case NodeType::BINARY_OP: {+                BinaryOp op = static_cast<BinaryOp>(read_u8());+                auto left = read_node();+                auto right = read_node();+                return std::make_shared<Node>(BinaryOpNode(op, left, right, line));+            }+            case NodeType::UNARY_OP: {+                UnaryOp op = static_cast<UnaryOp>(read_u8());+                auto operand = read_node();+                return std::make_shared<Node>(UnaryOpNode(op, operand, line));+            }+            case NodeType::ATTRSET: {+                bool recursive = read_u8() != 0;+                uint32_t num_attrs = read_u32();+                AttrsetNode attrs(recursive, line);+                for (uint32_t i = 0; i < num_attrs; i++) {+                    std::string key = read_string();+                    auto val = read_node();+                    attrs.attrs.push_back({key, val});+                }+                return std::make_shared<Node>(std::move(attrs));+            }+            case NodeType::SELECT: {+                auto expr = read_node();+                auto attr = read_node();+                return std::make_shared<Node>(SelectNode(expr, attr, line));+            }+            case NodeType::HAS_ATTR: {+                auto expr = read_node();+                auto attr = read_node();+                return std::make_shared<Node>(HasAttrNode(expr, attr, line));+            }+            case NodeType::WITH: {+                auto attrs = read_node();+                auto body = read_node();+                return std::make_shared<Node>(WithNode(attrs, body, line));+            }+            case NodeType::IF: {+                auto cond = read_node();+                auto then_branch = read_node();+                auto else_branch = read_node();+                return std::make_shared<Node>(IfNode(cond, then_branch, else_branch, line));+            }+            case NodeType::LET: {+                uint32_t num_bindings = read_u32();+                std::vector<std::pair<std::string, std::shared_ptr<Node>>> bindings;+                for (uint32_t i = 0; i < num_bindings; i++) {+                    std::string key = read_string();+                    auto val = read_node();+                    bindings.push_back({key, val});+                }+                auto body = read_node();+                LetNode let(body, line);+                let.bindings = std::move(bindings);+                return std::make_shared<Node>(std::move(let));+            }+            case NodeType::LETREC: {+                uint32_t num_bindings = read_u32();+                std::vector<std::pair<std::string, std::shared_ptr<Node>>> bindings;+                for (uint32_t i = 0; i < num_bindings; i++) {+                    std::string key = read_string();+                    auto val = read_node();+                    bindings.push_back({key, val});+                }+                auto body = read_node();+                LetRecNode letrec(body, line);+                letrec.bindings = std::move(bindings);+                return std::make_shared<Node>(std::move(letrec));+            }+            case NodeType::ASSERT: {+                auto cond = read_node();+                auto body = read_node();+                return std::make_shared<Node>(AssertNode(cond, body, line));+            }+            default:+                throw std::runtime_error("Unknown node type in IR");+        }+    } };  Deserializer::Deserializer() : pImpl(std::make_unique<Impl>()) {}@@ -256,7 +376,7 @@ IRModule Deserializer::deserialize(const std::vector<uint8_t>& data) {     }      if (pImpl->read_u8()) {-        // TODO: deserialize AST+        module.entry = pImpl->read_node();     }      return module;