sema: fix dynamic type annotation of generic function calls may leave some types unresolved

Author: mertcandav

src/julec/obj/cxx/scope.jule

@@ -133,7 +133,7 @@ impl scopeCoder {
 	}
 
 	// Common head object-code for iterations of all kind.
-	fn iterHead[T](mut &self, mut &it: T, mut &ref: bool, begin: str) {
+	fn iterHead(mut &self, mut &it: &sema::RangeIter, mut &ref: bool, begin: str) {
 		self.oc.write("{\n")
 		self.oc.addIndent()
 		self.oc.indent()

std/jule/README.md

@@ -97,6 +97,36 @@ An example of a faulty analysis scenario:
 
   - **(14.1)** If enum's type supports the `iota`, so incremental enumeration, the first member uses the `iota` variable as expression by default. So, it enables the incremental enumeration for the following fields.
 
+- **(15)** The recheck strategy revalidates types rather than creating a new instance. Its advantage lies in checking the existing instance again, instead of initializing a new one. This approach improves speed and efficiency by avoiding the need to verify all types for a general type—instead, only the types that require revalidation are rechecked when necessary.
+  \
+  Types that need to be rechecked most often arise during the processing of generic types. Below is an example scenario:
+  ```
+  struct MyStruct[T1, T2] {
+  	x: T1
+  	y: T2
+  }
+
+  fn NewMyStruct[T1, T2](x: T1, y: T2): MyStruct[T1, T2] {
+  	ret MyStruct[T1, T2]{x, y}
+  }
+
+  fn main() {
+  	mc := NewMyStruct(123, 789)
+  	_ = mc
+  }
+  ```
+  In the example above, the `NewMyStruct` function is invoked with dynamic annotation, which means the generic types are initially treated as pseudo types. In this context, the return type is nominally `MyStruct[int, int]`, but since the structure has not yet been fully type-checked, the field types still internally reference the pseudo types `T1` and `T2`.
+  
+  As a result, when evaluating the expression `MyStruct[T1, T2]{x, y}`, a type mismatch error occurs — because the values `x` and `y` are of type `int`, while the structure fields are still marked with unresolved pseudo types. Since `int` and unresolved pseudo types are not compatible, the compiler raises an error.
+  
+  With the standard strategy, re-checking all function types from scratch using the resolved generic types is not only more costly but also problematic. That's because the type-checking algorithm, for the sake of performance, does not re-check already existing instances.
+  
+  In this case, `MyStruct[int, int]` would already be considered an existing instance. Initially, a generic instance like `MyStruct[T1, T2]` is registered. When the generic types are resolved via dynamic type annotation, the registered instance is updated to reflect the concrete types, i.e., it becomes `MyStruct[int, int]`.
+  
+  As a result, the type checker will recognize `MyStruct[int, int]` as an already-handled case and skip re-validation, even though the type-checking for the structure's internal fields has not yet been completed. This leads to incomplete type-checking and potential errors if no mechanism like recheck strategy is used to force revalidation.
+  
+  With the recheck strategy, when a function instance is created using pseudo generic types, any types that depend on these pseudo types—such as structures that require re-validation—are temporarily stored in memory. After dynamic type annotation resolves the actual types, the recheck algorithm is triggered to revalidate those stored types. This ensures that all types relying on the initially unresolved generic parameters are now correctly and fully type-checked using the concrete types. As a result, the issues arising from incomplete or mismatched type assumptions are resolved, making the generic system more robust and accurate without sacrificing performance.
+
 ### Implicit Imports
 
 Implicit imports are as described in developer reference (9). This section addresses which package is supported and what special behaviors it has.

std/jule/sema/eval.jule

@@ -96,7 +96,6 @@ const (
 	evalExceptional               // Allows calling exceptional functions.
 )
 
-// Evaluator.
 struct eval {
 	s:          &sema // Used for error logging.
 	lookup:     Lookup
@@ -1197,9 +1196,15 @@ impl eval {
 
 	// Checks new generics function instance.
 	// If instance is already exist, f will point to exist instantantiation.
-	fn checkGenericFunc(mut &self, mut &f: &FuncIns, mut &et: &token::Token, mut &model: Expr): (ok: bool, exist: bool) {
+	// If recheckNeed is not nil, function will checked with recheck strategy.
+	fn checkGenericFunc(mut &self, mut &f: &FuncIns, mut &et: &token::Token,
+		mut &model: Expr, mut recheckNeed: []recheckableType): (ok: bool, exist: bool) {
 		mut old := f
-		ok, exist = self.s.checkGenericFunc(f, et)
+		if recheckNeed == nil {
+			ok, exist = self.s.checkGenericFunc(f, et)
+		} else {
+			ok, exist = self.s.checkGenericFuncRecheck(f, et, recheckNeed)
+		}
 		if ok && exist {
 			// Update model by exist function instance.
 			// Generic functions returns always new instance, because might be
@@ -1245,7 +1250,7 @@ impl eval {
 			ret
 		}
 
-		ok, _ := self.checkGenericFunc(f, i.Expr.Token, v.Model)
+		ok, _ := self.checkGenericFunc(f, i.Expr.Token, v.Model, nil)
 		if ok {
 			v.Type.Kind = f
 		} else {
@@ -2242,6 +2247,10 @@ impl eval {
 			errorToken: fc.Token,
 		}
 
+		// This will be used to collect recheck-needed types if dynamic annotation enabled.
+		// See developer reference (15).
+		let mut recheckNeed: []recheckableType
+
 		if !dynamicAnnotation {
 			if !f.reloaded {
 				ok := self.s.reloadFuncInsTypes(f)
@@ -2255,18 +2264,23 @@ impl eval {
 			if existInstance != nil {
 				f = existInstance
 			}
-		} else if !self.s.buildFuncNonGenericTypes(f, fcac.ignored) {
-			v = nil
-			ret
+		} else {
+			// Use non-nil slice for dynamic type annotation.
+			// Thus we can use recheck strategy even for zero recheck-need cases.
+			recheckNeed = make([]recheckableType, 0, len(f.Params)/2)
+			if !self.s.buildFuncNonGenericTypes(f, fcac.ignored, recheckNeed) {
+				v = nil
+				ret
+			}
 		}
 
 		fcac.f = f
 
 		mut ok := false
 		if f.Decl.Owner != nil {
-			old, self.s = self.s, old // Save current Sema.
+			old, self.s = self.s, old // Save current sema.
 			ok = fcac.check()
-			old, self.s = self.s, old // Save owner Sema.
+			old, self.s = self.s, old // Save owner sema.
 		} else {
 			ok = fcac.check()
 		}
@@ -2276,7 +2290,7 @@ impl eval {
 				v = nil
 				ret
 			}
-			ok, _ = self.checkGenericFunc(f, fc.Token, v.Model)
+			ok, _ = self.checkGenericFunc(f, fc.Token, v.Model, recheckNeed)
 			if !ok {
 				v = nil
 				ret

std/jule/sema/sema.jule

@@ -848,18 +848,19 @@ impl sema {
 	//	- For non-generic type parsed string type kinds.
 	//	- For checking non-generic types.
 	fn buildNonGenericType(mut &self, mut &ast: &ast::Type,
-		mut &generics: []&ast::Generic, mut &ignored: []&Type): &Type {
+		mut &generics: []&ast::Generic, mut &ignored: []&Type, mut &recheckNeed: []recheckableType): &Type {
 		mut tc := &typeChecker{
 			s: self,
 			rootLookup: self,
 			lookup: self,
 			ignoreGenerics: generics,
 			ignoredGenerics: &ignored,
+			recheckNeed: &recheckNeed,
 		}
 		ret tc.checkDecl(ast)
 	}
 
-	fn buildFuncNonGenericTypes(mut &self, mut f: &FuncIns, mut &ignored: []&Type): (ok: bool) {
+	fn buildFuncNonGenericTypes(mut &self, mut f: &FuncIns, mut &ignored: []&Type, mut &recheckNeed: []recheckableType): (ok: bool) {
 		let mut generics: []&ast::Generic = nil
 		if f.Decl.IsMethod() {
 			generics = append(f.Decl.Generics, f.Decl.Owner.Generics...)
@@ -870,12 +871,12 @@ impl sema {
 			ok = true
 			for (_, mut p) in f.Params {
 				if !p.Decl.IsSelf() {
-					p.Type = sema.buildNonGenericType(p.Decl.TypeSym.Decl, generics, unsafe { ignored })
+					p.Type = sema.buildNonGenericType(p.Decl.TypeSym.Decl, generics, unsafe { ignored }, unsafe { recheckNeed })
 					ok = ok && p.Type != nil
 				}
 			}
 			if !f.Decl.IsVoid() {
-				f.Result = sema.buildNonGenericType(f.Decl.Result.TypeSym.Decl, generics, unsafe { ignored })
+				f.Result = sema.buildNonGenericType(f.Decl.Result.TypeSym.Decl, generics, unsafe { ignored }, unsafe { recheckNeed })
 				ok = ok && f.Result != nil
 			}
 			ret
@@ -978,36 +979,50 @@ impl sema {
 		p.Type.Variadic = p.Decl.Variadic
 	}
 
+	// Reload type of function's self (receiver) parameter.
+	fn reloadSelf(mut &self, mut f: &FuncIns) {
+		if f.Owner == nil {
+			// Trait methods have not owner yet. Skip them.
+			ret
+		}
+		// No parameters, no receiver.
+		if len(f.Params) == 0 {
+			ret
+		}
+		mut p := f.Params[0]
+		// Receiver parameter already have a type, return immediately.
+		if p.Type != nil {
+			ret
+		}
+		if p.Decl.IsRef() {
+			p.Type = &Type{
+				Kind: &Sptr{
+					Elem: &Type{
+						Kind: f.Owner,
+					},
+				},
+			}
+		} else {
+			p.Type = &Type{Kind: f.Owner}
+		}
+	}
+
 	fn reloadFuncInsTypes(mut &self, mut f: &FuncIns): bool {
 		if f.IsBuiltin() || f.IsAnon() {
 			ret true
 		}
 		ret self.funcEnvironment(f, fn(mut &sema: &sema, mut &generics: []&TypeAlias): bool {
+			self.reloadSelf(f)
 			mut ok := true
 			for (_, mut p) in f.Params {
 				if p.Decl.IsSelf() {
-					if f.Owner == nil {
-						// Trait methods have not owner yet. Skip them.
-						continue
-					}
-					if p.Decl.IsRef() {
-						p.Type = &Type{
-							Kind: &Sptr{
-								Elem: &Type{
-									Kind: f.Owner,
-								},
-							},
-						}
-					} else {
-						p.Type = &Type{Kind: f.Owner}
-					}
+					continue
+				}
+				p.Type = sema.buildTypeWithGenerics(p.Decl.TypeSym.Decl, generics, f.Refers)
+				if p.Type != nil {
+					self.checkFuncParamKind(p)
 				} else {
-					p.Type = sema.buildTypeWithGenerics(p.Decl.TypeSym.Decl, generics, f.Refers)
-					if p.Type != nil {
-						self.checkFuncParamKind(p)
-					} else {
-						ok = false
-					}
+					ok = false
 				}
 			}
 			if !f.Decl.IsVoid() {
@@ -2269,6 +2284,52 @@ impl sema {
 		ret nil
 	}
 
+	fn recheckType(mut &self, mut t: recheckableType, mut &errorToken: &token::Token,
+		mut &refers: &ReferenceStack): (ok: bool) {
+		mut tc := &typeChecker{
+			s: self,
+			rootLookup: self,
+			lookup: self,
+			refers: refers,
+		}
+		ret tc.recheck(t, errorToken)
+	}
+
+	// Basically same as the checkGenericFunc,
+	// but checks the function with the recheck strategy.
+	// See developer reference (15).
+	fn checkGenericFuncRecheck(mut &self, mut &f: &FuncIns, mut &et: &token::Token,
+		mut recheckNeed: []recheckableType): (ok: bool, exist: bool) {
+		// If len(recheckNeed)>0, check the types before handling function.
+		if len(recheckNeed) > 0 {
+			ok = true
+			for (_, mut t) in recheckNeed {
+				ok = self.recheckType(t, et, f.Refers) && ok
+			}
+			if !ok {
+				ret false, false
+			}
+		}
+		mut existInstance := f.Decl.appendInstance(f)
+		// If instance already exist with same generics, return immediately.
+		// This function should be already checked, or it will be.
+		if existInstance != nil {
+			// Set f to exist one.
+			f = existInstance
+			ret true, true
+		}
+		// We still need to check self parameter.
+		self.reloadSelf(f)
+		// TODO: [check] is possible to optimize here using same environment with realoadFuncInsTypes?
+		if !self.checkConstraintsFunc(f, et, existInstance) {
+			ret false, false
+		}
+		// Check generic function instance instantly.
+		self.checkFuncInsCaller(f, et)
+		ok = true
+		ret
+	}
+
 	// Checks new generics function instance.
 	// If instance is already exist, f will point to exist instantantiation.
 	fn checkGenericFunc(mut &self, mut &f: &FuncIns, mut &et: &token::Token): (ok: bool, exist: bool) {