parser: minor optimization for tuple expression handling

Author: mertcandav

std/jule/parser/expr.jule

@@ -649,20 +649,20 @@ impl exprBuilder {
 		// Remove expression tokens.
 		// Holds only indexing tokens.
 		// Includes brackets.
-		tokens = tokens[len(exprTokens):]
+		mut bracketTokens := tokens[len(exprTokens):]
 
 		// Catch slicing expressions.
-		mut splitTokens := tokens[1 : len(tokens)-1] // Remove brackets.
+		mut splitTokens := bracketTokens[1 : len(bracketTokens)-1] // Remove brackets.
 		mut start, mut to := splitDelim(splitTokens, token::Colon)
 		if start != nil || to != nil {
-			ret self.buildSlicing(exprTokens, start, to, errorToken, tokens[len(tokens)-1])
+			ret self.buildSlicing(exprTokens, start, to, errorToken, bracketTokens[len(bracketTokens)-1])
 		}
-		if tokens[1].Id == token::DblColon {
+		if bracketTokens[1].Id == token::DblColon {
 			// Special case: catch x[::] and x[::index3] like expressions.
 			self.pushErr(errorToken, log::MiddleIndexRequired)
 			ret nil
 		}
-		ret self.buildIndexing(exprTokens, tokens, errorToken)
+		ret self.buildIndexing(exprTokens, bracketTokens, errorToken)
 	}
 
 	fn buildExclRight(mut self, mut &tokens: []&token::Token): ast::ExprData {
@@ -818,12 +818,14 @@ impl exprBuilder {
 	}
 
 	fn buildKind(mut self, mut &tokens: []&token::Token): ast::ExprData {
-		mut parts, errors := parts(tokens, token::Comma, true)
-		if errors != nil {
-			self.p.errors = append(self.p.errors, errors...)
-			ret nil
-		} else if len(parts) > 1 {
-			ret self.buildTuple(parts)
+		if isTupleExpr(tokens) {
+			mut parts, errors := parts(tokens, token::Comma, true)
+			if errors != nil {
+				self.p.errors = append(self.p.errors, errors...)
+				ret nil
+			} else if len(parts) > 1 {
+				ret self.buildTuple(parts)
+			}
 		}
 		ret self.build(tokens)
 	}

std/jule/parser/parser.jule

@@ -128,6 +128,27 @@ fn parts(mut &tokens: []&token::Token, id: int, exprMust: bool): (parts: [][]&to
 	ret
 }
 
+fn isTupleExpr(mut &tokens: []&token::Token): bool {
+	if len(tokens) == 0 {
+		ret false
+	}
+	mut rangeN := 0
+	for _, token in tokens {
+		match token.Id {
+		| token::LBrace | token::LBracket | token::LParent:
+			rangeN++
+		| token::RBrace | token::RBracket | token::RParent:
+			rangeN--
+		| token::Comma:
+			if rangeN > 0 {
+				continue
+			}
+			ret true
+		}
+	}
+	ret false
+}
+
 fn getCloseOfBrace(left: int): int {
 	match left {
 	| token::RParent: