Bruce/tomo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

WIP, but functional interfaces

Browse Source
This commit is contained in:
Bruce Hill 2024-05-12 13:50:06 -04:00
parent a20f522fd6
commit d143c72b22
13 changed files with 437 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -29,7 +29,7 @@ BUILTIN_OBJS=builtins/array.o builtins/bool.o builtins/nums.o builtins/functions
all: libtomo.so tomo
tomo: tomo.c SipHash/halfsiphash.o ast.o parse.o environment.o types.o typecheck.o structs.o enums.o compile.o repl.o
tomo: tomo.c SipHash/halfsiphash.o ast.o parse.o environment.o types.o typecheck.o structs.o enums.o interfaces.o compile.o repl.o
libtomo.so: $(BUILTIN_OBJS) SipHash/halfsiphash.o
$(CC) $^ $(CFLAGS) $(EXTRA) $(CWARN) $(G) $(O) $(OSFLAGS) -lgc -lcord -lm -lunistring -ldl -Wl,-soname,libtomo.so -shared -o $@

71
ast.c
View File

@ -136,6 +136,7 @@ CORD ast_to_xml(ast_t *ast)
T(StructDef, "<StructDef name=\"%s\">%r<namespace>%r</namespace></StructDef>", data.name, arg_list_to_xml(data.fields), ast_to_xml(data.namespace))
T(EnumDef, "<EnumDef name=\"%s\"><tags>%r</tags><namespace>%r</namespace></EnumDef>", data.name, tags_to_xml(data.tags), ast_to_xml(data.namespace))
T(LangDef, "<LangDef name=\"%s\">%r</LangDef>", data.name, ast_to_xml(data.namespace))
T(InterfaceDef, "<InterfaceDef name=\"%s\">%r%r</InterfaceDef>", data.name, type_ast_to_xml(data.type_parameter), arg_list_to_xml(data.fields))
T(Index, "<Index>%r%r</Index>", optional_tagged("indexed", data.indexed), optional_tagged("index", data.index))
T(FieldAccess, "<FieldAccess field=\"%s\">%r</FieldAccess>", data.field, ast_to_xml(data.fielded))
T(Optional, "<Optional>%r</Optional>", ast_to_xml(data.value))
@ -150,7 +151,7 @@ CORD ast_to_xml(ast_t *ast)
CORD type_ast_to_xml(type_ast_t *t)
{
if (!t) return "\x1b[35mNULL\x1b[m";
if (!t) return "NULL";
switch (t->tag) {
#define T(type, ...) case type: { auto data = t->__data.type; (void)data; return CORD_asprintf(__VA_ARGS__); }
@ -195,4 +196,72 @@ bool is_idempotent(ast_t *ast)
}
}
bool type_ast_eq(type_ast_t *x, type_ast_t *y)
{
if (x->tag != y->tag) return false;
switch (x->tag) {
case UnknownTypeAST: return true;
case VarTypeAST: return streq(Match(x, VarTypeAST)->name, Match(y, VarTypeAST)->name);
case PointerTypeAST: {
auto x_info = Match(x, PointerTypeAST);
auto y_info = Match(y, PointerTypeAST);
return (x_info->is_optional == y_info->is_optional
&& x_info->is_stack == y_info->is_stack
&& x_info->is_readonly == y_info->is_readonly
&& type_ast_eq(x_info->pointed, y_info->pointed));
}
case ArrayTypeAST: return type_ast_eq(Match(x, ArrayTypeAST)->item, Match(y, ArrayTypeAST)->item);
case TableTypeAST: {
auto tx = Match(x, TableTypeAST);
auto ty = Match(y, TableTypeAST);
return type_ast_eq(tx->key, ty->key) && type_ast_eq(tx->value, ty->value);
}
case FunctionTypeAST: {
auto x_fn = Match(x, FunctionTypeAST);
auto y_fn = Match(y, FunctionTypeAST);
if (!type_ast_eq(x_fn->ret, y_fn->ret))
return false;
for (arg_ast_t *x_arg = x_fn->args, *y_arg = y_fn->args; x_arg || y_arg; x_arg = x_arg->next, y_arg = y_arg->next) {
if (!x_arg || !y_arg) return false;
if (!x_arg->type)
errx(1, "I can't compare function types that don't have all explicitly typed args");
if (!y_arg->type)
errx(1, "I can't compare function types that don't have all explicitly typed args");
if (!type_ast_eq(x_arg->type, y_arg->type))
return false;
}
return true;
}
}
return true;
}
type_ast_t *replace_type_ast(type_ast_t *t, type_ast_t *target, type_ast_t *replacement)
{
if (!t) return t;
if (type_ast_eq(t, target))
return replacement;
#define REPLACED_MEMBER(t, tag, member) ({ t = memcpy(GC_MALLOC(sizeof(type_ast_t)), (t), sizeof(type_ast_t)); Match((struct type_ast_s*)(t), tag)->member = replace_type_ast(Match((t), tag)->member, target, replacement); t; })
switch (t->tag) {
case UnknownTypeAST:
case VarTypeAST: return t;
case PointerTypeAST: return REPLACED_MEMBER(t, PointerTypeAST, pointed);
case ArrayTypeAST: return REPLACED_MEMBER(t, ArrayTypeAST, item);
case TableTypeAST: {
t = REPLACED_MEMBER(t, TableTypeAST, key);
return REPLACED_MEMBER(t, TableTypeAST, value);
}
case FunctionTypeAST: {
auto fn = Match(t, FunctionTypeAST);
t = REPLACED_MEMBER(t, FunctionTypeAST, ret);
arg_ast_t *args = LIST_MAP(fn->args, old_arg, .type=replace_type_ast(old_arg->type, target, replacement));
Match((struct type_ast_s*)t, FunctionTypeAST)->args = args;
return t;
}
}
return t;
#undef REPLACED_MEMBER
}
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

