From 966b6a31ae3dedb241bc2fcd7c697ca9726c985f Mon Sep 17 00:00:00 2001
From: sergeych <real.sergeych@gmail.com>
Date: Sun, 29 Mar 2026 03:57:02 +0300
Subject: [PATCH] extended inference of fun return type

---
 .../kotlin/net/sergeych/lyng/Compiler.kt      | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt b/lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt
index 9deb84d..b8ef0f8 100644
--- a/lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt
+++ b/lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt
@@ -172,6 +172,7 @@ class Compiler(
     private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
     private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
     private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
+    private val callableReturnTypeDeclByName: MutableMap<String, TypeDecl> = mutableMapOf()
     private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
     private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
         mutableMapOf()
@@ -4313,14 +4314,17 @@ class Compiler(
             is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
             is ConstRef -> inferTypeDeclFromConst(ref.constValue)
             is CallRef -> {
+                val targetName = when (val target = ref.target) {
+                    is LocalVarRef -> target.name
+                    is FastLocalVarRef -> target.name
+                    is LocalSlotRef -> target.name
+                    else -> null
+                }
+                if (targetName != null) {
+                    callableReturnTypeDeclByName[targetName]?.let { return it }
+                }
                 inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) }
                     ?: run {
-                        val targetName = when (val target = ref.target) {
-                            is LocalVarRef -> target.name
-                            is FastLocalVarRef -> target.name
-                            is LocalSlotRef -> target.name
-                            else -> null
-                        }
                         if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
                             TypeDecl.Simple(targetName, false)
                         } else {
@@ -8157,6 +8161,10 @@ class Compiler(
                         inferredReturnClass
                 }
             }
+            val inferredReturnDecl = returnTypeDecl ?: inferredReturnClass?.let { TypeDecl.Simple(it.className, false) }
+            if (declKind != SymbolKind.MEMBER && inferredReturnDecl != null) {
+                callableReturnTypeDeclByName[name] = inferredReturnDecl
+            }
             val fnStatements = rawFnStatements?.let { stmt ->
                 if (!compileBytecode) return@let stmt
                 val paramKnownClasses = mutableMapOf<String, ObjClass>()