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

Initial pass at namespacing

Browse Source
This commit is contained in:
Bruce Hill 2024-03-03 13:04:50 -05:00
parent 4dc70c84d4
commit ec7a9e5f10
10 changed files with 86 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
builtins/integers.h
View File

@ -43,7 +43,6 @@ DEFINE_INT_TYPE(int8_t, Int8);
#define Int__hex Int64__hex
#define Int__octal Int64__octal
#define Int__random Int64__random
#define Int_namespace_t Int64_namespace_t
#define Int Int64
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

19
compile.c
View File

@ -609,15 +609,21 @@ CORD compile(env_t *env, ast_t *ast)
if (ast->tag == FunctionCall) {
auto call = Match(ast, FunctionCall);
fn_t = get_type(env, call->fn);
if (fn_t->tag != FunctionType)
if (fn_t->tag == TypeInfoType) {
type_t *t = Match(fn_t, TypeInfoType)->type;
if (!(t->tag == StructType))
code_err(call->fn, "This is not a type that has a constructor");
fn_t = Type(FunctionType, .args=Match(t, StructType)->fields, .ret=t);
} else if (fn_t->tag != FunctionType) {
code_err(call->fn, "This is not a function, it's a %T", fn_t);
}
args = call->args;
fn = compile(env, call->fn);
} else {
auto method = Match(ast, MethodCall);
fn_t = get_method_type(env, method->self, method->name);
args = new(arg_ast_t, .value=method->self, .next=method->args);
binding_t *b = get_method_binding(env, method->self, method->name);
binding_t *b = get_namespace_binding(env, method->self, method->name);
if (!b) code_err(ast, "No such method");
fn = b->code;
}
@ -902,6 +908,15 @@ CORD compile(env_t *env, ast_t *ast)
type_t *fielded_t = get_type(env, f->fielded);
type_t *value_t = value_type(fielded_t);
switch (value_t->tag) {
case TypeInfoType: {
auto info = Match(value_t, TypeInfoType);
table_t *namespace = Table_str_get(env->type_namespaces, info->name);
if (!namespace) code_err(f->fielded, "I couldn't find a namespace for this type");
binding_t *b = Table_str_get(namespace, f->field);
if (!b) code_err(ast, "I couldn't find the field '%s' on this type", f->field);
if (!b->code) code_err(ast, "I couldn't figure out how to compile this field");
return b->code;
}
case StructType: {
for (arg_t *field = Match(value_t, StructType)->fields; field; field = field->next) {
if (streq(field->name, f->field)) {

9
enums.c
View File

@ -95,8 +95,7 @@ void compile_enum_def(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD_appendf(&env->code->typedefs, "typedef struct %s_s %s_t;\n", def->name, def->name);
CORD_appendf(&env->code->typedefs, "typedef struct { TypeInfo type; } %s_namespace_t;\n", def->name);
CORD_appendf(&env->code->typedefs, "extern %s_namespace_t %s;\n", def->name, def->name);
CORD_appendf(&env->code->typedefs, "extern const TypeInfo %s;\n", def->name);
CORD enum_def = CORD_all("struct ", def->name, "_s {\n"
"\tenum {");
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
@ -108,14 +107,14 @@ void compile_enum_def(env_t *env, ast_t *ast)
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
compile_struct_def(env, WrapAST(ast, StructDef, .name=heap_strf("%s$%s", def->name, tag->name), .fields=tag->fields));
enum_def = CORD_all(enum_def, def->name, "$", tag->name, "_t ", tag->name, ";\n");
CORD_appendf(&env->code->typedefs, "#define %s__%s(...) ((%s_t){$tag$%s$%s, .%s={__VA_ARGS__}})\n",
CORD_appendf(&env->code->typedefs, "#define %s$tagged$%s(...) ((%s_t){$tag$%s$%s, .%s={__VA_ARGS__}})\n",
def->name, tag->name, def->name, def->name, tag->name, tag->name);
}
enum_def = CORD_cat(enum_def, "};\n};\n");
env->code->typecode = CORD_cat(env->code->typecode, enum_def);
type_t *t = Table_str_get(env->types, def->name);
CORD typeinfo = CORD_asprintf("public %s_namespace_t %s = {{%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
CORD typeinfo = CORD_asprintf("public const TypeInfo %s = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
def->name, def->name, type_size(t), type_align(t));
env->code->funcs = CORD_all(
@ -129,7 +128,7 @@ void compile_enum_def(env_t *env, ast_t *ast)
".equal=(void*)", def->name, "__equal, "
".hash=(void*)", def->name, "__hash, "
".compare=(void*)", def->name, "__compare");
typeinfo = CORD_cat(typeinfo, "}}}};\n");
typeinfo = CORD_cat(typeinfo, "}}};\n");
env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);
}

21
environment.c
View File

@ -72,7 +72,7 @@ env_t *new_compilation_unit(void)
};
for (size_t i = 0; i < sizeof(global_types)/sizeof(global_types[0]); i++) {
binding_t *binding = new(binding_t, .type=Type(TypeInfoType));
binding_t *binding = new(binding_t, .type=Type(TypeInfoType, .name=global_types[i].name, .type=global_types[i].type));
Table_str_set(env->globals, global_types[i].name, binding);
Table_str_set(env->types, global_types[i].name, global_types[i].type);
}
@ -104,7 +104,7 @@ binding_t *get_binding(env_t *env, const char *name)
return Table_str_get(env->locals, name);
}
binding_t *get_method_binding(env_t *env, ast_t *self, const char *name)
binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name)
{
type_t *self_type = get_type(env, self);
if (!self_type)
@ -121,11 +121,18 @@ binding_t *get_method_binding(env_t *env, ast_t *self, const char *name)
table_t *ns = Table_str_get(env->type_namespaces, "Str");
return Table_str_get(ns, name);
}
case StructType: case EnumType: {
errx(1, "Struct/enum methods not implemented");
// const char *name = cls_type->tag == StructType ? Match(cls_type, StructType)->name : Match(cls_type, EnumType)->name;
// table_t *namespace = Table_str_get(env->type_namespaces, name);
// if (!name)
case TypeInfoType: case StructType: case EnumType: {
const char *name;
switch (cls_type->tag) {
case TypeInfoType: name = Match(cls_type, TypeInfoType)->name; break;
case StructType: name = Match(cls_type, StructType)->name; break;
case EnumType: name = Match(cls_type, EnumType)->name; break;
default: errx(1, "Unreachable");
}
table_t *namespace = Table_str_get(env->type_namespaces, name);
if (!namespace) return NULL;
return Table_str_get(namespace, name);
}
default: break;
}

2
environment.h
View File

@ -32,7 +32,7 @@ __attribute__((noreturn))
void compiler_err(file_t *f, const char *start, const char *end, const char *fmt, ...);
binding_t *get_binding(env_t *env, const char *name);
void set_binding(env_t *env, const char *name, binding_t *binding);
binding_t *get_method_binding(env_t *env, ast_t *self, const char *name);
binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name);
#define code_err(ast, ...) compiler_err((ast)->file, (ast)->start, (ast)->end, __VA_ARGS__)
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

