Assert that our return-type annotations are correct

And fix a bunch of places that they weren't.

src/runtime/builtin_modules/builtins.cpp

@@ -1084,10 +1084,9 @@ void setupBuiltins() {
         new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::new_, UNKNOWN, 3, 1, false, false), { boxInt(0) }));
     enumerate_cls->giveAttr(
         "__iter__", new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::iter, typeFromClass(enumerate_cls), 1)));
-    enumerate_cls->giveAttr(
-        "next", new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::next, typeFromClass(enumerate_cls), 1)));
-    enumerate_cls->giveAttr("__hasnext__", new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::hasnext,
-                                                                           typeFromClass(enumerate_cls), 1)));
+    enumerate_cls->giveAttr("next", new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::next, BOXED_TUPLE, 1)));
+    enumerate_cls->giveAttr("__hasnext__",
+                            new BoxedFunction(boxRTFunction((void*)BoxedEnumerate::hasnext, BOXED_BOOL, 1)));
     enumerate_cls->freeze();
     builtins_module->giveAttr("enumerate", enumerate_cls);
 
@@ -1130,7 +1129,7 @@ void setupBuiltins() {
     builtins_module->giveAttr(
         "dir", new BoxedBuiltinFunctionOrMethod(boxRTFunction((void*)dir, LIST, 1, 1, false, false), { NULL }));
     builtins_module->giveAttr(
-        "vars", new BoxedBuiltinFunctionOrMethod(boxRTFunction((void*)vars, LIST, 1, 1, false, false), { NULL }));
+        "vars", new BoxedBuiltinFunctionOrMethod(boxRTFunction((void*)vars, UNKNOWN, 1, 1, false, false), { NULL }));
     builtins_module->giveAttr("object", object_cls);
     builtins_module->giveAttr("str", str_cls);
     builtins_module->giveAttr("basestring", basestring_cls);

src/runtime/builtin_modules/thread.cpp

@@ -149,8 +149,8 @@ void setupThread() {
     thread_lock_cls = new BoxedHeapClass(object_cls, NULL, 0, sizeof(BoxedThreadLock), false, "lock");
     thread_lock_cls->giveAttr("__module__", boxStrConstant("thread"));
     thread_lock_cls->giveAttr(
-        "acquire",
-        new BoxedFunction(boxRTFunction((void*)BoxedThreadLock::acquire, NONE, 2, 1, false, false), { boxInt(1) }));
+        "acquire", new BoxedFunction(boxRTFunction((void*)BoxedThreadLock::acquire, BOXED_BOOL, 2, 1, false, false),
+                                     { boxInt(1) }));
     thread_lock_cls->giveAttr("release", new BoxedFunction(boxRTFunction((void*)BoxedThreadLock::release, NONE, 1)));
     thread_lock_cls->giveAttr("acquire_lock", thread_lock_cls->getattr("acquire"));
     thread_lock_cls->giveAttr("release_lock", thread_lock_cls->getattr("release"));

src/runtime/int.cpp

@@ -863,13 +863,13 @@ void setupInt() {
     int_cls->giveAttr("__nonzero__", new BoxedFunction(boxRTFunction((void*)intNonzero, BOXED_BOOL, 1)));
     int_cls->giveAttr("__repr__", new BoxedFunction(boxRTFunction((void*)intRepr, STR, 1)));
     int_cls->giveAttr("__hash__", new BoxedFunction(boxRTFunction((void*)intHash, BOXED_INT, 1)));
-    int_cls->giveAttr("__divmod__", new BoxedFunction(boxRTFunction((void*)intDivmod, BOXED_TUPLE, 2)));
+    int_cls->giveAttr("__divmod__", new BoxedFunction(boxRTFunction((void*)intDivmod, UNKNOWN, 2)));
 
     int_cls->giveAttr("__hex__", new BoxedFunction(boxRTFunction((void*)intHex, STR, 1)));
     int_cls->giveAttr("__oct__", new BoxedFunction(boxRTFunction((void*)intOct, STR, 1)));
 
     int_cls->giveAttr("__new__",
-                      new BoxedFunction(boxRTFunction((void*)intNew, BOXED_INT, 2, 1, false, false), { boxInt(0) }));
+                      new BoxedFunction(boxRTFunction((void*)intNew, UNKNOWN, 2, 1, false, false), { boxInt(0) }));
 
     int_cls->giveAttr("__init__",
                       new BoxedFunction(boxRTFunction((void*)intInit, NONE, 2, 1, true, false), { boxInt(0) }));

