diffsitter

The five command part isn't really possible but you can use custom diffs for merges, git diff, etc. pretty easily. There are projects like diffsitter ( https://github.com/afnanenayet/diffsitter ) for doing more intelligent diffs like this for supported languages. EDIT: and then an example for the merge stuff I couldn't find while typing before: https://mergiraf.org/ and HN discussion a few years ago: https://news.ycombinator.com/item?id=42093756

I might have misinterpreted what you mean as “standard” (I was originally thinking like you meant that the standard dictates all operations must be safe and doing things like the unsafe/unchecked option references would be outside the standard). I realized that you might mean it like it should be the default behavior, so correct me if I’m wrong there. Yeah I agree that sane defaults would be nice and that things like unchecked accesses should be more explicit. Having linear types to properly enforce issues with things like use-after-move would also be awesome. I don’t know that anyone has ever accused C++ of being particularly ergonomic. Sum types and pattern matching would be awesome. Nothing wrong with being a Rust fanboy :), I have written some (https://github.com/afnanenayet/diffsitter).

for diffing syntax trees, I've been trying out diffsitter, and it feels pretty good so far https://github.com/afnanenayet/diffsitter

I'm pretty sure this counts. https://github.com/afnanenayet/diffsitter Certainly the idea has been suggested many times. I think people end up formatting both before/after and doing a diff on formatted before against formatted after. I've done that.

There is also diffsitter. I was testing it a month ago, it works fine. Not sure what language-aware diffing exactly means, but diffsitter uses tree-sitter and it is comparing ASTs and CSTs of the files. [1] https://github.com/afnanenayet/diffsitter

Or https://github.com/afnanenayet/diffsitter. I've tried both and I like them. No preference or notable opinions on them yet!

I think your skepticism is justified, but there are two tools that I have seen that use tree-sitter for diffing: https://github.com/wilfred/difftastic https://github.com/afnanenayet/diffsitter (I have not tried either personally.)

One more tree-sitter based diffing tool - diffsitter https://github.com/afnanenayet/diffsitter

Several threads here point to difftastic: https://github.com/Wilfred/difftastic I know a lot of people who have a lot of hope for diffsitter (or something like it): https://github.com/afnanenayet/diffsitter Personally, I think the reason most "good" semantic diff tools are proprietary is that they are huge amounts of effort that are mostly "hacks" and "heuristics" bandaged together in ways that people don't want to let out how the sausage was made. But I also think "general, language agnostic AST-based semantic diff" is a mountain peak we cannot reach (probably ever), and I believe my experiments found an interesting local maxima that people are maybe passing by on the way to that ideal mountain (lexer-based diffs rather than parser-based diffs): https://github.com/WorldMaker/tokdiff

I believe Unison is the only attempt to do this at a programming language/environment level. For Git diffs, there is Diffsitter, which uses Tree Sitter to generate semantic diffs of code files: https://github.com/afnanenayet/diffsitter I have not used it, but it is high on my todo list.

I think everyone may be interested in: https://github.com/afnanenayet/diffsitter Github having an option to have their PR GUI use an AST diff like this could be a fun and useful option.

Counterpoint: a quick google reveals diffsitter: https://github.com/afnanenayet/diffsitter The output could be a lot more compact, it could do better at adding context (in the same way https://github.com/romgrk/nvim-treesitter-context does, etc), but if you're interested in this it's really within reach, go help out. I wonder if you can use it for automerge yet.

Anyone know how to compute the diff between two ASTs if the edits _are_ known, either in general or with tree-sitter. The method used by diffsitter is to compute the path with minimal editing distance: https://github.com/afnanenayet/diffsitter/blob/main/src/ast..... In the case where the edits are known (because you're re-creating the AST per keystroke), you can save parsing time by passing in the old tree and a set of edits: https://tree-sitter.github.io/tree-sitter/using-parsers#edit.... Intuitively, I feel like there should be a way to reduce diffing time as well to avoid O(mn) run and space time that comes from the dynamic programming solution to compute the minimal edit.