9
structs.c
View File

@ -137,12 +137,11 @@ void compile_struct_def(env_t *env, ast_t *ast)
CORD_appendf(&env->code->typecode, "};\n");
// Typeinfo:
CORD_appendf(&env->code->typedefs, "typedef struct { TypeInfo type; } %s_namespace_t;\n", def->name);
CORD_appendf(&env->code->typedefs, "extern %s_namespace_t %s;\n", def->name, def->name);
CORD_appendf(&env->code->typedefs, "extern const TypeInfo %s;\n", def->name);
type_t *t = Table_str_get(env->types, def->name);
CORD typeinfo = CORD_asprintf("public %s_namespace_t %s = {{%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
def->name, def->name, type_size(t), type_align(t));
CORD typeinfo = CORD_asprintf("public const TypeInfo %s = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
def->name, type_size(t), type_align(t));
typeinfo = CORD_all(typeinfo, ".as_str=(void*)", def->name, "__as_str, ");
env->code->funcs = CORD_all(env->code->funcs, compile_str_method(env, ast));
@ -156,7 +155,7 @@ void compile_struct_def(env_t *env, ast_t *ast)
".hash=(void*)", def->name, "__hash, "
".compare=(void*)", def->name, "__compare");
}
typeinfo = CORD_cat(typeinfo, "}}}};\n");
typeinfo = CORD_cat(typeinfo, "}}};\n");
env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);
}

