std/jule/token: refactoring with reimplemented API

Author: mertcandav

src/julec/obj/cxx/expr.jule

@@ -228,11 +228,11 @@ impl exprCoder {
 		self.oc.write(")(")
 		self.oc.write(xVar)
 		match op.Id {
-		| token::Id.Solidus
-		| token::Id.SolidusEq:
+		| token::Solidus
+		| token::SolidusEq:
 			self.oc.write(" / ")
-		| token::Id.Percent
-		| token::Id.PercentEq:
+		| token::Percent
+		| token::PercentEq:
 			self.oc.write(" % ")
 		}
 		self.oc.write(yVar)
@@ -242,7 +242,7 @@ impl exprCoder {
 	// Tries to handle binary expressions with dynamic types and reports whether
 	// it successful. Should support all dynamic types.
 	fn unsafeDynamicBinary(mut &self, mut &buf: strings::Builder,
-		mut l: sema::OperandExpr, mut r: sema::OperandExpr, op: token::Id): bool {
+		mut l: sema::OperandExpr, mut r: sema::OperandExpr, op: int): bool {
 		// Return immediately if binary expression is not contain dynamic type.
 		// Handle traits separately, see documentation of obj::IsAny.
 		// They handled as <any> type, but not have pure any type implementation,
@@ -281,7 +281,7 @@ impl exprCoder {
 		})
 
 		buf.WriteByte('(')!
-		if op == token::Id.NotEq {
+		if op == token::NotEq {
 			buf.WriteByte('!')!
 		}
 		i := self.oc.pushAnyType(t)
@@ -307,14 +307,14 @@ impl exprCoder {
 	}
 
 	fn _unsafeBinaryNoDynamic(mut &self, mut &buf: strings::Builder, &l: str,
-		&r: str, mut &lk: &sema::Type, mut &rk: &sema::Type, op: token::Id, kind: str) {
+		&r: str, mut &lk: &sema::Type, mut &rk: &sema::Type, op: int, kind: str) {
 		match {
 		| lk.Array() != nil:
 			// If this binary operator comparing array type.
 			// The left operand is will be array one always.
 			arr := lk.Array()
 			mut ins := obj::FindFuncGenericInstance(meta::Program.Runtime.ArrayCmp, arr.Elem)
-			if op == token::Id.NotEq {
+			if op == token::NotEq {
 				buf.WriteByte('!')!
 			}
 			identCoder.funcIns(buf, ins)
@@ -336,9 +336,9 @@ impl exprCoder {
 
 		// guarantee integer wrap around if expressions is not a condition
 		match op {
-		| token::Id.Gt | token::Id.GtEq
-		| token::Id.Lt | token::Id.LtEq
-		| token::Id.Eqs | token::Id.NotEq:
+		| token::Gt | token::GtEq
+		| token::Lt | token::LtEq
+		| token::DblEq | token::NotEq:
 			// No op.
 		|:
 			lp := lk.Prim()
@@ -363,9 +363,9 @@ impl exprCoder {
 	}
 
 	fn _unsafeBinary(mut &self, mut &buf: strings::Builder, mut l: sema::OperandExpr,
-		mut r: sema::OperandExpr, op: token::Id, kind: str) {
+		mut r: sema::OperandExpr, op: int, kind: str) {
 		// Special cases for comparable types.
-		if (op == token::Id.Eqs || op == token::Id.NotEq) && self.unsafeDynamicBinary(buf, l, r, op) {
+		if (op == token::DblEq || op == token::NotEq) && self.unsafeDynamicBinary(buf, l, r, op) {
 			ret
 		}
 		ls := writeAndReadFromBuf(self.oc.Buf, fn() { self.possibleRefExpr(l.Model) })
@@ -439,15 +439,15 @@ impl exprCoder {
 
 	fn binary(mut &self, mut m: &sema::BinaryExpr) {
 		match m.Op.Id {
-		| token::Id.Solidus | token::Id.Percent:
+		| token::Solidus | token::Percent:
 			if env::Safety {
 				self.divByZeroBinary(m.Op, m.Left, m.Right)
 				ret
 			}
-		| token::Id.Shl:
+		| token::Shl:
 			self.shl(m.Left, m.Right)
 			ret
-		| token::Id.Shr:
+		| token::Shr:
 			self.shr(m.Left, m.Right)
 			ret
 		}
@@ -477,7 +477,7 @@ impl exprCoder {
 	fn unary(mut &self, mut m: &sema::UnaryExpr) {
 		// guarantee integer wrap around
 		match m.Op.Id {
-		| token::Id.Plus | token::Id.Minus | token::Id.Caret:
+		| token::Plus | token::Minus | token::Caret:
 			lp := m.Expr.Type.Prim()
 			if lp != nil && types::IsInt(lp.Kind) {
 				self.oc.write("(")
@@ -490,12 +490,12 @@ impl exprCoder {
 		}
 
 		match m.Op.Id {
-		| token::Id.Caret:
+		| token::Caret:
 			self.oc.write("(~(")
 			self.possibleRefExpr(m.Expr.Model)
 			self.oc.write("))")
 			ret
-		| token::Id.Star:
+		| token::Star:
 			if env::Production || m.Expr.Type.Sptr() == nil {
 				break
 			}
@@ -1569,7 +1569,7 @@ impl exprCoder {
 			match type m.Err.Model {
 			| &sema::Var:
 				v := m.Err.Model.(&sema::Var)
-				if v.Ident == token::Kind.Error {
+				if v.Ident == "error" {
 					if hasDefer {
 						self.oc.write(deferStackName + ".call();\n")
 						self.oc.indent()
@@ -1585,7 +1585,7 @@ impl exprCoder {
 			match type m.Err.Model {
 			| &sema::Var:
 				v := m.Err.Model.(&sema::Var)
-				if v.Ident == token::Kind.Error {
+				if v.Ident == "error" {
 					self.oc.write(">{.error=except.error}")
 					ret
 				}
@@ -2378,11 +2378,11 @@ fn utoa(mut &s: strings::Builder, x: u64) {
 }
 
 fn structBinary(mut &buf: strings::Builder, mut &s: &sema::StructIns, &l: str,
-	&r: str, op: token::Id, kind: str) {
-	if op != token::Id.Eqs && op != token::Id.NotEq {
+	&r: str, op: int, kind: str) {
+	if op != token::DblEq && op != token::NotEq {
 		panic("cxx: unsupported token occurred for structure binary, this is an implementation mistake")
 	}
-	if op == token::Id.NotEq {
+	if op == token::NotEq {
 		buf.WriteByte('!')!
 	}
 	identCoder.structureIns(buf, s)
@@ -2457,7 +2457,7 @@ struct useExprMemory {
 	DestType: &sema::Type
 	Model:    sema::Expr
 	Type:     int
-	OpId:     token::Id
+	OpId:     int
 	OpKind:   str
 }
 

src/julec/obj/cxx/ident.jule

@@ -5,6 +5,7 @@
 use "env"
 use "obj"
 use "std/conv"
+use "std/jule"
 use "std/jule/build"
 use "std/jule/directive"
 use "std/jule/sema"
@@ -113,7 +114,7 @@ impl identCoder {
 	}
 
 	static fn param(mut &buf: strings::Builder, &p: &sema::Param) {
-		if token::IsAnonIdent(p.Ident) || token::IsIgnoreIdent(p.Ident) {
+		if jule::IsAnon(p.Ident) || jule::IsBlank(p.Ident) {
 			ret
 		}
 		if p.IsSelf() {
@@ -151,7 +152,7 @@ impl identCoder {
 			buf.WriteStr(f.Ident)!
 			ret
 		}
-		if token::IsIgnoreIdent(f.Ident) {
+		if jule::IsBlank(f.Ident) {
 			// If the identifier is blank, there may be other fields like that.
 			// So handle them with unique identifier, avoid duplication.
 			buf.WriteStr("_field_")!
@@ -167,9 +168,9 @@ impl identCoder {
 		match {
 		| v.Binded:
 			buf.WriteStr(v.Ident)!
-		| v.Ident == token::Kind.Error:
+		| v.Ident == "error":
 			buf.WriteStr("except.error")!
-		| v.Ident == token::Kind.Self:
+		| v.Ident == "self":
 			buf.WriteStr(identSelf)!
 		| v.RetOrder == -1:
 			// The single return variable is just this one.

src/julec/obj/cxx/object.jule

@@ -555,7 +555,7 @@ impl ObjectCoder {
 			self.anyObj.WriteStr("_eq(void *alloc, void *other) noexcept { ")!
 			if comparable {
 				self.anyObj.WriteStr("return ")!
-				self.ec._unsafeBinaryNoDynamic(self.anyObj, lmodel, rmodel, t, t, token::Id.Eqs, token::Kind.Eqs)
+				self.ec._unsafeBinaryNoDynamic(self.anyObj, lmodel, rmodel, t, t, token::DblEq, "==")
 				self.anyObj.WriteStr("; }\n")!
 			} else {
 				self.anyObj.WriteStr(`__jule_panic((`)!
@@ -934,7 +934,7 @@ impl ObjectCoder {
 			identCoder.field(fIdent, f.Decl)
 			lmodel += fIdent.Str()
 			rmodel += fIdent.Str()
-			self.ec._unsafeBinaryNoDynamic(self.Buf, lmodel, rmodel, f.Type, f.Type, token::Id.Eqs, token::Kind.Eqs)
+			self.ec._unsafeBinaryNoDynamic(self.Buf, lmodel, rmodel, f.Type, f.Type, token::DblEq, "==")
 			lmodel = lmodel[:len(lmodel)-fIdent.Len()]
 			rmodel = rmodel[:len(rmodel)-fIdent.Len()]
 		}
@@ -1072,7 +1072,7 @@ impl ObjectCoder {
 		for (_, mut m) in hash.methods {
 			mut ins := m.Instances[0]
 			for (i, mut ip) in ins.Params[1:] {
-				if token::IsAnonIdent(ip.Decl.Ident) {
+				if jule::IsAnon(ip.Decl.Ident) {
 					ip.Decl.Ident = "_" + conv::Itoa(i)
 				}
 			}
@@ -1163,8 +1163,8 @@ impl ObjectCoder {
 				DestType: v.TypeSym.Type,
 				Model: v,
 				Type: useExprPlain,
-				OpId: token::Id.Eq,
-				OpKind: token::Kind.Eq,
+				OpId: token::Eq,
+				OpKind: "=",
 			})
 		} else {
 			identCoder.var(self.Buf, v)
@@ -1175,7 +1175,7 @@ impl ObjectCoder {
 	}
 
 	fn var(mut &self, mut v: &sema::Var) {
-		if token::IsIgnoreIdent(v.Ident) {
+		if jule::IsBlank(v.Ident) {
 			ret
 		}
 		if v.ValueSym != nil && v.ValueSym.Expr != nil {
@@ -1491,7 +1491,7 @@ impl ObjectCoder {
 		for (_, mut v) in self.ir.Ordered.Globals {
 			// Skip blank identifiers, do not declare them.
 			// Initialization expressions will be executed when variables initializing.
-			if token::IsIgnoreIdent(v.Ident) {
+			if jule::IsBlank(v.Ident) {
 				continue
 			}
 			self.tc.kind(self.Buf, v.TypeSym.Type)
@@ -1614,7 +1614,7 @@ impl ObjectCoder {
 			}
 			self.Buf.WriteByte(indentKind)!
 			// If variable have blank identifier, just execute the initialization expression.
-			if token::IsIgnoreIdent(v.Ident) {
+			if jule::IsBlank(v.Ident) {
 				self.ec.model(v.ValueSym.Value.Model)
 				self.write(";\n")
 				continue

src/julec/obj/cxx/scope.jule

@@ -644,9 +644,9 @@ impl scopeCoder {
 		// handle it like the equal operator
 		mut op := a.Op.Id
 		mut kind := a.Op.Kind
-		if a.Op.Id == token::Id.ColonEq {
-			op = token::Id.Eq
-			kind = token::Kind.Eq
+		if a.Op.Id == token::ColonEq {
+			op = token::Eq
+			kind = "="
 		}
 
 		mut fc := isExceptionalResult(a.Right.Model)
@@ -662,15 +662,15 @@ impl scopeCoder {
 		}
 
 		match a.Op.Id {
-		| token::Id.SolidusEq | token::Id.PercentEq:
+		| token::SolidusEq | token::PercentEq:
 			if env::Safety {
 				self.divByZeroAssign(a)
 				ret
 			}
-		| token::Id.ShlEq:
+		| token::ShlEq:
 			self.shl(a)
 			ret
-		| token::Id.ShrEq:
+		| token::ShrEq:
 			self.shr(a)
 			ret
 		}
@@ -833,8 +833,8 @@ impl scopeCoder {
 					Ident: assignResultName,
 				},
 				Type: useExprPlain,
-				OpId: token::Id.Eq,
-				OpKind: token::Kind.Eq,
+				OpId: token::Eq,
+				OpKind: "=",
 			}
 			self.oc.write(" " + assignResultName + ";\n")
 			self.oc.indent()
@@ -982,7 +982,7 @@ impl scopeCoder {
 						Model: expr.Model,
 						Type: expr.Type,
 					}
-					self.oc.ec._unsafeBinary(self.oc.Buf, l, r, token::Id.Eqs, token::Kind.Eqs)
+					self.oc.ec._unsafeBinary(self.oc.Buf, l, r, token::DblEq, "==")
 				|:
 					self.oc.write(matchExpr)
 					mut tk := expr.Model.(&sema::Type)
@@ -1281,8 +1281,8 @@ impl scopeCoder {
 					Ident: resultName,
 				},
 				Type: useExprPlain,
-				OpId: token::Id.Eq,
-				OpKind: token::Kind.Eq,
+				OpId: token::Eq,
+				OpKind: "=",
 			}
 			self.oc.ec.handleExceptionalCallWithData(fc, dest)
 			self.oc.write("\n")
@@ -1342,8 +1342,8 @@ impl scopeCoder {
 				DestType: r.Func.Result,
 				Model: rv,
 				Type: useExprPlain,
-				OpId: token::Id.Eq,
-				OpKind: token::Kind.Eq,
+				OpId: token::Eq,
+				OpKind: "=",
 			}
 			self.oc.ec.handleExceptionalCallWithData(fc, dest)
 		} else {

src/julec/obj/ir.jule

@@ -220,7 +220,7 @@ fn buildCompileInfo(): importer::CompileInfo {
 fn pushRuntimeToAST(mut &f: &ast::AST) {
 	mut decl := &ast::Use{
 		Token: nil, // Nil token is a flag for implicit declaration.
-		Path: &token::Token{Id: token::Id.Lit, Kind: `"std/runtime"`},
+		Path: &token::Token{Id: token::Lit, Kind: `"std/runtime"`},
 		Alias: nil,
 		Binded: false,
 	}

src/julec/opt/boundary.jule

@@ -119,7 +119,7 @@ fn fitsSize(mut e1: sema::Expr, mut e2: sema::Expr): bool {
 	| &sema::UnaryExpr:
 		mut uem1 := e1.(&sema::UnaryExpr)
 		mut uem2 := e2.(&sema::UnaryExpr)
-		if uem1.Op.Id != token::Id.Star || uem1.Op.Id != uem2.Op.Id {
+		if uem1.Op.Id != token::Star || uem1.Op.Id != uem2.Op.Id {
 			ret false
 		}
 		ret fitsSize(uem1.Expr.Model, uem2.Expr.Model)
@@ -179,7 +179,7 @@ fn getBoundaryVar(m: sema::Expr): uintptr {
 		ret uintptr(m.(&sema::StructSubIdentExpr).Field)
 	| &sema::UnaryExpr:
 		uem := m.(&sema::UnaryExpr)
-		if uem.Op.Id == token::Id.Star { // Dereferencing.
+		if uem.Op.Id == token::Star { // Dereferencing.
 			ret getBoundaryVar(uem.Expr.Model)
 		}
 	}

src/julec/opt/dynamic.jule

@@ -127,7 +127,7 @@ fn getDynamicVar(m: sema::Expr): uintptr {
 		ret uintptr(m.(&sema::StructSubIdentExpr).Field)
 	| &sema::UnaryExpr:
 		uem := m.(&sema::UnaryExpr)
-		if uem.Op.Id == token::Id.Star { // Dereferencing.
+		if uem.Op.Id == token::Star { // Dereferencing.
 			ret getDynamicVar(uem.Expr.Model)
 		}
 	}