lsp_req_errors.txt

warning: unused imports: `DerefMut` and `Deref`
 --> gridmesh\src\tensor.rs:3:16
  |
3 | use std::ops::{Deref, DerefMut};
  |                ^^^^^  ^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

warning: `gridmesh` (lib) generated 1 warning (run `cargo fix --lib -p gridmesh` to apply 1 suggestion)
warning: unused import: `anyhow`
 --> src\compiler.rs:6:14
  |
6 | use anyhow::{anyhow, Result};
  |              ^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

warning: unused import: `std::process::Command`
 --> src\compiler.rs:8:5
  |
8 | use std::process::Command;
  |     ^^^^^^^^^^^^^^^^^^^^^

warning: unused imports: `take_while1` and `tuple`
 --> src\interface\parser.rs:3:28
  |
3 |     bytes::complete::{tag, take_while1},
  |                            ^^^^^^^^^^^
...
7 |     sequence::{delimited, pair, preceded, tuple},
  |                                           ^^^^^

warning: unused import: `Param`
 --> src\languages\python\mod.rs:3:49
  |
3 | ...Options, FunctionSig, Param, WitType};
  |                          ^^^^^

warning: unused import: `Param`
 --> src\languages\rust\mod.rs:3:49
  |
3 | ...Options, FunctionSig, Param, WitType};
  |                          ^^^^^

warning: unused import: `FunctionSig`
 --> src\wit_gen.rs:5:20
  |
5 | use crate::types::{FunctionSig, WitType};
  |                    ^^^^^^^^^^^

warning: use of deprecated function `nom::sequence::tuple`: `Parser` is directly implemented for tuples
 --> src\interface\parser.rs:7:43
  |
7 |     sequence::{delimited, pair, preceded, tuple},
  |                                           ^^^^^
  |
  = note: `#[warn(deprecated)]` on by default

warning: unused variable: `i`
  --> src\compiler.rs:32:10
   |
32 |     for (i, block) in parsed.blocks.iter().enumerate...
   |          ^ help: if this is intentional, prefix it with an underscore: `_i`
   |
   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `opts`
  --> src\compiler.rs:58:38
   |
58 | ...les: &[Vec<u8>], opts: &CompileOptions) -> Result...
   |                     ^^^^ help: if this is intentional, prefix it with an underscore: `_opts`

warning: unused variable: `remaining`
  --> src\interface\parser.rs:68:10
   |
