jule: add exceptional forwarding operator

Author: mertcandav

std/jule/ast/node.jule

@@ -196,6 +196,10 @@ struct BinaryExpr {
 	Op: &token::Token // Operator.
 }
 
+// Special exceptional handler scopes.
+let mut Ignored = new(ScopeTree)   // Exception is ignored, like foo()!
+let mut Forwarded = new(ScopeTree) // Exception is forwarded, like foo()?
+
 // Function call expression kind.
 struct CallExpr {
 	Token:     &token::Token
@@ -210,13 +214,6 @@ impl CallExpr {
 	fn Unhandled(self): bool {
 		ret self.Exception == nil
 	}
-
-	// Reports whether exception is ignored.
-	fn Ignored(self): bool {
-		// Report true if the Unsafe field is true.
-		// Unsafe field used mark for exception ignored calls like: x()!
-		ret self.Exception != nil && self.Exception.Unsafe
-	}
 }
 
 // Typed brace instantiating expression.

std/jule/parser/expr.jule

@@ -1045,13 +1045,26 @@ impl exprBuilder {
 					self.pushErr(t, "trailing not operator expects a function call")
 					break
 				}
-				if f.Ignored() {
+				if f.Exception == ast::Ignored {
 					self.pushErr(t, "function call already ignores the exceptional")
 					break
 				}
-				f.Exception = &ast::ScopeTree{
-					Unsafe: true,
+				f.Exception = ast::Ignored
+			| token::QMARK:
+				t := self.t
+				self.next()
+				// Trailing question-mark operator.
+				// It should be call expression to an exceptional function.
+				mut f, isFunc := ast::Unparen(x).Data.(&ast::CallExpr)
+				if !isFunc {
+					self.pushErr(t, "trailing question-mark operator expects a function call")
+					break
+				}
+				if f.Exception == ast::Forwarded {
+					self.pushErr(t, "function call already forwards the exceptional")
+					break
 				}
+				f.Exception = ast::Forwarded
 			| token::ELSE:
 				t := self.t
 				self.next()

std/jule/sema/eval.jule

@@ -2229,9 +2229,31 @@ impl eval {
 			| fc.Unhandled():
 				self.pushErr(fc.Token, log::UnhandledExceptional)
 				self.pushSuggestion(log::HandleExceptional)
-			| fc.Ignored():
-				// Ok.
-				break
+			| fc.Exception == ast::Ignored:
+				model.Except = nil
+			| fc.Exception == ast::Forwarded:
+				mut s, (ok) := self.lookup.(&scopeChecker)
+				if ok {
+					if s.isDeferred() {
+						self.s.pushErr(fc.Token, "function call forwards exception in a deferred scope")
+					} else {
+						mut root := s.getRoot()
+						if root.owner.Decl.Exceptional {
+							model.Except = s.getChild()
+							mut ec := buildVoidValue()
+							ec.Model = &BuiltinErrorCallExpr{
+								Func: root.owner,
+								Err: &Value{
+									Model: self.evalVar(buildErrorVar(model.Except, fc), fc.Token).Model,
+								},
+							}
+							model.Except.Stmts = append(model.Except.Stmts, ec)
+							break
+						}
+					}
+				}
+				self.s.pushErr(fc.Token, "function call forwards exceptional in non-exceptional scope")
+				self.s.pushSuggestion("make the function exceptional to forward")
 			|:
 				// Handled with scope.
 				self.processExceptionalHandler(f, fc, v)

std/jule/sema/model.jule

@@ -111,7 +111,7 @@ struct FuncCallExpr {
 	IsCo:     bool
 	Expr:     Expr
 	Args:     []Expr
-	Except:   &Scope
+	Except:   &Scope // Nil for ignored.
 	Assigned: bool
 }
 

std/jule/token/scan.jule

@@ -596,6 +596,9 @@ impl Scanner {
 					token.ID = COLON
 					token.Kind = ":"
 				}
+			| '?':
+				token.ID = QMARK
+				token.Kind = "?"
 			| ';':
 				token.ID = SEMICOLON
 				token.Kind = ";"

std/jule/token/token.jule

@@ -15,6 +15,7 @@ const (
 	SEP       // ::
 	HASH      // #
 	ELLIPSIS  // ...
+	QMARK     // ?
 
 	COMMENT // /*..*/ or //...
 	NAME    // identifier