ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/Makefile.vc

@@ -14,23 +14,23 @@ default: runtest runtest_shared
 
 runtest:\
 Makefile runtest.c alloc_fail.c test_parse.c test_parse_error.c test_parse_roundtrip.c \
-test_indent.c test_typecheck.c test_numba.c test_typedef.c test_match.c test_buffer.c \
-test.h alloc_fail.h \
+test_indent.c test_typecheck.c test_numba.c test_typedef.c test_match.c test_unify.c \
+test_buffer.c test.h alloc_fail.h \
 $(SRCDIR)\ndtypes.h $(SRCDIR)\$(LIBSTATIC)
 	$(CC) -I$(SRCDIR) $(CFLAGS) -DTEST_ALLOC /Feruntest runtest.c \
             alloc_fail.c test_parse.c test_parse_error.c test_parse_roundtrip.c \
             test_indent.c test_typecheck.c test_numba.c test_typedef.c test_match.c \
-            test_buffer.c \
+            test_unify.c test_buffer.c \
             $(SRCDIR)\$(LIBSTATIC)
 
 runtest_shared:\
 Makefile runtest.c alloc_fail.c test_parse.c test_parse_error.c test_parse_roundtrip.c \
-test_indent.c test_typedef.c test_match.c test.h alloc_fail.h \
+test_indent.c test_typedef.c test_match.c test_unify.c test.h alloc_fail.h \
 $(SRCDIR)\ndtypes.h $(SRCDIR)\$(LIBSHARED)
 	$(CC) -I$(SRCDIR) $(CFLAGS_SHARED) -DTEST_ALLOC /Feruntest_shared runtest.c \
             alloc_fail.c test_parse.c test_parse_error.c test_parse_roundtrip.c \
             test_indent.c test_typecheck.c test_numba.c test_typedef.c test_match.c \
-            test_buffer.c \
+            test_unify.c test_buffer.c \
             $(SRCDIR)\$(LIBSHARED)
 
 

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/runtest.c

