SourceLocation location;

NodeType kind = ND_INVALID;

Node() = default;

explicit Node(const NodeType ty)

: kind(ty) {}

virtual ~Node() = default;

/// Returns a tag which identifies the node's kind

[[nodiscard]] virtual NodeType getNodeType() const {

return kind;

}

/// Is the node allowed to appear in global context (E.g. Functions, Vars)?

[[nodiscard]] virtual bool isGlobal() const {

return false;

}

/// Is the node representing a literal?

[[nodiscard]] virtual bool isLiteral() const {

return false;

}

/// Fetches the `IdentInfo*` that a node is holding, if any

virtual IdentInfo* getIdentInfo() {

throw std::runtime_error("getIdentInfo called on Node instance");

}

/// Convenient method to fetch the wrapped-node from an expression

virtual Node* getExprValue() {

throw std::runtime_error("getExprValue called on Node instance");

}

/// Returns the wrapped-node if the node is a wrapper, returns the instance itself otherwise

virtual Node* getWrappedNodeOrInstance() {

return this;

}

[[nodiscard]] virtual Ident* getIdent() {

return nullptr;

}

virtual Type* getSwType() {

throw std::runtime_error("getSwType: unimplemented!");

}

template <typename From>

std::add_pointer_t<From> to() {

return dynamic_cast<std::add_pointer_t<From>>(this);

}

std::string_view name;

IdentInfo* id;

std::span<Ident*> constraints;

explicit

GenericParam() : Node(ND_GENERIC_PARAM), id(nullptr) {}

[[nodiscard]]

NodeType getNodeType() const override {

return ND_GENERIC_PARAM;

}

std::string_view name;

std::string_view extern_attributes;

std::span<GenericParam*> generic_params;

bool is_extern = false;

bool is_exported = false;

bool is_monomorphization = false;

explicit GlobalNode(const NodeType ty)

: Node(ty) {}

[[nodiscard]]

bool isGlobal() const override {

return true;

}

bool is_comptime = false;

Node* expr = nullptr;

Type* expr_type = nullptr;

explicit Expression(): Node(ND_EXPR) {}

static Expression makeExpression(Node* node) {

Expression expr;

expr.expr = node;

return expr;

}

// set the type of sub-expression instances to `to`

void setType(Type* to);

IdentInfo* getIdentInfo() override {

return expr->getIdentInfo();

}

[[nodiscard]] Node* getExprValue() override {

return expr;

}

[[nodiscard]] NodeType getNodeType() const override {

return ND_EXPR;

}

Node* getWrappedNodeOrInstance() override {

return expr->getWrappedNodeOrInstance();

}

bool operator==(const Expression& other) const {

return this->expr == other.expr && this->expr_type == other.expr_type;

}

Type* getSwType() override {

return expr_type;

}

int8_t arity = 2; // the no. of operands the operator requires

Token::TokenValue tokenid{};

std::span<Node*> operands; // the operands

// for the special case of the `&` operator, where a `mut` can appear right after it

bool is_mutable = false;

enum OpTag_t {

BINARY_ADD,

BINARY_SUB,

MUL,

DIV,

MOD,

EXP,

EXP_ASSIGN,

UNARY_ADD,

UNARY_SUB,

LOGICAL_AND,

LOGICAL_OR,

LOGICAL_NOT,

LOGICAL_NOTEQUAL,

LOGICAL_EQUAL,

GREATER_THAN,

GREATER_THAN_OR_EQUAL,

LESS_THAN,

LESS_THAN_OR_EQUAL,

DOT,

INDEXING_OP,

DEREFERENCE,

ADDRESS_TAKING,

CAST_OP,

ASSIGNMENT,

ADD_ASSIGN,

MUL_ASSIGN,

SUB_ASSIGN,

DIV_ASSIGN,

MOD_ASSIGN,

BITWISE_OR,

BITWISE_AND,

BITWISE_XOR,

BITWISE_NOT,

BITWISE_LSHIFT,

BITWISE_RSHIFT,

BITWISE_OR_ASSIGN,

BITWISE_AND_ASSIGN,

BITWISE_XOR_ASSIGN,

BITWISE_LSHIFT_ASSIGN,

BITWISE_RSHIFT_ASSIGN,

ALIGNOF,

SIZEOF,

TYPEOF,

INVALID

};

