support for System.Exception.get_InnerException

[joprice]

Would it be possible to support System.Exception.get_InnerException?

It currently fails at compile time with error FABLE: System.Exception.get_InnerException is not supported by Fable.

For javascript, it could map to the cause parameter:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause#rethrowing_an_error_with_a_cause

and on python

https://python-future.org/compatible_idioms.html#raising-exceptions raise_from

Not sure about other targets, but it can be helpful for debugging to make use of the underlying platform's ability to decorate an error with additional context information, but not lose track of the original message and trace.

[MangelMaxime]

I will have a look at it, for JavaScript it should be easy enough because F# exception don't derive from Error for performance reason, so we have full control over the type:

Current type:

// Exception is intentionally not derived from Error, for performance reasons (see #2160)
export class Exception {
  constructor(public message?: string) { }
}

We could have an additional argument and the getter that goes with it.

I have however a question regarding the F# code you are trying to map from? Looking online for inner exception with F# I found:

open System

type FooException(message:string, innerException:Exception) =
   inherit Exception(message)

let e = new Exception()

raise (new FooException("test", e))

Is it what you are trying to do or something else? I am asking because the raise_from confuse me a little here and perhaps you have speaking about another F# feature that I don't know.

[joprice]

Yes I’m trying to wrap the exception and later drill into the cause. From what I understood in the python docs raise_from solves a similar goal but I could be wrong. I’m less familiar with best practices in python for error handling as I mostly use it for scripting but in this case I’m using it for a jobs system so want to be able to get to the root cause of errors quickly with as much context preserved as possible.

[MangelMaxime]

It seems like in Python 3, they have raise ... from ... at least this is one of the result when looking for python inner exception on Google.

If we use raise_from or raise ... from ... (which perhaps is the same stuff with sugar syntax when looking at the written side by side like that), it seems like we would be able to follow Python ways of doing stuff and probably keep stacks trace etc.

But, I am not sure how we would be able to access to innerException property from FooException. I think to mimic F# behavior/API, we will still need to pass innerException to FSharpException type :

Fable/src/fable-library-py/fable_library/types.py

Lines 245 to 292 in 1cc7df5

	class FSharpException(Exception, IComparable):
	def __init__(self) -> None:
	self.Data0: Any = None
	def __str__(self) -> str:
	return record_to_string(self) # type: ignore
	def __repr__(self) -> str:
	return str(self)
	def __eq__(self, other: Any) -> bool:
	if self is other:
	return True
	if other is None:
	return False
	return self.Data0 == other.Data0
	def __lt__(self, other: Any) -> bool:
	if not isinstance(other, FSharpException):
	return False
	if self.Data0:
	if other.Data0:
	return self.Data0 < other.Data0
	else:
	return False
	elif not self.Data0:
	if other.Data0:
	return False
	else:
	return True
	return super().__lt__(other)
	def __hash__(self) -> int:
	return hash(self.Data0)
	def GetHashCode(self) -> int:
	return hash(self)
	def Equals(self, other: FSharpException):
	return record_equals(self, other)
	def CompareTo(self, other: FSharpException):
	return compare(self.Data0, other.Data0)

and detect that we are passing innerException to also try to apply the raise ... from ... syntax. Some experimentation is needed to check what the native Python behaviour is and how close can we get while keeping support for the F# API.