9
ast.h
View File

@ -111,7 +111,7 @@ typedef enum {
Skip, Stop, Pass,
Return,
Extern,
StructDef, EnumDef, LangDef,
StructDef, EnumDef, LangDef, InterfaceDef,
Index, FieldAccess, Optional,
DocTest,
Use,
@ -249,6 +249,12 @@ struct ast_s {
const char *name;
ast_t *namespace;
} LangDef;
struct {
const char *name;
type_ast_t *type_parameter;
arg_ast_t *fields;
ast_t *namespace;
} InterfaceDef;
struct {
ast_t *indexed, *index;
bool unchecked;
@ -284,5 +290,6 @@ CORD type_ast_to_xml(type_ast_t *ast);
int printf_ast(FILE *stream, const struct printf_info *info, const void *const args[]);
ast_list_t *get_ast_children(ast_t *ast);
bool is_idempotent(ast_t *ast);
type_ast_t *replace_type_ast(type_ast_t *t, type_ast_t *target, type_ast_t *replacement);
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

1
builtins/util.h
View File

@ -13,7 +13,6 @@
#define streq(a, b) (((a) == NULL && (b) == NULL) || (((a) == NULL) == ((b) == NULL) && strcmp(a, b) == 0))
#define new(t, ...) ((t*)memcpy(GC_MALLOC(sizeof(t)), &(t){__VA_ARGS__}, sizeof(t)))
#define copy(obj_ptr) ((__typeof(obj_ptr))memcpy(GC_MALLOC(sizeof(*(obj_ptr))), obj_ptr, sizeof(*(obj_ptr))))
#define grow(arr, new_size) ((typeof (arr))GC_REALLOC(arr, (sizeof(arr[0]))*(new_size)))
#define Match(x, _tag) ((x)->tag == _tag ? &(x)->__data._tag : (errx(1, __FILE__ ":%d This was supposed to be a " # _tag "\n", __LINE__), &(x)->__data._tag))
#define Tagged(t, _tag, ...) new(t, .tag=_tag, .__data._tag={__VA_ARGS__})

85
compile.c
View File

@ -10,6 +10,7 @@
#include "compile.h"
#include "enums.h"
#include "structs.h"
#include "interfaces.h"
#include "environment.h"
#include "typecheck.h"
#include "builtins/util.h"
@ -107,6 +108,10 @@ CORD compile_type(env_t *env, type_t *t)
auto e = Match(t, EnumType);
return CORD_all(e->env->file_prefix, e->name, "_t");
}
case InterfaceType: {
auto s = Match(t, InterfaceType);
return CORD_all(s->env->file_prefix, s->name, "_t");
}
case TypeInfoType: return "TypeInfo";
default: compiler_err(NULL, NULL, NULL, "Not implemented");
}
@ -424,7 +429,6 @@ CORD compile_statement(env_t *env, ast_t *ast)
return CORD_EMPTY;
}
case LangDef: {
// TODO: implement
auto def = Match(ast, LangDef);
CORD_appendf(&env->code->typedefs, "typedef CORD %r%s_t;\n", env->file_prefix, def->name);
CORD_appendf(&env->code->typedefs, "extern const TypeInfo %r%s;\n", env->file_prefix, def->name);
@ -434,6 +438,10 @@ CORD compile_statement(env_t *env, ast_t *ast)
compile_namespace(env, def->name, def->namespace);
return CORD_EMPTY;
}
case InterfaceDef: {
compile_interface_def(env, ast);
return CORD_EMPTY;
}
case FunctionDef: {
auto fndef = Match(ast, FunctionDef);
bool is_private = Match(fndef->name, Var)->name[0] == '_';
@ -810,6 +818,8 @@ CORD compile_statement(env_t *env, ast_t *ast)
return CORD_EMPTY;
}
default:
if (!is_discardable(env, ast))
code_err(ast, "The result of this statement cannot be discarded");
return CORD_asprintf("(void)%r;", compile(env, ast));
}
}
@ -843,8 +853,9 @@ CORD expr_as_text(env_t *env, CORD expr, type_t *t, CORD color)
case TableType: return CORD_asprintf("Table$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
case FunctionType: case ClosureType: return CORD_asprintf("Func$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
case PointerType: return CORD_asprintf("Pointer$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
case StructType: case EnumType: return CORD_asprintf("(%r)->CustomInfo.as_text(stack(%r), %r, %r)",
compile_type_info(env, t), expr, color, compile_type_info(env, t));
case StructType: case EnumType: case InterfaceType:
return CORD_asprintf("(%r)->CustomInfo.as_text(stack(%r), %r, %r)",
compile_type_info(env, t), expr, color, compile_type_info(env, t));
default: compiler_err(NULL, NULL, NULL, "Stringifying is not supported for %T", t);
}
}
@ -1468,8 +1479,14 @@ CORD compile(env_t *env, ast_t *ast)
code = CORD_all(code, compile_type(env, arg_type), " $", arg->name, ", ");
}
for (ast_list_t *stmt = Match(lambda->body, Block)->statements; stmt; stmt = stmt->next)
(void)compile_statement(body_scope, stmt->ast);
// Find which variables are captured in the closure:
env_t *tmp_scope = fresh_scope(body_scope);
for (ast_list_t *stmt = Match(lambda->body, Block)->statements; stmt; stmt = stmt->next) {
if (stmt->next)
(void)compile_statement(tmp_scope, stmt->ast);
else
(void)compile(tmp_scope, stmt->ast);
}
CORD userdata;
if (Table$length(*fn_ctx.closed_vars) == 0) {
@ -1625,6 +1642,36 @@ CORD compile(env_t *env, ast_t *ast)
return CORD_all("Table$clear(", self, ")");
} else code_err(ast, "There is no '%s' method for tables", call->name);
}
case InterfaceType: {
auto methodcall = Match(ast, MethodCall);
binding_t *b = get_namespace_binding(env, methodcall->self, methodcall->name);
if (b) {
type_t *fn_t = get_method_type(env, methodcall->self, methodcall->name);
arg_ast_t *args = new(arg_ast_t, .value=methodcall->self, .next=methodcall->args);
return CORD_all(b->code, "(", compile_arguments(env, ast, Match(fn_t, FunctionType)->args, args), ")");
} else {
auto interface = Match(self_value_t, InterfaceType);
for (arg_t *field = interface->fields; field; field = field->next) {
if (streq(field->name, methodcall->name)) {
env_t tmp_env = *env;
tmp_env.types = new(table_t, .fallback=tmp_env.types);
Table$str_set(tmp_env.types, interface->type_parameter, self_value_t);
type_t *field_t = field->type;
if (field_t->tag == ClosureType)
field_t = Match(field_t, ClosureType)->fn;
arg_t *type_args = Match(field_t, FunctionType)->args;
CORD args = compile_arguments(env, ast, type_args->next, methodcall->args);
bool is_ptr = Match(field_t, FunctionType)->args->type->tag == PointerType;
return CORD_all("({ ", compile_type(env, self_value_t), " $self = ",
compile_to_pointer_depth(env, methodcall->self, 0, false), "; ",
"$self.", methodcall->name, "(", is_ptr ? CORD_EMPTY : "*", "(", compile_type(env, self_value_t), "*)$self.$obj",
args == CORD_EMPTY ? CORD_EMPTY : ", ", args, "); })");
}
}
code_err(ast, "There is no method called '%s' on the interface type %s", methodcall->name, interface->name);
}
}
default: {
auto methodcall = Match(ast, MethodCall);
type_t *fn_t = get_method_type(env, methodcall->self, methodcall->name);
@ -1644,10 +1691,29 @@ CORD compile(env_t *env, ast_t *ast)
} else if (fn_t->tag == TypeInfoType) {
type_t *t = Match(fn_t, TypeInfoType)->type;
if (t->tag == StructType) {
// Struct constructor:
fn_t = Type(FunctionType, .args=Match(t, StructType)->fields, .ret=t);
CORD fn = compile(env, call->fn);
return CORD_all(fn, "(", compile_arguments(env, ast, Match(fn_t, FunctionType)->args, call->args), ")");
} else if (t->tag == InterfaceType) {
// Interface constructor:
if (!call->args) code_err(ast, "You need to provide an argument to this interface constructor");
if (call->args->next) code_err(ast, "This interface constructor only takes one argument");
auto interface = Match(t, InterfaceType);
ast_t *impl = call->args->value;
type_t *impl_t = get_type(env, impl);
if (impl_t->tag != PointerType)
impl = WrapAST(impl, HeapAllocate, impl);
CORD c = CORD_all("(", compile_type(env, t), "){", compile(env, impl));
for (arg_t *field = interface->fields->next; field; field = field->next) {
binding_t *b = get_namespace_binding(env, impl, field->name);
if (!b) code_err(ast, "The type %T doesn't have '%s' for the interface %T", impl_t, field->name, t);
// TODO: typecheck implementation!
c = CORD_all(c, ", (void*)", b->code);
}
return CORD_cat(c, "}");
} else if (t->tag == IntType || t->tag == NumType) {
// Int/Num constructor:
if (!call->args || call->args->next)
code_err(call->fn, "This constructor takes exactly 1 argument");
type_t *actual = get_type(env, call->args->value);
@ -1816,6 +1882,9 @@ CORD compile(env_t *env, ast_t *ast)
}
code_err(ast, "There is no '%s' field on tables", f->field);
}
case InterfaceType: {
code_err(ast, "Interface field access is not yet implemented");
}
case ModuleType: {
const char *name = Match(value_t, ModuleType)->name;
env_t *module_env = Table$str_get(*env->imports, name);
@ -1881,7 +1950,7 @@ CORD compile(env_t *env, ast_t *ast)
case Extern: code_err(ast, "Externs are not supported yet");
case TableEntry: code_err(ast, "Table entries should not be compiled directly");
case Declare: case Assign: case UpdateAssign: case For: case While: case StructDef: case LangDef:
case EnumDef: case FunctionDef: case Skip: case Stop: case Pass: case Return: case DocTest:
case EnumDef: case FunctionDef: case InterfaceDef: case Skip: case Stop: case Pass: case Return: case DocTest:
code_err(ast, "This is not a valid expression");
case Unknown: code_err(ast, "Unknown AST");
}
@ -1937,6 +2006,10 @@ CORD compile_type_info(env_t *env, type_t *t)
auto e = Match(t, EnumType);
return CORD_all("(&", e->env->file_prefix, e->name, ")");
}
case InterfaceType: {
auto i = Match(t, InterfaceType);
return CORD_all("(&", i->env->file_prefix, i->name, ")");
}
case ArrayType: {
type_t *item_t = Match(t, ArrayType)->item_type;
return CORD_asprintf("$ArrayInfo(%r)", compile_type_info(env, item_t));

2
enums.h
View File

@ -2,8 +2,6 @@
// Compilation of tagged unions (enums)
#include <gc/cord.h>
#include "ast.h"
#include "environment.h"

6
environment.c
View File

@ -321,9 +321,13 @@ binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name)
return struct_->env ? get_binding(struct_->env, name) : NULL;
}
case EnumType: {
auto enum_ = Match(cls_type, StructType);
auto enum_ = Match(cls_type, EnumType);
return enum_->env ? get_binding(enum_->env, name) : NULL;
}
case InterfaceType: {
auto interface = Match(cls_type, InterfaceType);
return interface->env ? get_binding(interface->env, name) : NULL;
}
case TypeInfoType: {
auto info = Match(cls_type, TypeInfoType);
return info->env ? get_binding(info->env, name) : NULL;

120
interfaces.c Normal file
View File

@ -0,0 +1,120 @@
// Logic for compiling interfaces
#include <ctype.h>
#include <gc/cord.h>
#include <gc.h>
#include <stdio.h>
#include "ast.h"
#include "builtins/text.h"
#include "compile.h"
#include "interfaces.h"
#include "environment.h"
#include "typecheck.h"
#include "builtins/util.h"
static CORD compile_str_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, InterfaceDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
const char *name = def->name;
const char *dollar = strrchr(name, '$');
if (dollar) name = dollar + 1;
CORD str_func = CORD_asprintf("static CORD %r$as_text(%r_t *interface, bool use_color) {\n"
"\tif (!interface) return \"%s\";\n", full_name, full_name, name);
return CORD_all(str_func, "\treturn CORD_asprintf(use_color ? \"\\x1b[0;1m", name, "\\x1b[m<%p>\" : \"", name, "<%p>\", interface->$obj);\n}");
}
static CORD compile_compare_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, InterfaceDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
return CORD_all("static int ", full_name, "$compare(const ", full_name, "_t *x, const ", full_name,
"_t *y, const TypeInfo *info) {\n"
"(void)info;\n",
"return (x->$obj > y->$obj) - (x->$obj < y->$obj);\n}");
}
static CORD compile_equals_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, InterfaceDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
return CORD_all("static bool ", full_name, "$equal(const ", full_name, "_t *x, const ", full_name,
"_t *y, const TypeInfo *info) {\n"
"(void)info;\n",
"return (x->$obj == y->$obj);\n}");
}
static CORD compile_hash_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, InterfaceDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
return CORD_all("static uint32_t ", full_name, "$hash(const ", full_name, "_t *interface, const TypeInfo *info) {\n"
"(void)info;\n"
"uint32_t hash;\n"
"halfsiphash(&interface->$obj, sizeof(void*), TOMO_HASH_VECTOR, (uint8_t*)&hash, sizeof(hash));\n"
"return hash;\n}\n");
}
void compile_interface_def(env_t *env, ast_t *ast)
{
auto def = Match(ast, InterfaceDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD_appendf(&env->code->typedefs, "typedef struct %r_s %r_t;\n", full_name, full_name);
CORD_appendf(&env->code->typedefs, "#define %r(...) ((%r_t){__VA_ARGS__})\n", full_name, full_name);
CORD_appendf(&env->code->typecode, "struct %r_s {\nvoid *$obj;\n", full_name);
type_ast_t *replacement_type_ast = NewTypeAST(ast->file, ast->start, ast->end, VarTypeAST, .name=def->name);
for (arg_ast_t *field = def->fields; field; field = field->next) {
type_ast_t *field_type = replace_type_ast(field->type, def->type_parameter, replacement_type_ast);
type_t *field_t = parse_type_ast(env, field_type);
if (field_t->tag == ClosureType)
field_t = Match(field_t, ClosureType)->fn;
CORD decl = compile_declaration(env, field_t, field->name);
CORD_appendf(&env->code->typecode, "%r%s;\n", decl,
field_t->tag == BoolType ? ":1" : "");
}
CORD_appendf(&env->code->typecode, "};\n");
// Typeinfo:
CORD_appendf(&env->code->typedefs, "extern const TypeInfo %r;\n", full_name);
type_t *t = Table$str_get(*env->types, def->name);
assert(t && t->tag == InterfaceType);
auto interface = Match(t, InterfaceType);
CORD typeinfo = CORD_asprintf("public const TypeInfo %r = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
full_name, type_size(t), type_align(t));
typeinfo = CORD_all(typeinfo, ".as_text=(void*)", full_name, "$as_text, ");
env->code->funcs = CORD_all(env->code->funcs, compile_str_method(env, ast));
if (interface->fields && !interface->fields->next) { // Single member, can just use its methods
type_t *member_t = interface->fields->type;
switch (member_t->tag) {
case TextType:
typeinfo = CORD_all(typeinfo, ".hash=(void*)", type_to_cord(member_t), "$hash", ", ");
// fallthrough
case IntType: case NumType:
typeinfo = CORD_all(typeinfo, ".compare=(void*)", type_to_cord(member_t), "$compare, "
".equal=(void*)", type_to_cord(member_t), "$equal, ");
// fallthrough
case BoolType: goto got_methods;
default: break;
}
}
if (interface->fields) {
env->code->funcs = CORD_all(env->code->funcs, compile_compare_method(env, ast),
compile_equals_method(env, ast), compile_hash_method(env, ast));
typeinfo = CORD_all(
typeinfo,
".compare=(void*)", full_name, "$compare, "
".equal=(void*)", full_name, "$equal, "
".hash=(void*)", full_name, "$hash");
}
got_methods:;
typeinfo = CORD_cat(typeinfo, "}}};\n");
env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);
compile_namespace(env, def->name, def->namespace);
}
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

