# ink! Analyzer: Retroactive funding for ink! v5 support Hello, I'm [David Semakula (@davidsemakula)][me] - the creator of [ink! analyzer][ink-analyzer]. [me]: https://github.com/davidsemakula [ink-analyzer]: https://github.com/ink-analyzer ## What's ink! analyzer? [ink! analyzer][ink-analyzer] is a collection of modular and reusable libraries and tools for semantic analysis of [ink!] smart contracts. In short, ink! analyzer is to ink!, what [rust-analyzer] is to [Rust]. [ink!]: https://use.ink [rust-analyzer]: https://github.com/rust-lang/rust-analyzer [Rust]: https://www.rust-lang.org/ More technically, rust-analyzer is a Rust compiler frontend/semantic analyzer for [IDEs][IDE] that's built on a lossless and resilient parser (this part is very important for IDE/editor tooling because the program is essentially perpetually incorrect as you type in an IDE/editor). So rust-analyzer "understands" core Rust language concepts (e.g. that a trait implementation like `impl MyTrait for MyStruct {}` must define all the required associated items of the trait), and provides [intelligent editing features][intellisense] to help you with those kinds of core Rust language features. However, when it comes to [Rust syntax extensions/DSLs like ink!'s attribute macros][ink-macros], when you annotate a `mod` item with `#[ink::contract]`, all rust-analyzer "knows" is that this is a custom attribute, it doesn't "know" that an ink! contract `mod` must have exactly one `struct` item annotated with `#[ink(storage)]` or any of the other semantic rules for ink! contracts, so this is where ink! analyzer comes in 🙂. [IDE]: https://en.wikipedia.org/wiki/Integrated\_development\_environment [intellisense]: https://code.visualstudio.com/docs/editor/intellisense [ink-macros]: https://use.ink/getting-started/creating-an-ink-project/ For a deeper dive on the problems ink! analyzer solves and technical details about its architecture, check out [this detailed introductory blog post][ink-analyzer-intro]. You can also check out [this awesome X/Twitter thread by the ink! lang team][twitter-thread] for a quick walkthrough of ink! analyzer features. [ink-analyzer-intro]: https://analyze.ink/blog/introducing-ink-analyzer [twitter-thread]: https://twitter.com/ink\_lang/status/1762795949259448776 ## Adoption ink! analyzer's most user/developer facing component is currently a [Visual Studio Code extension][vs-code-extension], which has over *~350 unique installs* (first released in Aug/2023). However, ink! analyzer is built with an IDE/editor agnostic architecture to maximize re-usability of it's core components i.e. - [A modular domain-specific semantic analysis library for ink!][semantic-analyzer] built on a resilient and lossless parser. - A [Language Server Protocol (LSP)][LSP] [implementation][lsp-server] built on top of the aforementioned semantic analysis library.  *Figure 1: ink! Analyzer - LSP based Architecture Diagram* These two components (i.e. the [semantic analyzer][semantic-analyzer] and [language server][lsp-server]) can be reused to add ink! language support to multiple IDEs, code editors and other development tools. In particular, a large number of IDEs and code editors support LSP servers, these include [Visual Studio Code, Visual Studio, Vim / Neovim, Emacs, Atom, Sublime Text, Acme, Lapce, Eclipse and many more][lsp-tools]. [semantic-analyzer]: https://github.com/ink-analyzer/ink-analyzer/tree/master/crates/analyzer [lsp-server]: https://github.com/ink-analyzer/ink-analyzer/tree/master/crates/lsp-server [vs-code-extension]: https://marketplace.visualstudio.com/items?itemName=ink-analyzer.ink-analyzer [LSP]: https://microsoft.github.io/language-server-protocol/ [lsp-tools]: https://microsoft.github.io/language-server-protocol/implementors/tools/ Therefore, ink! analyzer makes it relatively easy for: - Users to enable ink! language support for their IDE, code editor or other development tool if it has either a native/built-in or third-party LSP client that can be configured to launch an LSP server using an executable command (i.e. the path to an [installed ink! Language Server binary][lsp-server-install]) and can use stdio (standard in/standard out) as the message transport. - Developers to either build extensions/plugins/integrations that add ink! language support to any tool with robust LSP client libraries/APIs/modules, or add first-class ink! language support to an existing LSP client (e.g. an open-source extension/plugin/integration). [lsp-server-install]: https://github.com/ink-analyzer/ink-analyzer/tree/master/crates/lsp-server#installation The latter option typically provides a better user experience as the user doesn't have to manually install (and update) the ink! Language Server as it can be bundled (or installed/updated) by the extension/plugin/integration. The [Visual Studio Code extension][vs-code-extension] serves as a showcase and [reference implementation][vs-code-extension-src] for this use case/approach. However, ink! analyzer also [distributes compiled ink! Language Server (`ink-lsp-server`) binaries for most of the major platforms/architectures][ink-lsp-server-releases] for non-VS Code users and developers. [vs-code-extension-src]: https://github.com/ink-analyzer/ink-vscode [ink-lsp-server-releases]: https://github.com/ink-analyzer/ink-analyzer/releases **NOTE:** While the first version of the [ink! analyzer VS Code extension][vs-code-extension] was released in Aug/2023, work on the core components (i.e. [semantic analyzer][semantic-analyzer] and [language server][lsp-server]) started well before in Mar/2023. ## Proposal Ask This treasury proposal requests *retroactive funding* for adding [ink! v5][ink-v5] support to ink! analyzer. Requested Amount: $26,500 / 2,812.27 DOT[^1] [ink-v5]: https://github.com/paritytech/ink/releases/tag/v5.0.0 | Breakdown/Tasks | Hours | |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------| | Add architectural foundations for supporting both v4 and v5 language versions across [IR, semantic analyzer and language server][ink-analyzer-architecture] | ~24 | | Update IR (Intermediate Representation) and attribute parser to support all v5 syntax and entities (including deeply nested meta-items and @ selector values) while preserving legacy support for v4 (also includes unit tests) | ~80 | | Add diagnostics and quickfixes for v5 entities and related attribute macros and arguments (while preserving legacy support for v4)
| ~136 | | Add v5 support for completions, code/intent actions, hover content, inlay hints and signature help (while preserving legacy support for v4)
| ~96 | | Add v5 codegen (while preserving legacy support for v4) | ~8 | | General maintenance and performance improvements
| 48 | | Integration tests (across semantic analyzer, language server and VS Code extension) | ~24 | | Documentation | ~8 | | **Total Hours** | **424** | | **Hourly Rate** | **$62.5** | | **Total Amount** | **$26,500** | **NOTE:** All ink! analyzer components are [fully open-source][ink-analyzer] and distributed under [OSI approved licenses][OSI-licenses]. [ink-analyzer-architecture]: https://github.com/ink-analyzer/ink-analyzer/blob/master/README.md#architecture [OSI-licenses]: https://opensource.org/licenses ## Previous Funding All previous work for ink! analyzer was funded by two generous [Web3 Foundation technical grants][w3f-grants]. - https://github.com/w3f/Grants-Program/blob/master/applications/ink-analyzer.md ($30,000) - https://github.com/w3f/Grants-Program/blob/master/applications/ink-analyzer-phase-2.md ($59,600) However, with the project now relatively mature and having some meaningful adoption, I'm looking to move to a retroactive treasury funding model for future updates. **NOTE:** [ink! v5][ink-v5] has only recently been released (13/Mar/2024), and so was outside the scope of the above [Web3 Foundation][w3f-grants] technical grants. However, work on ink! v5 support in ink! analyzer started well before the official ink! v5 release. [w3f-grants]: https://grants.web3.foundation/ ## Why not Wasm Smart Contracts Bounty / ink!ubator ? Historically, as noted above, all previous work for ink! analyzer was funded by [Web3 Foundation technical grants][w3f-grants]. This is partly because [development of ink! analyzer kicked off in Mar/2023][ink-analyzer-pr], while the [ink!ubator: Ecosystem Grants][inkubator-grants] program [only started receiving grant applications around ~May/2023][inkubator-pr] (note that discussions for the [Wasm Smart Contracts Bounty][wasm-bounty] started well before this though). In the present, with [ink!ubator being an incubation program following a cohort schedule][inkubator], and ink! analyzer now being a relatively mature project with some meaningful adoption, the need to support new [ink! features and syntax][ink-v5] as close to release as possible (hence the choice of retroactive funding), means the ink!ubator cohort schedule is not a good fit for this stage of the project. [ink-analyzer-pr]: https://github.com/w3f/Grants-Program/pull/1615 [inkubator]: https://use.ink/ubator [inkubator-grants]: https://github.com/use-inkubator/Ecosystem-Grants [inkubator-pr]: https://github.com/use-inkubator/Ecosystem-Grants/pull/7 [wasm-bounty]: https://polkadot.polkassembly.io/bounty/19 ## More about the author. I'm an independent Software Engineer & Systems Architect with over 10+ years of experience. I also [*independently* contribute][ra-contributions] to [rust-analyzer] (a Rust compiler front-end for IDEs). I've also made some [*independent* contributions][ink-contributions] to [ink!][ink-repo]. You can check out my [GitHub profile][me] and/or my [personal website][website] for more details. [website]: https://davidsemakula.com/ [ra-contributions]: https://github.com/rust-lang/rust-analyzer/pulls?q=is%3Apr+author%3Adavidsemakula [ink-contributions]: https://github.com/paritytech/ink/pulls?q=is%3Apr+author%3Adavidsemakula [ink-repo]: https://github.com/paritytech/ink [^1]: DOT/USD rate uses EMA30 rate from [Subscan](https://polkadot.subscan.io/tools/charts?type=price) retrieved on 27/Mar/2024.
Ink! Analyzer is a tool created by David Semakula that helps analyze ink! smart contracts. It is like rust-analyzer but for ink!, which is a language for making smart contracts. The analyzer helps with understanding the rules of ink! contracts and gives useful features for editing them. It works with many different tools, like Visual Studio Code, and can be used to add ink! support to other tools too.
David is asking for money to update ink! Analyzer so it can work with the newest version of ink!, called ink! v5. He wants to make it better and faster, and also write instructions for people to use it. He has already gotten money from the Web3 Foundation to work on ink! Analyzer before, but he thinks it's time to get money from the treasury instead. David is a software engineer with a lot of experience and has also helped with rust-analyzer and ink! in the past.
