diff --git a/src/spider/CMakeLists.txt b/src/spider/CMakeLists.txt
index 943ff9d02..0574842ef 100644
--- a/src/spider/CMakeLists.txt
+++ b/src/spider/CMakeLists.txt
@@ -255,6 +255,7 @@ set(SPIDER_TDL_SHARED_HEADERS
     tdl/parser/ast/nodes.hpp
     tdl/parser/ast/utils.hpp
     tdl/parser/ErrorListener.hpp
+    tdl/parser/Exception.hpp
     tdl/parser/parse.hpp
     tdl/parser/SourceLocation.hpp
     CACHE INTERNAL
diff --git a/src/spider/tdl/parser/Exception.hpp b/src/spider/tdl/parser/Exception.hpp
new file mode 100644
index 000000000..ba6cdded8
--- /dev/null
+++ b/src/spider/tdl/parser/Exception.hpp
@@ -0,0 +1,78 @@
+#ifndef SPIDER_TDL_PARSER_EXCEPTION_HPP
+#define SPIDER_TDL_PARSER_EXCEPTION_HPP
+
+#include <exception>
+#include <system_error>
+#include <type_traits>
+
+#include <ystdlib/error_handling/Result.hpp>
+
+#include <spider/tdl/Error.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+namespace spider::tdl::parser {
+class Exception : public std::exception {
+public:
+    // Static methods
+    /**
+     * @tparam T The expected value type on success.
+     * @param result
+     * @param source_location
+     * @return The value forwarded from `result` on success.
+     * @throws spider::tdl::parser::Exception if `result` indicates an error.
+     */
+    template <typename T>
+    requires std::is_move_constructible_v<T>
+    [[nodiscard]] static auto throw_tryx(
+            ystdlib::error_handling::Result<T, std::error_code> result,
+            SourceLocation source_location
+    ) -> T {
+        if (result.has_error()) {
+            throw Exception{result.error(), source_location};
+        }
+        return std::move(result.value());
+    }
+
+    /**
+     * @param result
+     * @param source_location
+     * @throws spider::tdl::parser::Exception if `result` indicates an error.
+     */
+    static auto throw_tryv(
+            ystdlib::error_handling::Result<void, std::error_code> result,
+            SourceLocation source_location
+    ) -> void {
+        if (result.has_error()) {
+            throw Exception{result.error(), source_location};
+        }
+    }
+
+    // Constructor
+    Exception(std::error_code error_code, SourceLocation source_location)
+            : m_error_code{error_code},
+              m_source_location{source_location} {}
+
+    // Methods implementing `std::exception`.
+    [[nodiscard]] auto what() const noexcept -> char const* override {
+        return "spider::tdl::parser::Exception";
+    }
+
+    // Methods
+    [[nodiscard]] auto get_error_code() const noexcept -> std::error_code { return m_error_code; }
+
+    [[nodiscard]] auto get_source_location() const noexcept -> SourceLocation {
+        return m_source_location;
+    }
+
+    [[nodiscard]] auto to_error() const -> Error {
+        return Error{std::string{what()}, m_source_location, m_error_code};
+    }
+
+private:
+    // Variables
+    std::error_code m_error_code;
+    SourceLocation m_source_location;
+};
+}  // namespace spider::tdl::parser
+
+#endif  // SPIDER_TDL_PARSER_EXCEPTION_HPP
diff --git a/src/spider/tdl/parser/TaskDefLang.g4 b/src/spider/tdl/parser/TaskDefLang.g4
index ef733e370..54de95006 100644
--- a/src/spider/tdl/parser/TaskDefLang.g4
+++ b/src/spider/tdl/parser/TaskDefLang.g4
@@ -1,80 +1,281 @@
 grammar TaskDefLang;
 
-translationUnit: (namespace | structDef)* EOF ;
+@header {
+#include <memory>
+#include <utility>
+#include <vector>
 
-namespace
-: 'namespace' id '{' (funcDef)* '}'
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+}
+
+translationUnit returns [std::unique_ptr<spider::tdl::parser::ast::TranslationUnit> tu]
+@init {
+    $tu = spider::tdl::parser::ast::TranslationUnit::create({
+            $ctx->start->getLine(),
+            $ctx->start->getCharPositionInLine()
+    });
+}
+: (namespace {
+    auto const ns_loc{$namespace.retval->get_source_location()};
+    spider::tdl::parser::Exception::throw_tryv(
+        $tu->add_namespace(std::move($namespace.retval)),
+        ns_loc
+    );
+} | structDef {
+    auto const struct_loc{$structDef.retval->get_source_location()};
+    spider::tdl::parser::Exception::throw_tryv(
+        $tu->add_struct_spec(std::move($structDef.retval)),
+        struct_loc
+    );
+})* EOF
+;
+
+namespace returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: 'namespace' id '{' funcDefs '}' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::Namespace::create(
+            std::move($id.retval),
+            std::move($funcDefs.retval),
+            loc
+        ),
+        loc
+    );
+}
+;
+
+funcDefs returns [std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval]
+@init {
+    $retval.clear();
+}
+: (funcDef {
+    $retval.emplace_back(std::move($funcDef.retval));
+})+
 ;
 
-funcDef
-: 'fn' id '(' params ')' ret ';'
+funcDef returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: 'fn' id '(' params ')' ret ';' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::Function::create(
+            std::move($id.retval),
+            std::move($ret.retval),
+            std::move($params.retval),
+            loc
+        ),
+        loc
+    );
+}
 ;
 
-ret
-: '->' retType
-|
+ret returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: '->' retType {
+    $retval = std::move($retType.retval);
+}
+| {
+    $retval = nullptr;
+}
 ;
 
-params
-: namedVarList
-|
+params returns [std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval]
+: namedVarList {
+    $retval = std::move($namedVarList.retval);
+}
+| {
+    $retval.clear();
+}
 ;
 
-namedVar
-: id ':' varType
+namedVar returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: id ':' varType {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::NamedVar::create(
+            std::move($id.retval),
+            std::move($varType.retval),
+            loc
+        ),
+        loc
+    );
+}
 ;
 
-namedVarList
-: namedVar
-| namedVarList ',' namedVar
+namedVarList returns [std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval]
+@init {
+    $retval.clear();
+}
+: first_named_var=namedVar {
+    $retval.emplace_back(std::move($first_named_var.retval));
+} (',' subsequent_named_var=namedVar {
+    $retval.emplace_back(std::move($subsequent_named_var.retval));
+})*
 ;
 
-structDef
-: 'struct' id '{' namedVarList (',')? '}' ';'
+structDef returns [std::shared_ptr<spider::tdl::parser::ast::StructSpec> retval]
+: 'struct' id '{' namedVarList (',')? '}' ';' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::StructSpec::create(
+            std::move($id.retval),
+            std::move($namedVarList.retval),
+            loc
+        ),
+        loc
+    );
+}
 ;
 
-id
-: ID
+id returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: ID {
+    $retval = spider::tdl::parser::ast::Identifier::create(
+        $ID.text,
+        spider::tdl::parser::SourceLocation{
+                $ctx->start->getLine(),
+                $ctx->start->getCharPositionInLine()
+        }
+    );
+}
 ;
 
-varType
-: builtinType
-| id
+varType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: builtinType {
+    $retval = std::move($builtinType.retval);
+}
+| id {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::Struct::create(std::move($id.retval), loc),
+        loc
+    );
+}
 ;
 
-retType
-: varType
-| tupleType
+retType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: varType {
+    $retval = std::move($varType.retval);
+}
+| tupleType {
+    $retval = std::move($tupleType.retval);
+}
 ;
 
-varTypeList
-: varType
-| varTypeList ',' varType
-|
+varTypeList returns [std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval]
+@init {
+    $retval.clear();
+}
+: first_var_type=varType {
+    $retval.emplace_back(std::move($first_var_type.retval));
+}
+(',' subsequent_var_type=varType {
+    $retval.emplace_back(std::move($subsequent_var_type.retval));
+})*
+| {
+    $retval.clear();
+}
 ;
 
-listType
-: 'List' '<' varType '>'
+listType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: 'List' '<' varType '>' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::List::create(std::move($varType.retval), loc),
+        loc
+    );
+}
 ;
 
-mapType
-: 'Map' '<' varType ',' varType '>'
+mapType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: 'Map' '<' key_type=varType ',' val_type=varType '>' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::Map::create(
+                std::move($key_type.retval),
+                std::move($val_type.retval),
+                loc
+        ),
+        loc
+    );
+}
 ;
 
-tupleType
-: 'Tuple' '<' varTypeList '>'
+tupleType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+: 'Tuple' '<' varTypeList '>' {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+    $retval = spider::tdl::parser::Exception::throw_tryx(
+        spider::tdl::parser::ast::Tuple::create(std::move($varTypeList.retval), loc),
+        loc
+    );
+}
 ;
 
-builtinType
-: 'int8'
-| 'int16'
-| 'int32'
-| 'int64'
-| 'float'
-| 'double'
-| 'bool'
-| listType
-| mapType
+builtinType returns [std::unique_ptr<spider::tdl::parser::ast::Node> retval]
+@init {
+    SourceLocation const loc{
+        $ctx->start->getLine(),
+        $ctx->start->getCharPositionInLine()
+    };
+}
+: 'int8' {
+    $retval = spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int8, loc);
+}
+| 'int16' {
+    $retval = spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int16, loc);
+}
+| 'int32' {
+    $retval = spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int32, loc);
+}
+| 'int64' {
+    $retval = spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int64, loc);
+}
+| 'float' {
+    $retval = spider::tdl::parser::ast::Float::create(
+            spider::tdl::parser::ast::FloatSpec::Float,
+            loc
+    );
+}
+| 'double' {
+    $retval = spider::tdl::parser::ast::Float::create(
+            spider::tdl::parser::ast::FloatSpec::Double,
+            loc
+    );
+}
+| 'bool' {
+    $retval = spider::tdl::parser::ast::Bool::create(loc);
+}
+| listType {
+    $retval = std::move($listType.retval);
+}
+| mapType {
+    $retval = std::move($mapType.retval);
+}
 ;
 
 ID: [a-zA-Z_][a-zA-Z0-9_]* ;
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.cpp
index 124d8d53a..c0b0c9ca4 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.cpp
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.cpp
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h
index 9444a86b3..b2fe2753d 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 #pragma once
@@ -25,6 +36,10 @@ class  TaskDefLangBaseVisitor : public TaskDefLangVisitor {
     return visitChildren(ctx);
   }
 
