jule: add generic type support to strict type aliases

Author: mertcandav

std/jule/README.md

@@ -18,7 +18,7 @@ It is also used by the official reference compiler JuleC and is developed in par
 
 - **(2)** All generic types represented by `sema::TypeAlias` structure, and pushed into symbol table of relevant scope. Appends to symbol table first owner function's (see (1)) generics, then appends function's owner's (structure, so owner function is actually a method) generics if exist.
 
-- **(3)** The `Generics` field of `sema::TypeAlias` structure is stores all generic types that used in evaluation of destination type kind of type alias. This types are deep references. Stores `*T` or `[]T`, but also stores deep usages such as `MyStruct[T]` or `fn(s: MyStruct[[]*T])` types.
+- **(3)** The `Generics` field of `sema::TypeAlias` stores generic type declaration of the type alias. They also will be used for the underlying structure type for the generic handling. The `alias` field of the underlying `sema::Struct` will point to the owner `sema::TypeAlias`.
 
 - **(4)** If the `referencer.owner` field of `sema::TypeChecker` structure is type alias which is uses `TypeChecker` instance to build it's own destination type kind. This is the hard reference to owner. Always points to root type alias of this build even in nested type builds. Used to collect generic dependencies (see (3)) and etc. of type aliaes.
 

std/jule/ast/node.jule