10
interfaces.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
// Compilation of user-defined interfaces
#include "ast.h"
#include "environment.h"
void compile_interface_def(env_t *env, ast_t *ast);
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

38
parse.c
View File

@ -91,6 +91,7 @@ static PARSER(parse_var);
static PARSER(parse_enum_def);
static PARSER(parse_struct_def);
static PARSER(parse_lang_def);
static PARSER(parse_interface_def);
static PARSER(parse_text);
static PARSER(parse_func_def);
static PARSER(parse_extern);
@ -1597,6 +1598,7 @@ PARSER(parse_namespace) {
if ((stmt=optional(ctx, &pos, parse_struct_def))
||(stmt=optional(ctx, &pos, parse_enum_def))
||(stmt=optional(ctx, &pos, parse_lang_def))
||(stmt=optional(ctx, &pos, parse_interface_def))
||(stmt=optional(ctx, &pos, parse_func_def))
||(stmt=optional(ctx, &pos, parse_use))
||(stmt=optional(ctx, &pos, parse_linker))
@ -1632,6 +1634,7 @@ PARSER(parse_file_body) {
if ((stmt=optional(ctx, &pos, parse_struct_def))
||(stmt=optional(ctx, &pos, parse_enum_def))
||(stmt=optional(ctx, &pos, parse_lang_def))
||(stmt=optional(ctx, &pos, parse_interface_def))
||(stmt=optional(ctx, &pos, parse_func_def))
||(stmt=optional(ctx, &pos, parse_use))
||(stmt=optional(ctx, &pos, parse_linker))
@ -1809,6 +1812,41 @@ PARSER(parse_lang_def) {
return NewAST(ctx->file, start, pos, LangDef, .name=name, .namespace=namespace);
}
PARSER(parse_interface_def) {
// interface Name(T; field:type, ...): namespace...
const char *start = pos;
if (!match_word(&pos, "interface")) return NULL;
int64_t starting_indent = get_indent(ctx, pos);
spaces(&pos);
const char *name = get_id(&pos);
if (!name)
parser_err(ctx, start, pos, "I expected a name for this interface");
spaces(&pos);
if (!match(&pos, "("))
parser_err(ctx, pos, pos, "I expected a '(' and a list of fields here");
type_ast_t *type_param = expect(ctx, start, &pos, parse_type, "I couldn't parse the type parameter for this interface");
whitespace(&pos);
expect_str(ctx, start, &pos, ";", "I expected a ';' here");
arg_ast_t *fields = parse_args(ctx, &pos, false);
expect_closing(ctx, &pos, ")", "I wasn't able to parse the rest of this interface definition");
ast_t *namespace = NULL;
if (match(&pos, ":")) {
const char *ns_pos = pos;
whitespace(&ns_pos);
int64_t ns_indent = get_indent(ctx, ns_pos);
if (ns_indent > starting_indent) {
pos = ns_pos;
namespace = optional(ctx, &pos, parse_namespace);
}
}
if (!namespace)
namespace = NewAST(ctx->file, pos, pos, Block, .statements=NULL);
return NewAST(ctx->file, start, pos, InterfaceDef, .name=name, .type_parameter=type_param, .fields=fields, .namespace=namespace);
}
arg_ast_t *parse_args(parse_ctx_t *ctx, const char **pos, bool allow_unnamed)
{
arg_ast_t *args = NULL;

68
typecheck.c
View File

@ -263,6 +263,41 @@ void bind_statement(env_t *env, ast_t *statement)
bind_statement(ns_env, stmt->ast);
break;
}
case InterfaceDef: {
auto def = Match(statement, InterfaceDef);
if (get_binding(env, def->name))
code_err(statement, "A %T called '%s' has already been defined", get_binding(env, def->name)->type, def->name);
env_t *ns_env = namespace_env(env, def->name);
arg_t *fields = new(arg_t, .name="$obj", .type=Type(PointerType, .pointed=Type(MemoryType))); // interface implementor
type_t *type = Type(InterfaceType, .name=def->name, .fields=fields, .opaque=true, .env=ns_env); // placeholder
type_ast_t *replacement_type_ast = NewTypeAST(statement->file, statement->start, statement->end, VarTypeAST, .name=def->name);
Table$str_set(env->types, def->name, type);
for (arg_ast_t *field_ast = def->fields; field_ast; field_ast = field_ast->next) {
if (!field_ast->type)
code_err(field_ast->value, "Interface fields must have defined types, not default values");
type_ast_t *field_type = replace_type_ast(field_ast->type, def->type_parameter, replacement_type_ast);
type_t *field_t = parse_type_ast(env, field_type);
if (field_t->tag == ClosureType)
field_t = Match(field_t, ClosureType)->fn;
if ((field_t->tag == InterfaceType && Match(field_t, InterfaceType)->opaque)
|| (field_t->tag == EnumType && Match(field_t, EnumType)->opaque))
code_err(field_ast->type, "This type is recursive and would create an infinitely sized interface. Try using a pointer.");
fields = new(arg_t, .name=field_ast->name, .type=field_t, .default_val=field_ast->value, .next=fields);
}
REVERSE_LIST(fields);
type->__data.InterfaceType.fields = fields; // populate placeholder
type->__data.InterfaceType.opaque = false;
type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env);
Table$str_set(env->locals, def->name, new(binding_t, .type=typeinfo_type, .code=CORD_all(env->file_prefix, def->name)));
for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next) {
bind_statement(ns_env, stmt->ast);
}
break;
}
case Use: {
env_t *module_env = load_module(env, statement);
for (table_t *bindings = module_env->locals; bindings != module_env->globals; bindings = bindings->fallback) {
@ -552,7 +587,7 @@ type_t *get_type(env_t *env, ast_t *ast)
if (fn_type_t->tag == TypeInfoType) {
type_t *t = Match(fn_type_t, TypeInfoType)->type;
if (t->tag == StructType || t->tag == IntType || t->tag == NumType)
if (t->tag == StructType || t->tag == InterfaceType || t->tag == IntType || t->tag == NumType)
return t; // Constructor
code_err(call->fn, "This is not a type that has a constructor");
}
@ -593,6 +628,31 @@ type_t *get_type(env_t *env, ast_t *ast)
else if (streq(call->name, "clear")) return Type(VoidType);
else code_err(ast, "There is no '%s' method for tables", call->name);
}
case InterfaceType: {
auto methodcall = Match(ast, MethodCall);
binding_t *b = get_namespace_binding(env, methodcall->self, methodcall->name);
if (b) {
if (b->type->tag != FunctionType)
code_err(ast, "'%s' is not a function, it's a %T", methodcall->name, b->type);
return Match(b->type, FunctionType)->ret;
} else {
auto interface = Match(self_value_t, InterfaceType);
for (arg_t *field = interface->fields; field; field = field->next) {
if (streq(field->name, methodcall->name)) {
env_t tmp_env = *env;
tmp_env.types = new(table_t, .fallback=tmp_env.types);
Table$str_set(tmp_env.types, interface->type_parameter, self_value_t);
type_t *field_t = field->type;
if (field_t->tag == ClosureType)
field_t = Match(field_t, ClosureType)->fn;
if (field_t->tag != FunctionType)
code_err(ast, "'%s' is not a function, it's a %T", methodcall->name, b->type);
return Match(field_t, FunctionType)->ret;
}
}
code_err(ast, "There is no method called '%s' on the interface type %s", methodcall->name, interface->name);
}
}
default: {
type_t *fn_type_t = get_method_type(env, call->self, call->name);
if (!fn_type_t)
@ -614,7 +674,7 @@ type_t *get_type(env_t *env, ast_t *ast)
// Early out if the type is knowable without any context from the block:
switch (last->ast->tag) {
case UpdateAssign: case Assign: case Declare: case FunctionDef: case StructDef: case EnumDef: case LangDef:
case UpdateAssign: case Assign: case Declare: case FunctionDef: case StructDef: case EnumDef: case LangDef: case InterfaceDef:
return Type(VoidType);
default: break;
}
@ -791,7 +851,7 @@ type_t *get_type(env_t *env, ast_t *ast)
return Type(ClosureType, Type(FunctionType, .args=args, .ret=ret));
}
case FunctionDef: case StructDef: case EnumDef: case LangDef: {
case FunctionDef: case StructDef: case EnumDef: case LangDef: case InterfaceDef: {
return Type(VoidType);
}
@ -930,7 +990,7 @@ type_t *get_type(env_t *env, ast_t *ast)
bool is_discardable(env_t *env, ast_t *ast)
{
switch (ast->tag) {
case UpdateAssign: case Assign: case Declare: case FunctionDef: case StructDef: case EnumDef: case LangDef: case Use:
case UpdateAssign: case Assign: case Declare: case FunctionDef: case StructDef: case EnumDef: case LangDef: case InterfaceDef: case Use:
return true;
default: break;
}

41
types.c
View File

@ -45,6 +45,9 @@ CORD type_to_cord(type_t *t) {
auto struct_ = Match(t, StructType);
return struct_->name;
}
case InterfaceType: {
return Match(t, InterfaceType)->name;
}
case PointerType: {
auto ptr = Match(t, PointerType);
CORD sigil = ptr->is_stack ? "&" : "@";
@ -213,6 +216,7 @@ bool has_heap_memory(type_t *t)
}
return false;
}
case InterfaceType: return true;
default: return false;
}
}
@ -289,6 +293,7 @@ bool can_leave_uninitialized(type_t *t)
}
return true;
}
case InterfaceType: return false;
default: return false;
}
}
@ -316,6 +321,13 @@ static bool _can_have_cycles(type_t *t, table_t *seen)
}
return false;
}
case InterfaceType: {
for (arg_t *field = Match(t, InterfaceType)->fields; field; field = field->next) {
if (_can_have_cycles(field->type, seen))
return true;
}
return false;
}
default: return false;
}
}
@ -362,6 +374,13 @@ type_t *replace_type(type_t *t, type_t *target, type_t *replacement)
Match((struct type_s*)t, EnumType)->tags = tags;
return t;
}
case InterfaceType: {
auto interface = Match(t, InterfaceType);
arg_t *fields = LIST_MAP(interface->fields, field, .type=replace_type(field->type, target, replacement));
t = COPY(t);
Match((struct type_s*)t, InterfaceType)->fields = fields;
return t;
}
default: return t;
}
#undef COPY
@ -382,9 +401,10 @@ size_t type_size(type_t *t)
case FunctionType: return sizeof(void*);
case ClosureType: return sizeof(struct {void *fn, *userdata;});
case PointerType: return sizeof(void*);
case StructType: {
size_t size = 0;
for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
case StructType: case InterfaceType: {
arg_t *fields = t->tag == StructType ? Match(t, StructType)->fields : Match(t, InterfaceType)->fields;
size_t size = t->tag == StructType ? 0 : sizeof(void*);
for (arg_t *field = fields; field; field = field->next) {
type_t *field_type = field->type;
if (field_type->tag == BoolType) {
size += 1; // Bit packing
@ -432,9 +452,10 @@ size_t type_align(type_t *t)
case FunctionType: return __alignof__(void*);
case ClosureType: return __alignof__(struct {void *fn, *userdata;});
case PointerType: return __alignof__(void*);
case StructType: {
size_t align = 0;
for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
case StructType: case InterfaceType: {
arg_t *fields = t->tag == StructType ? Match(t, StructType)->fields : Match(t, InterfaceType)->fields;
size_t align = t->tag == StructType ? 0 : sizeof(void*);
for (arg_t *field = fields; field; field = field->next) {
size_t field_align = type_align(field->type);
if (field_align > align) align = field_align;
}
@ -466,6 +487,14 @@ type_t *get_field_type(type_t *t, const char *field_name)
}
return NULL;
}
case InterfaceType: {
auto interface = Match(t, InterfaceType);
for (arg_t *field = interface->fields; field; field = field->next) {
if (streq(field->name, field_name))
return field->type;
}
return NULL;
}
case EnumType: {
auto e = Match(t, EnumType);
for (tag_t *tag = e->tags; tag; tag = tag->next) {

7
types.h
View File

@ -52,6 +52,7 @@ struct type_s {
PointerType,
StructType,
EnumType,
InterfaceType,
TypeInfoType,
ModuleType,
} tag;
@ -98,6 +99,12 @@ struct type_s {
bool opaque;
struct env_s *env;
} EnumType;
struct {
const char *name, *type_parameter;
arg_t *fields;
bool opaque;
struct env_s *env;
} InterfaceType;
struct {
const char *name;
type_t *type;