E2 Error Type

[Denneisk]

Error type for errors instead of passing a string. Try/catch could still have a version for old string passing, but an error type would be nicer as, ideally, error type would also pass the entire trace and have a sort of type/ID system so you don't have to 1:1 compare every error message.

Suggested API:

• Error type string, to decouple error message from its purpose (e.g., rate limits should all be the same type of error)
• Accessors for error trace, such as error:startLine(), error:endLine(), error:startCol(), error:endCol()
• Error creation methods, such as newError(string type, string message)
  • Intended for library developers
• A way to throw errors one step above in the trace, at least for functions, so UDF calls can error on their invocation instead of in their code(?)

try {
    
    entity():setPos(vec())
    entity():setPos(vec()) # Will throw an error with type "rate limit"
    
    let NewError = newError("script", "You activated my error!")

    NewError:throw() # Most likely not synonymous with error(NewError)
    
    
} catch(Err:error) {
    if(Err == "rate limit") { # error == string overload for operator==
        print("Hit a rate limit at line " + Err:lineStart())
    else {
        error(Err) # Errors at the original trace?
    }
}

E2 internals would also be converted to use error objects to ensure consistency.

local errorGeneric = Error.new("generic", "This function is not implemented!")
-- I know there's already a construct in WireLib.Debug for errors

e2function number badCode()
    return self:throw(errorGeneric, 0)
end

Assuming E2 OOPs comes out before this does, I'm hoping that try/catch can be more typical to something like Java/C# where you have to specify the class of exception.

[vurvdev]

The idea is interesting but the plan was always to eventually allow throwing arbitrary types. Also I don't think any other language includes backtraces with try catch

[Denneisk]

In certain other languages, you can only catch specifically typed exceptions. The idea would be that if the error in E2 doesn't match the errors you want to catch, you can just throw it again, except at the original trace.

[Denneisk]

Would arbitrary types conflict with an error type anyway? Being able to generalize errors under a single identifier is very useful.