Question/suggestion about exceptions

[Graham St Jack]

Sean Kelly wrote:
> Ary Manzana wrote:
>> Graham St Jack wrote:
>>> Is there a way to automatically keep track of what exceptions may be 
>>> thrown by a function or method? Ideally, what I am looking for is 
>>> something like Java's "throws" keyword, but I would be happy with 
>>> almost anything.
>>>
>>> It is way too hard to develop reliable code of any size that uses 
>>> exceptions extensively, because as things change, you lose track of 
>>> what exceptions are thrown from where. Some sort of compiler support 
>>> would make this a lot easier.
>>>
>>> What I had in mind was an optional compiler warning and a new 
>>> "throws" keyword. The compiler would (optionally) issue a warning if 
>>> a function or method can throw an exception that it hasn't declared 
>>> that it "throws". With this assistance, it becomes is easy to keep 
>>> track of what can be thrown from where. Making it a warning and 
>>> optional stops it from breaking existing code, and makes quick code 
>>> hacks easy to write still.
>>>
>>> Thoughts?
>>
>> I totally support this idea. Is it hard to implement in the compiler? 
>> Of course, there should also be a hierarchy of exceptions, just like 
>> Java: RuntimeException dosen't signal an error when not try-catching it.
>>
>> Thoughts? :-)
> 
> It won't work with extern (C) functions, since the exception list would 
> probably be a part of the mangled function name.  This is why 'throws' 
> goes basically unused in C++, even though the feature is present.
> 
> 
> Sean

I can't be too hard to implement in the compiler because Java does it 
already. However, a lot of people find the discipline of having to think 
about exception handling too disruptive to the creative process (I have 
mixed feelings too). This is why I suggested adding the feature as an 
optional warning. That way you can crank out code without difficulty, 
then go back later and think about exception handling.

It doesn't need to work with extern (C) functions because they don't 
throw exceptions, and even if they did, you could wrap the problematic 
ones in D code so that exceptions would be tracked from there.

I agree that an exception hierarchy is a good thing, and I like the Java 
approach of the compiler errors only being generated for exceptions 
rather than "errors" like out-of-memory. Something like that could be 
done here too because D uses an exception hierarchy too - maybe by 
telling the compiler via a switch what exception base class (and all 
specializations) you want to be warned about.