add type resolving for structs and fn params
- add a printer for the symbol table - add error contexts to type pass
This commit is contained in:
parent
8afab8e4ed
commit
e2cca03d52
|
@ -1,5 +1,18 @@
|
||||||
// import std;
|
// import std;
|
||||||
|
|
||||||
|
struct B {
|
||||||
|
field i32
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Awoo {
|
||||||
|
b B
|
||||||
|
other_field i32
|
||||||
|
}
|
||||||
|
|
||||||
|
fn test_function() Awoo {
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
fn multwo(num: i32, double_flag: bool) i32 {
|
fn multwo(num: i32, double_flag: bool) i32 {
|
||||||
// TODO resolve expr variables
|
// TODO resolve expr variables
|
||||||
if (true) {
|
if (true) {
|
||||||
|
|
|
@ -3,6 +3,7 @@ const tokens = @import("tokens.zig");
|
||||||
const Token = tokens.Token;
|
const Token = tokens.Token;
|
||||||
|
|
||||||
usingnamespace @import("ast.zig");
|
usingnamespace @import("ast.zig");
|
||||||
|
usingnamespace @import("comp_ctx.zig");
|
||||||
|
|
||||||
const warn = std.debug.warn;
|
const warn = std.debug.warn;
|
||||||
|
|
||||||
|
@ -335,3 +336,66 @@ pub fn printStmt(ident: usize, stmt: *const Stmt) void {
|
||||||
else => std.debug.warn("UnknownStmt-{}", @tagName(stmt.*)),
|
else => std.debug.warn("UnknownStmt-{}", @tagName(stmt.*)),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// very bad but be like that
|
||||||
|
fn retWithName(prefix: []const u8, inner: []const u8) []const u8 {
|
||||||
|
var ret_nam_buf = std.heap.direct_allocator.alloc(u8, 256) catch unreachable;
|
||||||
|
return std.fmt.bufPrint(ret_nam_buf[0..], "{}({})", prefix, inner) catch unreachable;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn prettyType(typ: SymbolUnderlyingType) []const u8 {
|
||||||
|
return switch (typ) {
|
||||||
|
.Integer32 => "i32",
|
||||||
|
.Integer64 => "i64",
|
||||||
|
.Bool => "bool",
|
||||||
|
|
||||||
|
.OpaqueType => |ident| retWithName("opaque", ident),
|
||||||
|
.Struct => |ident| retWithName("struct", ident),
|
||||||
|
|
||||||
|
else => unreachable,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn printContext(ctx: CompilationContext) void {
|
||||||
|
var it = ctx.symbol_table.iterator();
|
||||||
|
|
||||||
|
while (it.next()) |kv| {
|
||||||
|
switch (kv.value) {
|
||||||
|
.Function => |fn_sym| {
|
||||||
|
std.debug.warn(
|
||||||
|
"function {} returns {}\n",
|
||||||
|
kv.key,
|
||||||
|
prettyType(fn_sym.return_type),
|
||||||
|
);
|
||||||
|
|
||||||
|
var param_it = fn_sym.parameters.iterator();
|
||||||
|
while (param_it.next()) |param_kv| {
|
||||||
|
std.debug.warn(
|
||||||
|
"\tparameter {} typ {}\n",
|
||||||
|
param_kv.key,
|
||||||
|
prettyType(param_kv.value),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
.Struct => |typemap| {
|
||||||
|
std.debug.warn("struct '{}'\n", kv.key);
|
||||||
|
var map_it = typemap.iterator();
|
||||||
|
while (map_it.next()) |map_kv| {
|
||||||
|
std.debug.warn(
|
||||||
|
"\tfield {} type {}\n",
|
||||||
|
map_kv.key,
|
||||||
|
prettyType(map_kv.value),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
.Variable => std.debug.warn(
|
||||||
|
"variable {} type {}\n",
|
||||||
|
kv.key,
|
||||||
|
kv.value,
|
||||||
|
),
|
||||||
|
else => unreachable,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
@ -256,7 +256,7 @@ pub const Codegen = struct {
|
||||||
},
|
},
|
||||||
|
|
||||||
else => {
|
else => {
|
||||||
std.debug.warn("got unhandled Node {}\n", node.*);
|
std.debug.warn("TODO handle node type {}\n", @tagName(node.*));
|
||||||
unreachable;
|
unreachable;
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
|
@ -270,7 +270,7 @@ pub const Codegen = struct {
|
||||||
defer llvm.LLVMDisposeModule(mod);
|
defer llvm.LLVMDisposeModule(mod);
|
||||||
|
|
||||||
for (root.Root.toSlice()) |child| {
|
for (root.Root.toSlice()) |child| {
|
||||||
std.debug.warn("cgen: gen child {}\n", child);
|
std.debug.warn("cgen: gen {}\n", @tagName(child));
|
||||||
try self.genNode(mod, &child);
|
try self.genNode(mod, &child);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,21 +1,32 @@
|
||||||
const std = @import("std");
|
const std = @import("std");
|
||||||
|
const ast = @import("ast.zig");
|
||||||
|
|
||||||
pub const CompilationError = error{TypeError};
|
pub const CompilationError = error{TypeError};
|
||||||
|
|
||||||
pub const SymbolTable = std.hash_map.StringHashMap(SymbolData);
|
pub const SymbolTable = std.hash_map.StringHashMap(SymbolData);
|
||||||
|
pub const TypeList = std.ArrayList(SymbolUnderlyingType);
|
||||||
|
|
||||||
pub const SymbolUnderlyingTypeEnum = enum {
|
pub const SymbolUnderlyingTypeEnum = enum {
|
||||||
Integer32,
|
Integer32,
|
||||||
Integer64,
|
Integer64,
|
||||||
Bool,
|
Bool,
|
||||||
CustomType,
|
|
||||||
|
// opaque unsolved identifier
|
||||||
|
OpaqueType,
|
||||||
|
|
||||||
|
// solved custom type
|
||||||
|
Struct,
|
||||||
|
Enum,
|
||||||
};
|
};
|
||||||
|
|
||||||
pub const SymbolUnderlyingType = union(SymbolUnderlyingTypeEnum) {
|
pub const SymbolUnderlyingType = union(SymbolUnderlyingTypeEnum) {
|
||||||
Integer32: void,
|
Integer32: void,
|
||||||
Integer64: void,
|
Integer64: void,
|
||||||
Bool: void,
|
Bool: void,
|
||||||
CustomType: []const u8,
|
OpaqueType: []const u8,
|
||||||
|
|
||||||
|
Struct: []const u8,
|
||||||
|
Enum: []const u8,
|
||||||
};
|
};
|
||||||
|
|
||||||
// functions, for our purposes, other than symbols, have:
|
// functions, for our purposes, other than symbols, have:
|
||||||
|
@ -26,18 +37,20 @@ pub const FunctionSymbol = struct {
|
||||||
|
|
||||||
/// Parameters for a function are also a table instead of an ArrayList
|
/// Parameters for a function are also a table instead of an ArrayList
|
||||||
/// because we want to resolve identifiers to them.
|
/// because we want to resolve identifiers to them.
|
||||||
parameters: SymbolTable,
|
parameters: UnderlyingTypeMap,
|
||||||
symbols: SymbolTable,
|
symbols: SymbolTable,
|
||||||
|
|
||||||
/// Find a given identifier in the function. Can resolve to either a parameter
|
/// Find a given identifier in the function. Can resolve to either a parameter
|
||||||
pub fn findSymbol(self: *const FuncionSymbol, identifier: []const u8) ?Symbol {
|
pub fn findSymbol(self: *const @This(), identifier: []const u8) ?SymbolData {
|
||||||
// try to find it on overall variable symbols
|
// try to find it on overall variable symbols
|
||||||
var var_sym = self.symbols.get(identifier);
|
|
||||||
if (var_sym != null) return var_sym;
|
|
||||||
|
|
||||||
var param_sym = self.parameters.get(identifier);
|
// TODO
|
||||||
if (param_sym != null) return param_sym;
|
|
||||||
|
|
||||||
|
//var var_sym = self.symbols.get(identifier);
|
||||||
|
//if (var_sym != null) return var_sym.?.value;
|
||||||
|
|
||||||
|
//var param_sym = self.parameters.get(identifier);
|
||||||
|
//if (param_sym != null) return param_sym.?.value;
|
||||||
return null;
|
return null;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
@ -94,7 +107,7 @@ pub const CompilationContext = struct {
|
||||||
if (std.mem.eql(u8, typ, typ_ident)) return builtin_types[idx];
|
if (std.mem.eql(u8, typ, typ_ident)) return builtin_types[idx];
|
||||||
}
|
}
|
||||||
|
|
||||||
return .CustomType;
|
return .OpaqueType;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Solve a given type string into a full fleged SymbolUnderlyingType.
|
/// Solve a given type string into a full fleged SymbolUnderlyingType.
|
||||||
|
@ -110,7 +123,40 @@ pub const CompilationContext = struct {
|
||||||
.Integer32 => SymbolUnderlyingType{ .Integer32 = {} },
|
.Integer32 => SymbolUnderlyingType{ .Integer32 = {} },
|
||||||
.Integer64 => SymbolUnderlyingType{ .Integer64 = {} },
|
.Integer64 => SymbolUnderlyingType{ .Integer64 = {} },
|
||||||
.Bool => SymbolUnderlyingType{ .Bool = {} },
|
.Bool => SymbolUnderlyingType{ .Bool = {} },
|
||||||
.CustomType => SymbolUnderlyingType{ .CustomType = typ_ident },
|
.OpaqueType => SymbolUnderlyingType{ .OpaqueType = typ_ident },
|
||||||
|
else => unreachable,
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn insertStruct(self: *@This(), struc: ast.Struct, field_types: TypeList) !void {
|
||||||
|
var type_map = UnderlyingTypeMap.init(self.allocator);
|
||||||
|
|
||||||
|
for (struc.fields.toSlice()) |field, idx| {
|
||||||
|
_ = try type_map.put(field.name.lexeme, field_types.at(idx));
|
||||||
|
}
|
||||||
|
|
||||||
|
_ = try self.symbol_table.put(struc.name.lexeme, SymbolData{ .Struct = type_map });
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn insertFn(
|
||||||
|
self: *@This(),
|
||||||
|
decl: ast.FnDecl,
|
||||||
|
ret_type: SymbolUnderlyingType,
|
||||||
|
param_types: TypeList,
|
||||||
|
symbols: SymbolTable,
|
||||||
|
) !void {
|
||||||
|
var type_map = UnderlyingTypeMap.init(self.allocator);
|
||||||
|
|
||||||
|
for (decl.params.toSlice()) |param, idx| {
|
||||||
|
_ = try type_map.put(param.name.lexeme, param_types.at(idx));
|
||||||
|
}
|
||||||
|
|
||||||
|
_ = try self.symbol_table.put(decl.func_name.lexeme, SymbolData{
|
||||||
|
.Function = FunctionSymbol{
|
||||||
|
.return_type = ret_type,
|
||||||
|
.parameters = type_map,
|
||||||
|
.symbols = symbols,
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
|
@ -51,7 +51,10 @@ pub fn run(allocator: *std.mem.Allocator, slice: []const u8) !Result {
|
||||||
printer.printNode(root, 0);
|
printer.printNode(root, 0);
|
||||||
|
|
||||||
var solver = types.TypeSolver.init(allocator);
|
var solver = types.TypeSolver.init(allocator);
|
||||||
var ctx = solver.pass(root);
|
var ctx = try solver.pass(root);
|
||||||
|
|
||||||
|
std.debug.warn("symbol table\n");
|
||||||
|
printer.printContext(ctx);
|
||||||
|
|
||||||
var cgen = codegen.Codegen.init(allocator);
|
var cgen = codegen.Codegen.init(allocator);
|
||||||
try cgen.gen(root);
|
try cgen.gen(root);
|
||||||
|
|
136
src/types.zig
136
src/types.zig
|
@ -3,44 +3,162 @@ const ast = @import("ast.zig");
|
||||||
|
|
||||||
const comp = @import("comp_ctx.zig");
|
const comp = @import("comp_ctx.zig");
|
||||||
|
|
||||||
|
const CompileError = @import("codegen.zig").CompileError;
|
||||||
|
const Token = @import("tokens.zig").Token;
|
||||||
|
|
||||||
|
const SymbolUnderlyingType = comp.SymbolUnderlyingType;
|
||||||
|
|
||||||
pub const TypeSolver = struct {
|
pub const TypeSolver = struct {
|
||||||
allocator: *std.mem.Allocator,
|
allocator: *std.mem.Allocator,
|
||||||
|
|
||||||
|
// error handling
|
||||||
|
err_ctx: ?[]const u8 = null,
|
||||||
|
err_tok: ?Token = null,
|
||||||
|
hadError: bool = false,
|
||||||
|
|
||||||
pub fn init(allocator: *std.mem.Allocator) TypeSolver {
|
pub fn init(allocator: *std.mem.Allocator) TypeSolver {
|
||||||
return TypeSolver{ .allocator = allocator };
|
return TypeSolver{ .allocator = allocator };
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn setErrContext(self: *@This(), comptime fmt: ?[]const u8, args: ...) void {
|
||||||
|
if (fmt == null) {
|
||||||
|
self.err_ctx = null;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO allocate buffer on init() and use it
|
||||||
|
var buf = self.allocator.alloc(u8, 256) catch unreachable;
|
||||||
|
self.err_ctx = std.fmt.bufPrint(buf, fmt.?, args) catch unreachable;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn setErrToken(self: *@This(), tok: ?Token) void {
|
||||||
|
self.err_tok = tok;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn doError(self: *@This(), comptime fmt: []const u8, args: ...) void {
|
||||||
|
self.hadError = true;
|
||||||
|
|
||||||
|
std.debug.warn("type error");
|
||||||
|
if (self.err_tok) |tok| {
|
||||||
|
std.debug.warn(" at line {}", tok.line);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (self.err_ctx) |ctx| {
|
||||||
|
std.debug.warn(" on {}", ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
std.debug.warn("\n\t");
|
||||||
|
std.debug.warn(fmt, args);
|
||||||
|
std.debug.warn("\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolve a type in global scope
|
||||||
|
fn resolveGlobalType(
|
||||||
|
self: *@This(),
|
||||||
|
ctx: *comp.CompilationContext,
|
||||||
|
identifier: []const u8,
|
||||||
|
) ?SymbolUnderlyingType {
|
||||||
|
// assume the identifier references a builtin
|
||||||
|
var typ = ctx.solveType(identifier);
|
||||||
|
|
||||||
|
switch (typ) {
|
||||||
|
.OpaqueType => |val| {
|
||||||
|
// solve for opaque so it isnt opaque
|
||||||
|
var sym = ctx.symbol_table.get(val);
|
||||||
|
if (sym != null)
|
||||||
|
return switch (sym.?.value) {
|
||||||
|
.Struct => SymbolUnderlyingType{ .Struct = val },
|
||||||
|
.Enum => SymbolUnderlyingType{ .Enum = val },
|
||||||
|
|
||||||
|
else => blk: {
|
||||||
|
self.doError(
|
||||||
|
"expected struct or enum for type '{}', got {}",
|
||||||
|
val,
|
||||||
|
sym,
|
||||||
|
);
|
||||||
|
break :blk null;
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
self.doError("Unknown type: '{}'", val);
|
||||||
|
return null;
|
||||||
|
},
|
||||||
|
|
||||||
|
else => return typ,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn nodePass(
|
pub fn nodePass(
|
||||||
self: *@This(),
|
self: *@This(),
|
||||||
ctx: *comp.CompilationContext,
|
ctx: *comp.CompilationContext,
|
||||||
node: *ast.Node,
|
node: *ast.Node,
|
||||||
) void {
|
) !void {
|
||||||
switch (node.*) {
|
switch (node.*) {
|
||||||
.Root => unreachable,
|
.Root => unreachable,
|
||||||
.FnDecl => |decl| {
|
.FnDecl => |decl| {
|
||||||
var ret_type = ctx.solveType(decl.return_type.lexeme);
|
self.setErrToken(decl.return_type);
|
||||||
|
self.setErrContext("function {}", decl.func_name.lexeme);
|
||||||
|
var ret_type = self.resolveGlobalType(ctx, decl.return_type.lexeme);
|
||||||
|
|
||||||
// TODO maybe solve when custom?
|
std.debug.warn("resolved fn {} type: {}\n", decl.func_name.lexeme, ret_type);
|
||||||
|
|
||||||
std.debug.warn("fn {} type: {}\n", decl.func_name.lexeme, ret_type);
|
var parameters = comp.TypeList.init(self.allocator);
|
||||||
|
for (decl.params.toSlice()) |param| {
|
||||||
|
var param_type = self.resolveGlobalType(ctx, param.typ.lexeme);
|
||||||
|
if (param_type == null) continue;
|
||||||
|
try parameters.append(param_type.?);
|
||||||
|
}
|
||||||
|
|
||||||
// ctx.insertFn(decl.name.lexeme, ret_type);
|
// TODO symbols and scope resolution, that's
|
||||||
|
// its own can of worms
|
||||||
|
var symbols = comp.SymbolTable.init(self.allocator);
|
||||||
|
|
||||||
|
// TODO go through body, resolve statements, expressions
|
||||||
|
// and everything else
|
||||||
|
|
||||||
|
if (ret_type != null and parameters.len == decl.params.len) {
|
||||||
|
try ctx.insertFn(decl, ret_type.?, parameters, symbols);
|
||||||
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
|
.Struct => |struc| {
|
||||||
|
self.setErrToken(struc.name);
|
||||||
|
self.setErrContext("struct {}", struc.name.lexeme);
|
||||||
|
|
||||||
|
var types = comp.TypeList.init(self.allocator);
|
||||||
|
|
||||||
|
for (struc.fields.toSlice()) |field| {
|
||||||
|
self.setErrToken(field.name);
|
||||||
|
var field_type = self.resolveGlobalType(ctx, field.typ.lexeme);
|
||||||
|
if (field_type == null) continue;
|
||||||
|
try types.append(field_type.?);
|
||||||
|
}
|
||||||
|
|
||||||
|
// only determine struct as fully resolved
|
||||||
|
// when length of declared types == length of resolved types
|
||||||
|
|
||||||
|
// we don't return type errors from the main loop so we can
|
||||||
|
// keep going and find more type errors
|
||||||
|
if (types.len == struc.fields.len)
|
||||||
|
try ctx.insertStruct(struc, types);
|
||||||
|
},
|
||||||
|
|
||||||
|
// TODO enums are u32
|
||||||
|
//.Enum => {},
|
||||||
|
|
||||||
// TODO infer type of expr in const
|
// TODO infer type of expr in const
|
||||||
//.ConstDecl => {},
|
//.ConstDecl => {},
|
||||||
//.Struct => {},
|
|
||||||
//.Enum => {},
|
|
||||||
else => unreachable,
|
else => unreachable,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn pass(self: *@This(), root: *ast.Node) comp.CompilationContext {
|
pub fn pass(self: *@This(), root: *ast.Node) !comp.CompilationContext {
|
||||||
var ctx = comp.CompilationContext.init(self.allocator);
|
var ctx = comp.CompilationContext.init(self.allocator);
|
||||||
|
|
||||||
var slice = root.Root.toSlice();
|
var slice = root.Root.toSlice();
|
||||||
for (slice) |_, idx| {
|
for (slice) |_, idx| {
|
||||||
self.nodePass(&ctx, &slice[idx]);
|
try self.nodePass(&ctx, &slice[idx]);
|
||||||
}
|
}
|
||||||
|
|
||||||
return ctx;
|
return ctx;
|
||||||
|
|
Loading…
Reference in New Issue