3 ms·
The D language compiler uses a technique I call "poisoning" which has greatly reduced cascading error messages. The idea is whenever an error is found in an AST
by WalterBright 3y ago
The D language compiler uses a technique I call "poisoning" which has greatly reduced cascading error messages. The idea is whenever an error is found in an AST node, the AST node is replaced with an "error" node. Any combination of an error node with another node is replaced with an error node. Error messages for error nodes are suppressed.
It works far better than attempting to repair the AST into some plausible state.
It's analogous to the propagation of NaN values in floating point code.
- jansvoboda11 3y agoDo you cut off this poisoning at any point?
- WalterBright 3y agoIf something else depends on the successful semantic analysis of those poisoned nodes, they get poisoned as well. It's all based on dependency.
- tester756 3y agoBut with this approach you arent able to provide e.g intellisense or other IDE hints for valid things within this node, right?
- WalterBright 3y agoA hint can be provided where the original error is diagnosed. I doubt hints on cascaded errors would be of any use.
- tester756 3y agoif you have function like "public intd Test() { ... typing new line }" then you will not provide hints when writing that new line due to "intd" being invalid type?
- WalterBright 3y agoA function's declaration is not affected by its body, so that shouldn't be a problem.
- tnh 3y agoThings within the node are fine because errors propagate upwards. The problem is things like: Foo getFoo(int); getFoo().???; // want code completion! `getFoo()` is missing an argument, but you still want to complete Foo's members. If you type `getFoo().getBar()` you want go-to-definition to work on `getBar`. In clang, we use heuristics to preserve the type in high-confidence cases. (here overload resolution for `getFoo` failed, but there was only one candidate function). This means you can get cascading errors in those cases (but often that's a good thing, especially in an IDE - tradeoffs).
- munificent 3y agoI've got a compiler for a hobby language that uses this technique too (I probably got it from you, unless I heard it from someone else). It's really really nice. Super easy to implement and really does cut down on cascaded errors. I also use it during type checking. There is a special "error" type. If an expression produces a type error, the yielded type of that expression becomes "error". Surrounding expressions that consume that type will see the error type and suppress any other type errors they might otherwise produce. That way, you only see the original type error.
- WalterBright 3y agoYup, dmd also has an error type: https://github.com/dlang/dmd/blob/master/compiler/src/dmd/mtype.d#L1633 https://github.com/dlang/dmd/blob/master/compiler/src/dmd/mt...
- nathan_douglas 3y agoFunny, I was just gonna comment and say that I learned this One Weird Trick… and then realized I’d learned it from you. (Hi, Bob! I was actually just using your recursive shadowcasting algorithm as a reference yesterday.) I feel like I just got an Erdos number or something.
- munificent 3y ago:D
- tnh 3y ago> Surrounding expressions that consume that type will see the error type and suppress any other type errors they might otherwise produce. We added a slightly-cursed version of this to clang. The goal was: include more broken code in the AST instead of dropping it on the floor, without adding noisy error cascades. The problem is, adding a special case to all "surrounding expressions that consume that type" is literally thousands of places. It's often unclear exactly what to do, because "consume" means so many things in C++ (think overload resolution and argument-dependent lookup) and because certain type errors are used in metaprogramming (thanks, SFINAE). So this would cost a lot of complexity, and it's too late to redesign clang around it. But C++ already has a mechanism to suppress typechecking! Inside a template, most analysis of code that depends on a template parameter is deferred until instantiation. The implementation of this is hugely complicated and expensive to maintain, but that cost is sunk. So we piggy-backed on this mechanism: clang's error type is `<dependent type>`. The type of this expression depends on how the programmer fixes their error :-) And that's the story of how C gained dependent types (https://godbolt.org/z/szGdeGhrr https://godbolt.org/z/szGdeGhrr), because why should C++ have all the fun? (This leaves out a bunch of nuance, of course the truth is always more complicated)
- kazinator 3y agoYou can trivially reduce the number of messages to one by bailing on the first error.
- pvillano 3y agoThat makes error driven development difficult. I think a compiler should attempt to emit one error message per human error
- lifthrasiir 3y agoI think this is very commonly used and possibly independently discovered a lot of times---I had done so for example---because it is a very logical conclusion. Clang has `RecoveryExpr` [1] for this purpose (I couldn't find a GCC equivalent). [1] https://clang.llvm.org/doxygen/classclang_1_1RecoveryExpr.html https://clang.llvm.org/doxygen/classclang_1_1RecoveryExpr.ht...