OpTag_t op_type = INVALID;

Type* common_type = nullptr; // the common type of its operands

explicit Op()

: Node(ND_OP) {}

explicit Op(Token::TokenValue tokenid, int8_t arity);

static OpTag_t getTagFor(Token::TokenValue tokenid, int arity);

// set the type of sub-expression instances to `to`

void setType(Type* to) const;

[[nodiscard]]

NodeType getNodeType() const override { return ND_OP; }

Type* getSwType() override { return common_type; }

[[nodiscard]] Node* getLHS() const {

assert(!operands.empty());

return operands.at(0);

}

[[nodiscard]] Node* getRHS() const {

assert(operands.size() >= 2);

return operands.at(1);

}

static int getLBPFor(OpTag_t op);

static int getRBPFor(OpTag_t op);

static int getPBPFor(OpTag_t op);

Expression* value = nullptr;

FunctionType* parent_fn_type = nullptr; // holds the function-signature of the parent

explicit

ReturnStatement()

: Node(ND_RET) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_RET;

}

std::string_view value;

explicit IntLit(const std::string_view val)

: Node(ND_INT), value(val) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_INT;

}

[[nodiscard]] bool isLiteral() const override {

return true;

}

std::string_view value;

explicit FloatLit(const std::string_view val)

: Node(ND_FLOAT), value(val) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_FLOAT;

}

[[nodiscard]] bool isLiteral() const override {

return true;

}

bool value;

explicit BoolLit(const bool is_true)

: Node(ND_BOOL), value(is_true) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_BOOL;

}

[[nodiscard]] bool isLiteral() const override {

return true;

}

char value;

explicit CharLit(const char val)

: Node(ND_CHAR)

, value(val) {}

std::string_view value;

explicit StrLit(const std::string_view val)

: Node(ND_STR), value(val) {}

[[nodiscard]]

NodeType getNodeType() const override {

return ND_STR;

}

[[nodiscard]]

bool isLiteral() const override {

return true;

}

std::span<GenericArg*> generic_args;

GenericArgList()

: Node(ND_GEN_ARG_LIST) {}

[[nodiscard]] auto front() const { return generic_args.front(); }

[[nodiscard]] auto begin() const { return generic_args.begin(); }

[[nodiscard]] auto end() const { return generic_args.end(); }

[[nodiscard]] auto size() const { return generic_args.size(); }

[[nodiscard]] bool empty() const { return generic_args.empty(); }

[[nodiscard]] auto at(const std::size_t i) const { return generic_args.at(i); }

struct Qualifier {

std::string_view name;

GenericArgList generic_args;

IdentInfo* value = nullptr; // for partial resolution

};

bool has_generic_args = false;

IdentInfo* value = nullptr;

std::span<Qualifier> full_qualification;

// to keep pre-computed generic instantiation steps to avoid repetitive looping

std::unordered_map<Type*, Type*> type_instantiation_map;

explicit Ident()

: Node(ND_IDENT) {}

explicit Ident(IdentInfo* val)

: Ident() { value = val; }

/// Convenience constructor for the creation of temporary objects, not to be used for

/// the construction of AST nodes

explicit Ident(const std::span<Qualifier> full_qualification)

: full_qualification(full_qualification) {}

IdentInfo* getIdentInfo() override {

return value;

}

[[nodiscard]] NodeType getNodeType() const override {

return ND_IDENT;

}

[[nodiscard]] Ident* getIdent() override {

return this;

}

[[nodiscard]]

std::string toString() const {

std::string ret;

for (const auto& qual : full_qualification) {

ret += std::string(qual.name) + "::";

} ret.pop_back();

ret.pop_back();

return ret;

}

using ArraySize_t = std::variant<std::monostate, Node*, std::size_t>;

enum Modifiers { Reference, Pointer };

Type* type = nullptr;

bool is_mutable = false;

bool is_slice = false;

bool is_pointer = false;

bool is_reference = false;

Ident* type_id = nullptr;

Expression* array_size{}; // set if the type is an array

TypeWrapper* of_type{}; // set in the case of wrapper types (refs, ptr, arrays, slices)

explicit TypeWrapper()

: Node(ND_TYPE) {}

explicit TypeWrapper(Type* ty)

: Node(ND_TYPE), type(ty) {}

[[nodiscard]]

Type* getSwType() override {

return type;

}

