Document the process for increasing language support

[robrix]

We’re getting interest in adding support for languages, so we should document the overall process.

Given that we’re migrating away from using assignment &c., I think we should explicitly leave that out (tho prolly we should note that we don’t support diffing for the new-style grammar-derived ASTs just yet).

I think that makes the steps something like:

1. Make a tree-sitter parser (link to tree-sitter docs)
2. Add the parser to haskell-tree-sitter (link to an example PR?)
3. Add the parser to semantic
4. (Potentially) implement compilation to Core & build/generate a prelude

We should also be careful to document what you get with each step. Like, the first one gives you Atom support, the second & third give you semantic support (modulo any generic functionality we haven’t implemented yet), and the fourth gives you full analysis support.

[robrix]

cc @shaziyabandukia

[patrickt]

I think that we should mention assignment, at least for now, since we’re still several months away from the new-style grammar-derived ASTs – if only to impress on people that adding new languages is, for now, a lot of work.

[robrix]

I think that we should mention assignment, at least for now, since we’re still several months away from the new-style grammar-derived ASTs – if only to impress on people that adding new languages is, for now, a lot of work.

Fair point. Can we at least say “please don’t do this to yourself”? 😊

[damieng]

Are these new style AST's not based on tree-sitter? I got about 50% through a C# grammar when I worked on the Atom team I'd be keen on picking back up if it'll be used on GitHub for this but obviously don't want to waste effort if something new is in the pipeline.

[patrickt]

@damieng The new-style ASTs will be based on tree-sitter, so we’ll still need a tree-sitter-c# grammar/package: indeed, we'll generate Haskell type definitions generated directly from the tree-sitter grammar. What will change is that the internal sum-of-products AST representation (see Data.Term and Language.Syntax.*) will be obviated, as we’ll instead translate the new-style ASTs directly into Data.Core expressions (from semantic-core).

[robrix]

The TH code to generate the datatypes is already on haskell-tree-sitter’s master, and cf tree-sitter/haskell-tree-sitter#144 for @aymannadeem’s work on building said ASTs from tree-sitter parses.

[robrix]

What will change is that the internal sum-of-products AST representation (see Data.Term and Language.Syntax.*) will be obviated, as we’ll instead translate the new-style ASTs directly into Data.Core expressions (from semantic-core).

Note that non-analytical (i.e. syntactic rather than truly semantic) computations won’t need this last step, as we should be able to e.g. diff generically over the new ASTs too (once we get that far).

[patrickt]

Tracking in #131

[patrickt]

Fixed with #131.