2017-12-21 19:37:06 +00:00
- Feature Name: libsyntax2
- Start Date: 2017-12-30
2017-12-21 19:28:23 +00:00
- RFC PR: (leave this empty)
- Rust Issue: (leave this empty)
2017-12-21 19:37:06 +00:00
>I think the lack of reusability comes in object-oriented languages,
>not functional languages. Because the problem with object-oriented
>languages is they’
>carry around with them. You wanted a banana but what you got was a
>gorilla holding the banana and the entire jungle.
>
>If you have referentially transparent code, if you have pure
>functions — all the data comes in its input arguments and everything
>goes out and leave no state behind — it’
>
> **Joe Armstrong**
2017-12-21 19:28:23 +00:00
# Summary
[summary]: #summary
2017-12-21 19:37:06 +00:00
The long-term plan is to rewrite libsyntax parser and syntax tree data
structure to create a software component independent of the rest of
rustc compiler and suitable for the needs of IDEs and code
editors. This RFCs is the first step of this plan, whose goal is to
find out if this is possible at least in theory. If it is possible,
the next steps would be a prototype implementation as a crates.io
crate and a separate RFC for integrating the prototype with rustc,
other tools, and eventual libsyntax removal.
Note that this RFC does not propose to stabilize any API for working
with rust syntax: the semver version of the hypothetical library would
be `0.1.0` .
2017-12-21 19:28:23 +00:00
# Motivation
[motivation]: #motivation
2017-12-22 12:31:48 +00:00
## Reusability
2017-12-22 00:43:39 +00:00
In theory, parsing can be a pure function, which takes a `&str` as an
input, and produces a `ParseTree` as an output.
This is great for reusability: for example, you can compile this
function to WASM and use it for fast client-side validation of syntax
on the rust playground, or you can develop tools like `rustfmt` on
stable Rust outside of rustc repository, or you can embed the parser
into your favorite IDE or code editor.
This is also great for correctness: with such simple interface, it's
possible to write property-based tests to thoroughly compare two
different implementations of the parser. It's also straightforward to
create a comprehensive test suite, because all the inputs and outputs
are trivially serializable to human-readable text.
Another benefit is performance: with this signature, you can cache a
parse tree for each file, with trivial strategy for cache invalidation
(invalidate an entry when the underling file changes). On top of such
a cache it is possible to build a smart code indexer which maintains
the set of symbols in the project, watches files for changes and
automatically reindexes only changed files.
Unfortunately, the current libsyntax is far from this ideal. For
example, even the lexer makes use of the `FileMap` which is
essentially a global state of the compiler which represents all know
files. As a data point, it turned out to be easier to move `rustfmt`
inside of main `rustc` repository than to move libsyntax outside!
2017-12-22 12:31:48 +00:00
## IDE support
2017-12-22 00:43:39 +00:00
2017-12-22 12:31:48 +00:00
There is one big difference in how IDEs and compilers typically treat
source code.
2017-12-22 00:43:39 +00:00
2017-12-22 12:31:48 +00:00
In the compiler, it is convenient to transform the source
code into Abstract Syntax Tree form, which is independent of the
surface syntax. For example, it's convenient to discard comments,
whitespaces and desugar some syntactic constructs in terms of the
simpler ones.
2017-12-22 00:43:39 +00:00
2017-12-22 12:31:48 +00:00
In contrast, for IDEs it is crucial to have a lossless view of the
source code because, for example, it's important to preserve comments
during refactorings.
2017-12-22 00:43:39 +00:00
2017-12-22 12:31:48 +00:00
Currently rustc uses the AST approach, which preserves the source code
information to some extent by storing spans in the AST.
2017-12-22 00:43:39 +00:00
2017-12-21 19:28:23 +00:00
# Guide-level explanation
[guide-level-explanation]: #guide -level-explanation
2017-12-22 12:31:48 +00:00
Not applicable.
2017-12-21 19:28:23 +00:00
# Reference-level explanation
[reference-level-explanation]: #reference -level-explanation
2017-12-22 12:31:48 +00:00
This section proposes a new syntax tree data structure, which should
be suitable for both compiler and IDE. It is heavily inspired by [PSI]
data structure which used in [IntelliJ] based IDEs and in the Kotlin
compiler.
2017-12-21 19:28:23 +00:00
2017-12-22 12:31:48 +00:00
[PSI]: http://www.jetbrains.org/intellij/sdk/docs/reference_guide/custom_language_support/implementing_parser_and_psi.html
[IntelliJ]: https://github.com/JetBrains/intellij-community/
[Kotlin]: https://kotlinlang.org/
2017-12-21 19:28:23 +00:00
# Drawbacks
[drawbacks]: #drawbacks
Why should we *not* do this?
# Rationale and alternatives
[alternatives]: #alternatives
- Why is this design the best in the space of possible designs?
- What other designs have been considered and what is the rationale for not choosing them?
- What is the impact of not doing this?
# Unresolved questions
[unresolved]: #unresolved -questions
- What parts of the design do you expect to resolve through the RFC process before this gets merged?
- What parts of the design do you expect to resolve through the implementation of this feature before stabilization?
- What related issues do you consider out of scope for this RFC that could be addressed in the future independently of the solution that comes out of this RFC?