+  virtual std::any visitFuncDefs(TaskDefLangParser::FuncDefsContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
   virtual std::any visitFuncDef(TaskDefLangParser::FuncDefContext *ctx) override {
     return visitChildren(ctx);
   }
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp
index 7593af99b..3466b7402 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h
index adf3e09d3..b8809c65e 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 #pragma once
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp
index 4eb6f5cdc..8a2e2cec3 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 
@@ -53,9 +64,9 @@ void taskdeflangParserInitialize() {
 #endif
   auto staticData = std::make_unique<TaskDefLangParserStaticData>(
     std::vector<std::string>{
-      "translationUnit", "namespace", "funcDef", "ret", "params", "namedVar", 
-      "namedVarList", "structDef", "id", "varType", "retType", "varTypeList", 
-      "listType", "mapType", "tupleType", "builtinType"
+      "translationUnit", "namespace", "funcDefs", "funcDef", "ret", "params", 
+      "namedVar", "namedVarList", "structDef", "id", "varType", "retType", 
+      "varTypeList", "listType", "mapType", "tupleType", "builtinType"
     },
     std::vector<std::string>{
       "", "'namespace'", "'{'", "'}'", "'fn'", "'('", "')'", "';'", "'->'", 
@@ -69,50 +80,63 @@ void taskdeflangParserInitialize() {
     }
   );
   static const int32_t serializedATNSegment[] = {
-  	4,1,26,146,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,
+  	4,1,26,186,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,
   	7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,
-  	14,2,15,7,15,1,0,1,0,5,0,35,8,0,10,0,12,0,38,9,0,1,0,1,0,1,1,1,1,1,1,
-  	1,1,5,1,46,8,1,10,1,12,1,49,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
-  	2,1,3,1,3,1,3,3,3,64,8,3,1,4,1,4,3,4,68,8,4,1,5,1,5,1,5,1,5,1,6,1,6,1,
-  	6,1,6,1,6,1,6,5,6,80,8,6,10,6,12,6,83,9,6,1,7,1,7,1,7,1,7,1,7,3,7,90,
-  	8,7,1,7,1,7,1,7,1,8,1,8,1,9,1,9,3,9,99,8,9,1,10,1,10,3,10,103,8,10,1,
-  	11,1,11,1,11,3,11,108,8,11,1,11,1,11,1,11,5,11,113,8,11,10,11,12,11,116,
-  	9,11,1,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,14,
-  	1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,
-  	144,8,15,1,15,0,2,12,22,16,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
-  	0,0,148,0,36,1,0,0,0,2,41,1,0,0,0,4,52,1,0,0,0,6,63,1,0,0,0,8,67,1,0,
-  	0,0,10,69,1,0,0,0,12,73,1,0,0,0,14,84,1,0,0,0,16,94,1,0,0,0,18,98,1,0,
-  	0,0,20,102,1,0,0,0,22,107,1,0,0,0,24,117,1,0,0,0,26,122,1,0,0,0,28,129,
-  	1,0,0,0,30,143,1,0,0,0,32,35,3,2,1,0,33,35,3,14,7,0,34,32,1,0,0,0,34,
-  	33,1,0,0,0,35,38,1,0,0,0,36,34,1,0,0,0,36,37,1,0,0,0,37,39,1,0,0,0,38,
-  	36,1,0,0,0,39,40,5,0,0,1,40,1,1,0,0,0,41,42,5,1,0,0,42,43,3,16,8,0,43,
-  	47,5,2,0,0,44,46,3,4,2,0,45,44,1,0,0,0,46,49,1,0,0,0,47,45,1,0,0,0,47,
-  	48,1,0,0,0,48,50,1,0,0,0,49,47,1,0,0,0,50,51,5,3,0,0,51,3,1,0,0,0,52,
-  	53,5,4,0,0,53,54,3,16,8,0,54,55,5,5,0,0,55,56,3,8,4,0,56,57,5,6,0,0,57,
-  	58,3,6,3,0,58,59,5,7,0,0,59,5,1,0,0,0,60,61,5,8,0,0,61,64,3,20,10,0,62,
-  	64,1,0,0,0,63,60,1,0,0,0,63,62,1,0,0,0,64,7,1,0,0,0,65,68,3,12,6,0,66,
-  	68,1,0,0,0,67,65,1,0,0,0,67,66,1,0,0,0,68,9,1,0,0,0,69,70,3,16,8,0,70,
-  	71,5,9,0,0,71,72,3,18,9,0,72,11,1,0,0,0,73,74,6,6,-1,0,74,75,3,10,5,0,
-  	75,81,1,0,0,0,76,77,10,1,0,0,77,78,5,10,0,0,78,80,3,10,5,0,79,76,1,0,
-  	0,0,80,83,1,0,0,0,81,79,1,0,0,0,81,82,1,0,0,0,82,13,1,0,0,0,83,81,1,0,
-  	0,0,84,85,5,11,0,0,85,86,3,16,8,0,86,87,5,2,0,0,87,89,3,12,6,0,88,90,
-  	5,10,0,0,89,88,1,0,0,0,89,90,1,0,0,0,90,91,1,0,0,0,91,92,5,3,0,0,92,93,
-  	5,7,0,0,93,15,1,0,0,0,94,95,5,24,0,0,95,17,1,0,0,0,96,99,3,30,15,0,97,
-  	99,3,16,8,0,98,96,1,0,0,0,98,97,1,0,0,0,99,19,1,0,0,0,100,103,3,18,9,
-  	0,101,103,3,28,14,0,102,100,1,0,0,0,102,101,1,0,0,0,103,21,1,0,0,0,104,
-  	105,6,11,-1,0,105,108,3,18,9,0,106,108,1,0,0,0,107,104,1,0,0,0,107,106,
-  	1,0,0,0,108,114,1,0,0,0,109,110,10,2,0,0,110,111,5,10,0,0,111,113,3,18,
-  	9,0,112,109,1,0,0,0,113,116,1,0,0,0,114,112,1,0,0,0,114,115,1,0,0,0,115,
-  	23,1,0,0,0,116,114,1,0,0,0,117,118,5,12,0,0,118,119,5,13,0,0,119,120,
-  	3,18,9,0,120,121,5,14,0,0,121,25,1,0,0,0,122,123,5,15,0,0,123,124,5,13,
-  	0,0,124,125,3,18,9,0,125,126,5,10,0,0,126,127,3,18,9,0,127,128,5,14,0,
-  	0,128,27,1,0,0,0,129,130,5,16,0,0,130,131,5,13,0,0,131,132,3,22,11,0,
-  	132,133,5,14,0,0,133,29,1,0,0,0,134,144,5,17,0,0,135,144,5,18,0,0,136,
-  	144,5,19,0,0,137,144,5,20,0,0,138,144,5,21,0,0,139,144,5,22,0,0,140,144,
-  	5,23,0,0,141,144,3,24,12,0,142,144,3,26,13,0,143,134,1,0,0,0,143,135,
-  	1,0,0,0,143,136,1,0,0,0,143,137,1,0,0,0,143,138,1,0,0,0,143,139,1,0,0,
-  	0,143,140,1,0,0,0,143,141,1,0,0,0,143,142,1,0,0,0,144,31,1,0,0,0,12,34,
-  	36,47,63,67,81,89,98,102,107,114,143
+  	14,2,15,7,15,2,16,7,16,1,0,1,0,1,0,1,0,1,0,1,0,5,0,41,8,0,10,0,12,0,44,
+  	9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,2,4,2,58,8,2,11,2,12,
+  	2,59,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,3,4,76,8,
+  	4,1,5,1,5,1,5,1,5,3,5,82,8,5,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,
+  	1,7,5,7,95,8,7,10,7,12,7,98,9,7,1,8,1,8,1,8,1,8,1,8,3,8,105,8,8,1,8,1,
+  	8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,3,10,120,8,10,1,11,
+  	1,11,1,11,1,11,1,11,1,11,3,11,128,8,11,1,12,1,12,1,12,1,12,1,12,1,12,
+  	5,12,136,8,12,10,12,12,12,139,9,12,1,12,3,12,142,8,12,1,13,1,13,1,13,
+  	1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,15,1,15,1,15,
+  	1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
+  	1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,184,8,16,1,16,0,0,17,
+  	0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,0,0,187,0,42,1,0,0,0,2,
+  	47,1,0,0,0,4,57,1,0,0,0,6,61,1,0,0,0,8,75,1,0,0,0,10,81,1,0,0,0,12,83,
+  	1,0,0,0,14,88,1,0,0,0,16,99,1,0,0,0,18,110,1,0,0,0,20,119,1,0,0,0,22,
+  	127,1,0,0,0,24,141,1,0,0,0,26,143,1,0,0,0,28,149,1,0,0,0,30,157,1,0,0,
+  	0,32,183,1,0,0,0,34,35,3,2,1,0,35,36,6,0,-1,0,36,41,1,0,0,0,37,38,3,16,
+  	8,0,38,39,6,0,-1,0,39,41,1,0,0,0,40,34,1,0,0,0,40,37,1,0,0,0,41,44,1,
+  	0,0,0,42,40,1,0,0,0,42,43,1,0,0,0,43,45,1,0,0,0,44,42,1,0,0,0,45,46,5,
+  	0,0,1,46,1,1,0,0,0,47,48,5,1,0,0,48,49,3,18,9,0,49,50,5,2,0,0,50,51,3,
+  	4,2,0,51,52,5,3,0,0,52,53,6,1,-1,0,53,3,1,0,0,0,54,55,3,6,3,0,55,56,6,
+  	2,-1,0,56,58,1,0,0,0,57,54,1,0,0,0,58,59,1,0,0,0,59,57,1,0,0,0,59,60,
+  	1,0,0,0,60,5,1,0,0,0,61,62,5,4,0,0,62,63,3,18,9,0,63,64,5,5,0,0,64,65,
+  	3,10,5,0,65,66,5,6,0,0,66,67,3,8,4,0,67,68,5,7,0,0,68,69,6,3,-1,0,69,
+  	7,1,0,0,0,70,71,5,8,0,0,71,72,3,22,11,0,72,73,6,4,-1,0,73,76,1,0,0,0,
+  	74,76,6,4,-1,0,75,70,1,0,0,0,75,74,1,0,0,0,76,9,1,0,0,0,77,78,3,14,7,
+  	0,78,79,6,5,-1,0,79,82,1,0,0,0,80,82,6,5,-1,0,81,77,1,0,0,0,81,80,1,0,
+  	0,0,82,11,1,0,0,0,83,84,3,18,9,0,84,85,5,9,0,0,85,86,3,20,10,0,86,87,
+  	6,6,-1,0,87,13,1,0,0,0,88,89,3,12,6,0,89,96,6,7,-1,0,90,91,5,10,0,0,91,
+  	92,3,12,6,0,92,93,6,7,-1,0,93,95,1,0,0,0,94,90,1,0,0,0,95,98,1,0,0,0,
+  	96,94,1,0,0,0,96,97,1,0,0,0,97,15,1,0,0,0,98,96,1,0,0,0,99,100,5,11,0,
+  	0,100,101,3,18,9,0,101,102,5,2,0,0,102,104,3,14,7,0,103,105,5,10,0,0,
+  	104,103,1,0,0,0,104,105,1,0,0,0,105,106,1,0,0,0,106,107,5,3,0,0,107,108,
+  	5,7,0,0,108,109,6,8,-1,0,109,17,1,0,0,0,110,111,5,24,0,0,111,112,6,9,
+  	-1,0,112,19,1,0,0,0,113,114,3,32,16,0,114,115,6,10,-1,0,115,120,1,0,0,
+  	0,116,117,3,18,9,0,117,118,6,10,-1,0,118,120,1,0,0,0,119,113,1,0,0,0,
+  	119,116,1,0,0,0,120,21,1,0,0,0,121,122,3,20,10,0,122,123,6,11,-1,0,123,
+  	128,1,0,0,0,124,125,3,30,15,0,125,126,6,11,-1,0,126,128,1,0,0,0,127,121,
+  	1,0,0,0,127,124,1,0,0,0,128,23,1,0,0,0,129,130,3,20,10,0,130,137,6,12,
+  	-1,0,131,132,5,10,0,0,132,133,3,20,10,0,133,134,6,12,-1,0,134,136,1,0,
+  	0,0,135,131,1,0,0,0,136,139,1,0,0,0,137,135,1,0,0,0,137,138,1,0,0,0,138,
+  	142,1,0,0,0,139,137,1,0,0,0,140,142,6,12,-1,0,141,129,1,0,0,0,141,140,
+  	1,0,0,0,142,25,1,0,0,0,143,144,5,12,0,0,144,145,5,13,0,0,145,146,3,20,
+  	10,0,146,147,5,14,0,0,147,148,6,13,-1,0,148,27,1,0,0,0,149,150,5,15,0,
+  	0,150,151,5,13,0,0,151,152,3,20,10,0,152,153,5,10,0,0,153,154,3,20,10,
+  	0,154,155,5,14,0,0,155,156,6,14,-1,0,156,29,1,0,0,0,157,158,5,16,0,0,
+  	158,159,5,13,0,0,159,160,3,24,12,0,160,161,5,14,0,0,161,162,6,15,-1,0,
+  	162,31,1,0,0,0,163,164,5,17,0,0,164,184,6,16,-1,0,165,166,5,18,0,0,166,
+  	184,6,16,-1,0,167,168,5,19,0,0,168,184,6,16,-1,0,169,170,5,20,0,0,170,
+  	184,6,16,-1,0,171,172,5,21,0,0,172,184,6,16,-1,0,173,174,5,22,0,0,174,
+  	184,6,16,-1,0,175,176,5,23,0,0,176,184,6,16,-1,0,177,178,3,26,13,0,178,
+  	179,6,16,-1,0,179,184,1,0,0,0,180,181,3,28,14,0,181,182,6,16,-1,0,182,
+  	184,1,0,0,0,183,163,1,0,0,0,183,165,1,0,0,0,183,167,1,0,0,0,183,169,1,
+  	0,0,0,183,171,1,0,0,0,183,173,1,0,0,0,183,175,1,0,0,0,183,177,1,0,0,0,
+  	183,180,1,0,0,0,184,33,1,0,0,0,12,40,42,59,75,81,96,104,119,127,137,141,
+  	183
   };
   staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
 
@@ -203,6 +227,12 @@ std::any TaskDefLangParser::TranslationUnitContext::accept(tree::ParseTreeVisito
 TaskDefLangParser::TranslationUnitContext* TaskDefLangParser::translationUnit() {
   TranslationUnitContext *_localctx = _tracker.createInstance<TranslationUnitContext>(_ctx, getState());
   enterRule(_localctx, 0, TaskDefLangParser::RuleTranslationUnit);
+
+      antlrcpp::downCast<TranslationUnitContext *>(_localctx)->tu =  spider::tdl::parser::ast::TranslationUnit::create({
+              _localctx->start->getLine(),
+              _localctx->start->getCharPositionInLine()
+      });
+
   size_t _la = 0;
 
 #if __cplusplus > 201703L
@@ -214,35 +244,49 @@ TaskDefLangParser::TranslationUnitContext* TaskDefLangParser::translationUnit()
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(36);
+    setState(42);
     _errHandler->sync(this);
     _la = _input->LA(1);
     while (_la == TaskDefLangParser::T__0
 
     || _la == TaskDefLangParser::T__10) {
-      setState(34);
+      setState(40);
       _errHandler->sync(this);
       switch (_input->LA(1)) {
         case TaskDefLangParser::T__0: {
-          setState(32);
-          namespace_();
+          setState(34);
+          antlrcpp::downCast<TranslationUnitContext *>(_localctx)->namespaceContext = namespace_();
+
+              auto const ns_loc{antlrcpp::downCast<TranslationUnitContext *>(_localctx)->namespaceContext->retval->get_source_location()};
+              spider::tdl::parser::Exception::throw_tryv(
+                  _localctx->tu->add_namespace(std::move(antlrcpp::downCast<TranslationUnitContext *>(_localctx)->namespaceContext->retval)),
+                  ns_loc
+              );
+
           break;
         }
 
         case TaskDefLangParser::T__10: {
-          setState(33);
-          structDef();
+          setState(37);
+          antlrcpp::downCast<TranslationUnitContext *>(_localctx)->structDefContext = structDef();
+
+              auto const struct_loc{antlrcpp::downCast<TranslationUnitContext *>(_localctx)->structDefContext->retval->get_source_location()};
+              spider::tdl::parser::Exception::throw_tryv(
+                  _localctx->tu->add_struct_spec(std::move(antlrcpp::downCast<TranslationUnitContext *>(_localctx)->structDefContext->retval)),
+                  struct_loc
+              );
+
           break;
         }
 
       default:
         throw NoViableAltException(this);
       }
-      setState(38);
+      setState(44);
       _errHandler->sync(this);
       _la = _input->LA(1);
     }
-    setState(39);
+    setState(45);
     match(TaskDefLangParser::EOF);
    
   }
@@ -265,12 +309,8 @@ TaskDefLangParser::IdContext* TaskDefLangParser::NamespaceContext::id() {
   return getRuleContext<TaskDefLangParser::IdContext>(0);
 }
 
-std::vector<TaskDefLangParser::FuncDefContext *> TaskDefLangParser::NamespaceContext::funcDef() {
-  return getRuleContexts<TaskDefLangParser::FuncDefContext>();
-}
-
-TaskDefLangParser::FuncDefContext* TaskDefLangParser::NamespaceContext::funcDef(size_t i) {
-  return getRuleContext<TaskDefLangParser::FuncDefContext>(i);
+TaskDefLangParser::FuncDefsContext* TaskDefLangParser::NamespaceContext::funcDefs() {
+  return getRuleContext<TaskDefLangParser::FuncDefsContext>(0);
 }
 
 
@@ -289,7 +329,6 @@ std::any TaskDefLangParser::NamespaceContext::accept(tree::ParseTreeVisitor *vis
 TaskDefLangParser::NamespaceContext* TaskDefLangParser::namespace_() {
   NamespaceContext *_localctx = _tracker.createInstance<NamespaceContext>(_ctx, getState());
   enterRule(_localctx, 2, TaskDefLangParser::RuleNamespace);
-  size_t _la = 0;
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -300,24 +339,98 @@ TaskDefLangParser::NamespaceContext* TaskDefLangParser::namespace_() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(41);
+    setState(47);
     match(TaskDefLangParser::T__0);
-    setState(42);
-    id();
-    setState(43);
+    setState(48);
+    antlrcpp::downCast<NamespaceContext *>(_localctx)->idContext = id();
+    setState(49);
     match(TaskDefLangParser::T__1);
-    setState(47);
+    setState(50);
+    antlrcpp::downCast<NamespaceContext *>(_localctx)->funcDefsContext = funcDefs();
+    setState(51);
+    match(TaskDefLangParser::T__2);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<NamespaceContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::Namespace::create(
+                std::move(antlrcpp::downCast<NamespaceContext *>(_localctx)->idContext->retval),
+                std::move(antlrcpp::downCast<NamespaceContext *>(_localctx)->funcDefsContext->retval),
+                loc
+            ),
+            loc
+        );
+
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FuncDefsContext ------------------------------------------------------------------
+
+TaskDefLangParser::FuncDefsContext::FuncDefsContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<TaskDefLangParser::FuncDefContext *> TaskDefLangParser::FuncDefsContext::funcDef() {
+  return getRuleContexts<TaskDefLangParser::FuncDefContext>();
+}
+
+TaskDefLangParser::FuncDefContext* TaskDefLangParser::FuncDefsContext::funcDef(size_t i) {
+  return getRuleContext<TaskDefLangParser::FuncDefContext>(i);
+}
+
+
+size_t TaskDefLangParser::FuncDefsContext::getRuleIndex() const {
+  return TaskDefLangParser::RuleFuncDefs;
+}
+
+
+std::any TaskDefLangParser::FuncDefsContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<TaskDefLangVisitor*>(visitor))
+    return parserVisitor->visitFuncDefs(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+TaskDefLangParser::FuncDefsContext* TaskDefLangParser::funcDefs() {
+  FuncDefsContext *_localctx = _tracker.createInstance<FuncDefsContext>(_ctx, getState());
+  enterRule(_localctx, 4, TaskDefLangParser::RuleFuncDefs);
+
+      _localctx->retval.clear();
+
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(57); 
     _errHandler->sync(this);
     _la = _input->LA(1);
-    while (_la == TaskDefLangParser::T__3) {
-      setState(44);
-      funcDef();
-      setState(49);
+    do {
+      setState(54);
+      antlrcpp::downCast<FuncDefsContext *>(_localctx)->funcDefContext = funcDef();
+
+          _localctx->retval.emplace_back(std::move(antlrcpp::downCast<FuncDefsContext *>(_localctx)->funcDefContext->retval));
+
+      setState(59); 
       _errHandler->sync(this);
       _la = _input->LA(1);
-    }
-    setState(50);
-    match(TaskDefLangParser::T__2);
+    } while (_la == TaskDefLangParser::T__3);
    
   }
   catch (RecognitionException &e) {
@@ -362,7 +475,7 @@ std::any TaskDefLangParser::FuncDefContext::accept(tree::ParseTreeVisitor *visit
 
 TaskDefLangParser::FuncDefContext* TaskDefLangParser::funcDef() {
   FuncDefContext *_localctx = _tracker.createInstance<FuncDefContext>(_ctx, getState());
-  enterRule(_localctx, 4, TaskDefLangParser::RuleFuncDef);
+  enterRule(_localctx, 6, TaskDefLangParser::RuleFuncDef);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -373,20 +486,35 @@ TaskDefLangParser::FuncDefContext* TaskDefLangParser::funcDef() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(52);
+    setState(61);
     match(TaskDefLangParser::T__3);
-    setState(53);
-    id();
-    setState(54);
+    setState(62);
+    antlrcpp::downCast<FuncDefContext *>(_localctx)->idContext = id();
+    setState(63);
     match(TaskDefLangParser::T__4);
-    setState(55);
-    params();
-    setState(56);
+    setState(64);
+    antlrcpp::downCast<FuncDefContext *>(_localctx)->paramsContext = params();
+    setState(65);
     match(TaskDefLangParser::T__5);
-    setState(57);
-    ret();
-    setState(58);
+    setState(66);
+    antlrcpp::downCast<FuncDefContext *>(_localctx)->retContext = ret();
+    setState(67);
     match(TaskDefLangParser::T__6);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<FuncDefContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::Function::create(
+                std::move(antlrcpp::downCast<FuncDefContext *>(_localctx)->idContext->retval),
+                std::move(antlrcpp::downCast<FuncDefContext *>(_localctx)->retContext->retval),
+                std::move(antlrcpp::downCast<FuncDefContext *>(_localctx)->paramsContext->retval),
+                loc
+            ),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -423,7 +551,7 @@ std::any TaskDefLangParser::RetContext::accept(tree::ParseTreeVisitor *visitor)
 
 TaskDefLangParser::RetContext* TaskDefLangParser::ret() {
   RetContext *_localctx = _tracker.createInstance<RetContext>(_ctx, getState());
-  enterRule(_localctx, 6, TaskDefLangParser::RuleRet);
+  enterRule(_localctx, 8, TaskDefLangParser::RuleRet);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -433,21 +561,26 @@ TaskDefLangParser::RetContext* TaskDefLangParser::ret() {
     exitRule();
   });
   try {
-    setState(63);
+    setState(75);
     _errHandler->sync(this);
     switch (_input->LA(1)) {
       case TaskDefLangParser::T__7: {
         enterOuterAlt(_localctx, 1);
-        setState(60);
+        setState(70);
         match(TaskDefLangParser::T__7);
-        setState(61);
-        retType();
+        setState(71);
+        antlrcpp::downCast<RetContext *>(_localctx)->retTypeContext = retType();
+
+            antlrcpp::downCast<RetContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<RetContext *>(_localctx)->retTypeContext->retval);
+
         break;
       }
 
       case TaskDefLangParser::T__6: {
         enterOuterAlt(_localctx, 2);
 
+            antlrcpp::downCast<RetContext *>(_localctx)->retval =  nullptr;
+
         break;
       }
 
@@ -490,7 +623,7 @@ std::any TaskDefLangParser::ParamsContext::accept(tree::ParseTreeVisitor *visito
 
 TaskDefLangParser::ParamsContext* TaskDefLangParser::params() {
   ParamsContext *_localctx = _tracker.createInstance<ParamsContext>(_ctx, getState());
-  enterRule(_localctx, 8, TaskDefLangParser::RuleParams);
+  enterRule(_localctx, 10, TaskDefLangParser::RuleParams);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -500,19 +633,24 @@ TaskDefLangParser::ParamsContext* TaskDefLangParser::params() {
     exitRule();
   });
   try {
-    setState(67);
+    setState(81);
     _errHandler->sync(this);
     switch (_input->LA(1)) {
       case TaskDefLangParser::ID: {
         enterOuterAlt(_localctx, 1);
-        setState(65);
-        namedVarList(0);
+        setState(77);
+        antlrcpp::downCast<ParamsContext *>(_localctx)->namedVarListContext = namedVarList();
+
+            antlrcpp::downCast<ParamsContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<ParamsContext *>(_localctx)->namedVarListContext->retval);
+
         break;
       }
 
       case TaskDefLangParser::T__5: {
         enterOuterAlt(_localctx, 2);
 
+            _localctx->retval.clear();
+
         break;
       }
 
@@ -559,7 +697,7 @@ std::any TaskDefLangParser::NamedVarContext::accept(tree::ParseTreeVisitor *visi
 
 TaskDefLangParser::NamedVarContext* TaskDefLangParser::namedVar() {
   NamedVarContext *_localctx = _tracker.createInstance<NamedVarContext>(_ctx, getState());
-  enterRule(_localctx, 10, TaskDefLangParser::RuleNamedVar);
+  enterRule(_localctx, 12, TaskDefLangParser::RuleNamedVar);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -570,12 +708,26 @@ TaskDefLangParser::NamedVarContext* TaskDefLangParser::namedVar() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(69);
-    id();
-    setState(70);
+    setState(83);
+    antlrcpp::downCast<NamedVarContext *>(_localctx)->idContext = id();
+    setState(84);
     match(TaskDefLangParser::T__8);
-    setState(71);
-    varType();
+    setState(85);
+    antlrcpp::downCast<NamedVarContext *>(_localctx)->varTypeContext = varType();
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<NamedVarContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::NamedVar::create(
+                std::move(antlrcpp::downCast<NamedVarContext *>(_localctx)->idContext->retval),
+                std::move(antlrcpp::downCast<NamedVarContext *>(_localctx)->varTypeContext->retval),
+                loc
+            ),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -593,12 +745,12 @@ TaskDefLangParser::NamedVarListContext::NamedVarListContext(ParserRuleContext *p
   : ParserRuleContext(parent, invokingState) {
 }
 
-TaskDefLangParser::NamedVarContext* TaskDefLangParser::NamedVarListContext::namedVar() {
-  return getRuleContext<TaskDefLangParser::NamedVarContext>(0);
+std::vector<TaskDefLangParser::NamedVarContext *> TaskDefLangParser::NamedVarListContext::namedVar() {
+  return getRuleContexts<TaskDefLangParser::NamedVarContext>();
 }
 
-TaskDefLangParser::NamedVarListContext* TaskDefLangParser::NamedVarListContext::namedVarList() {
-  return getRuleContext<TaskDefLangParser::NamedVarListContext>(0);
+TaskDefLangParser::NamedVarContext* TaskDefLangParser::NamedVarListContext::namedVar(size_t i) {
+  return getRuleContext<TaskDefLangParser::NamedVarContext>(i);
 }
 
 
@@ -614,63 +766,53 @@ std::any TaskDefLangParser::NamedVarListContext::accept(tree::ParseTreeVisitor *
     return visitor->visitChildren(this);
 }
 
-
 TaskDefLangParser::NamedVarListContext* TaskDefLangParser::namedVarList() {
-   return namedVarList(0);
-}
+  NamedVarListContext *_localctx = _tracker.createInstance<NamedVarListContext>(_ctx, getState());
+  enterRule(_localctx, 14, TaskDefLangParser::RuleNamedVarList);
 
-TaskDefLangParser::NamedVarListContext* TaskDefLangParser::namedVarList(int precedence) {
-  ParserRuleContext *parentContext = _ctx;
-  size_t parentState = getState();
-  TaskDefLangParser::NamedVarListContext *_localctx = _tracker.createInstance<NamedVarListContext>(_ctx, parentState);
-  TaskDefLangParser::NamedVarListContext *previousContext = _localctx;
-  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
-  size_t startState = 12;
-  enterRecursionRule(_localctx, 12, TaskDefLangParser::RuleNamedVarList, precedence);
+      _localctx->retval.clear();
 
-    
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
 #else
   auto onExit = finally([=] {
 #endif
-    unrollRecursionContexts(parentContext);
+    exitRule();
   });
   try {
     size_t alt;
     enterOuterAlt(_localctx, 1);
-    setState(74);
-    namedVar();
-    _ctx->stop = _input->LT(-1);
-    setState(81);
+    setState(88);
+    antlrcpp::downCast<NamedVarListContext *>(_localctx)->first_named_var = namedVar();
+
+        _localctx->retval.emplace_back(std::move(antlrcpp::downCast<NamedVarListContext *>(_localctx)->first_named_var->retval));
+
+    setState(96);
     _errHandler->sync(this);
     alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
     while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
       if (alt == 1) {
-        if (!_parseListeners.empty())
-          triggerExitRuleEvent();
-        previousContext = _localctx;
-        _localctx = _tracker.createInstance<NamedVarListContext>(parentContext, parentState);
-        pushNewRecursionContext(_localctx, startState, RuleNamedVarList);
-        setState(76);
-
-        if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
-        setState(77);
+        setState(90);
         match(TaskDefLangParser::T__9);
-        setState(78);
-        namedVar(); 
+        setState(91);
+        antlrcpp::downCast<NamedVarListContext *>(_localctx)->subsequent_named_var = namedVar();
+
+            _localctx->retval.emplace_back(std::move(antlrcpp::downCast<NamedVarListContext *>(_localctx)->subsequent_named_var->retval));
+     
       }
-      setState(83);
+      setState(98);
       _errHandler->sync(this);
       alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
     }
+   
   }
   catch (RecognitionException &e) {
     _errHandler->reportError(this, e);
     _localctx->exception = std::current_exception();
     _errHandler->recover(this, _localctx->exception);
   }
+
   return _localctx;
 }
 
@@ -703,7 +845,7 @@ std::any TaskDefLangParser::StructDefContext::accept(tree::ParseTreeVisitor *vis
 
 TaskDefLangParser::StructDefContext* TaskDefLangParser::structDef() {
   StructDefContext *_localctx = _tracker.createInstance<StructDefContext>(_ctx, getState());
-  enterRule(_localctx, 14, TaskDefLangParser::RuleStructDef);
+  enterRule(_localctx, 16, TaskDefLangParser::RuleStructDef);
   size_t _la = 0;
 
 #if __cplusplus > 201703L
@@ -715,26 +857,40 @@ TaskDefLangParser::StructDefContext* TaskDefLangParser::structDef() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(84);
+    setState(99);
     match(TaskDefLangParser::T__10);
-    setState(85);
-    id();
-    setState(86);
+    setState(100);
+    antlrcpp::downCast<StructDefContext *>(_localctx)->idContext = id();
+    setState(101);
     match(TaskDefLangParser::T__1);
-    setState(87);
-    namedVarList(0);
-    setState(89);
+    setState(102);
+    antlrcpp::downCast<StructDefContext *>(_localctx)->namedVarListContext = namedVarList();
+    setState(104);
     _errHandler->sync(this);
 
     _la = _input->LA(1);
     if (_la == TaskDefLangParser::T__9) {
-      setState(88);
+      setState(103);
       match(TaskDefLangParser::T__9);
     }
-    setState(91);
+    setState(106);
     match(TaskDefLangParser::T__2);
-    setState(92);
+    setState(107);
     match(TaskDefLangParser::T__6);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<StructDefContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::StructSpec::create(
+                std::move(antlrcpp::downCast<StructDefContext *>(_localctx)->idContext->retval),
+                std::move(antlrcpp::downCast<StructDefContext *>(_localctx)->namedVarListContext->retval),
+                loc
+            ),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -771,7 +927,7 @@ std::any TaskDefLangParser::IdContext::accept(tree::ParseTreeVisitor *visitor) {
 
 TaskDefLangParser::IdContext* TaskDefLangParser::id() {
   IdContext *_localctx = _tracker.createInstance<IdContext>(_ctx, getState());
-  enterRule(_localctx, 16, TaskDefLangParser::RuleId);
+  enterRule(_localctx, 18, TaskDefLangParser::RuleId);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -782,8 +938,17 @@ TaskDefLangParser::IdContext* TaskDefLangParser::id() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(94);
-    match(TaskDefLangParser::ID);
+    setState(110);
+    antlrcpp::downCast<IdContext *>(_localctx)->idToken = match(TaskDefLangParser::ID);
+
+        antlrcpp::downCast<IdContext *>(_localctx)->retval =  spider::tdl::parser::ast::Identifier::create(
+            (antlrcpp::downCast<IdContext *>(_localctx)->idToken != nullptr ? antlrcpp::downCast<IdContext *>(_localctx)->idToken->getText() : ""),
+            spider::tdl::parser::SourceLocation{
+                    _localctx->start->getLine(),
+                    _localctx->start->getCharPositionInLine()
+            }
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -824,7 +989,7 @@ std::any TaskDefLangParser::VarTypeContext::accept(tree::ParseTreeVisitor *visit
 
 TaskDefLangParser::VarTypeContext* TaskDefLangParser::varType() {
   VarTypeContext *_localctx = _tracker.createInstance<VarTypeContext>(_ctx, getState());
-  enterRule(_localctx, 18, TaskDefLangParser::RuleVarType);
+  enterRule(_localctx, 20, TaskDefLangParser::RuleVarType);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -834,7 +999,7 @@ TaskDefLangParser::VarTypeContext* TaskDefLangParser::varType() {
     exitRule();
   });
   try {
-    setState(98);
+    setState(119);
     _errHandler->sync(this);
     switch (_input->LA(1)) {
       case TaskDefLangParser::T__11:
@@ -847,15 +1012,28 @@ TaskDefLangParser::VarTypeContext* TaskDefLangParser::varType() {
       case TaskDefLangParser::T__21:
       case TaskDefLangParser::T__22: {
         enterOuterAlt(_localctx, 1);
-        setState(96);
-        builtinType();
+        setState(113);
+        antlrcpp::downCast<VarTypeContext *>(_localctx)->builtinTypeContext = builtinType();
+
+            antlrcpp::downCast<VarTypeContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<VarTypeContext *>(_localctx)->builtinTypeContext->retval);
+
         break;
       }
 
       case TaskDefLangParser::ID: {
         enterOuterAlt(_localctx, 2);
-        setState(97);
-        id();
+        setState(116);
+        antlrcpp::downCast<VarTypeContext *>(_localctx)->idContext = id();
+
+            SourceLocation const loc{
+                _localctx->start->getLine(),
+                _localctx->start->getCharPositionInLine()
+            };
+            antlrcpp::downCast<VarTypeContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+                spider::tdl::parser::ast::Struct::create(std::move(antlrcpp::downCast<VarTypeContext *>(_localctx)->idContext->retval), loc),
+                loc
+            );
+
         break;
       }
 
@@ -902,7 +1080,7 @@ std::any TaskDefLangParser::RetTypeContext::accept(tree::ParseTreeVisitor *visit
 
 TaskDefLangParser::RetTypeContext* TaskDefLangParser::retType() {
   RetTypeContext *_localctx = _tracker.createInstance<RetTypeContext>(_ctx, getState());
-  enterRule(_localctx, 20, TaskDefLangParser::RuleRetType);
+  enterRule(_localctx, 22, TaskDefLangParser::RuleRetType);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -912,7 +1090,7 @@ TaskDefLangParser::RetTypeContext* TaskDefLangParser::retType() {
     exitRule();
   });
   try {
-    setState(102);
+    setState(127);
     _errHandler->sync(this);
     switch (_input->LA(1)) {
       case TaskDefLangParser::T__11:
@@ -926,15 +1104,21 @@ TaskDefLangParser::RetTypeContext* TaskDefLangParser::retType() {
       case TaskDefLangParser::T__22:
       case TaskDefLangParser::ID: {
         enterOuterAlt(_localctx, 1);
-        setState(100);
-        varType();
+        setState(121);
+        antlrcpp::downCast<RetTypeContext *>(_localctx)->varTypeContext = varType();
+
+            antlrcpp::downCast<RetTypeContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<RetTypeContext *>(_localctx)->varTypeContext->retval);
+
         break;
       }
 
       case TaskDefLangParser::T__15: {
         enterOuterAlt(_localctx, 2);
-        setState(101);
-        tupleType();
+        setState(124);
+        antlrcpp::downCast<RetTypeContext *>(_localctx)->tupleTypeContext = tupleType();
+
+            antlrcpp::downCast<RetTypeContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<RetTypeContext *>(_localctx)->tupleTypeContext->retval);
+
         break;
       }
 
@@ -958,12 +1142,12 @@ TaskDefLangParser::VarTypeListContext::VarTypeListContext(ParserRuleContext *par
   : ParserRuleContext(parent, invokingState) {
 }
 
-TaskDefLangParser::VarTypeContext* TaskDefLangParser::VarTypeListContext::varType() {
-  return getRuleContext<TaskDefLangParser::VarTypeContext>(0);
+std::vector<TaskDefLangParser::VarTypeContext *> TaskDefLangParser::VarTypeListContext::varType() {
+  return getRuleContexts<TaskDefLangParser::VarTypeContext>();
 }
 
-TaskDefLangParser::VarTypeListContext* TaskDefLangParser::VarTypeListContext::varTypeList() {
-  return getRuleContext<TaskDefLangParser::VarTypeListContext>(0);
+TaskDefLangParser::VarTypeContext* TaskDefLangParser::VarTypeListContext::varType(size_t i) {
+  return getRuleContext<TaskDefLangParser::VarTypeContext>(i);
 }
 
 
@@ -979,77 +1163,78 @@ std::any TaskDefLangParser::VarTypeListContext::accept(tree::ParseTreeVisitor *v
     return visitor->visitChildren(this);
 }
 
-
 TaskDefLangParser::VarTypeListContext* TaskDefLangParser::varTypeList() {
-   return varTypeList(0);
-}
+  VarTypeListContext *_localctx = _tracker.createInstance<VarTypeListContext>(_ctx, getState());
+  enterRule(_localctx, 24, TaskDefLangParser::RuleVarTypeList);
 
-TaskDefLangParser::VarTypeListContext* TaskDefLangParser::varTypeList(int precedence) {
-  ParserRuleContext *parentContext = _ctx;
-  size_t parentState = getState();
-  TaskDefLangParser::VarTypeListContext *_localctx = _tracker.createInstance<VarTypeListContext>(_ctx, parentState);
-  TaskDefLangParser::VarTypeListContext *previousContext = _localctx;
-  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
-  size_t startState = 22;
-  enterRecursionRule(_localctx, 22, TaskDefLangParser::RuleVarTypeList, precedence);
+      _localctx->retval.clear();
 
-    
+  size_t _la = 0;
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
 #else
   auto onExit = finally([=] {
 #endif
-    unrollRecursionContexts(parentContext);
+    exitRule();
   });
   try {
-    size_t alt;
-    enterOuterAlt(_localctx, 1);
-    setState(107);
+    setState(141);
     _errHandler->sync(this);
-    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
-    case 1: {
-      setState(105);
-      varType();
-      break;
-    }
+    switch (_input->LA(1)) {
+      case TaskDefLangParser::T__11:
+      case TaskDefLangParser::T__14:
+      case TaskDefLangParser::T__16:
+      case TaskDefLangParser::T__17:
+      case TaskDefLangParser::T__18:
+      case TaskDefLangParser::T__19:
+      case TaskDefLangParser::T__20:
+      case TaskDefLangParser::T__21:
+      case TaskDefLangParser::T__22:
+      case TaskDefLangParser::ID: {
+        enterOuterAlt(_localctx, 1);
+        setState(129);
+        antlrcpp::downCast<VarTypeListContext *>(_localctx)->first_var_type = varType();
 
-    case 2: {
-      break;
-    }
+            _localctx->retval.emplace_back(std::move(antlrcpp::downCast<VarTypeListContext *>(_localctx)->first_var_type->retval));
 
-    default:
-      break;
-    }
-    _ctx->stop = _input->LT(-1);
-    setState(114);
-    _errHandler->sync(this);
-    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx);
-    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
-      if (alt == 1) {
-        if (!_parseListeners.empty())
-          triggerExitRuleEvent();
-        previousContext = _localctx;
-        _localctx = _tracker.createInstance<VarTypeListContext>(parentContext, parentState);
-        pushNewRecursionContext(_localctx, startState, RuleVarTypeList);
-        setState(109);
-
-        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
-        setState(110);
-        match(TaskDefLangParser::T__9);
-        setState(111);
-        varType(); 
+        setState(137);
+        _errHandler->sync(this);
+        _la = _input->LA(1);
+        while (_la == TaskDefLangParser::T__9) {
+          setState(131);
+          match(TaskDefLangParser::T__9);
+          setState(132);
+          antlrcpp::downCast<VarTypeListContext *>(_localctx)->subsequent_var_type = varType();
+
+              _localctx->retval.emplace_back(std::move(antlrcpp::downCast<VarTypeListContext *>(_localctx)->subsequent_var_type->retval));
+
+          setState(139);
+          _errHandler->sync(this);
+          _la = _input->LA(1);
+        }
+        break;
       }
-      setState(116);
-      _errHandler->sync(this);
-      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx);
+
+      case TaskDefLangParser::T__13: {
+        enterOuterAlt(_localctx, 2);
+
+            _localctx->retval.clear();
+
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
     }
+   
   }
   catch (RecognitionException &e) {
     _errHandler->reportError(this, e);
     _localctx->exception = std::current_exception();
     _errHandler->recover(this, _localctx->exception);
   }
+
   return _localctx;
 }
 
@@ -1078,7 +1263,7 @@ std::any TaskDefLangParser::ListTypeContext::accept(tree::ParseTreeVisitor *visi
 
 TaskDefLangParser::ListTypeContext* TaskDefLangParser::listType() {
   ListTypeContext *_localctx = _tracker.createInstance<ListTypeContext>(_ctx, getState());
-  enterRule(_localctx, 24, TaskDefLangParser::RuleListType);
+  enterRule(_localctx, 26, TaskDefLangParser::RuleListType);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -1089,14 +1274,24 @@ TaskDefLangParser::ListTypeContext* TaskDefLangParser::listType() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(117);
+    setState(143);
     match(TaskDefLangParser::T__11);
-    setState(118);
+    setState(144);
     match(TaskDefLangParser::T__12);
-    setState(119);
-    varType();
-    setState(120);
+    setState(145);
+    antlrcpp::downCast<ListTypeContext *>(_localctx)->varTypeContext = varType();
+    setState(146);
     match(TaskDefLangParser::T__13);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<ListTypeContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::List::create(std::move(antlrcpp::downCast<ListTypeContext *>(_localctx)->varTypeContext->retval), loc),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -1137,7 +1332,7 @@ std::any TaskDefLangParser::MapTypeContext::accept(tree::ParseTreeVisitor *visit
 
 TaskDefLangParser::MapTypeContext* TaskDefLangParser::mapType() {
   MapTypeContext *_localctx = _tracker.createInstance<MapTypeContext>(_ctx, getState());
-  enterRule(_localctx, 26, TaskDefLangParser::RuleMapType);
+  enterRule(_localctx, 28, TaskDefLangParser::RuleMapType);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -1148,18 +1343,32 @@ TaskDefLangParser::MapTypeContext* TaskDefLangParser::mapType() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(122);
+    setState(149);
     match(TaskDefLangParser::T__14);
-    setState(123);
+    setState(150);
     match(TaskDefLangParser::T__12);
-    setState(124);
-    varType();
-    setState(125);
+    setState(151);
+    antlrcpp::downCast<MapTypeContext *>(_localctx)->key_type = varType();
+    setState(152);
     match(TaskDefLangParser::T__9);
-    setState(126);
-    varType();
-    setState(127);
+    setState(153);
+    antlrcpp::downCast<MapTypeContext *>(_localctx)->val_type = varType();
+    setState(154);
     match(TaskDefLangParser::T__13);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<MapTypeContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::Map::create(
+                    std::move(antlrcpp::downCast<MapTypeContext *>(_localctx)->key_type->retval),
+                    std::move(antlrcpp::downCast<MapTypeContext *>(_localctx)->val_type->retval),
+                    loc
+            ),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -1196,7 +1405,7 @@ std::any TaskDefLangParser::TupleTypeContext::accept(tree::ParseTreeVisitor *vis
 
 TaskDefLangParser::TupleTypeContext* TaskDefLangParser::tupleType() {
   TupleTypeContext *_localctx = _tracker.createInstance<TupleTypeContext>(_ctx, getState());
-  enterRule(_localctx, 28, TaskDefLangParser::RuleTupleType);
+  enterRule(_localctx, 30, TaskDefLangParser::RuleTupleType);
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -1207,14 +1416,24 @@ TaskDefLangParser::TupleTypeContext* TaskDefLangParser::tupleType() {
   });
   try {
     enterOuterAlt(_localctx, 1);
-    setState(129);
+    setState(157);
     match(TaskDefLangParser::T__15);
-    setState(130);
+    setState(158);
     match(TaskDefLangParser::T__12);
-    setState(131);
-    varTypeList(0);
-    setState(132);
+    setState(159);
+    antlrcpp::downCast<TupleTypeContext *>(_localctx)->varTypeListContext = varTypeList();
+    setState(160);
     match(TaskDefLangParser::T__13);
+
+        SourceLocation const loc{
+            _localctx->start->getLine(),
+            _localctx->start->getCharPositionInLine()
+        };
+        antlrcpp::downCast<TupleTypeContext *>(_localctx)->retval =  spider::tdl::parser::Exception::throw_tryx(
+            spider::tdl::parser::ast::Tuple::create(std::move(antlrcpp::downCast<TupleTypeContext *>(_localctx)->varTypeListContext->retval), loc),
+            loc
+        );
+
    
   }
   catch (RecognitionException &e) {
@@ -1255,7 +1474,13 @@ std::any TaskDefLangParser::BuiltinTypeContext::accept(tree::ParseTreeVisitor *v
 
 TaskDefLangParser::BuiltinTypeContext* TaskDefLangParser::builtinType() {
   BuiltinTypeContext *_localctx = _tracker.createInstance<BuiltinTypeContext>(_ctx, getState());
-  enterRule(_localctx, 30, TaskDefLangParser::RuleBuiltinType);
+  enterRule(_localctx, 32, TaskDefLangParser::RuleBuiltinType);
+
+      SourceLocation const loc{
+          _localctx->start->getLine(),
+          _localctx->start->getCharPositionInLine()
+      };
+
 
 #if __cplusplus > 201703L
   auto onExit = finally([=, this] {
@@ -1265,69 +1490,102 @@ TaskDefLangParser::BuiltinTypeContext* TaskDefLangParser::builtinType() {
     exitRule();
   });
   try {
-    setState(143);
+    setState(183);
     _errHandler->sync(this);
     switch (_input->LA(1)) {
       case TaskDefLangParser::T__16: {
         enterOuterAlt(_localctx, 1);
-        setState(134);
+        setState(163);
         match(TaskDefLangParser::T__16);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int8, loc);
+
         break;
       }
 
       case TaskDefLangParser::T__17: {
         enterOuterAlt(_localctx, 2);
-        setState(135);
+        setState(165);
         match(TaskDefLangParser::T__17);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int16, loc);
+
         break;
       }
 
       case TaskDefLangParser::T__18: {
         enterOuterAlt(_localctx, 3);
-        setState(136);
+        setState(167);
         match(TaskDefLangParser::T__18);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int32, loc);
+
         break;
       }
 
       case TaskDefLangParser::T__19: {
         enterOuterAlt(_localctx, 4);
-        setState(137);
+        setState(169);
         match(TaskDefLangParser::T__19);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Int::create(spider::tdl::parser::ast::IntSpec::Int64, loc);
+
         break;
       }
 
       case TaskDefLangParser::T__20: {
         enterOuterAlt(_localctx, 5);
-        setState(138);
+        setState(171);
         match(TaskDefLangParser::T__20);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Float::create(
+                    spider::tdl::parser::ast::FloatSpec::Float,
+                    loc
+            );
+
         break;
       }
 
       case TaskDefLangParser::T__21: {
         enterOuterAlt(_localctx, 6);
-        setState(139);
+        setState(173);
         match(TaskDefLangParser::T__21);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Float::create(
+                    spider::tdl::parser::ast::FloatSpec::Double,
+                    loc
+            );
+
         break;
       }
 
       case TaskDefLangParser::T__22: {
         enterOuterAlt(_localctx, 7);
-        setState(140);
+        setState(175);
         match(TaskDefLangParser::T__22);
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  spider::tdl::parser::ast::Bool::create(loc);
+
         break;
       }
 
       case TaskDefLangParser::T__11: {
         enterOuterAlt(_localctx, 8);
-        setState(141);
-        listType();
+        setState(177);
+        antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->listTypeContext = listType();
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->listTypeContext->retval);
+
         break;
       }
 
       case TaskDefLangParser::T__14: {
         enterOuterAlt(_localctx, 9);
-        setState(142);
-        mapType();
+        setState(180);
+        antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->mapTypeContext = mapType();
+
+            antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->retval =  std::move(antlrcpp::downCast<BuiltinTypeContext *>(_localctx)->mapTypeContext->retval);
+
         break;
       }
 
@@ -1345,37 +1603,6 @@ TaskDefLangParser::BuiltinTypeContext* TaskDefLangParser::builtinType() {
   return _localctx;
 }
 
-bool TaskDefLangParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
-  switch (ruleIndex) {
-    case 6: return namedVarListSempred(antlrcpp::downCast<NamedVarListContext *>(context), predicateIndex);
-    case 11: return varTypeListSempred(antlrcpp::downCast<VarTypeListContext *>(context), predicateIndex);
-
-  default:
-    break;
-  }
-  return true;
-}
-
-bool TaskDefLangParser::namedVarListSempred(NamedVarListContext *_localctx, size_t predicateIndex) {
-  switch (predicateIndex) {
-    case 0: return precpred(_ctx, 1);
-
-  default:
-    break;
-  }
-  return true;
-}
-
-bool TaskDefLangParser::varTypeListSempred(VarTypeListContext *_localctx, size_t predicateIndex) {
-  switch (predicateIndex) {
-    case 1: return precpred(_ctx, 2);
-
-  default:
-    break;
-  }
-  return true;
-}
-
 void TaskDefLangParser::initialize() {
 #if ANTLR4_USE_THREAD_LOCAL_CACHE
   taskdeflangParserInitialize();
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h
index bed4767d2..45c4b1554 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 #pragma once
@@ -20,10 +31,10 @@ class  TaskDefLangParser : public antlr4::Parser {
   };
 
   enum {
-    RuleTranslationUnit = 0, RuleNamespace = 1, RuleFuncDef = 2, RuleRet = 3, 
-    RuleParams = 4, RuleNamedVar = 5, RuleNamedVarList = 6, RuleStructDef = 7, 
-    RuleId = 8, RuleVarType = 9, RuleRetType = 10, RuleVarTypeList = 11, 
-    RuleListType = 12, RuleMapType = 13, RuleTupleType = 14, RuleBuiltinType = 15
+    RuleTranslationUnit = 0, RuleNamespace = 1, RuleFuncDefs = 2, RuleFuncDef = 3, 
+    RuleRet = 4, RuleParams = 5, RuleNamedVar = 6, RuleNamedVarList = 7, 
+    RuleStructDef = 8, RuleId = 9, RuleVarType = 10, RuleRetType = 11, RuleVarTypeList = 12, 
+    RuleListType = 13, RuleMapType = 14, RuleTupleType = 15, RuleBuiltinType = 16
   };
 
   explicit TaskDefLangParser(antlr4::TokenStream *input);
@@ -45,6 +56,7 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class TranslationUnitContext;
   class NamespaceContext;
+  class FuncDefsContext;
   class FuncDefContext;
   class RetContext;
   class ParamsContext;
@@ -62,6 +74,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  TranslationUnitContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::TranslationUnit> tu;
+    TaskDefLangParser::NamespaceContext *namespaceContext = nullptr;
+    TaskDefLangParser::StructDefContext *structDefContext = nullptr;
     TranslationUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     antlr4::tree::TerminalNode *EOF();
@@ -79,9 +94,27 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  NamespaceContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::IdContext *idContext = nullptr;
+    TaskDefLangParser::FuncDefsContext *funcDefsContext = nullptr;
     NamespaceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     IdContext *id();
+    FuncDefsContext *funcDefs();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  NamespaceContext* namespace_();
+
+  class  FuncDefsContext : public antlr4::ParserRuleContext {
+  public:
+    std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval;
+    TaskDefLangParser::FuncDefContext *funcDefContext = nullptr;
+    FuncDefsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
     std::vector<FuncDefContext *> funcDef();
     FuncDefContext* funcDef(size_t i);
 
@@ -90,10 +123,14 @@ class  TaskDefLangParser : public antlr4::Parser {
    
   };
 
-  NamespaceContext* namespace_();
+  FuncDefsContext* funcDefs();
 
   class  FuncDefContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::IdContext *idContext = nullptr;
+    TaskDefLangParser::ParamsContext *paramsContext = nullptr;
+    TaskDefLangParser::RetContext *retContext = nullptr;
     FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     IdContext *id();
@@ -109,6 +146,8 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  RetContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::RetTypeContext *retTypeContext = nullptr;
     RetContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     RetTypeContext *retType();
@@ -122,6 +161,8 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  ParamsContext : public antlr4::ParserRuleContext {
   public:
+    std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval;
+    TaskDefLangParser::NamedVarListContext *namedVarListContext = nullptr;
     ParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     NamedVarListContext *namedVarList();
@@ -135,6 +176,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  NamedVarContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::IdContext *idContext = nullptr;
+    TaskDefLangParser::VarTypeContext *varTypeContext = nullptr;
     NamedVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     IdContext *id();
@@ -149,10 +193,13 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  NamedVarListContext : public antlr4::ParserRuleContext {
   public:
+    std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval;
+    TaskDefLangParser::NamedVarContext *first_named_var = nullptr;
+    TaskDefLangParser::NamedVarContext *subsequent_named_var = nullptr;
     NamedVarListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
-    NamedVarContext *namedVar();
-    NamedVarListContext *namedVarList();
+    std::vector<NamedVarContext *> namedVar();
+    NamedVarContext* namedVar(size_t i);
 
 
     virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
@@ -160,9 +207,12 @@ class  TaskDefLangParser : public antlr4::Parser {
   };
 
   NamedVarListContext* namedVarList();
-  NamedVarListContext* namedVarList(int precedence);
+
   class  StructDefContext : public antlr4::ParserRuleContext {
   public:
+    std::shared_ptr<spider::tdl::parser::ast::StructSpec> retval;
+    TaskDefLangParser::IdContext *idContext = nullptr;
+    TaskDefLangParser::NamedVarListContext *namedVarListContext = nullptr;
     StructDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     IdContext *id();
@@ -177,6 +227,8 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  IdContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    antlr4::Token *idToken = nullptr;
     IdContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     antlr4::tree::TerminalNode *ID();
@@ -190,6 +242,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  VarTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::BuiltinTypeContext *builtinTypeContext = nullptr;
+    TaskDefLangParser::IdContext *idContext = nullptr;
     VarTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     BuiltinTypeContext *builtinType();
@@ -204,6 +259,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  RetTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::VarTypeContext *varTypeContext = nullptr;
+    TaskDefLangParser::TupleTypeContext *tupleTypeContext = nullptr;
     RetTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     VarTypeContext *varType();
@@ -218,10 +276,13 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  VarTypeListContext : public antlr4::ParserRuleContext {
   public:
+    std::vector<std::unique_ptr<spider::tdl::parser::ast::Node>> retval;
+    TaskDefLangParser::VarTypeContext *first_var_type = nullptr;
+    TaskDefLangParser::VarTypeContext *subsequent_var_type = nullptr;
     VarTypeListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
-    VarTypeContext *varType();
-    VarTypeListContext *varTypeList();
+    std::vector<VarTypeContext *> varType();
+    VarTypeContext* varType(size_t i);
 
 
     virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
@@ -229,9 +290,11 @@ class  TaskDefLangParser : public antlr4::Parser {
   };
 
   VarTypeListContext* varTypeList();
-  VarTypeListContext* varTypeList(int precedence);
+
   class  ListTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::VarTypeContext *varTypeContext = nullptr;
     ListTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     VarTypeContext *varType();
@@ -245,6 +308,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  MapTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::VarTypeContext *key_type = nullptr;
+    TaskDefLangParser::VarTypeContext *val_type = nullptr;
     MapTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     std::vector<VarTypeContext *> varType();
@@ -259,6 +325,8 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  TupleTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::VarTypeListContext *varTypeListContext = nullptr;
     TupleTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     VarTypeListContext *varTypeList();
@@ -272,6 +340,9 @@ class  TaskDefLangParser : public antlr4::Parser {
 
   class  BuiltinTypeContext : public antlr4::ParserRuleContext {
   public:
+    std::unique_ptr<spider::tdl::parser::ast::Node> retval;
+    TaskDefLangParser::ListTypeContext *listTypeContext = nullptr;
+    TaskDefLangParser::MapTypeContext *mapTypeContext = nullptr;
     BuiltinTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     virtual size_t getRuleIndex() const override;
     ListTypeContext *listType();
@@ -285,11 +356,6 @@ class  TaskDefLangParser : public antlr4::Parser {
   BuiltinTypeContext* builtinType();
 
 
-  bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
-
-  bool namedVarListSempred(NamedVarListContext *_localctx, size_t predicateIndex);
-  bool varTypeListSempred(VarTypeListContext *_localctx, size_t predicateIndex);
-
   // By default the static state used to implement the parser is lazily initialized during the first
   // call to the constructor. You can call this function if you wish to initialize the static state
   // ahead of time.
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.cpp
index 335f85166..9857518fa 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.cpp
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.cpp
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 
diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h
index 64563363b..090f77e43 100644
--- a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h
+++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h
@@ -1,4 +1,15 @@
 
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <spider/tdl/parser/ast/FloatSpec.hpp>
+#include <spider/tdl/parser/ast/IntSpec.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
+#include <spider/tdl/parser/Exception.hpp>
+#include <spider/tdl/parser/SourceLocation.hpp>
+
+
 // Generated from tdl/parser/TaskDefLang.g4 by ANTLR 4.13.2
 
 #pragma once
@@ -24,6 +35,8 @@ class  TaskDefLangVisitor : public antlr4::tree::AbstractParseTreeVisitor {
 
     virtual std::any visitNamespace(TaskDefLangParser::NamespaceContext *context) = 0;
 
+    virtual std::any visitFuncDefs(TaskDefLangParser::FuncDefsContext *context) = 0;
+
     virtual std::any visitFuncDef(TaskDefLangParser::FuncDefContext *context) = 0;
 
     virtual std::any visitRet(TaskDefLangParser::RetContext *context) = 0;
diff --git a/src/spider/tdl/parser/parse.cpp b/src/spider/tdl/parser/parse.cpp
index be197bda2..3eb9ad1c7 100644
--- a/src/spider/tdl/parser/parse.cpp
+++ b/src/spider/tdl/parser/parse.cpp
@@ -1,7 +1,8 @@
 #include "parse.hpp"
 
 #include <istream>
-#include <tuple>
+#include <memory>
+#include <utility>
 
 #include <antlr4-runtime.h>
 #include <boost/outcome/std_result.hpp>
@@ -9,11 +10,13 @@
 #include <spider/tdl/Error.hpp>
 #include <spider/tdl/parser/antlr_generated/TaskDefLangLexer.h>
 #include <spider/tdl/parser/antlr_generated/TaskDefLangParser.h>
+#include <spider/tdl/parser/ast/nodes.hpp>
 #include <spider/tdl/parser/ErrorListener.hpp>
+#include <spider/tdl/parser/Exception.hpp>
 
 namespace spider::tdl::parser {
 auto parse_translation_unit_from_istream(std::istream& input)
-        -> boost::outcome_v2::std_checked<void, Error> {
+        -> boost::outcome_v2::std_checked<std::unique_ptr<ast::TranslationUnit>, Error> {
     // Setup lexer
     antlr4::ANTLRInputStream input_stream{input};
     antlr_generated::TaskDefLangLexer lexer{&input_stream};
@@ -29,16 +32,31 @@ auto parse_translation_unit_from_istream(std::istream& input)
     parser.addErrorListener(&parser_error_listener);
 
     // Parse the translation unit
-    std::ignore = parser.translationUnit();
+    try {
+        auto* context{parser.translationUnit()};
 
-    if (lexer_error_listener.has_error()) {
-        return lexer_error_listener.error();
-    }
+        if (lexer_error_listener.has_error()) {
+            return lexer_error_listener.error();
+        }
 
-    if (parser_error_listener.has_error()) {
-        return parser_error_listener.error();
-    }
+        if (parser_error_listener.has_error()) {
+            return parser_error_listener.error();
+        }
+
+        return std::move(context->tu);
+    } catch (Exception const& e) {
+        // When an exception is caught, we still prioritize the parser and lexer errors since they
+        // are the root cause of the exceptions.
 
-    return boost::outcome_v2::success();
+        if (lexer_error_listener.has_error()) {
+            return lexer_error_listener.error();
+        }
+
+        if (parser_error_listener.has_error()) {
+            return parser_error_listener.error();
+        }
+
+        return e.to_error();
+    }
 }
 }  // namespace spider::tdl::parser
diff --git a/src/spider/tdl/parser/parse.hpp b/src/spider/tdl/parser/parse.hpp
index 01abfc980..3e9bc1a72 100644
--- a/src/spider/tdl/parser/parse.hpp
+++ b/src/spider/tdl/parser/parse.hpp
@@ -2,22 +2,23 @@
 #define SPIDER_TDL_PARSER_PARSE_HPP
 
 #include <istream>
+#include <memory>
 
 #include <boost/outcome/std_result.hpp>
 
 #include <spider/tdl/Error.hpp>
+#include <spider/tdl/parser/ast/nodes.hpp>
 
 namespace spider::tdl::parser {
 /**
  * Parses a TDL file as a translation unit from an input stream.
  * @param input The input stream containing the TDL content. The entire content will be considered
  * as a single translation unit.
- * @return A void result on success, or an error specified by an `Error` instance on failure.
- * NOTE: We will update this function to return an actual AST root on success once we add Antlr
- * actions.
+ * @return A result containing a unique ptr to the parsed translation unit on success, or an error
+ * specified by an `Error` instance on failure.
  */
 [[nodiscard]] auto parse_translation_unit_from_istream(std::istream& input)
-        -> boost::outcome_v2::std_checked<void, Error>;
+        -> boost::outcome_v2::std_checked<std::unique_ptr<ast::TranslationUnit>, Error>;
 }  // namespace spider::tdl::parser
 
 #endif  // SPIDER_TDL_PARSER_PARSE_HPP
diff --git a/tests/tdl/test-parser.cpp b/tests/tdl/test-parser.cpp
index 43a2f2844..45731c03d 100644
--- a/tests/tdl/test-parser.cpp
+++ b/tests/tdl/test-parser.cpp
@@ -5,6 +5,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <spider/tdl/parser/ast/nodes.hpp>
 #include <spider/tdl/parser/parse.hpp>
 #include <spider/tdl/parser/SourceLocation.hpp>
 
@@ -23,6 +24,9 @@ namespace test1 {
     // Function that returns an empty tuple
     fn return_empty_tuple() -> Tuple<>;
 
+    // Function that returns a Tuple of one element, and takes only one parameter
+    fn return_singleton_tuple(a: int64) -> Tuple<int32>;
+
     // Function that returns a tuple of containers
     fn return_tuple_of_containers() -> Tuple<List<int8>, Map<List<int8>, Map<int64, List<int8>>>>;
 }
@@ -50,9 +54,212 @@ namespace test2 {
 }
 )"};
 
-TEST_CASE("Parser test basic", "[tdl][parser]") {
+TEST_CASE("Parsing `cTestInput1`", "[tdl][parser]") {
     std::istringstream input_stream{std::string{cTestInput1}};
-    REQUIRE_FALSE(parse_translation_unit_from_istream(input_stream).has_error());
+    auto const parse_result{parse_translation_unit_from_istream(input_stream)};
+    REQUIRE_FALSE(parse_result.has_error());
+    auto const& translation_unit{parse_result.value()};
+
+    constexpr std::string_view cExpectedSerializedAst{
+            "[TranslationUnit]:\n"
+            "  StructSpecs:\n"
+            "    [StructSpec]:\n"
+            "      Name:Input\n"
+            "      Fields[0]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_0\n"
+            "          Type:\n"
+            "            [Type[Primitive[Int]]]:int8\n"
+            "      Fields[1]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_1\n"
+            "          Type:\n"
+            "            [Type[Primitive[Int]]]:int16\n"
+            "      Fields[2]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_2\n"
+            "          Type:\n"
+            "            [Type[Primitive[Int]]]:int32\n"
+            "      Fields[3]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_3\n"
+            "          Type:\n"
+            "            [Type[Primitive[Int]]]:int64\n"
+            "      Fields[4]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_4\n"
+            "          Type:\n"
+            "            [Type[Primitive[Float]]]:float\n"
+            "      Fields[5]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_5\n"
+            "          Type:\n"
+            "            [Type[Primitive[Float]]]:double\n"
+            "      Fields[6]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_6\n"
+            "          Type:\n"
+            "            [Type[Primitive[Bool]]]\n"
+            "      Fields[7]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_7\n"
+            "          Type:\n"
+            "            [Type[Container[List]]]:\n"
+            "              ElementType:\n"
+            "                [Type[Primitive[Int]]]:int8\n"
+            "      Fields[8]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:field_8\n"
+            "          Type:\n"
+            "            [Type[Container[Map]]]:\n"
+            "              KeyType:\n"
+            "                [Type[Container[List]]]:\n"
+            "                  ElementType:\n"
+            "                    [Type[Primitive[Int]]]:int8\n"
+            "              ValueType:\n"
+            "                [Type[Primitive[Float]]]:double\n"
+            "    [StructSpec]:\n"
+            "      Name:Output\n"
+            "      Fields[0]:\n"
+            "        [NamedVar]:\n"
+            "          Id:\n"
+            "            [Identifier]:processed_input\n"
+            "          Type:\n"
+            "            [Type[Container[Map]]]:\n"
+            "              KeyType:\n"
+            "                [Type[Primitive[Int]]]:int64\n"
+            "              ValueType:\n"
+            "                [Type[Struct]]:\n"
+            "                  Name:\n"
+            "                    [Identifier]:Input\n"
+            "  Namespaces:\n"
+            "    [Namespace]:\n"
+            "      Name:test1\n"
+            "      Func[0]:\n"
+            "        [Function]:\n"
+            "          Name:empty_func\n"
+            "          Return:\n"
+            "            void\n"
+            "          No Params\n"
+            "      Func[1]:\n"
+            "        [Function]:\n"
+            "          Name:add\n"
+            "          Return:\n"
+            "            [Type[Primitive[Int]]]:int64\n"
+            "          Params[0]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:a\n"
+            "              Type:\n"
+            "                [Type[Primitive[Int]]]:int32\n"
+            "          Params[1]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:b\n"
+            "              Type:\n"
+            "                [Type[Primitive[Int]]]:int32\n"
+            "      Func[2]:\n"
+            "        [Function]:\n"
+            "          Name:return_empty_tuple\n"
+            "          Return:\n"
+            "            [Type[Container[Tuple]]]:Empty\n"
+            "          No Params\n"
+            "      Func[3]:\n"
+            "        [Function]:\n"
+            "          Name:return_singleton_tuple\n"
+            "          Return:\n"
+            "            [Type[Container[Tuple]]]:\n"
+            "              Element[0]:\n"
+            "                [Type[Primitive[Int]]]:int32\n"
+            "          Params[0]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:a\n"
+            "              Type:\n"
+            "                [Type[Primitive[Int]]]:int64\n"
+            "      Func[4]:\n"
+            "        [Function]:\n"
+            "          Name:return_tuple_of_containers\n"
+            "          Return:\n"
+            "            [Type[Container[Tuple]]]:\n"
+            "              Element[0]:\n"
+            "                [Type[Container[List]]]:\n"
+            "                  ElementType:\n"
+            "                    [Type[Primitive[Int]]]:int8\n"
+            "              Element[1]:\n"
+            "                [Type[Container[Map]]]:\n"
+            "                  KeyType:\n"
+            "                    [Type[Container[List]]]:\n"
+            "                      ElementType:\n"
+            "                        [Type[Primitive[Int]]]:int8\n"
+            "                  ValueType:\n"
+            "                    [Type[Container[Map]]]:\n"
+            "                      KeyType:\n"
+            "                        [Type[Primitive[Int]]]:int64\n"
+            "                      ValueType:\n"
+            "                        [Type[Container[List]]]:\n"
+            "                          ElementType:\n"
+            "                            [Type[Primitive[Int]]]:int8\n"
+            "          No Params\n"
+            "    [Namespace]:\n"
+            "      Name:test2\n"
+            "      Func[0]:\n"
+            "        [Function]:\n"
+            "          Name:process_input\n"
+            "          Return:\n"
+            "            [Type[Struct]]:\n"
+            "              Name:\n"
+            "                [Identifier]:Output\n"
+            "          Params[0]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:input\n"
+            "              Type:\n"
+            "                [Type[Struct]]:\n"
+            "                  Name:\n"
+            "                    [Identifier]:Input\n"
+            "          Params[1]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:task_id\n"
+            "              Type:\n"
+            "                [Type[Primitive[Int]]]:int64\n"
+            "      Func[1]:\n"
+            "        [Function]:\n"
+            "          Name:process_inputs\n"
+            "          Return:\n"
+            "            [Type[Struct]]:\n"
+            "              Name:\n"
+            "                [Identifier]:Output\n"
+            "          Params[0]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:inputs\n"
+            "              Type:\n"
+            "                [Type[Container[List]]]:\n"
+            "                  ElementType:\n"
+            "                    [Type[Struct]]:\n"
+            "                      Name:\n"
+            "                        [Identifier]:Input\n"
+            "          Params[1]:\n"
+            "            [NamedVar]:\n"
+            "              Id:\n"
+            "                [Identifier]:task_id\n"
+            "              Type:\n"
+            "                [Type[Primitive[Int]]]:int64"
+    };
+    auto const serialize_result{translation_unit->serialize_to_str(0)};
+    REQUIRE_FALSE(serialize_result.has_error());
+    REQUIRE(serialize_result.value() == cExpectedSerializedAst);
 }
 
 TEST_CASE("Parser errors", "[tdl][parser]") {
@@ -86,6 +293,29 @@ TEST_CASE("Parser errors", "[tdl][parser]") {
         REQUIRE(error.get_message() == cExpectedErrorMessage);
         REQUIRE(error.get_source_location() == cExpectedErrorLocation);
     }
+
+    SECTION("Errors from parser exception") {
+        using spider::tdl::parser::ast::Namespace;
+
+        constexpr std::string_view cNamespaceContainingDuplicatedFunctionNames{
+                " namespace test { fn empty(); fn empty(); }"
+        };
+        std::istringstream input_stream{std::string{cNamespaceContainingDuplicatedFunctionNames}};
+        auto const parse_result{parse_translation_unit_from_istream(input_stream)};
+        REQUIRE(parse_result.has_error());
+        auto const& error{parse_result.error()};
+
+        constexpr std::string_view cExpectedErrorMessage{"spider::tdl::parser::Exception"};
+        constexpr SourceLocation cExpectedSourceLocation{1, 1};
+        REQUIRE(error.get_message() == cExpectedErrorMessage);
+        REQUIRE(error.get_source_location() == cExpectedSourceLocation);
+        auto const optional_error_code{error.get_error_code()};
+        REQUIRE(optional_error_code.has_value());
+        // Checked by the previous `REQUIRE`.
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        REQUIRE(optional_error_code.value()
+                == Namespace::ErrorCode{Namespace::ErrorCodeEnum::DuplicatedFunctionName});
+    }
 }
 }  // namespace