@@ -531,13 +531,14 @@ struct Conditional {
 
 // Type alias declaration.
 struct TypeAlias {
-	Scope:  &ScopeTree
-	Public: bool
-	Bind:   bool
-	Token:  &token::Token
-	Name:   str
-	Strict: bool
-	Type:   &Expr
+	Scope:    &ScopeTree
+	Public:   bool
+	Bind:     bool
+	Token:    &token::Token
+	Name:     str
+	Strict:   bool
+	Type:     &Expr
+	Generics: []&Generic
 }
 
 // Case of match-case.

std/jule/parser/parser.jule

@@ -293,6 +293,17 @@ impl parser {
 			ret tad
 		}
 		token = tokens[i]
+
+		mut genericsTokens := range(&i, token::LBRACK, token::RBRACK, tokens)
+		if genericsTokens != nil {
+			tad.Generics = self.buildGenerics(genericsTokens, token)
+		}
+		if i >= len(tokens) {
+			self.pushErr(tokens[i-1], "invalid syntax")
+			ret tad
+		}
+		token = tokens[i]
+
 		match token.ID {
 		| token::COLON:
 			tad.Strict = true

std/jule/sema/eval.jule

@@ -689,6 +689,13 @@ impl eval {
 			// But, as far as tested, there is no risk for current implementation.
 			// Future implementations should pay attention for here.
 			mut s := kind.(&StructIns)
+			// Handle generic strict type alias structure instances.
+			// They are must be instantiated and the source instance is a placeholder.
+			// Do not mutate it, never. Allocate a new instance, and handle it.
+			if len(ta.Generics) > 0 {
+				s = s.Decl.instance()
+				ret self._evalStruct(s)
+			}
 			self.pushReference(s)
 			v = self._evalStruct(s)
 		| &Enum:

std/jule/sema/sema.jule

@@ -703,7 +703,7 @@ impl sema {
 	// Checks TypeSYm, builds result as Type and collects referred type aliases.
 	// Skips already checked types.
 	// See also developer reference (9).
-	fn checkTypeSymWithRefers(mut &self, mut t: &TypeSym, mut l: Lookup, mut referencer: &referencer): (ok: bool) {
+	fn checkTypeSymWithRefers(mut &self, mut t: &TypeSym, mut l: Lookup, mut generics: []&TypeAlias, mut referencer: &referencer): (ok: bool) {
 		mut ta := false // Referencer owner is type alias.
 		if t.checked() {
 			match type referencer.owner {
@@ -714,7 +714,7 @@ impl sema {
 				ret true
 			}
 		}
-		mut tt := self.buildTypeWithRefers(t.Decl, l, nil, referencer)
+		mut tt := self.buildTypeWithRefers(t.Decl, l, generics, referencer)
 		if tt == nil || !ta {
 			t.Type = tt
 		} else {
@@ -730,7 +730,7 @@ impl sema {
 	// Checks type and builds result as Type.
 	// Skips already checked types.
 	fn checkTypeSym(mut &self, mut t: &TypeSym, mut l: Lookup): bool {
-		ret self.checkTypeSymWithRefers(t, l, nil)
+		ret self.checkTypeSymWithRefers(t, l, nil, nil)
 	}
 
 	// Same as the checkTypeSym but takes referencer.
@@ -1027,6 +1027,28 @@ impl sema {
 		ret self.basicFuncEnvironment(f, fn|mut sema| algo(f.env.sema, f.env.generics))
 	}
 
+	// Calls algo in the struct's native environment.
+	// Errors will be handled.
+	// Returns result of algo.
+	fn basicStructEnvironment(mut &self, mut s: &StructIns, algo: fn(mut sema: &sema): bool): bool {
+		s.fillEnviron()
+
+		if s.env.file != nil {
+			mut old := s.env.sema.getCurrentFile()
+			defer { s.env.sema.setCurrentFile(old) }
+			s.env.sema.setCurrentFile(s.env.file)
+		}
+
+		ok := algo(s.env.sema)
+
+		if s.env.sema != self {
+			self.errors = append(self.errors, s.env.sema.errors...)
+			s.env.sema.errors = nil
+		}
+
+		ret ok
+	}
+
 	fn checkFuncParamKind(mut &self, mut p: &ParamIns) {
 		p.Type.Variadic = p.Decl.Variadic
 		if p.Decl.Reference {
@@ -1195,7 +1217,7 @@ impl sema {
 		ret atc.checkValidity()
 	}
 
-	fn checkTypeAliasDeclKind(mut &self, mut ta: &TypeAlias, mut prev: &referencer, mut l: Lookup): (ok: bool) {
+	fn checkTypeAliasDeclKind(mut &self, mut ta: &TypeAlias, mut generics: []&TypeAlias, mut prev: &referencer, mut l: Lookup): (ok: bool) {
 		mut old := self.file
 		defer {
 			self.setCurrentFile(old)
@@ -1216,7 +1238,7 @@ impl sema {
 			defer { prev.next = nil }
 		}
 		referencer.tains = ta.Strict
-		ok = self.checkTypeSymWithRefers(ta.TypeSym, l, referencer)
+		ok = self.checkTypeSymWithRefers(ta.TypeSym, l, generics, referencer)
 		if ok && ta.TypeSym.Type.Array() != nil && ta.TypeSym.Type.Array().Auto {
 			self.pushErr(ta.TypeSym.Decl.Token, "auto-sized arrays are not allowed as value type")
 			ok = false
@@ -1241,8 +1263,33 @@ impl sema {
 			s.Decl.Token = ta.Token
 			s.Decl.Public = ta.Public
 			ta.TypeSym.Type = &Type{Kind: s}
+			if len(ta.Generics) > 0 {
+				if ta.Bind {
+					self.pushErr(ta.Token, "bind strict type alias cannot have generics")
+					ret false
+				}
+				ok = self.checkDeclGenerics(ta.Generics)
+				if !ok {
+					ret false
+				}
+				// Remove instances for generic type alias.
+				// This instance will be placeholder for the declaration.
+				// Generic type aliases handled like structs.
+				s.Decl.Instances = nil
+				// Assign type alias generics to underlying structure.
+				// This enables generic type analysis and support for the struct type.
+				// Also assign the type alias to the struct.
+				// See developer reference (3).
+				s.Decl.Generics = ta.Generics
+				s.Decl.alias = ta
+				ret true
+			}
+		} else if len(ta.Generics) > 0 {
+			self.pushErr(ta.Token, "soft type alias cannot have generics")
+			self.pushSuggestion("define as strict type alias, like; type @[Generics]: Type", ta.Name)
+			ret false
 		}
-		ok = self.checkTypeAliasDeclKind(ta, prev, l)
+		ok = self.checkTypeAliasDeclKind(ta, nil, prev, l)
 		if !ok {
 			ret false
 		}
@@ -2903,18 +2950,20 @@ impl sema {
 			self.setCurrentFile(f)
 			for (_, mut ta) in self.file.TypeAliases {
 				if ta.Strict {
-					mut s := ta.TypeSym.Type.Kind.(&StructIns)
-					if !s.checked {
-						s.checked = true
-						ok := self.precheckStructIns(s, nil, nil)
-						if !ok {
-							ret
+					mut s := ta.TypeSym.Type.Kind.(&StructIns).Decl
+					for (_, mut ins) in s.Instances {
+						if !ins.checked {
+							ins.checked = true
+							ok := self.precheckStructIns(ins, nil, nil)
+							if !ok {
+								ret
+							}
 						}
 					}
 					// We can check strict structures here. It should be safe
 					// as described above; structures will be prechecked if needed.
 					// So other unchecked strict type aliases should not be a concern.
-					self.checkTypeStruct(s.Decl)
+					self.checkTypeStruct(s)
 				}
 			}
 		}

std/jule/sema/struct.jule

@@ -55,6 +55,7 @@ struct Struct {
 	Instances: []&StructIns
 
 	checked: bool
+	alias:   &TypeAlias // See developer reference (3).
 }
 
 impl Struct {

std/jule/sema/sym.jule

@@ -100,6 +100,7 @@ fn buildTypeAlias(mut decl: &ast::TypeAlias): &TypeAlias {
 		Token: decl.Token,
 		Name: decl.Name,
 		TypeSym: buildType(decl.Type),
+		Generics: decl.Generics,
 	}
 }
 

std/jule/sema/type.jule

@@ -30,7 +30,7 @@ struct TypeAlias {
 	Token:    &token::Token
 	Name:     str
 	TypeSym:  &TypeSym
-	Generics: []&TypeAlias // See developer reference (1).
+	Generics: []&ast::Generic // See the developer reference (3).
 }
 
 // Kind of type declaration.
@@ -1078,21 +1078,20 @@ impl typeChecker {
 			}
 		}
 
-		// Push generic reference to owner type alias.
-		// See developer reference (3) and (4) for more information.
-		if ta.Generic && self.referencer != nil {
-			mut rta, ok := self.referencer.owner.(&TypeAlias)
-			if ok {
-				rta.Generics = append(rta.Generics, ta)
-			}
-		}
-
 		mut tk := &Type{
 			Provider: ta.Name,
 			Generic: ta.Generic,
 			Kind: ta.TypeSym.Type.Kind,
 		}
-		self.pushReferenceByKind(tk)
+
+		// Handle generic strict type alias structure instances.
+		// They are must be instantiated and the source instance is a placeholder.
+		// Do not mutate it, never. Allocate a new instance, and handle it.
+		if len(ta.Generics) > 0 {
+			tk.Kind = ta.TypeSym.Type.Kind.(&StructIns).Decl.instance()
+		} else {
+			self.pushReferenceByKind(tk)
+		}
 		ret tk
 	}
 
@@ -1158,6 +1157,21 @@ impl typeChecker {
 		if self.s != ins.Decl.sema && len(ins.Decl.Generics) > 0 {
 			self.s.meta.flags |= semametaGstruct
 		}
+
+		// If instance is generic strict type alias.
+		// Resolve the source type using resolved generics.
+		if len(ins.Generics) > 0 && ins.Decl.alias != nil {
+			ok = self.s.basicStructEnvironment(ins, fn|mut sema| {
+				ret unsafe { self.s.checkTypeAliasDeclKind(ins.Decl.alias, ins.env.generics, nil, sema) }
+			})
+			if !ok {
+				ret false
+			}
+			mut typ := ins.Decl.alias.TypeSym.Type
+			ins.Source = ins.Decl.alias.TypeSym.Type
+			ins.Decl.alias.TypeSym.Type = typ
+		}
+
 		ok = self.s.precheckStructIns(ins, self.getReferencer(), errorToken)
 		if ok && len(ins.Decl.Generics) > 0 {
 			// If gstruct collection mode already enabled for this sema,
@@ -1218,6 +1232,9 @@ impl typeChecker {
 		if len(s.Generics) == 0 {
 			ret false, nil
 		}
+		if s.alias != nil {
+			ret true, s.Generics
+		}
 		mut sc, mut ok := self.lookup.(&scopeChecker)
 		if ok {
 			root := sc.getHardRoot()