[Tolk] Auto-infer never for always-throwing functions

Previously, `never` could be specified, but was not auto-inferred.
(because it's done the same way in TypeScript)
Now, it's auto-inferred, which is more expected in our case.

Author: tolk-vm

tolk-tester/tests/inference-tests.tolk

@@ -111,8 +111,8 @@ fun alwaysThrowsNotAnnotated2() { alwaysThrows(); }
 fun test9() {
     __expect_type(alwaysThrows(), "never");
     __expect_type(alwaysThrows, "() -> never");
-    __expect_type(alwaysThrowsNotAnnotated(), "void");
-    __expect_type(alwaysThrowsNotAnnotated2(), "void");
+    __expect_type(alwaysThrowsNotAnnotated(), "never");
+    __expect_type(alwaysThrowsNotAnnotated2(), "never");
 }
 
 

tolk-tester/tests/invalid-typing/err-6427.tolk

@@ -1,4 +1,5 @@
 fun cantReturnVoidAndNonVoid(a: int | slice | builder) {
+    throw 123;
     match (a) {
         int => { return; }
         slice => {}

tolk-tester/tests/never-type-tests.tolk

@@ -1,5 +1,14 @@
 fun takeInt(a: int) {}
 
+fun alwaysThrows() {
+    throw 123;
+}
+
+fun alwaysThrowsButReturns() {
+    throw 123;
+    return 123;
+}
+
 @method_id(101)
 fun test1(x: int?) {
     if (x == null && x != null) {
@@ -21,6 +30,8 @@ fun test1(x: int?) {
 
 fun main() {
     __expect_type(test1, "(int?) -> int");
+    __expect_type(alwaysThrows(), "never");
+    __expect_type(alwaysThrowsButReturns(), "int");
 }
 
 /**

tolk-tester/tests/try-catch-tests.tolk

@@ -175,7 +175,7 @@ fun alwaysThrowX(x: int): never {
 }
 
 @noinline
-fun anotherNever(throw123: bool): never {
+fun anotherNever(throw123: bool) {    // auto-infer `never`
   if (throw123) { alwaysThrow123(); }
   alwaysThrowX(456);
 }

tolk-tester/tests/var-apply-tests.tolk

@@ -101,7 +101,7 @@ fun testVarApplyInTernary() {
     return t;
 }
 
-fun always_throw2(x: int) {
+fun always_throw2(x: int): void {
     throw 239 + x
 }
 

tolk/analyzer.cpp

@@ -24,7 +24,7 @@ namespace tolk {
 // for instance, variables after their call aren't considered used
 // its main purpose is `throw` statement, it's a call to a built-in `__throw` function
 static bool does_function_always_throw(FunctionPtr fun_ref) {
-  return fun_ref->declared_return_type == TypeDataNever::create();
+  return fun_ref->inferred_return_type == TypeDataNever::create();
 }
 
 /*

tolk/ast-replacer.h

@@ -210,6 +210,7 @@ class ASTReplacerInFunctionBody : public ASTReplacer {
 };
 
 
+const std::vector<FunctionPtr>& get_all_builtin_functions();
 const std::vector<FunctionPtr>& get_all_not_builtin_functions();
 const std::vector<GlobalConstPtr>& get_all_declared_constants();
 const std::vector<StructPtr>& get_all_declared_structs();

tolk/ast-visitor.h

@@ -211,6 +211,7 @@ class ASTVisitorFunctionBody : public ASTVisitor {
 };
 
 
+const std::vector<FunctionPtr>& get_all_builtin_functions();
 const std::vector<FunctionPtr>& get_all_not_builtin_functions();
 const std::vector<GlobalVarPtr>& get_all_declared_global_vars();
 const std::vector<GlobalConstPtr>& get_all_declared_constants();

tolk/builtins.cpp

@@ -43,11 +43,13 @@ static std::vector<LocalVarData> define_builtin_parameters(const std::vector<Typ
 static void define_builtin_func(const std::string& name, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const std::function<FunctionBodyBuiltinAsmOp::CompileToAsmOpImpl>& func, int flags) {
   auto* f_sym = new FunctionData(name, {}, "", nullptr, return_type, define_builtin_parameters(params_types, flags), flags, FunctionInlineMode::notCalculated, genericTs, nullptr, new FunctionBodyBuiltinAsmOp(func), nullptr);
   G.symtable.add_function(f_sym);
+  G.all_builtins.push_back(f_sym);
 }
 
 static void define_builtin_func(const std::string& name, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const std::function<FunctionBodyBuiltinGenerateOps::GenerateOpsImpl>& func, int flags) {
   auto* f_sym = new FunctionData(name, {}, "", nullptr, return_type, define_builtin_parameters(params_types, flags), flags, FunctionInlineMode::notCalculated, genericTs, nullptr, new FunctionBodyBuiltinGenerateOps(func), nullptr);
   G.symtable.add_function(f_sym);
+  G.all_builtins.push_back(f_sym);
 }
 
 static void define_builtin_method(const std::string& name, TypePtr receiver_type, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const std::function<FunctionBodyBuiltinAsmOp::CompileToAsmOpImpl>& func, int flags,
@@ -57,13 +59,15 @@ static void define_builtin_method(const std::string& name, TypePtr receiver_type
   f_sym->arg_order = arg_order;
   f_sym->ret_order = ret_order;
   G.symtable.add_function(f_sym);
+  G.all_builtins.push_back(f_sym);
   G.all_methods.push_back(f_sym);
 }
 
 void define_builtin_method(const std::string& name, TypePtr receiver_type, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const std::function<FunctionBodyBuiltinGenerateOps::GenerateOpsImpl>& func, int flags) {
   std::string method_name = name.substr(name.find('.') + 1);
   auto* f_sym = new FunctionData(name, {}, std::move(method_name), receiver_type, return_type, define_builtin_parameters(params_types, flags), flags, FunctionInlineMode::notCalculated, genericTs, nullptr, new FunctionBodyBuiltinGenerateOps(func), nullptr);
   G.symtable.add_function(f_sym);
+  G.all_builtins.push_back(f_sym);
   G.all_methods.push_back(f_sym);
 }
 
@@ -1500,7 +1504,7 @@ void define_builtins() {
   define_builtin_func("__throw", ParamsInt1, Never, nullptr,
                               compile_throw,
                                 0);
-  define_builtin_func("__throw_arg", {typeT, Int}, Never, declGenericT,
+  define_builtin_func("__throw_arg", {TypeDataUnknown::create(), Int}, Never, nullptr,
                               compile_throw_arg,
                                 0);
   define_builtin_func("__throw_if_unless", ParamsInt3, Unit, nullptr,

tolk/compiler-state.cpp

@@ -66,6 +66,10 @@ void CompilerSettings::parse_experimental_options_cmd_arg(const std::string& cmd
   }
 }
 
+const std::vector<FunctionPtr>& get_all_builtin_functions() {
+  return G.all_builtins;
+}
+
 const std::vector<FunctionPtr>& get_all_not_builtin_functions() {
   return G.all_functions;
 }