got rid of packages.

17 files changed, 58 insertions, 1767 deletions

diff --git a/build.sh b/build.sh
index 1dac15c..6dadf63 100755
--- a/build.sh
+++ b/build.sh
@@ -27,7 +27,7 @@ if [ "$1" = "" ]; then
 	fi
 fi
 
-DEBUG_FLAGS="-O0 -g3 -pipe $WARNINGS -std=c11 -DTOC_DEBUG"
+DEBUG_FLAGS="-O0 -no-pie -gdwarf-2 -pipe $WARNINGS -std=c11 -DTOC_DEBUG"
 RELEASE_FLAGS="-O3 -s -DNDEBUG $WARNINGS -std=c11"
 
 if [ "$1" = "release" ]; then
diff --git a/cgen.c b/cgen.c
index f11a94a..4c86f63 100644
--- a/cgen.c
+++ b/cgen.c
@@ -12,7 +12,6 @@ static void cgen_create(CGenerator *g, FILE *out, Identifiers *ids, Evaluator *e
 	g->indent_lvl = 0;
 	g->idents = ids;
 	g->allocr = allocr;
-	g->exptr = ev->typer->exptr;
 }
 
 static bool cgen_stmt(CGenerator *g, Statement *s);
@@ -62,7 +61,6 @@ static bool cgen_defs_decl(CGenerator *g, Declaration *d);
 	case EXPR_LITERAL_STR:												\
 	case EXPR_LITERAL_CHAR:												\
 	case EXPR_LITERAL_FLOAT:											\
-	case EXPR_PKG:														\
 	break;																\
 	case EXPR_UNARY_OP:													\
 	if (!f(g, e->unary.of)) return false;								\