src/runtime/list.cpp

@@ -762,7 +762,7 @@ void setupList() {
     list_cls->giveAttr("pop", new BoxedFunction(boxRTFunction((void*)listPop, UNKNOWN, 2, 1, false, false), { None }));
 
     list_cls->giveAttr("append", new BoxedFunction(boxRTFunction((void*)listAppend, NONE, 2)));
-    list_cls->giveAttr("extend", new BoxedFunction(boxRTFunction((void*)listIAdd, NONE, 2)));
+    list_cls->giveAttr("extend", new BoxedFunction(boxRTFunction((void*)listIAdd, LIST, 2)));
 
     CLFunction* setitem = createRTFunction(3, 0, false, false);
     addRTFunction(setitem, (void*)listSetitemInt, NONE, std::vector<ConcreteCompilerType*>{ LIST, BOXED_INT, UNKNOWN });

src/runtime/objmodel.cpp

@@ -2684,14 +2684,20 @@ Box* callCLFunc(CLFunction* f, CallRewriteArgs* rewrite_args, int num_output_arg
         rewrite_args->out_success = true;
     }
 
+    Box* r;
     if (closure && generator)
-        return chosen_cf->closure_generator_call(closure, generator, oarg1, oarg2, oarg3, oargs);
+        r = chosen_cf->closure_generator_call(closure, generator, oarg1, oarg2, oarg3, oargs);
     else if (closure)
-        return chosen_cf->closure_call(closure, oarg1, oarg2, oarg3, oargs);
+        r = chosen_cf->closure_call(closure, oarg1, oarg2, oarg3, oargs);
     else if (generator)
-        return chosen_cf->generator_call(generator, oarg1, oarg2, oarg3, oargs);
+        r = chosen_cf->generator_call(generator, oarg1, oarg2, oarg3, oargs);
     else
-        return chosen_cf->call(oarg1, oarg2, oarg3, oargs);
+        r = chosen_cf->call(oarg1, oarg2, oarg3, oargs);
+
+    ASSERT(chosen_cf->spec->rtn_type->isFitBy(r->cls), "%s (%p) %s %s",
+           g.func_addr_registry.getFuncNameAtAddress(chosen_cf->code, true, NULL).c_str(), chosen_cf->code,
+           chosen_cf->spec->rtn_type->debugName().c_str(), r->cls->tp_name);
+    return r;
 }
 
 

src/runtime/tuple.cpp

@@ -388,7 +388,7 @@ void setupTuple() {
     CLFunction* getitem = createRTFunction(2, 0, 0, 0);
     addRTFunction(getitem, (void*)tupleGetitemInt, UNKNOWN,
                   std::vector<ConcreteCompilerType*>{ BOXED_TUPLE, BOXED_INT });
-    addRTFunction(getitem, (void*)tupleGetitemSlice, SLICE, std::vector<ConcreteCompilerType*>{ BOXED_TUPLE, SLICE });
+    addRTFunction(getitem, (void*)tupleGetitemSlice, UNKNOWN, std::vector<ConcreteCompilerType*>{ BOXED_TUPLE, SLICE });
     addRTFunction(getitem, (void*)tupleGetitem, UNKNOWN, std::vector<ConcreteCompilerType*>{ BOXED_TUPLE, UNKNOWN });
     tuple_cls->giveAttr("__getitem__", new BoxedFunction(getitem));