std/comptime: add the Tag mehod to comptimeDecl

Author: mertcandav

std/comptime/decl.jule

@@ -68,6 +68,12 @@ impl comptimeDecl {
 	// Returns count of tags as constant expression.
 	// Supports only structure fields.
 	fn Tags(self): int
+
+	// Returns the value of the tag corresponding to the key as a constant expression.
+	// Supports only structure fields.
+	// Parameter key should be constant.
+	// Returns empty string if key is not exist in the tags.
+	fn Tag(self, key: str): str
 }
 
 */

std/comptime/value.jule

@@ -29,20 +29,20 @@ impl comptimeValue {
 
 	// Returns comptimeValue for field access expression.
 	// Supports only structure types.
-	// Parameter ident should be constant.
+	// Parameter name should be constant.
 	// It allows access to private fields.
-	fn Field(self, ident: str): comptimeValue
+	fn Field(self, name: str): comptimeValue
 
-	// Same as the Field method, but takes constant index instead of identifier.
+	// Same as the Field method, but takes constant index instead of name.
 	fn FieldByIndex(self, index: int): comptimeValue
 
 	// Returns comptimeValue for method access expression.
 	// Supports only structure types.
-	// Parameter ident should be constant.
+	// Parameter name should be constant.
 	// It allows access to private methods.
 	// It will not use the actual kind, so this method an provide
 	// access to methods of the any strict type alias.
-	fn Method(self, ident: str): comptimeValue
+	fn Method(self, name: str): comptimeValue
 
 	// Unwraps expression for runtime execution.
 	fn Unwrap(self)

std/jule/sema/comptime.jule

@@ -2000,7 +2000,43 @@ impl comptimeDecl {
 				Model: constant,
 			}
 		|:
-			panic("sema: comptimeDecl.Tags: unimplemented declaration kind")
+			e.pushErr(fc.Token, log::InvalidTypeForFunc, self.declAsStr(), "Tag")
+			ret nil
+		}
+	}
+
+	fn _Tag(mut &self, mut &e: &eval, mut &fc: &ast::FuncCallExpr): &Value {
+		if len(fc.Args) > 1 {
+			e.pushErr(fc.Args[1].Token, log::ArgumentOverflow, "Tag")
+			ret nil
+		}
+		f, field := self.decl.(&Field)
+		if !field {
+			e.pushErr(fc.Token, log::InvalidTypeForFunc, self.declAsStr(), "Tag")
+			ret nil
+		}
+		mut arg := fc.Args[0]
+		mut v := e.evalExpr(arg, evalDefault)
+		if v == nil {
+			ret nil
+		}
+		if !v.IsConst() {
+			e.pushErr(arg.Token, log::ExprNotConst)
+			ret nil
+		}
+		prim := v.Type.Prim()
+		if prim == nil || !prim.IsStr() {
+			e.pushErr(arg.Token, log::IncompatibleTypes, str(types::Str), v.Type.Str())
+			ret nil
+		}
+		key := v.Constant.ReadStr()
+		value, _ := f.Tags[key]
+		mut constant := constant::Const.NewStr(value)
+		ret &Value{
+			untyped: true,
+			Type: primStr,
+			Constant: constant,
+			Model: constant,
 		}
 	}
 
@@ -2083,6 +2119,13 @@ impl comptimeDecl {
 				},
 			}
 			ret buildAsComptimeMethodData(method)
+		| "Tag":
+			mut method := &FuncIns{
+				caller: fn(mut &e: &eval, mut &fc: &ast::FuncCallExpr, mut &_: &Value): &Value {
+					ret self._Tag(e, fc)
+				},
+			}
+			ret buildAsComptimeMethodData(method)
 		|:
 			ret nil
 		}