@@ -288,13 +286,6 @@ static inline void cgen_ident_simple(CGenerator *g, Identifier i) {
 }
 
 static void cgen_ident(CGenerator *g, Identifier i) {
-	IdentDecl *idecl = ident_decl(i);
-	if (idecl && idecl->kind == IDECL_DECL && (idecl->decl->flags & DECL_EXPORT)) {
-		assert(g->pkg_prefix);
-		cgen_write(g, "%s__", g->pkg_prefix);
-	} else if (i->from_pkg) {
-		cgen_write(g, "%s__", i->from_pkg->c.prefix);
-	}
 	if (i == g->main_ident) {
 		/* don't conflict with C's main! */
 		cgen_write(g, "main__");
@@ -338,7 +329,6 @@ static bool cgen_type_pre(CGenerator *g, Type *t, Location where) {
 		case BUILTIN_F32: cgen_write(g, "f32"); break;
 		case BUILTIN_F64: cgen_write(g, "f64"); break;
 		case BUILTIN_TYPE:
-		case BUILTIN_PKG:
 			assert(0); break;
 		} break;
 	case TYPE_PTR:
@@ -772,7 +762,6 @@ static bool cgen_set_tuple(CGenerator *g, Expression *exprs, Identifier *idents,
 	case EXPR_C:
 	case EXPR_BUILTIN:
 	case EXPR_TYPE:
-	case EXPR_PKG:
 		assert(0);
 		return false;
 	}
@@ -1241,7 +1230,6 @@ static bool cgen_expr_pre(CGenerator *g, Expression *e) {
 	case EXPR_FN:
 	case EXPR_C:
 	case EXPR_TYPE:
-	case EXPR_PKG:
 		break;
 	}
 	return true;
@@ -1373,19 +1361,14 @@ static bool cgen_expr(CGenerator *g, Expression *e) {
 			handled = true;
 			break;
 		case BINARY_DOT: {
-			if (type_is_builtin(&e->binary.lhs->type, BUILTIN_PKG)) {
-				assert(e->binary.lhs->kind == EXPR_VAL);
-				cgen_ident(g, e->binary.dot.pkg_ident);
-				handled = true;
-			} else {
-				cgen_write(g, "(");
-				cgen_expr(g, e->binary.lhs);
-				bool is_ptr = e->binary.lhs->type.kind == TYPE_PTR;
-				cgen_write(g, is_ptr ? "->" :".");
-				cgen_ident_simple(g, e->binary.dot.field->name);
-				cgen_write(g, ")");
-				handled = true;
-			}
+
+			cgen_write(g, "(");
+			cgen_expr(g, e->binary.lhs);
+			bool is_ptr = e->binary.lhs->type.kind == TYPE_PTR;
+			cgen_write(g, is_ptr ? "->" :".");
+			cgen_ident_simple(g, e->binary.dot.field->name);
+			cgen_write(g, ")");
+			handled = true;
 		} break;
 		}
 		if (handled) break;
@@ -1586,7 +1569,6 @@ static bool cgen_expr(CGenerator *g, Expression *e) {
 		   a tuple, e.g. 3, 5;, but we've errored about that before
 		*/
 	case EXPR_TYPE:
-	case EXPR_PKG:
 		assert(0);
 		break;
 	case EXPR_FN: {
@@ -1863,7 +1845,6 @@ static bool cgen_val_ptr(CGenerator *g, void *v, Type *t, Location where) {
 		case BUILTIN_CHAR: cgen_write(g, "'\\x%02x'", *(char *)v); break;
 		case BUILTIN_BOOL: cgen_write(g, "%s", *(bool *)v ? "true" : "false"); break;
 		case BUILTIN_TYPE:
-		case BUILTIN_PKG:
 			assert(0);
 			break;
 		}
@@ -2071,18 +2052,6 @@ static bool cgen_defs_expr(CGenerator *g, Expression *e) {
 	if (e->kind == EXPR_FN) {
 	    if (!cgen_defs_fn(g, e->fn, &e->type))
 			return false;
-	} else if (e->kind == EXPR_BINARY_OP) {
-		if (e->binary.op == BINARY_DOT && type_is_builtin(&e->binary.lhs->type, BUILTIN_PKG)
-			&& e->type.kind == TYPE_FN) {
-			Identifier ident = e->binary.dot.pkg_ident;
-			Declaration *d = ident_decl(ident)->decl;
-			FnExpr *f = (d->flags & DECL_FOUND_VAL) ? d->val.fn : d->expr.fn;
-			if (fn_has_any_const_params(f)) {
-				/* define instances */
-				if (!cgen_defs_fn(g, f, &e->type))
-					return false;
-			}
-		}
 	}
 	cgen_recurse_subexprs(g, e, cgen_defs_expr, cgen_defs_block, cgen_defs_decl);
 	return true;
@@ -2138,7 +2107,6 @@ static bool cgen_file(CGenerator *g, ParsedFile *f) {
 	g->block = NULL;
 	g->fn = NULL;
 	g->file = f;
-	g->pkg_prefix = g->evalr->typer->pkg_name;
 
 	/* 
 	   TODO: don't include stdio.h with posix file descriptors
@@ -2168,8 +2136,7 @@ static bool cgen_file(CGenerator *g, ParsedFile *f) {
 	if (!cgen_decls_file(g, f))
 		return false;
 	cgen_write(g, "/* code */\n");
-	if (!f->pkg_name)
-		cgen_write(g, "int main() {\n\tmain__();\n\treturn 0;\n}\n\n");
+	cgen_write(g, "int main() {\n\tmain__();\n\treturn 0;\n}\n\n");
 	arr_foreach(f->stmts, Statement, s) {
 		if (!cgen_defs_stmt(g, s))
 			return false;
diff --git a/copy.c b/copy.c
index 0a034f6..02c23e4 100644
--- a/copy.c
+++ b/copy.c
@@ -265,9 +265,6 @@ static void copy_expr(Copier *c, Expression *out, Expression *in) {
 		if (sin->to)
 			sout->to = copy_expr_(c, sin->to);
 	} break;
-	case EXPR_PKG:
-		out->pkg.name_expr = copy_expr_(c, in->pkg.name_expr);
-		break;
 	case EXPR_TYPE:
 		copy_type(c, &out->typeval, &in->typeval);
 		break;
diff --git a/decls_cgen.c b/decls_cgen.c
index b0382b5..c62b02f 100644
--- a/decls_cgen.c
+++ b/decls_cgen.c
@@ -113,59 +113,6 @@ static bool cgen_decls_expr(CGenerator *g, Expression *e) {
 		Type *lhs_type = &e->binary.lhs->type;
 		if (lhs_type->kind == TYPE_PTR)
 			lhs_type = lhs_type->ptr;
-		if (e->binary.op == BINARY_DOT && type_is_builtin(lhs_type, BUILTIN_PKG)) {
-			Identifier ident = e->binary.dot.pkg_ident;
-			IdentDecl *idecl = ident_decl(ident);
-			assert(idecl);
-			assert(idecl->kind == IDECL_DECL);
-			Declaration *d = idecl->decl;
-			if (e->type.kind == TYPE_FN) {
-				FnExpr *f = NULL;
-				if (d->flags & DECL_FOUND_VAL)
-					f = d->val.fn;
-				else if (d->expr.kind == EXPR_FN)
-					f = d->expr.fn;
-				if (f) {
-					if (fn_has_any_const_params(f)) {
-						/* declare the instances */
-						f->c.name = ident;
-						if (!cgen_fn_decl(g, f, &e->type))
-							return false;
-					} else {
-						bool out_param = cgen_uses_ptr(&f->ret_type);
-						/* extern function declaration */
-						cgen_write(g, "extern ");
-						if (out_param) {
-							cgen_write(g, "void");
-						} else {
-							if (!cgen_type_pre(g, &f->ret_type, e->where))
-								return false;
-						}
-						cgen_write(g, " ");
-						cgen_ident(g, ident);
-						if (!cgen_fn_args(g, f, 0, 0))
-							return false;
-						if (!out_param) {
-							if (!cgen_type_post(g, &f->ret_type, e->where))
-								return false;
-						}
-						cgen_write(g, ";");
-						cgen_nl(g);
-					}
-					break;
-				}
-			}
-			/* extern variable declaration */
-			cgen_write(g, "extern ");
-			if (!cgen_type_pre(g, &e->type, e->where))
-				return false;
-			cgen_write(g, " ");
-			cgen_ident(g, ident);
-			if (!cgen_type_post(g, &e->type, e->where))
-				return false;
-			cgen_write(g, ";");
-			cgen_nl(g);
-		}
 	} break;
 	default:
 		break;
diff --git a/eval.c b/eval.c
index 32804e0..8019f4f 100644
--- a/eval.c
+++ b/eval.c
@@ -53,7 +53,6 @@ static size_t compiler_sizeof_builtin(BuiltinType b) {
 	case BUILTIN_CHAR: return sizeof(char); /* = 1 */
 	case BUILTIN_BOOL: return sizeof(bool);
 	case BUILTIN_TYPE: return sizeof(Type *);
-	case BUILTIN_PKG: return sizeof(Package *);
 	}
 	assert(0);
 	return 0;
@@ -162,7 +161,6 @@ static bool builtin_truthiness(Value *v, BuiltinType b) {
 	case BUILTIN_BOOL: return v->boolv;
 	case BUILTIN_CHAR: return v->charv != 0;
 	case BUILTIN_TYPE:
-	case BUILTIN_PKG:
 		break;
 	}
 	assert(0); return false;
@@ -300,10 +298,6 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) {
 		case BUILTIN_F64: fprintf(f, F64_FMT, *(F64 *)p); break;
 		case BUILTIN_CHAR: fprint_char_literal(f, *(char *)p); break;
 		case BUILTIN_BOOL: fprintf(f, "%s", *(bool *)p ? "true" : "false"); break;
-		case BUILTIN_PKG: {
-			Package *pkg = *(Package **)p;
-			fprintf(f, "<package at %p>", (void *)pkg);
-		} break;
 		case BUILTIN_TYPE:
 			fprint_type(f, *(Type **)p);
 			break;
@@ -434,7 +428,7 @@ static void val_free(Value *v, Type *t) {
 		builtin_casts_to_num(low);							\
 	case BUILTIN_CHAR: vout->charv = (char)vin->low; break;	\
 	case BUILTIN_BOOL: vout->boolv = vin->low != 0; break;	\
-	case BUILTIN_PKG: case BUILTIN_TYPE: assert(0); break;	\
+	case BUILTIN_TYPE: assert(0); break;					\
 	} break
 
 #define builtin_float_casts(low, up)							\
@@ -443,7 +437,7 @@ static void val_free(Value *v, Type *t) {
 		builtin_casts_to_num(low);								\
 	case BUILTIN_BOOL: vout->boolv = vin->low != 0.0f; break;	\
 	case BUILTIN_CHAR:											\
-	case BUILTIN_PKG: case BUILTIN_TYPE:						\
+	case BUILTIN_TYPE:											\
 		assert(0); break;										\
 	} break
 	
@@ -473,12 +467,10 @@ static void val_builtin_cast(Value *vin, BuiltinType from, Value *vout, BuiltinT
 		case BUILTIN_F64:
 		case BUILTIN_BOOL:
 		case BUILTIN_TYPE:
-		case BUILTIN_PKG:
 			assert(0); break;
 		}
 		break;
 	case BUILTIN_TYPE:
-	case BUILTIN_PKG:
 		assert(0);
 		break;
 	}
@@ -554,7 +546,6 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) {
 			case BUILTIN_F32:
 			case BUILTIN_F64:
 			case BUILTIN_TYPE:
-			case BUILTIN_PKG:
 				assert(0); break;
 			}
 			break;
@@ -629,9 +620,6 @@ static void eval_deref(Value *v, void *ptr, Type *type) {
 		case BUILTIN_TYPE:
 			v->type = *(Type **)ptr;
 			break;
-		case BUILTIN_PKG:
-			v->pkg = *(Package **)ptr;
-			break;
 		}
 		break;
 	case TYPE_SLICE:
@@ -670,9 +658,6 @@ static void eval_deref_set(void *set, Value *to, Type *type) {
 		case BUILTIN_TYPE:
 			*(Type **)set = to->type;
 			break;
-		case BUILTIN_PKG:
-			*(Package **)set = to->pkg;
-			break;
 		}
 		break;
 	case TYPE_SLICE:
@@ -747,7 +732,11 @@ static void *eval_ptr_to_struct_field(Evaluator *ev, Expression *dot_expr) {
 		return NULL;
 	void *struc_data;
 	if (is_ptr) {
-		struc_data = *(void **)struc.ptr;
+		struc_data = struc.ptr;
+		if (struc_data == NULL) {
+			err_print(dot_expr->where, "Attempt to dereference NULL pointer.");
+			return false;
+		}
 	} else {
 		struc_data = struc.struc;
 	}
@@ -936,7 +925,7 @@ static void eval_numerical_bin_op(Value lhs, Type *lhs_type, BinaryOp op, Value
 		val_cast(&lhs, lhs_type, &lhs, cast_to);				\
 		val_cast(&rhs, rhs_type, &rhs, cast_to);				\
 		assert(lhs_type->kind == TYPE_BUILTIN);					\
-		switch (builtin) {										\
+		switch (cast_to->builtin) {								\
 			eval_binary_bool_op_nums(builtin, op);				\
 		default:												\
 			assert(!("Invalid builtin to "#op)[0]); break;		\
@@ -1181,11 +1170,6 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) {
 			if (!eval_expr(ev, rhs_expr, &rhs)) return false;
 		switch (e->binary.op) {
 		case BINARY_DOT: {
-			if (type_is_builtin(&lhs_expr->type, BUILTIN_PKG)) {
-				if (!eval_ident(ev, e->binary.dot.pkg_ident, v, rhs_expr->where))
-					return false;
-				break;
-			}
 			void *ptr = eval_ptr_to_struct_field(ev, e);
 			if (!ptr) return false;
 			eval_deref(v, ptr, &e->type);
@@ -1316,7 +1300,6 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) {
 					boolt.builtin = BUILTIN_BOOL;
 					Value cont;
 					eval_numerical_bin_op(lhs, &fo->type, step_is_negative ? BINARY_GE : BINARY_LE, rhs, &fo->range.to->type, &cont, &boolt);
-					
 					if (!cont.boolv) break;
 				}
 				if (value_val) *value_val = x;
@@ -1447,8 +1430,9 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) {
 			fn = &e->call.instance->fn;
 		} else {
 			Value fnv;
-			if (!eval_expr(ev, e->call.fn, &fnv))
+			if (!eval_expr(ev, e->call.fn, &fnv)) {
 				return false;
+			}
 			fn = fnv.fn;
 		}
 		if (fn->flags & FN_EXPR_FOREIGN) {
@@ -1464,11 +1448,10 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) {
 				return false;
 			break;
 		}
-		
 		/* make sure function body is typed before calling it */
-		if (!types_block(ev->typer, &fn->body))
+		if (!types_block(ev->typer, &fn->body)) {
 			return false;
-
+		}
 		/* NOTE: we're not calling fn_enter because we're manually entering the function */
 		
 		/* set parameter values */
@@ -1607,9 +1590,6 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) {
 	case EXPR_VAL:
 		*v = e->val;
 		break;
-	case EXPR_PKG:
-		assert(0);
-		break;
 	}
 	return true;
 }
diff --git a/foreign.c b/foreign.c
index a5b63e7..b55a908 100644
--- a/foreign.c
+++ b/foreign.c
@@ -139,9 +139,6 @@ static bool arg_list_start(av_alist *arg_list, void (*fn)(), Value *return_val,
 		case BUILTIN_TYPE:
 			av_start_ptr(*arg_list, fn, Type *, &return_val->type);
 			break;
-		case BUILTIN_PKG:
-			av_start_ptr(*arg_list, fn, Package *, &return_val->pkg);
-			break;
 		}
 		break;
 	case TYPE_STRUCT: {
@@ -237,9 +234,6 @@ static bool arg_list_add(av_alist *arg_list, Value *val, Type *type, Location wh
 		case BUILTIN_BOOL:
 			av_uchar(*arg_list, val->boolv);
 			break;
-		case BUILTIN_PKG:
-			av_ptr(*arg_list, Package *, val->pkg);
-			break;
 		case BUILTIN_TYPE:
 			av_ptr(*arg_list, Type *, val->type);
 			break;
diff --git a/instance_table.c b/instance_table.c
index f67b901..9527cec 100644
--- a/instance_table.c
+++ b/instance_table.c
@@ -142,10 +142,6 @@ static U64 val_ptr_hash(void *v, Type *t) {
 		case BUILTIN_BOOL: return (U64)*(bool *)v;
 		case BUILTIN_TYPE:
 			return type_hash(*(Type **)v);
-		case BUILTIN_PKG: {
-			Package *pkg = *(Package **)v;
-			return (U64)pkg;
-		} break;
 		}
 		assert(0);
 		return 0;
@@ -222,8 +218,6 @@ static bool val_ptr_eq(void *u, void *v, Type *t) {
 			bool ret = type_eq(*(Type **)u, *(Type **)v);
 			return ret;
 		}
-		case BUILTIN_PKG:
-			return *(Package **)u == *(Package **)v;
 		}
 		break;
 	case TYPE_VOID:
diff --git a/main.c b/main.c
index 311b967..496c3cc 100644
--- a/main.c
+++ b/main.c
@@ -100,13 +100,8 @@ int main(int argc, char **argv) {
 	
 	Typer tr;
 	Evaluator ev;
-	Exporter exptr = {0};
 	evalr_create(&ev, &tr, &main_allocr);
 	typer_create(&tr, &ev, &err_ctx, &main_allocr, &idents);
-#ifdef TOC_DEBUG
-	exptr.export_all_ident_names = true;
-#endif
-	tr.exptr = &exptr;
 	
 	if (!block_enter(NULL, f.stmts, SCOPE_CHECK_REDECL)) /* enter global scope */
 		return EXIT_FAILURE;
diff --git a/package.c b/package.c
deleted file mode 100644
index 42ab5bf..0000000
--- a/package.c
+++ /dev/null
@@ -1,1353 +0,0 @@
-/*
-  Copyright (C) 2019, 2020 Leo Tenenbaum.
-  This file is part of toc. toc is distributed under version 3 of the GNU General Public License, without any warranty whatsoever.
-  You should have received a copy of the GNU General Public License along with toc. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#define TOP_FMT_VERSION 0
-
-static bool export_decl(Exporter *ex, Declaration *d);
-static bool export_block(Exporter *ex, Block *b);
-static bool export_expr(Exporter *ex, Expression *e);
-static bool export_fn(Exporter *ex, FnExpr *f);
-static bool import_footer(Importer *i);
-static void import_decl(Importer *im, Declaration *d);
-static void import_expr(Importer *im, Expression *e);
-static void import_block(Importer *im, Block *b);
-static FnExpr *import_fn(Importer *im);
-static void export_decl_external(Exporter *ex, Declaration *d);
-static inline Expression *import_expr_(Importer *im);
-static bool export_struct(Exporter *ex, StructDef *s);
-static StructDef *import_struct(Importer *im);
-
-
-static void exptr_create(Exporter *ex, FILE *out, const char *filename, ErrCtx *err_ctx) {
-	/* construct full filename */
-	ex->out = out;
-	ex->exporting_to.ctx = err_ctx;
-	ex->exporting_to.filename = filename;
-	ex->ident_id = 0;
-	ex->nexported_fns = 0;
-	ex->nexported_structs = 0;
-	ex->exported_idents = NULL;
-	ex->started = false;
-	ex->code = NULL;
-}
-
-static inline void *imptr_malloc(Importer *i, size_t n) {
-	return allocr_malloc(i->allocr, n);
-}
-
-static inline void *imptr_calloc(Importer *i, size_t n, size_t s) {
-	return allocr_calloc(i->allocr, n, s);
-}
-
-static inline void export_u8(Exporter *ex, U8 u8) {
-	write_u8(ex->out, u8);
-}
-static inline U8 import_u8(Importer *i) {
-	return read_u8(i->in);
-}
-static inline void export_i8(Exporter *ex, I8 i8) {
-	write_i8(ex->out, i8);
-}
-static inline I8 import_i8(Importer *i) {
-	return read_i8(i->in);
-}
-static inline void export_u16(Exporter *ex, U16 u16) {
-	write_u16(ex->out, u16);
-}
-static inline U16 import_u16(Importer *i) {
-	return read_u16(i->in);
-}
-static inline void export_i16(Exporter *ex, I16 i16) {
-	write_i16(ex->out, i16);
-}
-static inline I16 import_i16(Importer *i) {
-	return read_i16(i->in);
-}
-static inline void export_u32(Exporter *ex, U32 u32) {
-	write_u32(ex->out, u32);
-}
-static inline U32 import_u32(Importer *i) {
-	return read_u32(i->in);
-}
-static inline void export_i32(Exporter *ex, I32 i32) {
-	write_i32(ex->out, i32);
-}
-static inline I32 import_i32(Importer *i) {
-	return read_i32(i->in);
-}
-static inline void export_u64(Exporter *ex, U64 u64) {
-	write_u64(ex->out, u64);
-}
-static inline U64 import_u64(Importer *i) {
-	return read_u64(i->in);
-}
-static inline void export_i64(Exporter *ex, I64 i64) {
-	write_i64(ex->out, i64);
-}
-static inline I64 import_i64(Importer *i) {
-	return read_i64(i->in);
-}
-static inline void export_f32(Exporter *ex, F32 f32) {
-	write_f32(ex->out, f32);
-}
-static inline F32 import_f32(Importer *i) {
-	return read_f32(i->in);
-}
-static inline void export_f64(Exporter *ex, F64 f64) {
-	write_f64(ex->out, f64);
-}
-static inline F64 import_f64(Importer *i) {
-	return read_f64(i->in);
-}
-static inline void export_bool(Exporter *ex, bool b) {
-	write_bool(ex->out, b);
-}
-static inline bool import_bool(Importer *i) {
-	return read_bool(i->in);
-}
-static inline void export_char(Exporter *ex, char c) {
-	write_char(ex->out, c);
-}
-static inline char import_char(Importer *i) {
-	return read_char(i->in);
-}
-static inline void export_vlq(Exporter *ex, U64 x) {
-	write_vlq(ex->out, x);
-}
-static inline U64 import_vlq(Importer *i) {
-	return read_vlq(i->in);
-}
-static inline void export_len(Exporter *ex, size_t len) {
-	export_vlq(ex, (U64)len);
-}
-static inline size_t import_len(Importer *i) {
-	return (size_t)import_vlq(i);
-}
-
-
-static size_t import_arr_(Importer *im, void **arr, size_t sz) {
-	*arr = NULL;
-	size_t len = import_len(im);
-	arr_set_lena_(arr, len, sz, im->allocr);
-	return len;
-}
-/* 
-reads length and allocates an array of that length
-returns length 
-*/
-#define import_arr(im, arr) import_arr_(im, (void **)arr, sizeof **(arr))
-
-static inline void export_str(Exporter *ex, const char *str, size_t len) {
-#ifdef TOC_DEBUG
-	for (size_t i = 0; i < len; ++i)
-		export_char(ex, *str++);
-#else
-	fwrite(str, 1, len, ex->out);
-#endif
-}
-
-static inline char *import_str(Importer *i, size_t len) {
-	char *str = imptr_malloc(i, len+1);
-	str[len] = 0;
-	fread(str, 1, len, i->in);
-	return str;
-}
-
-static inline void export_cstr(Exporter *ex, const char *str) {
-	size_t len = strlen(str);
-	export_len(ex, len);
-	export_str(ex, str, len);
-}
-							   
-static inline char *import_cstr(Importer *i) {
-	size_t len = import_len(i);
-	return import_str(i, len);
-}
-
-
-static void export_location(Exporter *ex, Location where) {
-	/* for now, we only export the line */
-	export_vlq(ex, (U64)where.start->pos.line);
-}
-static Location import_location(Importer *im) {
-	Location l;
-	l.file = im->importing_from;
-	l.start = NULL;
-	l.simple_location.line = (U32)import_vlq(im);
-	return l;
-}
-
-static void export_ident_name(Exporter *ex, Identifier ident) {
-	if (ident->export_name) return;
-	*(Identifier *)arr_add(&ex->exported_idents) = ident;
-	ident->export_name = true;
-}
-
-
-/* handles NULL */
-static inline void export_ident(Exporter *ex, Identifier i) {
-	if (!i) {
-		export_vlq(ex, 0);
-		return;
-	}
-	IdentDecl *idecl = ident_decl(i);
-	
-	if (idecl && idecl->scope == NULL && idecl->kind == IDECL_DECL) {
-		/* make sure this is exported */
-		export_decl_external(ex, idecl->decl);
-	}
-	if (!i->export_id) {
-		i->export_id = ++ex->ident_id;
-	}
-	export_vlq(ex, i->export_id);
-	if (ex->export_all_ident_names)
-		export_ident_name(ex, i);
-}
-static inline Identifier import_ident(Importer *im) {
-	U64 id = import_vlq(im);
-	assert(id <= im->max_ident_id);
-	return im->ident_map[id];
-}
-
-static const U8 toc_package_indicator[3] = {116, 111, 112};
-
-/* writes the header */
-static void exptr_start(Exporter *ex, const char *pkg_name, size_t pkg_name_len) {
-	const char *code = ex->code;
-	ex->decls_to_export = NULL;
-	ex->started = true;
-	export_u8(ex, toc_package_indicator[0]);
-	export_u8(ex, toc_package_indicator[1]);
-	export_u8(ex, toc_package_indicator[2]);
-	export_u32(ex, TOP_FMT_VERSION);
-	assert(ftell(ex->out) == 7L);
-	export_u64(ex, 0); /* placeholder for footer offset in file */
-	export_len(ex, pkg_name_len);
-	export_str(ex, pkg_name, pkg_name_len);
-	
-	bool has_code = code != NULL;
-	export_bool(ex, has_code);
-	if (has_code) {
-		size_t len = strlen(code);
-		export_len(ex, len);
-		export_str(ex, code, len);
-	}
-}
-
-/* where = where was this imported. don't free fname while imported stuff is in use. */
-static Package *import_pkg(PackageManager *pkgmgr, Allocator *allocr, const char *fname, ErrCtx *parent_ctx, Location where) {
-	
-	Package *p = str_hash_table_get(&pkgmgr->pkgs, fname, strlen(fname));
-	if (p) return p;
-	p = str_hash_table_insert(&pkgmgr->pkgs, fname, strlen(fname));
-	p->filename = fname;
-	FILE *f = fopen(fname, "r");
-	if (!f) {
-		err_print(where, "Could not open package file: %s.", fname);
-		return NULL;
-	}
-
-	Importer i = {0};
-	i.allocr = allocr;
-	i.pkgmgr = pkgmgr;
-	i.importing_from = imptr_calloc(&i, 1, sizeof *i.importing_from);
-	i.importing_from->filename = fname;
-	i.importing_from->ctx = parent_ctx;
-	idents_create(&p->idents);
-	i.pkg = p;
-	i.in = f;
-	i.import_location = where;
-	
-		
-	/* read header */
-	U8 toc[3];
-	toc[0] = import_u8(&i);
-	toc[1] = import_u8(&i);
-	toc[2] = import_u8(&i);
-	if (toc[0] != toc_package_indicator[0] ||
-		toc[1] != toc_package_indicator[1] ||
-		toc[2] != toc_package_indicator[2]) {
-		err_print(where, "%s is not a toc package file.", fname);
-		goto err;
-	}
-	U32 version_written = import_u32(&i);
-	if (version_written != TOP_FMT_VERSION) {
-		warn_print(where, "Warning: toc version mismatch. Package was created with version " U32_FMT " but version " STRINGIFY(TOP_FMT_VERSION) " is being used.\n"
-				   "The package may be read incorrectly.",
-				   version_written);
-	}
-	U64 footer_offset = import_u64(&i);
-	size_t pkg_name_len = import_len(&i);
-	char *pkg_name = import_str(&i, pkg_name_len);
-	p->name = allocr_malloc(allocr, pkg_name_len + 1);
-	p->c.prefix = p->name;
-	memcpy(p->name, pkg_name, pkg_name_len);
-	p->name[pkg_name_len] = 0;
-	bool has_code = import_bool(&i);
-	if (has_code) {
-		size_t code_len = import_len(&i);
-		char *code = import_str(&i, code_len);
-		i.importing_from->contents = code;
-	}
-	long decls_offset = ftell(f);
-	fseek(f, (long)footer_offset, SEEK_SET);
-	/* read footer */
-	if (!import_footer(&i)) {
-	    goto err;
-	}
-	fseek(f, decls_offset, SEEK_SET);
-	/* read declarations */
-	size_t ndecls = import_u32(&i);
-	p->stmts = NULL;
-	/* printf("%lu decls\n",ndecls); */
-	for (size_t idx = 0; idx < ndecls; ++idx) {
-		/* printf("-importing one @ %lu\n",ftell(i.in)); */
-		Statement *s = arr_add(&p->stmts);
-		s->kind = STMT_DECL;
-		import_decl(&i, &s->decl);
-	}
-
-	if (ftell(i.in) != (long)footer_offset) {
-		err_print(where, "Something strange happened when importing this package. Expected to be at byte #%ld but actually at byte #%ld.", (long)footer_offset, ftell(i.in));
-		goto err;
-	}	
-	free(i.ident_map);
-	i.ident_map = NULL;
-	if (!block_enter(NULL, p->stmts, 0))
-		goto err;
-	fclose(f);
-	return p;
- err:
-	free(i.ident_map);
-	fclose(f);
-	return NULL;
-	
-}
-
-/* needs to handle unresolved AND resolved types! (for fns with const params) */
-static bool export_type(Exporter *ex, Type *type, Location where) {
-	if (type->kind == TYPE_BUILTIN) {
-		export_u8(ex, (U8)((int)type->builtin + TYPE_COUNT));
-	} else {	
-		export_u8(ex, (U8)type->kind);
-	}
-	assert(sizeof type->flags == 1);
-	export_u8(ex, type->flags);
-	switch (type->kind) {
-	case TYPE_VOID:
-	case TYPE_UNKNOWN:
-	case TYPE_BUILTIN:
-		break;
-	case TYPE_PTR: export_type(ex, type->ptr, where); break;
-	case TYPE_SLICE: export_type(ex, type->slice, where); break;
-	case TYPE_TUPLE:
-		export_len(ex, arr_len(type->tuple));
-		arr_foreach(type->tuple, Type, sub)
-			if (!export_type(ex, sub, where))
-				return false;
-		break;
-	case TYPE_ARR:
-		if (type->flags & TYPE_IS_RESOLVED)
-			export_vlq(ex, type->arr.n);
-		else
-			if (!export_expr(ex, type->arr.n_expr))
-				return false;
-		
-		if (!export_type(ex, type->arr.of, where))
-			return false;
-		break;
-	case TYPE_FN: {
-		size_t ntypes = arr_len(type->fn.types);
-		export_len(ex, ntypes);
-		arr_foreach(type->fn.types, Type, sub)
-			if (!export_type(ex, sub, where))
-				return false;
-		export_bool(ex, type->fn.constness != NULL);
-
-		if (type->fn.constness) {
-			possibly_static_assert(sizeof(Constness) == 1); /* future-proofing */
-			size_t nparams = ntypes - 1;
-			for (size_t i = 0; i < nparams; ++i)
-				export_u8(ex, type->fn.constness[i]);
-		}
-	} break;
-	case TYPE_STRUCT: {
-		StructDef *struc = type->struc;
-		export_struct(ex, struc);
-	} break;
-	case TYPE_EXPR:
-		if (!export_expr(ex, type->expr))
-			return false;
-		break;
-	}
-	return true;
-}
-
-static inline Type *imptr_new_type(Importer *im) {
-	return imptr_calloc(im, 1, sizeof(Type));
-}
-static inline Expression *imptr_new_expr(Importer *im) {
-	return imptr_calloc(im, 1, sizeof(Expression));
-}
-
-static void import_type(Importer *im, Type *type) {
-	U8 kind = import_u8(im);
-	if (kind > TYPE_COUNT) {
-		type->kind = TYPE_BUILTIN;
-		type->builtin = (BuiltinType)(kind - TYPE_COUNT);
-	} else {
-		type->kind = (TypeKind)kind;
-	}
-	type->flags = import_u8(im);
-	unsigned is_resolved = type->flags & TYPE_IS_RESOLVED;
-	switch (type->kind) {
-	case TYPE_VOID:
-	case TYPE_BUILTIN:
-	case TYPE_UNKNOWN:
-		break;
-	case TYPE_PTR:
-		import_type(im, type->ptr = imptr_new_type(im));
-		break;
-	case TYPE_SLICE:
-		import_type(im, type->slice = imptr_new_type(im));
-		break;
-	case TYPE_TUPLE: {
-		size_t ntypes = import_arr(im, &type->tuple);
-		for (size_t i = 0; i < ntypes; ++i) {
-			import_type(im, &type->tuple[i]);
-		}
-	} break;
-	case TYPE_ARR:
-		if (is_resolved)
-			type->arr.n = import_vlq(im);
-		else
-			type->arr.n_expr = import_expr_(im);
-		import_type(im, type->arr.of = imptr_new_type(im));
-		break;
-	case TYPE_FN: {
-		size_t i, ntypes = import_arr(im, &type->fn.types);
-		for (i = 0; i < ntypes; ++i)
-			import_type(im, &type->fn.types[i]);
-		bool has_constness = import_bool(im);
-		if (has_constness) {
-			size_t nparams = ntypes - 1;
-			type->fn.constness = imptr_malloc(im, nparams * sizeof *type->fn.constness);
-			for (i = 0; i < nparams; ++i)
-				type->fn.constness[i] = import_u8(im);
-		} else type->fn.constness = NULL;
-	} break;
-	case TYPE_STRUCT: {
-		type->struc = import_struct(im);
-	} break;
-	case TYPE_EXPR:
-		type->expr = import_expr_(im);
-		break;
-	}
-}
-
-static bool export_val(Exporter *ex, Value val, Type *type, Location where);
-static bool export_val_ptr(Exporter *ex, void *v, Type *type, Location where) {
-	switch (type->kind) {
-	case TYPE_VOID: break;
-	case TYPE_BUILTIN:
-		switch (type->builtin) {
-		case BUILTIN_I8: export_i8(ex, *(I8 *)v); break;
-		case BUILTIN_U8: export_u8(ex, *(U8 *)v); break;
-		case BUILTIN_I16: export_i16(ex, *(I16 *)v); break;
-		case BUILTIN_U16: export_u16(ex, *(U16 *)v); break;
-		case BUILTIN_I32: export_i32(ex, *(I32 *)v); break;
-		case BUILTIN_U32: export_u32(ex, *(U32 *)v); break;
-		case BUILTIN_I64: export_i64(ex, *(I64 *)v); break;
-		case BUILTIN_U64: export_u64(ex, *(U64 *)v); break;
-		case BUILTIN_F32: export_f32(ex, *(F32 *)v); break;
-		case BUILTIN_F64: export_f64(ex, *(F64 *)v); break;
-		case BUILTIN_BOOL: export_bool(ex, *(bool *)v); break;
-		case BUILTIN_CHAR: export_char(ex, *(char *)v); break;
-		case BUILTIN_TYPE:
-			if (!export_type(ex, *(Type **)v, where))
-				return false;
-			break;
-		case BUILTIN_PKG:
-			export_cstr(ex, (*(Package **)v)->filename);
-			break;
-		}
-		break;
-	case TYPE_TUPLE: {
-		size_t n = arr_len(type->tuple);
-		Value *vals = *(Value **)v;
-		for (size_t i = 0; i < n; ++i) {
-			if (!export_val(ex, vals[i], &type->tuple[i], where))
-				return false;
-		}
-	} break;
-	case TYPE_PTR:
-		err_print(where, "Cannot export pointer.");
-		return false;
-	case TYPE_ARR: {
-		size_t item_size = compiler_sizeof(type->arr.of);
-		char *ptr = v;
-		for (U64 i = 0; i < type->arr.n; ++i) {
-			if (!export_val_ptr(ex, ptr, type->arr.of, where))
-				return false;
-			ptr += item_size;
-		}
-	} break;
-	case TYPE_STRUCT:
-		eval_struct_find_offsets(type->struc);
-		arr_foreach(type->struc->fields, Field, f) {
-			if (!export_val_ptr(ex, (char *)v + f->offset, &f->type, where))
-				return false;
-		}
-		break;
-	case TYPE_SLICE: {
-		Slice slice = *(Slice *)v;
-		I64 n = slice.n;
-		size_t item_size = compiler_sizeof(type->slice);
-		export_i64(ex, n);
-		char *ptr = slice.data;
-		for (I64 i = 0; i < n; ++i) {
-			if (!export_val_ptr(ex, ptr, type->slice, where))
-				return false;
-			ptr += item_size;
-		}
-	} break;
-	case TYPE_FN:
-		if (!export_fn(ex, *(FnExpr **)v))
-			return false;
-		break;
-	case TYPE_UNKNOWN:
-	case TYPE_EXPR:
-		assert(0);
-		return false;
-	}
-	return true;
-}
-
-static inline Value import_val(Importer *im, Type *type, Location where);
-static void import_val_ptr(Importer *im, void *v, Type *type, Location where) {
-	switch (type->kind) {
-	case TYPE_VOID: break;
-	case TYPE_BUILTIN:
-		switch (type->builtin) {
-		case BUILTIN_I8: *(I8 *)v = import_i8(im); break;
-		case BUILTIN_U8: *(U8 *)v = import_u8(im); break;
-		case BUILTIN_I16: *(I16 *)v = import_i16(im); break;
-		case BUILTIN_U16: *(U16 *)v = import_u16(im); break;
-		case BUILTIN_I32: *(I32 *)v = import_i32(im); break;
-		case BUILTIN_U32: *(U32 *)v = import_u32(im); break;
-		case BUILTIN_I64: *(I64 *)v = import_i64(im); break;
-		case BUILTIN_U64: *(U64 *)v = import_u64(im); break;
-		case BUILTIN_F32: *(F32 *)v = import_f32(im); break;
-		case BUILTIN_F64: *(F64 *)v = import_f64(im); break;
-		case BUILTIN_BOOL: *(bool *)v = import_bool(im); break;
-		case BUILTIN_CHAR: *(char *)v = import_char(im); break;
-		case BUILTIN_TYPE:
-			import_type(im, *(Type **)v = imptr_new_type(im));
-			break;
-		case BUILTIN_PKG: {
-			char *fname = import_cstr(im);
-			Package *pkg = *(Package **)v = import_pkg(im->pkgmgr, im->allocr, fname, im->err_ctx, where);
-			if (!pkg) {
-				/* TODO: make this bool */
-				return;
-			}
-		} break;
-		}
-		break;
-	case TYPE_TUPLE: {
-		Value **vals = (Value **)v;
-		size_t n = arr_len(type->tuple);
-		*vals = imptr_malloc(im, n * sizeof **vals);
-		for (size_t i = 0; i < n; ++i) {
-			(*vals)[i] = import_val(im, &type->tuple[i], where);
-		}
-	} break;
-	case TYPE_ARR: {
-		size_t item_size = compiler_sizeof(type->arr.of);
-		U64 n = type->arr.n;
-		char *ptr = v;
-		for (U64 i = 0; i < n; ++i) {
-			import_val_ptr(im, ptr, type->arr.of, where);
-			ptr += item_size;
-		}
-	} break;
-	case TYPE_STRUCT: {
-		eval_struct_find_offsets(type->struc);
-		arr_foreach(type->struc->fields, Field, f) {
-			import_val_ptr(im, (char *)v + f->offset, &f->type, where);
-		}
-	} break;
-	case TYPE_FN:
-		*(FnExpr **)v = import_fn(im);
-		break;
-	case TYPE_SLICE: {
-		Slice *slice = v;
-		I64 n = slice->n = import_i64(im);
-		size_t item_size = compiler_sizeof(type->slice);
-		if (n <= 0) {
-			slice->data = NULL;
-		} else {
-			char *ptr = slice->data = imptr_malloc(im, (U64)n * item_size);
-			for (I64 i = 0; i < n; ++i) {
-				import_val_ptr(im, ptr, type->slice, where);
-				ptr += item_size;
-			}
-		}
-	} break;
-	case TYPE_PTR:
-	case TYPE_UNKNOWN:
-	case TYPE_EXPR:
-		assert(0);
-		break;
-	}
-}
-
-
-static inline bool export_val(Exporter *ex, Value val, Type *type, Location where) {
-	return export_val_ptr(ex, val_get_ptr(&val, type), type, where);
-}
-
-static inline Value import_val(Importer *im, Type *type, Location where) {
-	Value val;
-	val = val_alloc(im->allocr, type);
-	import_val_ptr(im, val_get_ptr(&val, type), type, where);
-	return val;
-}
-
-static inline bool export_optional_val(Exporter *ex, Value *val, Type *type, Location where) {
-	bool has_val = val != NULL;
-	export_bool(ex, has_val);
-	if (has_val) {
-		return export_val(ex, *val, type, where);
-	} else {
-		return true;
-	}
-}
-
-static inline Value *import_optional_val(Importer *im, Type *type, Location where) {
-	if (import_bool(im)) {
-		Value *val = imptr_malloc(im, sizeof *val);
-		*val = import_val(im, type, where);
-		return val;
-	}
-	return NULL;
-}
-
-/* e can be NULL! */
-static inline bool export_optional_expr(Exporter *ex, Expression *e) {
-	bool has_e = e != NULL;
-	export_bool(ex, has_e);
-	if (has_e)
-		return export_expr(ex, e);
-	else
-		return true;
-}
-
-static inline Expression *import_optional_expr(Importer *im) {
-	if (import_bool(im)) {
-		return import_expr_(im);
-	}
-	return NULL;
-}
-
-static bool export_expr(Exporter *ex, Expression *e) {
-	possibly_static_assert(sizeof e->flags == 1);
-	export_u8(ex, (U8)e->flags);
-	assert(e->kind < 256);
-	export_u8(ex, (U8)e->kind);
-	export_location(ex, e->where);
-	unsigned found_type = e->flags & EXPR_FOUND_TYPE;
-    if (found_type) {
-		if (!export_type(ex, &e->type, e->where))
-			return false;
-	}
-	switch (e->kind) {
-	case EXPR_LITERAL_INT:
-		/* smaller int literals are more common */
-		export_vlq(ex, e->intl);
-		break;
-	case EXPR_LITERAL_FLOAT:
-		if (!found_type || (e->type.flags & TYPE_IS_FLEXIBLE) || e->type.builtin == BUILTIN_F64)
-			export_f64(ex, (F64)e->floatl);
-		else
-			export_f32(ex, (F32)e->floatl);
-		break;
-	case EXPR_LITERAL_BOOL:
-		export_bool(ex, e->booll);
-		break;
-	case EXPR_LITERAL_CHAR:
-		export_char(ex, e->charl);
-		break;
-	case EXPR_LITERAL_STR:
-		export_len(ex, e->strl.len);
-		fwrite(e->strl.str, 1, e->strl.len, ex->out);
-		break;
-	case EXPR_C:
-		if (!export_expr(ex, e->c.code))
-			return false;
-		break;
-	case EXPR_BUILTIN:
-		if (found_type) {
-			possibly_static_assert(BUILTIN_VAL_COUNT <= 256);
-			export_u8(ex, (U8)e->builtin.which.val);
-		} else {
-			if (!export_expr(ex, e->builtin.which.expr))
-				return false;
-		}
-		break;
-	case EXPR_IDENT:
-		export_ident(ex, e->ident);
-		break;
-	case EXPR_UNARY_OP:
-		export_u8(ex, (U8)e->unary.op);
-		if (!export_expr(ex, e->unary.of))
-			return false;
-		break;
-	case EXPR_BINARY_OP:
-		export_u8(ex, (U8)e->binary.op);
-		if (!export_expr(ex, e->binary.lhs))
-			return false;
-		if (!export_expr(ex, e->binary.rhs))
-			return false;
-		break;
-	case EXPR_VAL:
-		if (!export_val(ex, e->val, &e->type, e->where))
-			return false;
-		break;
-	case EXPR_TUPLE:
-		export_len(ex, arr_len(e->tuple));
-		arr_foreach(e->tuple, Expression, item)
-			if (!export_expr(ex, item))
-				return false;
-		break;
-	case EXPR_TYPE:
-		if (!export_type(ex, &e->typeval, e->where))
-			return false;
-		break;
-	case EXPR_FN:
-		if (!export_fn(ex, e->fn))
-			return false;
-		break;
-	case EXPR_BLOCK:
-		if (!export_block(ex, &e->block))
-			return false;
-		break;
-	case EXPR_NEW:
-		if (!export_type(ex, &e->new.type, e->where))
-			return false;
-		if (!export_optional_expr(ex, e->new.n))
-			return false;
-		break;
-	case EXPR_CAST:
-		if (!export_expr(ex, e->cast.expr)
-			|| !export_type(ex, &e->cast.type, e->where))
-			return false;
-		break;
-	case EXPR_CALL: {
-		CallExpr *c = &e->call;
-		if (!export_expr(ex, c->fn))
-			return false;
-		if (found_type) {
-			export_len(ex, arr_len(c->arg_exprs));
-			arr_foreach(c->arg_exprs, Expression, arg)
-				if (!export_expr(ex, arg))
-					return false;
-		} else {
-			export_len(ex, arr_len(c->args));
-			arr_foreach(c->args, Argument, arg) {
-				export_location(ex, arg->where);
-				export_ident(ex, arg->name);
-				if (!export_expr(ex, &arg->val))
-					return false;
-			}
-		}
-	} break;
-	case EXPR_IF: {
-		IfExpr *i = &e->if_;
-		if (!export_optional_expr(ex, i->cond))
-			return false;
-		if (!export_block(ex, &i->body)) return false;
-		if (!export_optional_expr(ex, i->next_elif))
-			return false;
-	} break;
-	case EXPR_WHILE: {
-		WhileExpr *w = &e->while_;
-		if (!export_optional_expr(ex, w->cond))
-			return false;
-		if (!export_block(ex, &w->body))
-			return false;
-	} break;
-	case EXPR_PKG:
-		assert(!found_type);
-		if (!export_expr(ex, e->pkg.name_expr))
-			return false;
-		break;
-	case EXPR_SLICE: {
-		SliceExpr *s = &e->slice;
-		if (!export_expr(ex, s->of)) return false;
-		if (!export_optional_expr(ex, s->from))
-			return false;
-		if (!export_optional_expr(ex, s->to))
-			return false;
-	} break;
-	case EXPR_FOR: {
-		ForExpr *fo = e->for_;
-		if (!for_enter(e))
-			return false;
-		possibly_static_assert(sizeof fo->flags == 1);
-		export_u8(ex, fo->flags);
-		if ((fo->flags & FOR_ANNOTATED_TYPE) || found_type)
-			if (!export_type(ex, &fo->type, e->where))
-			    goto for_fail;
-		export_ident(ex, fo->index);
-		export_ident(ex, fo->value);
-		if (fo->flags & FOR_IS_RANGE) {
-			if (!export_expr(ex, fo->range.from))
-			    goto for_fail;
-			if (!export_optional_expr(ex, fo->range.to))
-			    goto for_fail;
-			if (found_type) {
-				if (!export_optional_val(ex, fo->range.stepval, &fo->type, e->where))
-				    goto for_fail;
-			} else {
-				if (!export_optional_expr(ex, fo->range.step))
-					goto for_fail;
-			}
-		} else {
-			if (!export_expr(ex, fo->of))
-				goto for_fail;
-		}
-		if (!export_block(ex, &fo->body))
-		    goto for_fail;
-		for_exit(e);
-	} break;
-	for_fail:
-		for_exit(e);
-		return false;
-	}
-	return true;
-}
-
-/* returns a pointer, unlinke import_expr */
-static inline Expression *import_expr_(Importer *im) {
-	Expression *e = imptr_new_expr(im);
-	import_expr(im, e);
-	return e;
-}
-
-static void import_expr(Importer *im, Expression *e) {
-	e->flags = import_u8(im);
-	e->kind = import_u8(im);
-	e->where = import_location(im);
-	unsigned found_type = e->flags & EXPR_FOUND_TYPE;
-	if (found_type) {
-		import_type(im, &e->type);
-	}
-	switch (e->kind) {
-	case EXPR_LITERAL_INT:
-		e->intl = import_vlq(im);
-		break;
-	case EXPR_LITERAL_FLOAT:
-		if (!found_type || (e->type.flags & TYPE_IS_FLEXIBLE) || e->type.builtin == BUILTIN_F64)
-			e->floatl = (Floating)import_f64(im);
-		else
-			e->floatl = (Floating)import_f32(im);
-		break;
-	case EXPR_LITERAL_BOOL:
-		e->booll = import_bool(im);
-		break;
-	case EXPR_LITERAL_CHAR:
-		e->charl = import_char(im);
-		break;
-	case EXPR_LITERAL_STR: {
-		size_t len = import_len(im);
-		fread(e->strl.str = malloc(len), 1, len, im->in);
-	} break;
-	case EXPR_C:
-		e->c.code = import_expr_(im);
-		break;
-	case EXPR_BUILTIN:
-		if (found_type) {
-			possibly_static_assert(BUILTIN_VAL_COUNT <= 256);
-			e->builtin.which.val = import_u8(im);
-		} else {
-			e->builtin.which.expr = import_expr_(im);
-		}
-		break;
-	case EXPR_IDENT:
-		e->ident = import_ident(im);
-		break;
-	case EXPR_UNARY_OP:
-		e->unary.op = import_u8(im);
-		e->unary.of = import_expr_(im);
-		break;
-	case EXPR_BINARY_OP:
-		e->binary.op = import_u8(im);
-		e->binary.lhs = import_expr_(im);
-		e->binary.rhs = import_expr_(im);
-		break;
-	case EXPR_VAL:
-		e->val = import_val(im, &e->type, e->where);
-		break;
-	case EXPR_TUPLE:
-		import_arr(im, &e->tuple);
-		arr_foreach(e->tuple, Expression, sub) {
-			import_expr(im, sub);
-		}
-		break;
-	case EXPR_TYPE:
-		import_type(im, &e->typeval);
-		break;
-	case EXPR_FN:
-		e->fn = import_fn(im);
-		break;
-	case EXPR_BLOCK:
-		import_block(im, &e->block);
-		break;
-	case EXPR_NEW:
-		import_type(im, &e->new.type);
-		e->new.n = import_optional_expr(im);
-		break;
-	case EXPR_CAST:
-		e->cast.expr = import_expr_(im);
-		import_type(im, &e->cast.type);
-		break;
-	case EXPR_CALL: {
-		CallExpr *c = &e->call;
-		memset(c, 0, sizeof *c);
-		c->fn = import_expr_(im);
-		if (found_type) {
-			import_arr(im, &c->arg_exprs);
-			arr_foreach(c->arg_exprs, Expression, arg)
-				import_expr(im, arg);
-		} else {
-			import_arr(im, &c->args);
-			arr_foreach(c->args, Argument, arg) {
-				arg->where = import_location(im);
-				arg->name = import_ident(im);
-				import_expr(im, &arg->val);
-			}
-		}
-	} break;
-	case EXPR_IF: {
-		IfExpr *i = &e->if_;
-		i->cond = import_optional_expr(im);
-		import_block(im, &i->body);
-		i->next_elif = import_optional_expr(im);
-	} break;
-	case EXPR_WHILE: {
-		WhileExpr *w = &e->while_;
-		w->cond = import_optional_expr(im);
-		import_block(im, &w->body);
-	} break;
-	case EXPR_PKG:
-		assert(!found_type);
-		e->pkg.name_expr = import_expr_(im);
-		break;
-	case EXPR_SLICE: {
-		SliceExpr *s = &e->slice;
-		s->of = import_expr_(im);
-		s->from = import_optional_expr(im);
-		s->to = import_optional_expr(im);
-	} break;
-	case EXPR_FOR: {
-		ForExpr *fo = e->for_ = imptr_calloc(im, 1, sizeof *fo);
-		fo->flags = import_u8(im);
-		if ((fo->flags & FOR_ANNOTATED_TYPE) || found_type)
-			import_type(im, &fo->type);
-		fo->index = import_ident(im);
-		fo->value = import_ident(im);
-		if (fo->flags & FOR_IS_RANGE) {
-			fo->range.from = import_expr_(im);
-			fo->range.to = import_optional_expr(im);
-			if (found_type) {
-				fo->range.stepval = import_optional_val(im, &fo->type, e->where);
-			} else {
-				fo->range.step = import_optional_expr(im);
-			}
-		} else {
-			fo->of = import_expr_(im);
-		}
-		import_block(im, &fo->body);
-	} break;
-	}
-}
-
-static bool export_decl(Exporter *ex, Declaration *d) {
-	if (d->flags & DECL_MARKED_FOR_EXPORTING) {
-		arr_foreach(d->idents, Identifier, ident) {
-			export_ident_name(ex, *ident);
-		}
-	}
-	
-	assert(ex->started);
-	possibly_static_assert(sizeof d->flags == 2);
-	export_u16(ex, d->flags);
-
-	if ((d->flags & DECL_FOUND_TYPE) && d->type.kind == TYPE_UNKNOWN) {
-		err_print(d->where, "Can't export declaration of unknown type.");
-		return false;
-	}
-	
-	export_location(ex, d->where);
-	export_len(ex, arr_len(d->idents));
-	arr_foreach(d->idents, Identifier, ident) {
-		export_ident(ex, *ident);
-	}
-
-	if (d->flags & (DECL_FOUND_TYPE | DECL_ANNOTATES_TYPE)) {
-		if (!export_type(ex, &d->type, d->where))
-			return false;
-	}
-	if (d->flags & DECL_FOUND_VAL) {
-		if (!export_val(ex, d->val, &d->type, d->where))
-			return false;
-	} else if (d->flags & DECL_HAS_EXPR) {
-		if (!export_expr(ex, &d->expr))
-			return false;
-	} else if (d->flags & DECL_FOREIGN) {
-		if (!(d->flags & DECL_FOUND_TYPE)) {
-			if (!export_expr(ex, d->foreign.name))
-				return false;
-			if (!export_expr(ex, d->foreign.lib))
-				return false;
-		}
-	}
-	return true;
-}
-
-static void import_decl(Importer *im, Declaration *d) {
-	possibly_static_assert(sizeof d->flags == 2);
-	d->flags = import_u16(im);
-	d->flags &= (DeclFlags)~(DeclFlags)DECL_EXPORT;
-	d->where = import_location(im);
-	d->idents = NULL;
-	size_t n_idents = import_arr(im, &d->idents);
-	for (size_t i = 0; i < n_idents; ++i) {
-		d->idents[i] = import_ident(im);
-	}
-	if (d->flags & (DECL_FOUND_TYPE | DECL_ANNOTATES_TYPE)) {
-		import_type(im, &d->type);
-	}
-	if (d->flags & DECL_FOUND_VAL) {
-		d->val = import_val(im, &d->type, d->where);
-		if (d->flags & DECL_HAS_EXPR) {
-			d->expr.kind = EXPR_VAL;
-			d->expr.val = d->val;
-		}
-		d->flags &= (DeclFlags)~(DeclFlags)DECL_HAS_EXPR;
-	} else if (d->flags & DECL_HAS_EXPR) {
-		import_expr(im, &d->expr);
-	} else if (d->flags & DECL_FOREIGN) {
-		if (!(d->flags & DECL_FOUND_TYPE)) {
-			d->foreign.name = import_expr_(im);
-			d->foreign.lib = import_expr_(im);
-		}
-	}
-}
-
-/* exports a declaration. to be used by other files instead of export_decl. */
-static void export_decl_external(Exporter *ex, Declaration *d) {
-	if (!(d->flags & DECL_MARKED_FOR_EXPORTING)) {
-		d->flags |= DECL_MARKED_FOR_EXPORTING;
-		*(Declaration **)arr_add(&ex->decls_to_export) = d;
-	}
-}
-
-static bool export_stmt(Exporter *ex, Statement *s) {
-	possibly_static_assert(sizeof s->flags == 1);
-	export_u8(ex, s->flags);
-	export_u8(ex, (U8)s->kind);
-	export_location(ex, s->where);
-	switch (s->kind) {
-	case STMT_EXPR:
-		if (!export_expr(ex, &s->expr))
-			return false;
-		break;
-	case STMT_DECL:
-		if (!export_decl(ex, &s->decl))
-			return false;
-		break;
-	case STMT_RET: {
-		possibly_static_assert(sizeof s->ret.flags == 1);
-		export_u8(ex, (U8)s->ret.flags);
-		if (s->ret.flags & RET_HAS_EXPR)
-			if (!export_expr(ex, &s->ret.expr))
-				return false;
-	} break;
-	case STMT_INCLUDE:
-		if (s->flags & STMT_TYPED) {
-			export_len(ex, arr_len(s->inc.stmts));
-			arr_foreach(s->inc.stmts, Statement, sub)
-				if (!export_stmt(ex, sub))
-					return false;
-		} else {
-			if (!export_expr(ex, &s->inc.filename))
-				return false;
-		}
-		break;
-	}
-	return true;
-}
-
-static void import_stmt(Importer *im, Statement *s) {
-	s->flags = import_u8(im);
-	s->kind = import_u8(im);
-	s->where = import_location(im);
-	switch (s->kind) {
-	case STMT_EXPR:
-		import_expr(im, &s->expr);
-		break;
-	case STMT_DECL:
-		import_decl(im, &s->decl);
-		break;
-	case STMT_INCLUDE:
-		if (s->flags & STMT_TYPED) {
-			import_arr(im, &s->inc.stmts);
-			arr_foreach(s->inc.stmts, Statement, sub)
-				import_stmt(im, sub);
-		} else {
-			import_expr(im, &s->inc.filename);
-		}
-		break;
-	case STMT_RET:
-		s->ret.flags = import_u8(im);
-		if (s->ret.flags & RET_HAS_EXPR)
-			import_expr(im, &s->expr);
-		break;
-	}
-	/* fprint_stmt(stdout, s); printf("\n"); */
-}
-
-static bool export_block(Exporter *ex, Block *b) {
-	if (!block_enter(b, b->stmts, 0))
-		return false;
-	
-	possibly_static_assert(sizeof b->flags == 1);
-	export_u8(ex, b->flags);
-	export_location(ex, b->where);
-	export_len(ex, arr_len(b->stmts));
-	arr_foreach(b->stmts, Statement, s) {
-		if (!export_stmt(ex, s))
-			goto err;
-	}
-	if (!export_optional_expr(ex, b->ret_expr))
-	    goto err;
-
-	block_exit(b, b->stmts);
-	return true;
- err:
-	block_exit(b, b->stmts);
-	return false;
-}
-
-static void import_block(Importer *im, Block *b) {
-	b->flags = import_u8(im);
-	b->where = import_location(im);
-	import_arr(im, &b->stmts);
-	arr_foreach(b->stmts, Statement, s) {
-		import_stmt(im, s);
-	}
-	b->ret_expr = import_optional_expr(im);
-}
-
-static bool export_fn(Exporter *ex, FnExpr *f) {
-	
-	export_bool(ex, f->export.id == 0);
-	if (f->export.id == 0) {
-		f->export.id = ++ex->nexported_fns;
-		export_vlq(ex, f->export.id);
-		if (!fn_enter(f, 0))
-			return false;
-	
-		possibly_static_assert(sizeof f->flags == 1);
-		export_u8(ex, f->flags);
-		if (f->flags & FN_EXPR_FOREIGN) {
-			export_cstr(ex, f->foreign.name);
-			export_cstr(ex, f->foreign.lib);
-		} else {
-			export_location(ex, f->where);
-			export_len(ex, arr_len(f->params));
-			arr_foreach(f->params, Declaration, param) {
-				if (!export_decl(ex, param))
-					goto err;
-				arr_foreach(param->idents, Identifier, ident) {
-					export_ident_name(ex, *ident);
-				}
-			}
-			if (!export_type(ex, &f->ret_type, f->where))
-				goto err;
-			export_len(ex, arr_len(f->ret_decls));
-			arr_foreach(f->ret_decls, Declaration, ret_decl)
-				if (!export_decl(ex, ret_decl))
-					goto err;
-			if (!export_block(ex, &f->body))
-				goto err;
-		}
-		fn_exit(f);
-		return true;
-	err:
-		fn_exit(f);
-		return false;
-	} else {
-		export_vlq(ex, f->export.id);
-		return true;
-	}
-}
-
-static FnExpr *import_fn(Importer *im) {
-	FnExpr *f;
-	if (import_bool(im)) {
-		/* import function definition */
-		f = &im->fns[import_vlq(im)];
-		f->flags = import_u8(im);
-		if (f->flags & FN_EXPR_FOREIGN) {
-			f->foreign.name = import_cstr(im);
-			f->foreign.lib = import_cstr(im);
-		} else {
-			f->where = import_location(im);
-			import_arr(im, &f->params);
-			arr_foreach(f->params, Declaration, param) {
-				import_decl(im, param);
-			}
-			import_type(im, &f->ret_type);
-			import_arr(im, &f->ret_decls);
-			arr_foreach(f->ret_decls, Declaration, ret_decl)
-				import_decl(im, ret_decl);
-			import_block(im, &f->body);
-		}
-	} else {
-		f = &im->fns[import_vlq(im)];
-	}
-	return f;
-}
-
-static bool export_struct(Exporter *ex, StructDef *s) {
-	export_bool(ex, s->export.id == 0);
-	if (s->export.id == 0) {
-		s->export.id = ++ex->nexported_structs;
-		export_vlq(ex, s->export.id);
-		export_ident(ex, s->name);
-		if (s->name)
-			export_ident_name(ex, s->name);
-		export_len(ex, arr_len(s->fields));
-		arr_foreach(s->fields, Field, f) {
-			export_ident(ex, f->name);
-			export_ident_name(ex, f->name);
-			if (!export_type(ex, &f->type, s->where))
-				return false;
-		}
-	} else {
-		export_vlq(ex, s->export.id);
-	}
-	return true;
-}
-
-static StructDef *import_struct(Importer *im) {
-	StructDef *s;
-	if (import_bool(im)) {
-		s = &im->structs[import_vlq(im)];
-		s->name = import_ident(im);
-		size_t nfields = import_arr(im, &s->fields);
-		for (size_t i = 0; i < nfields; ++i) {
-			s->fields[i].name = import_ident(im);
-			import_type(im, &s->fields[i].type);
-		}
-	} else {
-		s = &im->structs[import_vlq(im)];
-	}
-	return s;
-}
-
-/* does NOT close the file */
-static bool exptr_finish(Exporter *ex) {
-	long ndecls_offset = ftell(ex->out);
-	export_u32(ex, 0);
-	/* NOTE: arr_len(ex->decls_to_export) may change during loop! */
-	for (size_t i = 0; i < arr_len(ex->decls_to_export); ++i) {
-		/* printf("-exporting one at %lu\n",ftell(ex->out)); */
-		Declaration *d = ex->decls_to_export[i];
-		if (!export_decl(ex, d))
-			return false;
-	}
-	{
-		long back = ftell(ex->out);
-		fseek(ex->out, ndecls_offset, SEEK_SET);
-		/* printf("%lu decls\n",arr_len(ex->decls_to_export)); */
-		export_u32(ex, (U32)arr_len(ex->decls_to_export));
-		fseek(ex->out, back, SEEK_SET);
-	}
-		
-	long footer_offset = ftell(ex->out);
-	export_vlq(ex, ex->nexported_fns);
-	export_vlq(ex, ex->nexported_structs);
-	/* export total number of identifiers */
-	export_vlq(ex, ex->ident_id);
-	/* export number of identifiers *whose names matter* */
-	export_len(ex, arr_len(ex->exported_idents));
-	arr_foreach(ex->exported_idents, Identifier, ident) {
-		Identifier i = *ident;
-		assert(i->export_name);
-		export_vlq(ex, i->export_id);
-		export_len(ex, i->len);
-		fprint_ident(ex->out, i);
-	}
-
-	fseek(ex->out, 7L, SEEK_SET);
-	export_u64(ex, (U64)footer_offset);
-	arr_clear(&ex->exported_idents);
-
-	if (ferror(ex->out)) {
-		Location none = {0};
-		none.file = &ex->exporting_to;
-		warn_print(none, "An error occured while writing the package output. It may be incorrect.");
-	}
-	
-	return true;
-}
-
-static bool import_footer(Importer *im) {
-	size_t i;
-
-	/* +1 because indexing starts at 1 */
-	U32 nfns = (U32)import_vlq(im);
-	im->fns = imptr_calloc(im, nfns+1, sizeof *im->fns);
-	U32 nstructs = (U32)import_vlq(im);
-	im->structs = imptr_calloc(im, nstructs+1, sizeof *im->structs);
-	
-	im->max_ident_id = import_vlq(im);
-	
-	im->ident_map = err_calloc(im->max_ident_id + 1, sizeof *im->ident_map);
-	size_t n_named_idents = import_len(im);
-	for (i = 0; i < n_named_idents; ++i) {
-		U64 id = import_vlq(im);
-		size_t name_len = import_vlq(im);
-		char *name = imptr_malloc(im, name_len+1);
-		name[name_len] = 0;
-		fread(name, 1, name_len, im->in);
-		im->ident_map[id] = ident_insert(&im->pkg->idents, &name);
-		im->ident_map[id]->imported = true;
-		im->ident_map[id]->from_pkg = im->pkg;
-	}
-	for (i = 1; i <= im->max_ident_id; ++i) {
-		if (!im->ident_map[i]) {
-			im->ident_map[i] = ident_new_anonymous(&im->pkg->idents);
-			im->ident_map[i]->imported = true;
-			im->ident_map[i]->from_pkg = im->pkg;
-		}
-	}
-
-	if (ferror(im->in)) {
-		warn_print(im->import_location, "An error occured while reading the package. It may be incorrect.");
-	}
-	
-	return true;
-}
-
-static void package_free(Package *pkg) {
-	idents_free(&pkg->idents);
-	arr_clear(&pkg->stmts);
-}
diff --git a/parse.c b/parse.c
index 50ebdee..0334dd1 100644
--- a/parse.c
+++ b/parse.c
@@ -48,7 +48,6 @@ static const char *expr_kind_to_str(ExprKind k) {
 	case EXPR_SLICE: return "slice";
 	case EXPR_TYPE: return "type";
 	case EXPR_VAL: return "value";
-	case EXPR_PKG: return "package";
 	}
 	assert(0);
 	return "";
@@ -152,7 +151,6 @@ static int kw_to_builtin_type(Keyword kw) {
 	case KW_F64: return BUILTIN_F64;
 	case KW_BOOL: return BUILTIN_BOOL;
 	case KW_CHAR: return BUILTIN_CHAR;
-	case KW_PACKAGE: return BUILTIN_PKG;
 	case KW_TYPE: return BUILTIN_TYPE;
 	default: return -1;
 	}
@@ -173,7 +171,6 @@ static Keyword builtin_type_to_kw(BuiltinType t) {
 	case BUILTIN_F64: return KW_F64;
 	case BUILTIN_BOOL: return KW_BOOL;
 	case BUILTIN_CHAR: return KW_CHAR;
-	case BUILTIN_PKG: return KW_PACKAGE;
 	case BUILTIN_TYPE: return KW_TYPE;
 	}
 	assert(0);
@@ -1040,12 +1037,6 @@ static bool parse_expr(Parser *p, Expression *e, Token *end) {
 		Token *start = t->token;
 		/* TODO: consider moving this after ops, so that "if true { 5 } else { 3 } as f32" is possible */
 		if (t->token->kind == TOKEN_KW) switch (t->token->kw) {
-			case KW_PKG:
-				++t->token;
-				e->kind = EXPR_PKG;
-				if (!parse_expr(p, e->pkg.name_expr = parser_malloc(p, sizeof *e->pkg.name_expr), expr_find_end(p, 0)))
-					return false;
-				goto success;
 			case KW_FN: {
 				/* this is a function */
 				e->kind = EXPR_FN;
@@ -2029,33 +2020,6 @@ static bool parse_stmt(Parser *p, Statement *s, bool *was_a_statement) {
 			t->token = end + 1;
 			return success;
 		}
-		case KW_PKG: {
-			/* declaration of package name */
-			Expression *pkg_name  = parser_new_expr(p);
-			++t->token;
-			Token *end = expr_find_end(p, 0);
-			if (!end || !token_is_kw(end, KW_SEMICOLON)) {
-				tokr_err(t, "No semicolon at end of package name.");
-				tokr_skip_to_eof(t);
-				return false;
-			}
-			if (p->block) {
-				tokr_err(t, "You must set the package name at global scope.");
-				t->token = end + 1;
-				return false;
-			}
-			if (p->parsed_file->pkg_name) {
-				tokr_err(t, "You've already set the package name.");
-				info_print(p->parsed_file->pkg_name->where, "The package name was previously set here.");
-				t->token = end + 1;
-				return false;
-			}
-			p->parsed_file->pkg_name = pkg_name;
-			bool success = parse_expr(p, pkg_name, end);
-			t->token = end + 1;
-			*was_a_statement = false;
-			return success;
-		}
 		default: break;
 		}
 	} else if (t->token->kind == TOKEN_DIRECT) {
@@ -2114,7 +2078,6 @@ static void parser_create(Parser *p, Tokenizer *t, Allocator *allocr) {
 static bool parse_file(Parser *p, ParsedFile *f) {
 	Tokenizer *t = p->tokr;
 	f->stmts = NULL;
-	f->pkg_name = NULL;
 	p->file = t->file;
 	p->parsed_file = f;
 	bool ret = true;
@@ -2352,12 +2315,6 @@ static void fprint_expr(FILE *out, Expression *e) {
 	case EXPR_VAL:
 		fprint_val(out, e->val, &e->type);
 		break;
-	case EXPR_PKG:
-		fprintf(out, "(pkg ");
-		assert(!found_type);
-		fprint_expr(out, e->pkg.name_expr);
-		fprintf(out, ")");
-		break;
 	}
 	if (found_type) {
 		fprintf(out, ":");
@@ -2479,7 +2436,6 @@ static bool expr_is_definitely_const(Expression *e) {
 	case EXPR_LITERAL_BOOL:
 	case EXPR_TYPE:
 	case EXPR_VAL:
-	case EXPR_PKG:
 		return true;
 	case EXPR_IF:
 	case EXPR_WHILE:
@@ -2501,9 +2457,6 @@ static bool expr_is_definitely_const(Expression *e) {
 				return false;
 			Type *lhs_type = &e->binary.lhs->type;
 			if (lhs_type->kind == TYPE_PTR) lhs_type = lhs_type->ptr;
-			if (type_is_builtin(lhs_type, BUILTIN_PKG)) {
-				return ident_is_definitely_const(e->binary.dot.pkg_ident);
-			}
 			return true;
 		}
 		return expr_is_definitely_const(e->binary.lhs)
diff --git a/std/arr.toc b/std/arr.toc
index 12d44f5..24fdf9f 100644
--- a/std/arr.toc
+++ b/std/arr.toc
@@ -1,13 +1,10 @@
-// array package
-pkg "arr";
-
-#export Arr ::= fn (t :: Type) Type {
+Arr ::= fn (t :: Type) Type {
 	struct {
 		   data : []t;
 		   cap : int;
 	}
 };
-#export arr_add ::= fn(t ::=, a : &Arr(t), x : t) {
+arr_add ::= fn(t ::=, a : &Arr(t), x : t) {
 		if a.data.len >= a.cap {
 		   a.cap = a.cap * 2 + 2;
 		   new_data := new(t, a.cap);
@@ -17,7 +14,7 @@ pkg "arr";
 		   }
 		   a.data = new_data;
 		}
-		a.data[a.data.len] = x;
 		a.data.len += 1;
+		a.data[a.data.len-1] = x;
 };
-#export arr_len ::= fn(t ::=, a : Arr(t)) int { a.data.len };
+arr_len ::= fn(t ::=, a : Arr(t)) int { a.data.len };
diff --git a/std/io.toc b/std/io.toc
index e9d73d6..dab2aea 100644
--- a/std/io.toc
+++ b/std/io.toc
@@ -1,5 +1,3 @@
-pkg "io";
-
 get_type_with_size ::= fn(size :: i64) Type {
 	if size == 1 { i8 }
 	elif size == 2 { i16 }
@@ -30,15 +28,7 @@ stdout_fwrite ::= fn(data: &u8, size: u64, nmemb: u64) {
 	c_fwrite(data, size as c_size_t, nmemb as c_size_t, #builtin("stdout"));
 };
 
-#export puts ::= fn(x: []char) {
+puts ::= fn(x: []char) {
 		stdout_fwrite(&x[0] as &u8, 1, x.len as u64);
 		toc_putchar('\n');
 };
-
-arr ::= pkg "arr";
-
-#export puts_arr ::= fn(x: arr.Arr([]char)) {
-		for s := x.data {
-			puts(s);
-		}
-};
\ No newline at end of file
diff --git a/test.toc b/test.toc
index 341642f..9046e3a 100644
--- a/test.toc
+++ b/test.toc
@@ -1,11 +1,20 @@
-arr ::= pkg "std/arr";
-io ::= pkg "std/io";
+#include "std/arr.toc";
+#include "std/io.toc";
+
+do_thing ::= fn() int {
+	x: Arr([]char);
+	arr_add(&x, "HI");
+	arr_add(&x, "Hello");
+	arr_add(&x, "How's");
+	arr_add(&x, "it");
+	arr_add(&x, "going");
+	for a := x.data {
+		 puts(a);
+	}
+	3
+};
+
 main ::= fn() {
-	 x: arr.Arr([]char);
-	 arr.arr_add(&x, "HI");
-	 arr.arr_add(&x, "Hello");
-	 arr.arr_add(&x, "How's");
-	 arr.arr_add(&x, "it");
-	 arr.arr_add(&x, "going");
-	 io.puts_arr(x);
+	 x ::= do_thing();
+	 do_thing();
 };
\ No newline at end of file
diff --git a/toc.c b/toc.c
index 9bb497e..99e4f5e 100644
--- a/toc.c
+++ b/toc.c
@@ -124,7 +124,6 @@ static char *read_entire_file(Allocator *a, ErrCtx *ectx, const char *filename)
 #include "foreign.c"
 #include "eval.c"
 #include "infer.c"
-#include "package.c"
 #include "types.c"
 static bool cgen_decls_file(CGenerator *g, ParsedFile *f);
 static bool cgen_sdecls_file(CGenerator *g, ParsedFile *f);
diff --git a/tokenizer.c b/tokenizer.c
index dc194ca..b34bc65 100644
--- a/tokenizer.c
+++ b/tokenizer.c
@@ -14,8 +14,7 @@ static const char *const keywords[KW_COUNT] =
 	 "int", "i8", "i16", "i32", "i64",
 	 "u8", "u16", "u32", "u64", "float", "f32", "f64", "Type",
 	 "Package",
-	 "char", "bool", "true", "false",
-	 "pkg"};
+	 "char", "bool", "true", "false"};
 
 static inline const char *kw_to_str(Keyword k) { return keywords[k]; }
 
diff --git a/types.c b/types.c
index 0cab515..3e038e6 100644
--- a/types.c
+++ b/types.c
@@ -172,8 +172,7 @@ static bool expr_must_lval(Expression *e) {
 	case EXPR_BLOCK:
 	case EXPR_SLICE:
 	case EXPR_TYPE:
-	case EXPR_VAL:
-	case EXPR_PKG: {
+	case EXPR_VAL: {
 		err_print(e->where, "Cannot use %s as l-value.", expr_kind_to_str(e->kind));
 		return false;
 	}
@@ -183,7 +182,7 @@ static bool expr_must_lval(Expression *e) {
 }
 
 
-/* does this type have a Type or a Package in it? (e.g. [5]Type, &&Package) */
+/* does this type have a Type or a Package in it? (e.g. [5]Type, &&Type) */
 static bool type_is_compileonly(Type *t) {
 	assert(t->flags & TYPE_IS_RESOLVED);
 	switch (t->kind) {
@@ -191,7 +190,7 @@ static bool type_is_compileonly(Type *t) {
 	case TYPE_UNKNOWN:
 		return false;
 	case TYPE_BUILTIN:
-		return t->builtin == BUILTIN_PKG || t->builtin == BUILTIN_TYPE;
+		return t->builtin == BUILTIN_TYPE;
 	case TYPE_PTR:
 		return type_is_compileonly(t->ptr);
 	case TYPE_SLICE:
@@ -612,7 +611,6 @@ static bool type_can_be_truthy(Type *t) {
 	case TYPE_BUILTIN:
 		switch (t->builtin) {
 		case BUILTIN_TYPE:
-		case BUILTIN_PKG:
 			return false;
 		case BUILTIN_I8:
 		case BUILTIN_U8:
@@ -678,7 +676,6 @@ static Status type_cast_status(Type *from, Type *to) {
 				case BUILTIN_BOOL:
 				case BUILTIN_CHAR:
 					return STATUS_NONE;
-				case BUILTIN_PKG:
 				case BUILTIN_TYPE:
 					return STATUS_ERR;
 				}
@@ -710,7 +707,6 @@ static Status type_cast_status(Type *from, Type *to) {
 				return STATUS_NONE;
 			case BUILTIN_CHAR:
 			case BUILTIN_TYPE:
-			case BUILTIN_PKG:
 				return STATUS_ERR;
 			}
 			assert(0);
@@ -722,7 +718,6 @@ static Status type_cast_status(Type *from, Type *to) {
 		case BUILTIN_BOOL:
 			return type_can_be_truthy(to) ? STATUS_NONE : STATUS_ERR;
 		case BUILTIN_TYPE:
-		case BUILTIN_PKG:
 			return STATUS_ERR;
 		}
 		break;
@@ -1063,14 +1058,16 @@ static bool types_expr(Typer *tr, Expression *e) {
 	e->flags |= EXPR_FOUND_TYPE; /* even if failed, pretend we found the type */
 	switch (e->kind) {
 	case EXPR_FN: {
-		if (!type_of_fn(tr, e->fn, &e->type, 0))
+		if (!type_of_fn(tr, e->fn, &e->type, 0)) {
 			return false;
+		}
 		if (fn_has_any_const_params(e->fn)) {
 			HashTable z = {0};
 			e->fn->instances = z;
 		} else {
-			if (!types_fn(tr, e->fn, &e->type, NULL))
+			if (!types_fn(tr, e->fn, &e->type, NULL)) {
 				return false;
+			}
 		}
 	} break;
 	case EXPR_LITERAL_INT:
@@ -1099,41 +1096,6 @@ static bool types_expr(Typer *tr, Expression *e) {
 		t->kind = TYPE_BUILTIN;
 		t->builtin = BUILTIN_CHAR;
 		break;
-	case EXPR_PKG: {
-		t->kind = TYPE_BUILTIN;
-		t->builtin = BUILTIN_PKG;
-		Expression *name_expr = e->pkg.name_expr;
-		if (!types_expr(tr, name_expr)) return false;
-		if (!type_is_slicechar(&name_expr->type)) {
-			char *s = type_to_str(&name_expr->type);
-			err_print(name_expr->where, "Package name is not of type []char (as it should be), but of type %s.",  s);
-			free(s);
-			return false;
-		}
-		Value name_val;
-		if (!eval_expr(tr->evalr, name_expr, &name_val))
-			return false;
-
-		Slice name_str = name_val.slice;
-		if (name_str.n < 0) {
-			err_print(name_expr->where, "Package name has negative length (" I64_FMT ")!", name_str.n);
-			return false;
-		}
-		size_t name_str_len = (size_t)name_str.n;
-		char *name_cstr = typer_malloc(tr, name_str_len + 1);
-		memcpy(name_cstr, name_str.data, name_str_len);
-		name_cstr[name_str.n] = '\0';
-	    char *filename = typer_malloc(tr, name_str_len + 6);
-		memcpy(filename, name_str.data, name_str_len);
-		strcpy(filename + name_str.n, ".top");
-		/* TODO: package paths */
-		Package *pkg = import_pkg(&tr->pkgmgr, tr->allocr, filename, tr->err_ctx, e->where);
-	    if (!pkg) {
-			return false;
-		}
-		e->kind = EXPR_VAL;
-		e->val.pkg = pkg;
-	} break;
 	case EXPR_FOR: {
 		ForExpr *fo = e->for_;
 		*(Expression **)typer_arr_add(tr, &tr->in_expr_decls) = e;
@@ -2069,45 +2031,6 @@ static bool types_expr(Typer *tr, Expression *e) {
 			if (struct_type->kind == TYPE_UNKNOWN) return true;
 			if (struct_type->kind == TYPE_PTR)
 				struct_type = struct_type->ptr;
-			
-			if (type_is_builtin(struct_type, BUILTIN_PKG)) {
-				if (rhs->kind != EXPR_IDENT) {
-					err_print(rhs->where, "Expected identifier for package access, but got %s.",
-							  expr_kind_to_str(rhs->kind));
-					return false;
-				}
-				{
-					Value pkg_val;
-					if (!eval_expr(tr->evalr, lhs, &pkg_val))
-						return false;
-					lhs->kind = EXPR_VAL;
-					if (lhs_type->kind == TYPE_PTR) {
-						/* that's a pointer to a package! */
-
-						/* soon it will be a package... */
-						lhs->type.kind = TYPE_BUILTIN;
-						lhs->type.builtin = BUILTIN_PKG;
-					
-						eval_deref(&lhs->val, pkg_val.ptr, &lhs->type);
-					} else {
-						lhs->val = pkg_val;
-					}
-				}
-				Package *pkg = lhs->val.pkg;
-				e->binary.dot.pkg_ident = ident_translate(rhs->ident, &pkg->idents);
-				if (!e->binary.dot.pkg_ident) {
-					char *ident_name = ident_to_str(rhs->ident);
-					
-					err_print(e->where, "%s was not imported from package %s.", ident_name, pkg->name);
-					free(ident_name);
-					return false;
-				}
-				if (!type_of_ident(tr, e->where, e->binary.dot.pkg_ident, t)) {
-					return false;
-				}
-				break;
-			}
-			
 			if (rhs->kind != EXPR_IDENT) {
 				err_print(rhs->where, "Expected identifier for struct member access, but got %s.",
 						  expr_kind_to_str(rhs->kind));
@@ -2279,8 +2202,8 @@ static bool types_block(Typer *tr, Block *b) {
 }
 
 static bool types_decl(Typer *tr, Declaration *d) {
-	bool success = true;
 	if (d->flags & DECL_FOUND_TYPE) return true;
+	bool success = true;
 
 	if ((d->flags & DECL_HAS_EXPR)
 		&& d->expr.kind == EXPR_TYPE
@@ -2418,17 +2341,7 @@ static bool types_decl(Typer *tr, Declaration *d) {
  ret:
 	/* pretend we found the type even if we didn't to prevent too many errors */
 	d->flags |= DECL_FOUND_TYPE;
-	if (success) {
-		if (d->flags & DECL_EXPORT) {
-			/* export it! */
-			if (!tr->pkg_name) {
-				err_print(d->where, "Declaration marked for exporting, but no package output was specified."); 
-				success = false;
-			} else {
-				export_decl_external(tr->exptr, d);
-			}
-		}
-	} else {
+	if (!success) {
 		/* use unknown type if we didn't get the type */
 		d->type.flags = TYPE_IS_RESOLVED;
 		d->type.was_expr = NULL;
@@ -2452,8 +2365,9 @@ static bool types_stmt(Typer *tr, Statement *s) {
 		}
 		break;
 	case STMT_DECL:
-		if (!types_decl(tr, &s->decl))
+		if (!types_decl(tr, &s->decl)) {
 			return false;
+		}
 		break;
 	case STMT_RET:
 		if (!tr->fn) {
@@ -2522,14 +2436,12 @@ static bool types_stmt(Typer *tr, Statement *s) {
 static void typer_create(Typer *tr, Evaluator *ev, ErrCtx *err_ctx, Allocator *allocr, Identifiers *idents) {
 	tr->block = NULL;
 	tr->blocks = NULL;
-	pkgmgr_create(tr->pkgmgr);
 	tr->fn = NULL;
 	tr->evalr = ev;
 	tr->err_ctx = err_ctx;
 	tr->exptr = NULL; /* by default, don't set an exporter */
 	tr->in_decls = NULL;
 	tr->in_expr_decls = NULL;
-	tr->pkg_name = NULL;
 	tr->allocr = allocr;
 	tr->idents = idents;
 	tr->is_reference_stack = NULL;
@@ -2538,52 +2450,11 @@ static void typer_create(Typer *tr, Evaluator *ev, ErrCtx *err_ctx, Allocator *a
 
 static bool types_file(Typer *tr, ParsedFile *f) {
 	bool ret = true;
-	FILE *pkg_fp = NULL;
 	tr->parsed_file = f;
-	if (f->pkg_name) {
-		Value pkg_name;
-		if (!types_expr(tr, f->pkg_name))
-			return false;
-		if (!type_is_slicechar(&f->pkg_name->type)) {
-			char *typestr = type_to_str(&f->pkg_name->type);
-			err_print(f->pkg_name->where, "Package names must be of type []char, but this is of type %s.", typestr);
-			free(typestr);
-			return false;
-		}
-		if (!eval_expr(tr->evalr, f->pkg_name, &pkg_name))
-			return false;
-		Slice pkg_name_slice = pkg_name.slice;
-		char *pkg_name_str = pkg_name_slice.data;
-		if (pkg_name_slice.n < 0) {
-			err_print(f->pkg_name->where, "Package name has a negative length (" I64_FMT ")!", pkg_name_slice.n);
-			return false;
-		}
-		size_t pkg_name_len = (size_t)pkg_name_slice.n;
-		
-		char *pkg_name_cstr = typer_malloc(tr, pkg_name_len+1);
-		memcpy(pkg_name_cstr, pkg_name_str, pkg_name_len);
-		pkg_name_cstr[pkg_name_len] = 0;
-		tr->pkg_name = pkg_name_cstr;
-		char *pkg_file_name = typer_malloc(tr, pkg_name_len+5);
-		sprintf(pkg_file_name, "%s.top", pkg_name_cstr);
-		pkg_fp = fopen(pkg_file_name, "wb");
-		if (!pkg_fp) {
-			err_print(f->pkg_name->where, "Could not open package output file: %s.", pkg_file_name);
-			free(pkg_file_name);
-			return false;
-		}
-		exptr_create(tr->exptr, pkg_fp, pkg_file_name, tr->err_ctx);
-		exptr_start(tr->exptr, pkg_name_str, pkg_name_len);
-	}
-
 	arr_foreach(f->stmts, Statement, s) {
 		if (!types_stmt(tr, s)) {
 			ret = false;
 		}
 	}
-	if (pkg_fp) {
-		exptr_finish(tr->exptr);
-		fclose(pkg_fp);
-	}
 	return ret;
 }
diff --git a/types.h b/types.h
index e9a2a6e..15643e8 100644
--- a/types.h
+++ b/types.h
@@ -163,7 +163,6 @@ typedef union Value {
 	union Value *tuple;
 	Slice slice;
 	struct Type *type;
-	struct Package *pkg;
 } Value;
 
 enum {
@@ -194,8 +193,6 @@ typedef struct IdentSlot {
 	bool anonymous; /* is this identifier not part of a tree? */
 	bool imported; /* was this identifier imported from a package? */
 	U64 export_id; /* 0 if there's no exported identifier here, otherwise unique positive integer associated with this identifier */
-	struct Package *from_pkg;
-	struct Package *pkg; /* NULL if this is not associated with a package */
 	IdentDecl *decls; /* array of declarations of this identifier */
 } IdentSlot;
 
@@ -303,7 +300,6 @@ typedef enum {
 			  KW_BOOL,
 			  KW_TRUE,
 			  KW_FALSE,
-			  KW_PKG,
 			  KW_COUNT
 } Keyword;
 
@@ -405,8 +401,7 @@ typedef enum {
 			  BUILTIN_F64,
 			  BUILTIN_CHAR,
 			  BUILTIN_BOOL,
-			  BUILTIN_TYPE,
-			  BUILTIN_PKG
+			  BUILTIN_TYPE
 } BuiltinType;
 
 
@@ -513,7 +508,6 @@ typedef enum {
 			  EXPR_BUILTIN,
 			  EXPR_SLICE,
 			  EXPR_TYPE,
-			  EXPR_PKG,
 			  /* 
 				 a value (it's useful to have this). 
 				 right now they don't work with cgen_set_tuple
@@ -734,7 +728,6 @@ typedef struct Expression {
 			struct Expression *rhs;
 			union {
 				Field *field; /* for struct. */
-				Identifier pkg_ident; /* for Package. */
 			} dot;
 		} binary;
 		CallExpr call;
@@ -752,9 +745,6 @@ typedef struct Expression {
 		struct {
 			Type type;
 		} del;
-		struct {
-			struct Expression *name_expr;
-		} pkg; /* can only exist before typing */
 		IfExpr if_;
 		WhileExpr while_;
 		ForExpr *for_;
@@ -856,7 +846,6 @@ typedef struct Statement {
 
 typedef struct ParsedFile {
 	Statement *stmts;
-	Expression *pkg_name;
 } ParsedFile;
 
 typedef struct Parser {
@@ -907,10 +896,6 @@ typedef struct Package {
 	} c;
 } Package;
 
-typedef struct PackageManager {
-	StrHashTable pkgs;
-} PackageManager;
-
 typedef struct Typer {
 	Allocator *allocr;
 	Evaluator *evalr;
@@ -921,43 +906,12 @@ typedef struct Typer {
 	Block *block;
 	Block **blocks; /* dyn array of all the block's we're in ([0] = NULL for global scope) */
 	FnExpr *fn; /* the function we're currently parsing. */
-	char *pkg_name;
 	ErrCtx *err_ctx;
 	/* for checking for problematic struct circular dependencies */
 	bool *is_reference_stack;
 	ParsedFile *parsed_file;
-	PackageManager pkgmgr;
 } Typer;
 
-typedef struct Exporter {
-	FILE *out; /* .top (toc package) to output to */
-	bool started;
-	bool export_all_ident_names; /* export every identifier's name, not just the important ones */
-	U64 ident_id;
-	File exporting_to;
-	U32 nexported_structs;
-	U32 nexported_fns;
-	Identifier *exported_idents; /* (only those whose names are exported) */ 
-	Declaration **decls_to_export; /* declarations which need to be exported at some point */
-	const char *code;
-} Exporter;
-
-typedef struct Importer {
-	FILE *in;
-	File *importing_from;
-	Package *pkg;
-	Allocator *allocr;
-	Identifier *ident_map; /* [i] = value of identifier with ID i */
-	ErrCtx *err_ctx;
-	Declaration *decls;
-	size_t max_ident_id;
-	Location import_location;
-	StructDef *structs;
-	FnExpr *fns;
-	PackageManager *pkgmgr;
-} Importer;
-
-
 typedef struct CGenerator {
 	Allocator *allocr;
 	FILE *outc;
@@ -968,10 +922,8 @@ typedef struct CGenerator {
 	Block *block;
 	FnExpr *fn; /* which function are we in? (NULL for none) - not used during decls */
 	Evaluator *evalr;
-	Exporter *exptr;
 	Identifier main_ident;
 	Identifiers *idents;
-	char *pkg_prefix;
 } CGenerator;
 
 #ifdef TOC_DEBUG