68 |     let (remaining, items) = many0(preceded(
   |          ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_remaining`

warning: function `parse_struct` is never used
  --> src\interface\parser.rs:81:4
   |
81 | fn parse_struct(input: &str) -> IResult<&str, Struct...
   |    ^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: function `parse_field` is never used
   --> src\interface\parser.rs:102:4
    |
102 | fn parse_field(input: &str) -> IResult<&str, Field> {
    |    ^^^^^^^^^^^

warning: method `to_lang_type` is never used
  --> src\languages\python\mod.rs:16:8
   |
11 | impl Python {
   | ----------- method in this implementation
...
16 |     fn to_lang_type(&self, wit_type: &WitType, optio...
   |        ^^^^^^^^^^^^

warning: `polyglot` (lib) generated 13 warnings (run `cargo fix --lib -p polyglot` to apply 9 suggestions)
    Checking poly-lsp v0.1.0 (C:\Users\adria\Downloads\pyrs polygot\pyrs\poly-lsp)
error: cannot find macro `anyhow` in this scope
   --> poly-lsp\src\delegator.rs:155:13
    |
155 |         Err(anyhow!("Server not found for lang: {}", lang))
    |             ^^^^^^
    |
    = note: `anyhow` is in scope, but it is a crate, not a macro
help: consider importing this macro
    |
  1 + use anyhow::anyhow;
    |

error: cannot find macro `anyhow` in this scope
   --> poly-lsp\src\delegator.rs:148:28
    |
148 |                 return Err(anyhow!("LSP Error: {:?}", err));
    |                            ^^^^^^
    |
    = note: `anyhow` is in scope, but it is a crate, not a macro
help: consider importing this macro
    |
  1 + use anyhow::anyhow;
    |

error: cannot find macro `anyhow` in this scope
  --> poly-lsp\src\delegator.rs:52:52
   |
52 |         let mut stdout = child.stdout.take().ok_or(anyhow!("Failed to open stdout"))?;
   |                                                    ^^^^^^
   |
   = note: `anyhow` is in scope, but it is a crate, not a macro
help: consider importing this macro
   |
 1 + use anyhow::anyhow;
   |

error: cannot find macro `anyhow` in this scope
  --> poly-lsp\src\delegator.rs:51:46
   |
51 |         let stdin = child.stdin.take().ok_or(anyhow!("Failed to open stdin"))?;
   |                                              ^^^^^^
   |
   = note: `anyhow` is in scope, but it is a crate, not a macro
help: consider importing this macro
   |
 1 + use anyhow::anyhow;
   |

error: cannot find macro `anyhow` in this scope
  --> poly-lsp\src\delegator.rs:43:29
   |
43 |             _ => return Err(anyhow!("Unsupported language for LSP delegation: {}", lang)),
   |                             ^^^^^^
   |
   = note: `anyhow` is in scope, but it is a crate, not a macro
help: consider importing this macro
   |
 1 + use anyhow::anyhow;
   |

warning: unused import: `anyhow`
 --> poly-lsp\src\json_rpc.rs:1:22
  |
1 | use anyhow::{Result, anyhow};
  |                      ^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
   --> poly-lsp\src\delegator.rs:32:53
    |
 32 |     pub async fn start_server(&self, lang: &str) -> Result<()> {
    |                                                     ^^^^^^ -- supplied 1 generic argument
    |                                                     |
    |                                                     expected 2 generic arguments
    |
note: enum defined here, with 2 generic parameters: `T`, `E`
   --> C:\Users\adria\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\result.rs:557:10
    |
557 | pub enum Result<T, E> {
    |          ^^^^^^ -  -
help: add missing generic argument
    |
 32 |     pub async fn start_server(&self, lang: &str) -> Result<(), E> {
    |                                                              +++

error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
   --> poly-lsp\src\delegator.rs:90:76
    |
 90 |     pub async fn notify(&self, lang: &str, method: &str, params: Value) -> Result<()> {
    |                                                                            ^^^^^^ -- supplied 1 generic argument
    |                                                                            |
    |                                                                            expected 2 generic arguments
    |
note: enum defined here, with 2 generic parameters: `T`, `E`
   --> C:\Users\adria\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\result.rs:557:10
    |
557 | pub enum Result<T, E> {
    |          ^^^^^^ -  -
help: add missing generic argument
    |
 90 |     pub async fn notify(&self, lang: &str, method: &str, params: Value) -> Result<(), E> {
    |                                                                                     +++

error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
   --> poly-lsp\src\delegator.rs:103:59
    |
103 |     pub async fn sync_open(&self, vfile: &VirtualFile) -> Result<()> {
    |                                                           ^^^^^^ -- supplied 1 generic argument
    |                                                           |
    |                                                           expected 2 generic arguments
    |
note: enum defined here, with 2 generic parameters: `T`, `E`
   --> C:\Users\adria\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\result.rs:557:10
    |
557 | pub enum Result<T, E> {
    |          ^^^^^^ -  -
help: add missing generic argument
    |
103 |     pub async fn sync_open(&self, vfile: &VirtualFile) -> Result<(), E> {
    |                                                                    +++

error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
   --> poly-lsp\src\delegator.rs:127:77
    |
127 |     pub async fn request(&self, lang: &str, method: &str, params: Value) -> Result<Value> {
    |                                                                             ^^^^^^ ----- supplied 1 generic argument
    |                                                                             |
    |                                                                             expected 2 generic arguments
    |
note: enum defined here, with 2 generic parameters: `T`, `E`
   --> C:\Users\adria\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\result.rs:557:10
    |
557 | pub enum Result<T, E> {
    |          ^^^^^^ -  -
help: add missing generic argument
    |
127 |     pub async fn request(&self, lang: &str, method: &str, params: Value) -> Result<Value, E> {
    |                                                                                         +++

error[E0282]: type annotations needed
  --> poly-lsp\src\delegator.rs:54:32
   |
54 |         let pending = Arc::new(DashMap::new());
   |                                ^^^^^^^^^^^^ cannot infer type of the type parameter `V` declared on the struct `DashMap`
...
65 |                                      let _ = sender.send(msg);
   |                                              ------ type must be known at this point
   |
help: consider specifying the generic arguments
   |
54 |         let pending = Arc::new(DashMap::<K, V>::new());
   |                                       ++++++++

Some errors have detailed explanations: E0107, E0282.
For more information about an error, try `rustc --explain E0107`.
warning: `poly-lsp` (bin "poly-lsp") generated 1 warning
error: could not compile `poly-lsp` (bin "poly-lsp") due to 10 previous errors; 1 warning emitted