[[nodiscard]]

NodeType getNodeType() const override {

return ND_TYPE;

}

std::string_view alias;

IdentInfo* ident = nullptr;

TypeWrapper* alias_for = nullptr;

TypeAlias()

: Node(ND_TYPE_ALIAS) {}

[[nodiscard]] NodeType getNodeType() const override { return ND_TYPE_ALIAS; }

explicit GenericArg(): Node(ND_GEN_ARG) {}

explicit GenericArg(Expression* expr)

: GenericArg() { value = expr; }

explicit GenericArg(TypeWrapper* ty)

: GenericArg() { value = ty; }

[[nodiscard]]

bool isType() const {

return std::holds_alternative<TypeWrapper*>(value);

}

[[nodiscard]]

bool isEmpty() const {

return std::holds_alternative<std::monostate>(value);

}

[[nodiscard]]

bool isExpression() const {

return std::holds_alternative<Expression*>(value);

}

Expression* getExpr() const {

return std::get<Expression*>(value);

}

TypeWrapper* getType() const {

return std::get<TypeWrapper*>(value);

}

std::variant<std::monostate, Expression*, TypeWrapper*> value;

IdentInfo* var_ident = nullptr;

TypeWrapper* var_type = nullptr;

Expression* value = nullptr;

bool initialized = false;

bool is_const = false;

bool is_volatile = false;

bool is_comptime = false;

explicit Var(): GlobalNode(ND_VAR) {}

[[nodiscard]] NodeType getNodeType() const override { return ND_VAR; }

IdentInfo* getIdentInfo() override {

return var_ident;

}

[[nodiscard]] Node* getExprValue() override { return value->expr; }

Scope* parent_scope = nullptr;

Namespace* symbols = nullptr;

std::span<Node*> children;

explicit Scope()

: Node(ND_SCOPE) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_SCOPE;

}

IdentInfo* ident = nullptr;

TypeWrapper* type = nullptr;

std::string_view name{};

Expression* value = nullptr;

bool is_const = false;

bool is_variadic = false;

bool is_instance_param = false;

bool is_initialized = false;

Parameter()

: Node(ND_PARAM) {}

bool is_static_method = true;

IdentInfo* ident = nullptr;

Scope* children = nullptr;

std::span<Parameter*> params;

TypeWrapper* return_type = nullptr;

explicit Function()

: GlobalNode(ND_FUNC) {}

IdentInfo* getIdentInfo() override {

return ident;

}

[[nodiscard]] NodeType getNodeType() const override {

return ND_FUNC;

}

Ident* ident = nullptr;

Type* signature = nullptr; // supposed to hold the signature of the callee

std::span<Expression*> args;

GenericArgList generic_args;

explicit FuncCall()

: Node(ND_CALL) {}

IdentInfo* getIdentInfo() override {

return ident->getIdentInfo();

}

Type* getSwType() override {

return signature;

}

[[nodiscard]] Ident* getIdent() override {

return ident;

}

[[nodiscard]] NodeType getNodeType() const override { return ND_CALL; }

enum Kind { INVALID, SIZEOF, TYPEOF, MEMCPY, MEMSET, ADV_PTR };

Kind intrinsic_type = INVALID;

std::span<Expression*> args;

Ident* ident = nullptr;

explicit Intrinsic()

: Node(ND_INTRINSIC) {}

void operator=(const FuncCall* call) {

args = call->args;

ident = call->ident;

static const std::unordered_map<std::string_view, Kind> tag_map = {

{"sizeof", SIZEOF},

{"typeof", TYPEOF},

{"memset", MEMSET},

{"memcpy", MEMCPY},

{"advance_pointer", ADV_PTR}

}; intrinsic_type = tag_map.at(ident->full_qualification.at(0).name);

}

[[nodiscard]] NodeType getNodeType() const override { return ND_INTRINSIC; }

struct ImportedSymbol_t {

std::string_view actual_name;

std::string_view assigned_alias;

};

bool is_wildcard = false;

sw::FileHandle* mod_handle = nullptr;

std::string_view alias;

std::span<ImportedSymbol_t> imported_symbols{};

explicit ImportNode()

: GlobalNode(ND_IMPORT) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_IMPORT;

}

Type* type = nullptr;

std::span<Expression*> elements;

explicit ArrayLit()