73
typecheck.c
View File

@ -110,6 +110,10 @@ void bind_statement(env_t *env, ast_t *statement)
}
case StructDef: {
auto def = Match(statement, StructDef);
table_t *namespace = new(table_t);
Table_str_set(env->type_namespaces, def->name, namespace);
arg_t *fields = NULL;
type_t *type = Type(StructType, .name=def->name, .fields=fields); // placeholder
for (arg_ast_t *field_ast = def->fields; field_ast; field_ast = field_ast->next) {
@ -119,15 +123,19 @@ void bind_statement(env_t *env, ast_t *statement)
REVERSE_LIST(fields);
type->__data.StructType.fields = fields; // populate placeholder
Table_str_set(env->types, def->name, type);
// TODO: bind body members
if (!type) code_err(statement, "I couldn't get this type");
type_t *constructor_t = Type(FunctionType, .args=Match(type, StructType)->fields, .ret=type);
Table_str_set(env->globals, def->name, new(binding_t, .type=constructor_t));
type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type);
Table_str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
break;
}
case EnumDef: {
auto def = Match(statement, EnumDef);
table_t *namespace = new(table_t);
Table_str_set(env->type_namespaces, def->name, namespace);
tag_t *tags = NULL;
type_t *type = Type(EnumType, .name=def->name, .tags=tags); // placeholder
for (tag_ast_t *tag_ast = def->tags; tag_ast; tag_ast = tag_ast->next) {
@ -144,12 +152,16 @@ void bind_statement(env_t *env, ast_t *statement)
type->__data.EnumType.tags = tags;
for (tag_t *tag = tags; tag; tag = tag->next) {
const char *name = heap_strf("%s__%s", def->name, tag->name);
type_t *constructor_t = Type(FunctionType, .args=Match(tag->type, StructType)->fields, .ret=type);
Table_str_set(env->globals, name, new(binding_t, .type=constructor_t));
Table_str_set(namespace, tag->name, new(binding_t, .type=constructor_t, .code=CORD_all(def->name, "$tagged$", tag->name)));
Table_str_set(env->types, heap_strf("%s$%s", def->name, tag->name), tag->type);
}
Table_str_set(env->types, def->name, type);
type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type);
Table_str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
// TODO: bind body members
break;
}
default: break;
@ -179,7 +191,7 @@ type_t *get_method_type(env_t *env, ast_t *self, const char *name)
type_t *self_type = get_type(env, self);
if (!self_type)
code_err(self, "I couldn't get this type");
binding_t *b = get_method_binding(env, self, name);
binding_t *b = get_namespace_binding(env, self, name);
if (!b || !b->type)
code_err(self, "No such method: %s", name);
return b->type;
@ -314,6 +326,14 @@ type_t *get_type(env_t *env, ast_t *ast)
case FieldAccess: {
auto access = Match(ast, FieldAccess);
type_t *fielded_t = get_type(env, access->fielded);
if (fielded_t->tag == TypeInfoType) {
auto info = Match(fielded_t, TypeInfoType);
table_t *namespace = Table_str_get(env->type_namespaces, info->name);
if (!namespace) code_err(access->fielded, "I couldn't find a namespace for this type");
binding_t *b = Table_str_get(namespace, access->field);
if (!b) code_err(ast, "I couldn't find the field '%s' on this type", access->field);
return b->type;
}
type_t *field_t = get_field_type(fielded_t, access->field);
if (!field_t)
code_err(ast, "%T objects don't have a field called '%s'", fielded_t, access->field);
@ -357,6 +377,13 @@ type_t *get_type(env_t *env, ast_t *ast)
type_t *fn_type_t = get_type(env, call->fn);
if (!fn_type_t)
code_err(call->fn, "I couldn't find this function");
if (fn_type_t->tag == TypeInfoType) {
type_t *t = Match(fn_type_t, TypeInfoType)->type;
if (t->tag == StructType)
return t; // Constructor
code_err(call->fn, "This is not a type that has a constructor");
}
if (fn_type_t->tag != FunctionType)
code_err(call->fn, "This isn't a function, it's a %T", fn_type_t);
auto fn_type = Match(fn_type_t, FunctionType);
@ -676,24 +703,15 @@ bool is_discardable(env_t *env, ast_t *ast)
return (t->tag == VoidType || t->tag == AbortType);
}
type_t *get_namespace_type(env_t *env, ast_t *namespace_ast, type_t *type)
type_t *get_file_type(env_t *env, const char *path)
{
arg_t *ns_fields = NULL;
if (type) {
ns_fields = new(arg_t, .name="type", .type=Type(TypeInfoType), .next=ns_fields);
if (type->tag == EnumType) {
// Add enum constructors:
auto enum_ = Match(type, EnumType);
for (tag_t *tag = enum_->tags; tag; tag = tag->next) {
type_t *constructor_t = Type(FunctionType, .args=Match(tag->type, StructType)->fields,
.ret=type);
ns_fields = new(arg_t, .name=tag->name, .type=constructor_t, .next=ns_fields);
}
}
}
// auto info = get_file_info(env, path);
file_t *f = load_file(path);
ast_t *ast = parse_file(f, NULL);
if (!ast) compiler_err(NULL, NULL, NULL, "Couldn't parse file: %s", path);
for (ast_list_t *stmts = Match(namespace_ast, Block)->statements; stmts; stmts = stmts->next) {
arg_t *ns_fields = NULL;
for (ast_list_t *stmts = Match(ast, Block)->statements; stmts; stmts = stmts->next) {
ast_t *stmt = stmts->ast;
doctest_inner:
switch (stmt->tag) {
@ -717,16 +735,7 @@ type_t *get_namespace_type(env_t *env, ast_t *namespace_ast, type_t *type)
default: break;
}
}
return Type(StructType, .fields=ns_fields);
}
type_t *get_file_type(env_t *env, const char *path)
{
// auto info = get_file_info(env, path);
file_t *f = load_file(path);
ast_t *ast = parse_file(f, NULL);
if (!ast) compiler_err(NULL, NULL, NULL, "Couldn't parse file: %s", path);
return get_namespace_type(env, ast, NULL);
return Type(StructType, .name=path, .fields=ns_fields);
}
type_t *get_arg_ast_type(env_t *env, arg_ast_t *arg)

1
typecheck.h
View File

@ -12,7 +12,6 @@ type_t *get_type(env_t *env, ast_t *ast);
void bind_statement(env_t *env, ast_t *statement);
type_t *get_math_type(env_t *env, ast_t *ast, type_t *lhs_t, type_t *rhs_t);
bool is_discardable(env_t *env, ast_t *ast);
type_t *get_namespace_type(env_t *env, ast_t *namespace_ast, type_t *type);
type_t *get_file_type(env_t *env, const char *path);
type_t *get_function_def_type(env_t *env, ast_t *ast);
type_t *get_arg_type(env_t *env, arg_t *arg);

2
types.c
View File

@ -53,7 +53,7 @@ CORD type_to_cord(type_t *t) {
return tagged->name;
}
case TypeInfoType: {
return "TypeInfo";
return CORD_all("TypeInfo(", Match(t, TypeInfoType)->name, ")");
}
default: {
raise(SIGABRT);

5
types.h
View File

@ -85,7 +85,10 @@ struct type_s {
const char *name;
tag_t *tags;
} EnumType;
struct {} TypeInfoType;
struct {
const char *name;
type_t *type;
} TypeInfoType;
} __data;
};