@@ -53,7 +53,8 @@ static int
 init_tests(void)
 {
     ndt_context_t *ctx;
-    ndt_t *t = NULL;
+    const ndt_t *t = NULL;
+    int ret;
 
     ctx = ndt_context_new();
     if (ctx == NULL) {
@@ -73,7 +74,10 @@ init_tests(void)
         ndt_context_del(ctx);
         return -1;
     }
-    if (ndt_typedef("defined_t", t, NULL, ctx) < 0) {
+
+    ret = ndt_typedef("defined_t", t, NULL, ctx);
+    ndt_decref(t);
+    if (ret < 0) {
         ndt_err_fprint(stderr, ctx);
         ndt_context_del(ctx);
         return -1;
@@ -85,7 +89,10 @@ init_tests(void)
         ndt_context_del(ctx);
         return -1;
     }
-    if (ndt_typedef("foo_t", t, NULL, ctx) < 0) {
+
+    ret = ndt_typedef("foo_t", t, NULL, ctx);
+    ndt_decref(t);
+    if (ret < 0) {
         ndt_err_fprint(stderr, ctx);
         ndt_context_del(ctx);
         return -1;
@@ -100,7 +107,7 @@ test_parse(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     char *s;
     int count = 0;
 
@@ -123,7 +130,7 @@ test_parse(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_parse: parse: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_parse: parse: FAIL: %s\n", *c);
@@ -152,7 +159,7 @@ test_parse(void)
 
             if (s != NULL) {
                 ndt_free(s);
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_parse: convert: FAIL: s != NULL after MemoryError\n");
                 fprintf(stderr, "test_parse: parse: FAIL: %s\n", *c);
@@ -164,13 +171,13 @@ test_parse(void)
             fprintf(stderr, "test_parse: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
 
         ndt_free(s);
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
     fprintf(stderr, "test_parse (%d test cases)\n", count);
@@ -184,7 +191,7 @@ test_parse_roundtrip(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     char *s;
     int count = 0;
 
@@ -211,7 +218,7 @@ test_parse_roundtrip(void)
             fprintf(stderr, "test_parse_roundtrip: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
@@ -220,13 +227,13 @@ test_parse_roundtrip(void)
             fprintf(stderr, "test_parse_roundtrip: convert: FAIL: input:     \"%s\"\n", *c);
             fprintf(stderr, "test_parse_roundtrip: convert: FAIL: roundtrip: \"%s\"\n", s);
             ndt_free(s);
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
 
         ndt_free(s);
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
     fprintf(stderr, "test_parse_roundtrip (%d test cases)\n", count);
@@ -240,7 +247,7 @@ test_parse_error(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -262,7 +269,7 @@ test_parse_error(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_parse_error: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_parse_error: FAIL: input: %s\n", *c);
@@ -274,7 +281,7 @@ test_parse_error(void)
             fprintf(stderr, "test_parse_error: FAIL: t != NULL after %s: %s\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
@@ -292,7 +299,7 @@ test_indent(void)
     const indent_testcase_t *tc;
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     char *s;
     int count = 0;
 
@@ -326,7 +333,7 @@ test_indent(void)
 
             if (s != NULL) {
                 ndt_free(s);
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_indent: convert: FAIL: s != NULL after MemoryError\n");
                 fprintf(stderr, "test_indent: convert: FAIL: %s\n", *c);
@@ -338,13 +345,13 @@ test_indent(void)
             fprintf(stderr, "test_indent: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
 
         ndt_free(s);
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
 
@@ -372,7 +379,7 @@ test_indent(void)
 
             if (s != NULL) {
                 ndt_free(s);
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_indent: convert: FAIL: s != NULL after MemoryError\n");
                 fprintf(stderr, "test_indent: convert: FAIL: %s\n", tc->input);
@@ -384,7 +391,7 @@ test_indent(void)
             fprintf(stderr, "test_indent: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
@@ -394,13 +401,13 @@ test_indent(void)
             fprintf(stderr, "test_indent: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
 
         ndt_free(s);
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
 
@@ -415,7 +422,7 @@ test_typedef(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -433,6 +440,7 @@ test_typedef(void)
             ndt_set_alloc_fail();
             (void)ndt_typedef(*c, t, NULL, ctx);
             ndt_set_alloc();
+            ndt_decref(t);
 
             if (ctx->err != NDT_MemoryError) {
                 break;
@@ -469,7 +477,7 @@ test_typedef_duplicates(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -487,19 +495,23 @@ test_typedef_duplicates(void)
             ndt_set_alloc_fail();
             (void)ndt_typedef(*c, t, NULL, ctx);
             ndt_set_alloc();
+            ndt_decref(t);
 
             if (ctx->err != NDT_MemoryError) {
+                if (ndt_typedef_find(*c, ctx) == NULL) {
+                    fprintf(stderr, "test_typedef: FAIL: key should be in map\n");
+                    fprintf(stderr, "test_typedef: FAIL: input: %s\n", *c);
+                    ndt_context_del(ctx);
+                    return -1;
+                }
                 break;
             }
-
-            if (ndt_typedef_find(*c, ctx) == NULL) {
-                fprintf(stderr, "test_typedef: FAIL: key should be in map\n");
-                fprintf(stderr, "test_typedef: FAIL: input: %s\n", *c);
-                ndt_context_del(ctx);
-                return -1;
-            }
         }
 
+        t = ndt_from_string("10 * 20 * {a : int64, b : ref(float64)}", ctx);
+        (void)ndt_typedef(*c, t, NULL, ctx);
+        ndt_decref(t);
+
         if (ctx->err != NDT_ValueError) {
             fprintf(stderr, "test_typedef: FAIL: no value error after duplicate key\n");
             fprintf(stderr, "test_typedef: FAIL: input: %s\n", *c);
@@ -521,7 +533,7 @@ test_typedef_error(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -539,6 +551,7 @@ test_typedef_error(void)
             ndt_set_alloc_fail();
             (void)ndt_typedef(*c, t, NULL, ctx);
             ndt_set_alloc();
+            ndt_decref(t);
 
             if (ctx->err != NDT_MemoryError) {
                 break;
@@ -575,7 +588,7 @@ test_equal(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t, *u;
+    const ndt_t *t, *u;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -596,29 +609,29 @@ test_equal(void)
 
         u = ndt_from_string(*(c+1), ctx);
         if (u == NULL) {
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             fprintf(stderr, "test_equal: FAIL: could not parse \"%s\"\n", *(c+1));
             return -1;
         }
 
         if (!ndt_equal(t, t)) {
-            ndt_del(t);
-            ndt_del(u);
+            ndt_decref(t);
+            ndt_decref(u);
             ndt_context_del(ctx);
             fprintf(stderr, "test_equal: FAIL: \"%s\" != \"%s\"\n", *c, *c);
             return -1;
         }
 
         if (ndt_equal(t, u)) {
-            ndt_del(t);
-            ndt_del(u);
+            ndt_decref(t);
+            ndt_decref(u);
             fprintf(stderr, "test_equal: FAIL: \"%s\" == \"%s\"\n", *c, *(c+1));
             return -1;
         }
 
-        ndt_del(t);
-        ndt_del(u);
+        ndt_decref(t);
+        ndt_decref(u);
         count++;
     }
 
@@ -633,8 +646,8 @@ test_match(void)
 {
     const match_testcase_t *t;
     ndt_context_t *ctx;
-    ndt_t *p;
-    ndt_t *c;
+    const ndt_t *p;
+    const ndt_t *c;
     int ret, count = 0;
 
     ctx = ndt_context_new();
@@ -653,7 +666,7 @@ test_match(void)
 
         c = ndt_from_string(t->candidate, ctx);
         if (c == NULL) {
-            ndt_del(p);
+            ndt_decref(p);
             ndt_context_del(ctx);
             fprintf(stderr, "test_match: FAIL: could not parse \"%s\"\n", t->candidate);
             return -1;
@@ -671,8 +684,8 @@ test_match(void)
             }
 
             if (ret != -1) {
-                ndt_del(p);
-                ndt_del(c);
+                ndt_decref(p);
+                ndt_decref(c);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_match: FAIL: expect ret == -1 after MemoryError\n");
                 fprintf(stderr, "test_match: FAIL: \"%s\"\n", t->pattern);
@@ -681,8 +694,8 @@ test_match(void)
         }
 
         if (ret != t->expected) {
-            ndt_del(p);
-            ndt_del(c);
+            ndt_decref(p);
+            ndt_decref(c);
             ndt_context_del(ctx);
             fprintf(stderr, "test_match: FAIL: expected %s\n", t->expected ? "true" : "false");
             fprintf(stderr, "test_match: FAIL: pattern: \"%s\"\n", t->pattern);
@@ -690,8 +703,8 @@ test_match(void)
             return -1;
         }
 
-        ndt_del(p);
-        ndt_del(c);
+        ndt_decref(p);
+        ndt_decref(c);
         count++;
     }
     fprintf(stderr, "test_match (%d test cases)\n", count);
@@ -700,9 +713,104 @@ test_match(void)
     return 0;
 }
 
+static int
+test_unify(void)
+{
+    const unify_testcase_t *t;
+    ndt_context_t *ctx;
+    const ndt_t *t1;
+    const ndt_t *t2;
+    const ndt_t *expected;
+    const ndt_t *ret;
+    int count = 0;
+
+    ctx = ndt_context_new();
+    if (ctx == NULL) {
+        fprintf(stderr, "error: out of memory");
+        return -1;
+    }
+
+    for (t = unify_tests; t->t1 != NULL; t++) {
+        t1 = ndt_from_string(t->t1, ctx);
+        if (t1 == NULL) {
+            fprintf(stderr, "test_unify: FAIL: could not parse t1 \"%s\"\n", t->t1);
+            ndt_context_del(ctx);
+            return -1;
+        }
+
+        t2 = ndt_from_string(t->t2, ctx);
+        if (t2 == NULL) {
+            ndt_decref(t1);
+            ndt_context_del(ctx);
+            fprintf(stderr, "test_unify: FAIL: could not parse t2 \"%s\"\n", t->t2);
+            return -1;
+        }
+
+        expected = NULL;
+        if (t->expected) {
+            expected = ndt_from_string(t->expected, ctx);
+            if (expected == NULL) {
+                ndt_decref(t1);
+                ndt_decref(t2);
+                ndt_context_del(ctx);
+                fprintf(stderr, "test_unify: FAIL: could not parse expected \"%s\"\n", t->expected);
+                return -1;
+            }
+        }
+
+        for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
+            ndt_err_clear(ctx);
+
+            ndt_set_alloc_fail();
+            ret = ndt_unify(t1, t2, ctx);
+            ndt_set_alloc();
+
+            if (ctx->err != NDT_MemoryError) {
+                break;
+            }
+
+            if (ret != NULL) {
+                ndt_decref(t1);
+                ndt_decref(t2);
+                ndt_decref(expected);
+                ndt_context_del(ctx);
+                fprintf(stderr, "test_unify: FAIL: expect ret == NULL after MemoryError\n");
+                fprintf(stderr, "test_unify: FAIL: \"%s\"\n", t->t1);
+                return -1;
+            }
+        }
+
+        ndt_decref(t1);
+        ndt_decref(t2);
+
+        if (ret == NULL && expected == NULL) {
+            ndt_err_clear(ctx);
+            continue;
+        }
+
+        if ((ret != NULL && expected != NULL) && ndt_equal(ret, expected)) {
+            ndt_decref(ret);
+            ndt_decref(expected);
+            count++;
+            continue;
+        }
+
+        ndt_decref(expected);
+        ndt_decref(ret);
+        fprintf(stderr, "test_unify: FAIL: expected \"%s\"\n", t->expected);
+        fprintf(stderr, "test_unify: FAIL: t1:      \"%s\"\n", t->t1);
+        fprintf(stderr, "test_unify: FAIL: t2:      \"%s\"\n", t->t2);
+        return -1;
+    }
+    fprintf(stderr, "test_unify (%d test cases)\n", count);
+
+    ndt_context_del(ctx);
+    return 0;
+}
+
 typedef struct {
     int64_t size;
-    ndt_t *types[NDT_MAX_ARGS];
+    const ndt_t *types[NDT_MAX_ARGS];
 } type_array_t;
 
 static type_array_t
@@ -726,14 +834,13 @@ types_from_string(const char * const *s, ndt_context_t *ctx)
 }
 
 static int
-validate_typecheck_test(const typecheck_testcase_t *test,
+validate_typecheck_test(ndt_apply_spec_t *spec,
                         const ndt_t *sig,
-                        ndt_apply_spec_t *spec,
+                        const typecheck_testcase_t *test,
                         int ret,
                         ndt_context_t *ctx)
 {
-    type_array_t out;
-    type_array_t broadcast;
+    type_array_t expected;
     int64_t i;
 
     if (!test->success) {
@@ -741,68 +848,62 @@ validate_typecheck_test(const typecheck_testcase_t *test,
             return 0;
         }
         ndt_err_format(ctx, NDT_RuntimeError,
-            "test_typecheck: unexpected success: %s  %s  %s",
-             test->signature, test->in[0], test->in[1]);
+            "test_typecheck: %s: expected success=false, got success=true",
+            test->loc);
         return -1;
     }
 
-    out = types_from_string(test->out, ctx);
-    if (out.size < 0) {
+    expected = types_from_string(test->types, ctx);
+    if (expected.size < 0) {
         return -1;
     }
 
-    broadcast = types_from_string(test->broadcast, ctx);
-    if (broadcast.size < 0) {
-        ndt_type_array_clear(broadcast.types, broadcast.size);
+    if (spec->outer_dims != test->outer_dims) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "test_typecheck: %s: expected outer_dims=%d, got outer_dims=%d",
+             test->loc, test->outer_dims, spec->outer_dims);
+        ndt_type_array_clear(expected.types, expected.size);
         return -1;
     }
 
-    if (spec->nout != sig->Function.nout ||
-        spec->nout != out.size) {
+    if (spec->nin != sig->Function.nin || spec->nin != test->nin) {
         ndt_err_format(ctx, NDT_RuntimeError,
-            "test_typecheck: expected nout==test->nout==%d, got nout==%d and "
-            "test->nout==%d\n", sig->Function.nout, spec->nout, out.size);
+            "test_typecheck: %s: expected nin=%d, got nin=%d",
+             test->loc, test->nin, spec->nin);
+        ndt_type_array_clear(expected.types, expected.size);
         return -1;
     }
 
-    if (spec->nbroadcast != broadcast.size) {
+    if (spec->nout != sig->Function.nout || spec->nout != test->nout) {
         ndt_err_format(ctx, NDT_RuntimeError,
-            "test_typecheck: expected nbroadcast==%d, got %d\n",
-            broadcast.size, spec->nbroadcast);
+            "test_typecheck: %s: expected nout=%d, got nout=%d",
+             test->loc, test->nout, spec->nout);
+        ndt_type_array_clear(expected.types, expected.size);
         return -1;
     }
 
-    if (spec->outer_dims != test->outer_dims) {
+    if (spec->nargs != sig->Function.nargs || spec->nargs != test->nargs ||
+        spec->nargs != expected.size) {
         ndt_err_format(ctx, NDT_RuntimeError,
-            "test_typecheck: expected outer_dims==%d, got %d\n",
-            test->outer_dims, spec->outer_dims);
+            "test_typecheck: %s: expected nargs=%d, got nargs=%d",
+             test->loc, test->nargs, spec->nargs);
+        ndt_type_array_clear(expected.types, expected.size);
         return -1;
     }
 
-    for (i = 0; i < spec->nout; i++) {
-        if (!ndt_equal(spec->out[i], out.types[i])) {
+    for (i = 0; i < spec->nargs; i++) {
+        if (!ndt_equal(spec->types[i], expected.types[i])) {
             ndt_err_format(ctx, NDT_RuntimeError,
-                "test_typecheck: out value %d: expected %s, got %s",
-                i, test->out[i], ndt_ast_repr(spec->out[i], ctx));
-            ndt_type_array_clear(out.types, out.size);
-            ndt_type_array_clear(broadcast.types, broadcast.size);
+                "test_typecheck: %s: expected %s, got %s",
+                test->loc,
+                ndt_ast_repr(expected.types[i], ctx),
+                ndt_ast_repr(spec->types[i], ctx));
+            ndt_type_array_clear(expected.types, expected.size);
             return -1;
         }
     }
 
-    for (i = 0; i < spec->nbroadcast; i++) {
-        if (!ndt_equal(spec->broadcast[i], broadcast.types[i])) {
-            ndt_err_format(ctx, NDT_RuntimeError,
-                "test_typecheck: broadcast value %d: expected %s, got %s",
-                i, test->broadcast[i], ndt_ast_repr(spec->broadcast[i], ctx));
-            ndt_type_array_clear(out.types, out.size);
-            ndt_type_array_clear(broadcast.types, broadcast.size);
-            return -1;
-        }
-    }
-
-    ndt_type_array_clear(out.types, out.size);
-    ndt_type_array_clear(broadcast.types, broadcast.size);
+    ndt_type_array_clear(expected.types, expected.size);
 
     return 0;
 }
@@ -813,8 +914,11 @@ test_typecheck(void)
     NDT_STATIC_CONTEXT(ctx);
     ndt_apply_spec_t spec = ndt_apply_spec_empty;
     const typecheck_testcase_t *test;
+    const ndt_t *types[NDT_MAX_DIM] = {NULL};
+    const int64_t li[NDT_MAX_DIM] = {0};
+    type_array_t args;
+    type_array_t kwargs;
     const ndt_t *sig = NULL;
-    type_array_t in;
     int count = 0;
     int ret = -1;
 
@@ -826,36 +930,60 @@ test_typecheck(void)
             goto error;
         }
 
-        in = types_from_string(test->in, &ctx);
-        if (in.size < 0) {
+        args = types_from_string(test->args, &ctx);
+        if (args.size < 0) {
+            goto error;
+        }
+        const int nin = args.size;
+
+        kwargs = types_from_string(test->kwargs, &ctx);
+        if (kwargs.size < 0) {
             goto error;
         }
+        const int nout = kwargs.size;
+
+        for (int i = 0; i < nin; i++) {
+            types[i] = args.types[i];
+        }
+
+        for (int i = 0; i < nout; i++) {
+            types[nin+i] = kwargs.types[i];
+        }
 
         for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
             ndt_err_clear(&ctx);
 
             ndt_set_alloc_fail();
-            ret = ndt_typecheck(&spec, sig, (const ndt_t **)in.types, in.size, NULL, NULL, &ctx);
+            ret = ndt_typecheck(&spec, sig, types, li, nin, nout, false, NULL,
+                                NULL, &ctx);
             ndt_set_alloc();
 
             if (ctx.err != NDT_MemoryError) {
                 break;
             }
 
-            ndt_apply_spec_clear(&spec);
+            assert(spec.flags == 0);
+            assert(spec.outer_dims == 0);
+            assert(spec.nin == 0);
+            assert(spec.nout == 0);
+            assert(spec.nargs == 0);
+
             if (ret != -1) {
                 ndt_err_format(&ctx, NDT_RuntimeError,
-                    "test_typecheck: expect nout == -1 after MemoryError\n"
-                    "test_typecheck: \"%s\"\n", test->signature);
+                    "test_typecheck: %s: nout != -1 after MemoryError\n",
+                    test->loc);
                 goto error;
             }
         }
 
+        ndt_type_array_clear(args.types, args.size);
+        ndt_type_array_clear(kwargs.types, kwargs.size);
         ndt_err_clear(&ctx);
-        ret = validate_typecheck_test(test, sig, &spec, ret, &ctx);
-        ndt_type_array_clear(in.types, in.size);
+
+        ret = validate_typecheck_test(&spec, sig, test, ret, &ctx);
+
         ndt_apply_spec_clear(&spec);
-        ndt_del((ndt_t *)sig);
+        ndt_decref(sig);
 
         if (ret < 0) {
             goto error;
@@ -883,7 +1011,7 @@ test_numba(void)
 {
     NDT_STATIC_CONTEXT(ctx);
     const numba_testcase_t *test;
-    ndt_t *t;
+    const ndt_t *t;
     char *sig = NULL;
     char *core = NULL;
     int count = 0;
@@ -909,7 +1037,7 @@ test_numba(void)
             }
 
             if (ret != -1) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_err_format(&ctx, NDT_RuntimeError,
                     "test_numba: expect ret == -1 after MemoryError\n"
                     "test_numba: \"%s\"\n", test->signature);
@@ -918,7 +1046,7 @@ test_numba(void)
         }
 
         ndt_err_clear(&ctx);
-        ndt_del(t);
+        ndt_decref(t);
 
         if (sig == NULL || strcmp(sig, test->sig) != 0) {
             ndt_err_format(&ctx, NDT_RuntimeError,
@@ -958,7 +1086,7 @@ test_static_context(void)
 {
     const char **c;
     NDT_STATIC_CONTEXT(ctx);
-    ndt_t *t;
+    const ndt_t *t;
     char *s;
     int count = 0;
 
@@ -975,7 +1103,7 @@ test_static_context(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 fprintf(stderr, "test_static_context: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_static_context: FAIL: %s\n", *c);
                 return -1;
@@ -1003,7 +1131,7 @@ test_static_context(void)
 
             if (s != NULL) {
                 ndt_free(s);
-                ndt_del(t);
+                ndt_decref(t);
                 fprintf(stderr, "test_static_context: FAIL: s != NULL after MemoryError\n");
                 fprintf(stderr, "test_static_context: FAIL: %s\n", *c);
                 ndt_context_del(&ctx);
@@ -1015,13 +1143,13 @@ test_static_context(void)
             fprintf(stderr, "test_static_context: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx.err),
                     ndt_context_msg(&ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(&ctx);
             return -1;
         }
 
         ndt_free(s);
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
 
@@ -1029,7 +1157,7 @@ test_static_context(void)
     t = ndt_from_string(s, &ctx);
     if (s == NULL) {
         fprintf(stderr, "test_static_context: FAIL: expected failure: \"%s\"\n", s);
-        ndt_del(t);
+        ndt_decref(t);
         ndt_context_del(&ctx);
         return -1;
     }
@@ -1069,7 +1197,7 @@ test_hash(void)
     hash_testcase_t buf[1000];
     ptrdiff_t n = 1;
     const char **c;
-    ndt_t *t;
+    const ndt_t *t;
     hash_testcase_t x;
     int i;
 
@@ -1093,7 +1221,7 @@ test_hash(void)
 
         x.hash = ndt_hash(t, &ctx);
         x.str = *c;
-        ndt_del(t);
+        ndt_decref(t);
 
         if (x.hash == -1) {
             fprintf(stderr, "test_hash: FAIL: hash==-1\n\n");
@@ -1125,7 +1253,7 @@ test_hash(void)
     x.hash = ndt_hash(t, &ctx);
     ndt_set_alloc();
 
-    ndt_del(t);
+    ndt_decref(t);
 
     if (x.hash != -1 || ctx.err != NDT_MemoryError) {
         fprintf(stderr, "test_hash: FAIL: expected failure, got %" PRI_ndt_ssize "\n\n", x.hash);
@@ -1144,7 +1272,7 @@ test_copy(void)
 {
     NDT_STATIC_CONTEXT(ctx);
     const char **c;
-    ndt_t *t, *u;
+    const ndt_t *t, *u;
     int count = 0;
 
     for (c = parse_tests; *c != NULL; c++) {
@@ -1171,8 +1299,8 @@ test_copy(void)
 
             if (u != NULL) {
                 fprintf(stderr, "test_copy: FAIL: unexpected success: \"%s\"\n", *c);
-                ndt_del(u);
-                ndt_del(t);
+                ndt_decref(u);
+                ndt_decref(t);
                 ndt_context_del(&ctx);
                 return -1;
             }
@@ -1182,21 +1310,21 @@ test_copy(void)
             fprintf(stderr, "test_copy: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx.err),
                     ndt_context_msg(&ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(&ctx);
             return -1;
         }
 
         if (!ndt_equal(t, u)) {
             fprintf(stderr, "test_copy: FAIL: copy: not equal\n\n");
-            ndt_del(t);
-            ndt_del(u);
+            ndt_decref(t);
+            ndt_decref(u);
             ndt_context_del(&ctx);
             return -1;
         }
 
-        ndt_del(u);
-        ndt_del(t);
+        ndt_decref(u);
+        ndt_decref(t);
         count++;
     }
 
@@ -1211,7 +1339,7 @@ test_buffer(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -1233,7 +1361,7 @@ test_buffer(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_buffer: convert: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_buffer: convert: FAIL: %s\n", *c);
@@ -1249,7 +1377,7 @@ test_buffer(void)
             return -1;
         }
 
-        ndt_del(t);
+        ndt_decref(t);
         count++;
     }
     fprintf(stderr, "test_buffer (%d test cases)\n", count);
@@ -1263,7 +1391,7 @@ test_buffer_roundtrip(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     char *s;
     int count = 0;
     int ret;
@@ -1287,7 +1415,7 @@ test_buffer_roundtrip(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_buffer: convert: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_buffer: convert: FAIL: %s\n", *c);
@@ -1316,7 +1444,7 @@ test_buffer_roundtrip(void)
 
             if (s != NULL) {
                 ndt_free(s);
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_buffer_roundtrip: convert: FAIL: s != NULL after MemoryError\n");
                 fprintf(stderr, "test_buffer_roundtrip: convert: FAIL: %s\n", *c);
@@ -1328,13 +1456,13 @@ test_buffer_roundtrip(void)
             fprintf(stderr, "test_buffer_roundtrip: convert: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
 
         ret = strcmp(s, *c);
-        ndt_del(t);
+        ndt_decref(t);
 
         if (ret != 0) {
             fprintf(stderr, "test_buffer_roundtrip: convert: FAIL: input: \"%s\" output: \"%s\"\n", *c, s);
@@ -1357,7 +1485,7 @@ test_buffer_error(void)
 {
     const char **c;
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
     int count = 0;
 
     ctx = ndt_context_new();
@@ -1379,7 +1507,7 @@ test_buffer_error(void)
             }
 
             if (t != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_buffer_error: FAIL: t != NULL after MemoryError\n");
                 fprintf(stderr, "test_buffer_error: FAIL: input: %s\n", *c);
@@ -1391,7 +1519,7 @@ test_buffer_error(void)
             fprintf(stderr, "test_buffer_error: FAIL: t != NULL after %s: %s\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_context_del(ctx);
             return -1;
         }
@@ -1407,9 +1535,8 @@ static int
 test_serialize(void)
 {
     const char **c;
-    ndt_meta_t *m;
     ndt_context_t *ctx;
-    ndt_t *t, *u;
+    const ndt_t *t, *u;
     int count = 0;
     char *bytes;
     int64_t len;
@@ -1421,17 +1548,8 @@ test_serialize(void)
     }
 
     for (c = parse_tests; *c != NULL; c++) {
-        m = ndt_meta_new(ctx);
-        if (m == NULL) {
-            ndt_context_del(ctx);
-            fprintf(stderr,
-                "test_serialize: FAIL: unexpected failure in meta_new");
-            return -1;
-        }
-
         t = ndt_from_string(*c, ctx);
         if (t == NULL) {
-            ndt_meta_del(m);
             ndt_context_del(ctx);
             fprintf(stderr,
                 "test_serialize: FAIL: unexpected failure in from_string");
@@ -1451,9 +1569,8 @@ test_serialize(void)
             }
 
             if (len >= 0 || bytes != NULL) {
-                ndt_del(t);
+                ndt_decref(t);
                 ndt_free(bytes);
-                ndt_meta_del(m);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_serialize: FAIL: invalid len or bytes after MemoryError\n");
                 fprintf(stderr, "test_serialize: FAIL: %s\n", *c);
@@ -1462,9 +1579,8 @@ test_serialize(void)
         }
 
         if (len < 0 || bytes == NULL) {
-            ndt_del(t);
+            ndt_decref(t);
             ndt_free(bytes);
-            ndt_meta_del(m);
             ndt_context_del(ctx);
             fprintf(stderr, "test_serialize: FAIL: invalid len or bytes (expected success)\n");
             fprintf(stderr, "test_serialize: FAIL: %s\n", *c);
@@ -1475,7 +1591,7 @@ test_serialize(void)
             ndt_err_clear(ctx);
 
             ndt_set_alloc_fail();
-            u = ndt_deserialize(m, bytes, len, ctx);
+            u = ndt_deserialize(bytes, len, ctx);
             ndt_set_alloc();
 
             if (ctx->err != NDT_MemoryError) {
@@ -1483,10 +1599,9 @@ test_serialize(void)
             }
 
             if (u != NULL) {
-                ndt_del(t);
-                ndt_del(u);
+                ndt_decref(t);
+                ndt_decref(u);
                 ndt_free(bytes);
-                ndt_meta_del(m);
                 ndt_context_del(ctx);
                 fprintf(stderr, "test_serialize: FAIL: u != NULL after MemoryError\n");
                 fprintf(stderr, "test_serialize: FAIL: %s\n", *c);
@@ -1499,9 +1614,8 @@ test_serialize(void)
             fprintf(stderr, "test_serialize: FAIL: got: %s: %s\n\n",
                     ndt_err_as_string(ctx->err),
                     ndt_context_msg(ctx));
-            ndt_del(t);
+            ndt_decref(t);
             ndt_free(bytes);
-            ndt_meta_del(m);
             ndt_context_del(ctx);
             return -1;
         }
@@ -1510,17 +1624,15 @@ test_serialize(void)
 
         if (!ndt_equal(u, t)) {
             fprintf(stderr, "test_serialize: FAIL: u != v in %s\n", *c);
-            ndt_del(t);
-            ndt_del(u);
-            ndt_meta_del(m);
+            ndt_decref(t);
+            ndt_decref(u);
             ndt_context_del(ctx);
             return -1;
         }
 
-        ndt_del(t);
-        ndt_del(u);
+        ndt_decref(t);
+        ndt_decref(u);
 
-        ndt_meta_del(m);
         count++;
     }
     fprintf(stderr, "test_serialize (%d test cases)\n", count);
@@ -1534,7 +1646,6 @@ static int
 test_serialize_fuzz(void)
 {
     ndt_context_t *ctx;
-    ndt_meta_t *m;
     char *buf;
     ssize_t ret, n;
     int src;
@@ -1572,23 +1683,13 @@ test_serialize_fuzz(void)
             return -1;
         }
 
-        m = ndt_meta_new(ctx);
-        if (m == NULL) {
-            ndt_free(buf);
-            close(src);
-            ndt_context_del(ctx);
-            fprintf(stderr, "\nmalloc error in fuzz tests\n");
-            return -1;
-        }
-
         ndt_err_clear(ctx);
-        ndt_t *t = ndt_deserialize(m, buf, n, ctx);
+        const ndt_t *t = ndt_deserialize(buf, n, ctx);
         if (t != NULL) {
-            ndt_del(t);
+            ndt_decref(t);
         }
 
         ndt_free(buf);
-        ndt_meta_del(m);
     }
     fprintf(stderr, "test_serialize_fuzz (%" PRIi64 " test cases)\n", i);
 
@@ -1608,6 +1709,7 @@ static int (*tests[])(void) = {
   test_typedef_error,
   test_equal,
   test_match,
+  test_unify,
   test_typecheck,
   test_numba,
   test_static_context,