: Node(ND_ARRAY) {}

Type* getSwType() override {

return type;

}

[[nodiscard]]

bool isLiteral() const override {

return true;

}

Expression* condition = nullptr;

Scope* children = nullptr;

explicit WhileLoop()

: Node(ND_WHILE) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_WHILE;

}

explicit BreakStmt(): Node(ND_BREAK) {}

[[nodiscard]] NodeType getNodeType() const override { return ND_BREAK;}

explicit ContinueStmt(): Node(ND_CONTINUE) {}

[[nodiscard]] NodeType getNodeType() const override { return ND_CONTINUE; }

IdentInfo* ident;

std::optional<TypeWrapper*> enum_type;

std::unordered_map<std::string_view, int> entries;

explicit Enum()

: GlobalNode(ND_ENUM)

, ident(nullptr) {}

int counter = 0;

void addEntry(const std::string_view id) {

entries.emplace(id, counter++);

}

template <bool keep_dynamic = false>

struct MethodSignature {

std::string_view name;

TypeWrapper* return_type{};

// true if the method's first parameter is an instance parameter (`&self`).

// in that case the first element of `params` is a placeholder (nullptr)

// whose type is resolved to a reference of the implementing type during

// conformance checking

bool is_instance_method = false;

std::conditional_t<keep_dynamic,

std::vector<TypeWrapper*>,

std::span<TypeWrapper*>> params{};

bool operator==(const MethodSignature& other) const {

if (name != other.name || is_instance_method != other.is_instance_method) return false;

if ((return_type && other.return_type) ? return_type->type != other.return_type->type

: return_type != other.return_type) return false;

return std::equal(params.begin(), params.end(),

other.params.begin(), other.params.end(),

[](const TypeWrapper* a, const TypeWrapper* b) {

if (!a || !b) return a == b;

return a->type == b->type;

});

}

operator MethodSignature<true>() const {

MethodSignature<true> result;

result.name = name;

result.return_type = return_type;

for (auto ty : params) {

result.params.push_back(ty);

} return result;

}

[[nodiscard]]

std::string toString() const {

std::string res = std::format("fn {}(", name);

for (const TypeWrapper* ty : params) {

res += "_: " + (ty ? (ty->type ? ty->type->toString() : "???") : "self");

res += ',';

}

res += "): " + (return_type->type ? return_type->type->toString() : "???");

return res;

}

};

IdentInfo* ident = nullptr;

std::span<Ident*> dependencies;

std::span<MethodSignature<>> methods;

std::span<TypeAlias*> type_aliases;

IdentInfo* getIdentInfo() override {

return ident;

}

explicit Protocol()

: GlobalNode(ND_PROTOCOL) {}

[[nodiscard]]

NodeType getNodeType() const override { return ND_PROTOCOL; }

Ident* protocol = nullptr;

TypeWrapper* impl_for = nullptr;

Scope* children = nullptr;

std::span<TypeAlias*> type_aliases;

ProtocolImpl(): GlobalNode(ND_PROTOCOL_IMPL) {}

[[nodiscard]]

TypeWrapper* getAliasTypeFor(const std::string_view name) const {

for (const TypeAlias* alias : type_aliases) {

if (alias->alias == name)

return alias->alias_for;

} return nullptr;

}

ForLoop(): Node(ND_FOR_LOOP) {}

IdentInfo* loop_var_id = nullptr;

TypeWrapper* loop_var_type = nullptr;

std::string_view loop_var_name{};

Expression* iterable = nullptr;

Scope* children = nullptr;

bool is_comptime = false;

IdentInfo* ident = nullptr;

Scope* members = nullptr;

std::span<Ident*> protocols;

explicit Struct() : GlobalNode(ND_STRUCT) {}

[[nodiscard]] NodeType getNodeType() const override {

return ND_STRUCT;

}

IdentInfo* getIdentInfo() override {

return ident;

}

bool is_comptime = false;

Expression* bool_expr = nullptr;

using elif_t = std::tuple<Expression*, Scope*>;

Scope* if_children{};

std::span<elif_t> elif_children{};

Scope* else_children{};

explicit Condition()

: Node(ND_COND) {}

[[nodiscard]] Node* getExprValue() override {

return bool_expr->expr;

}

[[nodiscard]] NodeType getNodeType() const override {

return ND_COND;

}