error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:126:5
    |
126 |     erg_common::error::Location::range(loc.row(), loc.column(), loc.row(), loc.column() + cont_len)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------  ------------  ---------  ----------------------- expected `u32`, found `usize`
    |                                        |          |             |
    |                                        |          |             expected `u32`, found `usize`
    |                                        |          expected `u32`, found `usize`
    |                                        expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_common-0.6.3/error.rs:273:18
    |
273 |     pub const fn range(ln_begin: u32, col_begin: u32, ln_end: u32, col_end: u32) -> Self {
    |                  ^^^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
126 |     erg_common::error::Location::range(loc.row().try_into().unwrap(), loc.column(), loc.row(), loc.column() + cont_len)
    |                                                 ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
126 |     erg_common::error::Location::range(loc.row(), loc.column().try_into().unwrap(), loc.row(), loc.column() + cont_len)
    |                                                               ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
126 |     erg_common::error::Location::range(loc.row(), loc.column(), loc.row().try_into().unwrap(), loc.column() + cont_len)
    |                                                                          ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
126 |     erg_common::error::Location::range(loc.row(), loc.column(), loc.row(), (loc.column() + cont_len).try_into().unwrap())
    |                                                                            +                       +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:268:21
    |
268 |         let token = Token::new(TokenKind::Symbol, cont, loc.row(), loc.column() - 1);
    |                     ^^^^^^^^^^                          ---------  ---------------- expected `u32`, found `usize`
    |                                                         |
    |                                                         expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
268 |         let token = Token::new(TokenKind::Symbol, cont, loc.row().try_into().unwrap(), loc.column() - 1);
    |                                                                  ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
268 |         let token = Token::new(TokenKind::Symbol, cont, loc.row(), (loc.column() - 1).try_into().unwrap());
    |                                                                    +                +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:270:19
    |
270 |         let dot = Token::new(TokenKind::Dot, ".", loc.row(), loc.column() - 1);
    |                   ^^^^^^^^^^                      ---------  ---------------- expected `u32`, found `usize`
    |                                                   |
    |                                                   expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
270 |         let dot = Token::new(TokenKind::Dot, ".", loc.row().try_into().unwrap(), loc.column() - 1);
    |                                                            ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
270 |         let dot = Token::new(TokenKind::Dot, ".", loc.row(), (loc.column() - 1).try_into().unwrap());
    |                                                              +                +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:276:21
    |
276 |         let token = Token::new(TokenKind::Symbol, name, loc.row(), loc.column() - 1);
    |                     ^^^^^^^^^^                          ---------  ---------------- expected `u32`, found `usize`
    |                                                         |
    |                                                         expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
276 |         let token = Token::new(TokenKind::Symbol, name, loc.row().try_into().unwrap(), loc.column() - 1);
    |                                                                  ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
276 |         let token = Token::new(TokenKind::Symbol, name, loc.row(), (loc.column() - 1).try_into().unwrap());
    |                                                                    +                +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:278:19
    |
278 |         let dot = Token::new(TokenKind::Dot, ".", loc.row(), loc.column() - 1);
    |                   ^^^^^^^^^^                      ---------  ---------------- expected `u32`, found `usize`
    |                                                   |
    |                                                   expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
278 |         let dot = Token::new(TokenKind::Dot, ".", loc.row().try_into().unwrap(), loc.column() - 1);
    |                                                            ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
278 |         let dot = Token::new(TokenKind::Dot, ".", loc.row(), (loc.column() - 1).try_into().unwrap());
    |                                                              +                +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:283:21
    |
283 |         let token = Token::new(TokenKind::Symbol, arg, loc.row(), loc.column() - 1);
    |                     ^^^^^^^^^^                         ---------  ---------------- expected `u32`, found `usize`
    |                                                        |
    |                                                        expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
283 |         let token = Token::new(TokenKind::Symbol, arg, loc.row().try_into().unwrap(), loc.column() - 1);
    |                                                                 ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
283 |         let token = Token::new(TokenKind::Symbol, arg, loc.row(), (loc.column() - 1).try_into().unwrap());
    |                                                                   +                +++++++++++++++++++++

error[E0308]: mismatched types
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:337:74
     |
337  |                 let tmp_name = VarName::from_str_and_line((&tmp).into(), expr.location.row());
     |                                --------------------------                ^^^^^^^^^^^^^^^^^^^ expected `u32`, found `usize`
     |                                |
     |                                arguments to this function are incorrect
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/ast.rs:2320:12
     |
2320 |     pub fn from_str_and_line(symbol: Str, line: u32) -> Self {
     |            ^^^^^^^^^^^^^^^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
337  |                 let tmp_name = VarName::from_str_and_line((&tmp).into(), expr.location.row().try_into().unwrap());
     |                                                                                             ++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:344:46
    |
344 |                     let index = Literal::new(Token::new(
    |                                              ^^^^^^^^^^
...
347 |                         elem.location.row(),
    |                         ------------------- expected `u32`, found `usize`
348 |                         elem.location.column() - 1,
    |                         -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
347 |                         elem.location.row().try_into().unwrap(),
    |                                            ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
348 |                         (elem.location.column() - 1).try_into().unwrap(),
    |                         +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:369:29
    |
369 |                 let token = Token::new(
    |                             ^^^^^^^^^^
...
372 |                     expr.location.row(),
    |                     ------------------- expected `u32`, found `usize`
373 |                     expr.location.column() - 1,
    |                     -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
372 |                     expr.location.row().try_into().unwrap(),
    |                                        ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
373 |                     (expr.location.column() - 1).try_into().unwrap(),
    |                     +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:404:39
    |
404 |             _other => TypeSpec::Infer(Token::new(
    |                                       ^^^^^^^^^^
...
407 |                 expr.location.row(),
    |                 ------------------- expected `u32`, found `usize`
408 |                 expr.location.column() - 1,
    |                 -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
407 |                 expr.location.row().try_into().unwrap(),
    |                                    ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
408 |                 (expr.location.column() - 1).try_into().unwrap(),
    |                 +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:433:23
    |
433 |         let l_brace = Token::new(l_kind, l_cont, expr_loc.row(), expr_loc.column() - 1);
    |                       ^^^^^^^^^^                 --------------  --------------------- expected `u32`, found `usize`
    |                                                  |
    |                                                  expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
433 |         let l_brace = Token::new(l_kind, l_cont, expr_loc.row().try_into().unwrap(), expr_loc.column() - 1);
    |                                                                ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
433 |         let l_brace = Token::new(l_kind, l_cont, expr_loc.row(), (expr_loc.column() - 1).try_into().unwrap());
    |                                                                  +                     +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:434:23
    |
434 |         let r_brace = Token::new(r_kind, r_cont, l_end, c_end);
    |                       ^^^^^^^^^^                 -----  ----- expected `u32`, found `usize`
    |                                                  |
    |                                                  expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
434 |         let r_brace = Token::new(r_kind, r_cont, l_end.try_into().unwrap(), c_end);
    |                                                       ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
434 |         let r_brace = Token::new(r_kind, r_cont, l_end, c_end.try_into().unwrap());
    |                                                              ++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:458:29
    |
458 |                 let token = Token::new(kind, cont, expr.location.row(), expr.location.column() - 1);
    |                             ^^^^^^^^^^             -------------------  -------------------------- expected `u32`, found `usize`
    |                                                    |
    |                                                    expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
458 |                 let token = Token::new(kind, cont, expr.location.row().try_into().unwrap(), expr.location.column() - 1);
    |                                                                       ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
458 |                 let token = Token::new(kind, cont, expr.location.row(), (expr.location.column() - 1).try_into().unwrap());
    |                                                                         +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:467:29
    |
467 |                 let token = Token::new(
    |                             ^^^^^^^^^^
...
470 |                     expr.location.row(),
    |                     ------------------- expected `u32`, found `usize`
471 |                     expr.location.column() - 2,
    |                     -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
470 |                     expr.location.row().try_into().unwrap(),
    |                                        ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
471 |                     (expr.location.column() - 2).try_into().unwrap(),
    |                     +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:475:61
    |
475 |             ExpressionType::False => Expr::Lit(Literal::new(Token::new(
    |                                                             ^^^^^^^^^^
...
478 |                 expr.location.row(),
    |                 ------------------- expected `u32`, found `usize`
479 |                 expr.location.column() - 1,
    |                 -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
478 |                 expr.location.row().try_into().unwrap(),
    |                                    ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
479 |                 (expr.location.column() - 1).try_into().unwrap(),
    |                 +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:481:60
    |
481 |             ExpressionType::True => Expr::Lit(Literal::new(Token::new(
    |                                                            ^^^^^^^^^^
...
484 |                 expr.location.row(),
    |                 ------------------- expected `u32`, found `usize`
485 |                 expr.location.column() - 1,
    |                 -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
484 |                 expr.location.row().try_into().unwrap(),
    |                                    ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
485 |                 (expr.location.column() - 1).try_into().unwrap(),
    |                 +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:487:60
    |
487 |             ExpressionType::None => Expr::Lit(Literal::new(Token::new(
    |                                                            ^^^^^^^^^^
...
490 |                 expr.location.row(),
    |                 ------------------- expected `u32`, found `usize`
491 |                 expr.location.column() - 1,
    |                 -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
490 |                 expr.location.row().try_into().unwrap(),
    |                                    ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
491 |                 (expr.location.column() - 1).try_into().unwrap(),
    |                 +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:493:64
    |
493 |             ExpressionType::Ellipsis => Expr::Lit(Literal::new(Token::new(
    |                                                                ^^^^^^^^^^
...
496 |                 expr.location.row(),
    |                 ------------------- expected `u32`, found `usize`
497 |                 expr.location.column() - 1,
    |                 -------------------------- expected `u32`, found `usize`
    |
note: associated function defined here
   --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
    |
403 |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
    |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
496 |                 expr.location.row().try_into().unwrap(),
    |                                    ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
    |
497 |                 (expr.location.column() - 1).try_into().unwrap(),
    |                 +                          +++++++++++++++++++++

error[E0308]: mismatched types
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:805:86
     |
805  |             Identifier::public_with_line(DOT, self.namespace.last().unwrap().into(), line);
     |             ---------------------------- arguments to this function are incorrect    ^^^^ expected `u32`, found `usize`
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/ast.rs:2434:12
     |
2434 |     pub fn public_with_line(dot: Token, name: Str, line: u32) -> Self {
     |            ^^^^^^^^^^^^^^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
805  |             Identifier::public_with_line(DOT, self.namespace.last().unwrap().into(), line.try_into().unwrap());
     |                                                                                          ++++++++++++++++++++

error[E0308]: mismatched types
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:999:75
     |
999  | ...                   VarName::from_str_and_line((&tmp).into(), stmt.location.row());
     |                       --------------------------                ^^^^^^^^^^^^^^^^^^^ expected `u32`, found `usize`
     |                       |
     |                       arguments to this function are incorrect
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/ast.rs:2320:12
     |
2320 |     pub fn from_str_and_line(symbol: Str, line: u32) -> Self {
     |            ^^^^^^^^^^^^^^^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
999  |                                 VarName::from_str_and_line((&tmp).into(), stmt.location.row().try_into().unwrap());
     |                                                                                              ++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:1014:58
     |
1014 | ...                   let index = Literal::new(Token::new(
     |                                                ^^^^^^^^^^
...
1017 | ...                       elem.location.row(),
     |                           ------------------- expected `u32`, found `usize`
1018 | ...                       elem.location.column() - 1,
     |                           -------------------------- expected `u32`, found `usize`
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
     |
403  |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
     |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1017 |                                     elem.location.row().try_into().unwrap(),
     |                                                        ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1018 |                                     (elem.location.column() - 1).try_into().unwrap(),
     |                                     +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:1267:59
     |
1267 |                     let mod_name = Expr::Lit(Literal::new(Token::new(
     |                                                           ^^^^^^^^^^
...
1270 |                         stmt.location.row(),
     |                         ------------------- expected `u32`, found `usize`
1271 |                         stmt.location.column() - 1,
     |                         -------------------------- expected `u32`, found `usize`
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
     |
403  |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
     |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1270 |                         stmt.location.row().try_into().unwrap(),
     |                                            ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1271 |                         (stmt.location.column() - 1).try_into().unwrap(),
     |                         +                          +++++++++++++++++++++

error[E0308]: arguments to this function are incorrect
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/py2erg-0.0.3/convert.rs:1309:55
     |
1309 |                 let mod_name = Expr::Lit(Literal::new(Token::new(
     |                                                       ^^^^^^^^^^
...
1312 |                     stmt.location.row(),
     |                     ------------------- expected `u32`, found `usize`
1313 |                     stmt.location.column() - 1,
     |                     -------------------------- expected `u32`, found `usize`
     |
note: associated function defined here
    --> /Users/boxed/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_parser-0.6.3/token.rs:403:12
     |
403  |     pub fn new<S: Into<Str>>(kind: TokenKind, cont: S, lineno: u32, col_begin: u32) -> Self {
     |            ^^^
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1312 |                     stmt.location.row().try_into().unwrap(),
     |                                        ++++++++++++++++++++
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
     |
1313 |                     (stmt.location.column() - 1).try_into().unwrap(),
     |                     +                          +++++++++++++++++++++

For more information about this error, try `rustc --explain E0308`.
error: could not compile `py2erg` due to 23 previous errors
warning: build failed, waiting for other jobs to finish...
error: failed to compile `pylyzer v0.0.3`, intermediate artifacts can be found at `/var/folders/p_/lmszy5p567g8g7mth15yhz3m0000gn/T/cargo-installC3Enfv`

--  NOTE: Must happen before plugins are required (otherwise wrong leader will be used)
vim.g.mapleader = ' '
vim.g.maplocalleader = ' '

-- Install package manager
--    https://github.com/folke/lazy.nvim
--    `:help lazy.nvim.txt` for more info
local lazypath = vim.fn.stdpath 'data' .. '/lazy/lazy.nvim'
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system {
    'git',
    'clone',
    '--filter=blob:none',
    'https://github.com/folke/lazy.nvim.git',
    '--branch=stable', -- latest stable release
    lazypath,
  }
end
vim.opt.rtp:prepend(lazypath)

-- NOTE: Here is where you install your plugins.
--  You can configure plugins using the `config` key.
--
--  You can also configure plugins after the setup call,
--    as they will be available in your neovim runtime.
require('lazy').setup({
  -- NOTE: First, some plugins that don't require any configuration

  -- Git related plugins
  'tpope/vim-fugitive',
  'tpope/vim-rhubarb',

  -- Detect tabstop and shiftwidth automatically
  'tpope/vim-sleuth',

  -- NOTE: This is where your plugins related to LSP can be installed.
  --  The configuration is done below. Search for lspconfig to find it below.
  {
    -- LSP Configuration & Plugins
    'neovim/nvim-lspconfig',
    dependencies = {
      -- Automatically install LSPs to stdpath for neovim
      { 'williamboman/mason.nvim', config = true },
      'williamboman/mason-lspconfig.nvim',

      -- Useful status updates for LSP
      -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
      { 'j-hui/fidget.nvim', opts = {} },

      -- Additional lua configuration, makes nvim stuff amazing!
      'folke/neodev.nvim',
    },
  },

  {
    -- Autocompletion
    'hrsh7th/nvim-cmp',
    dependencies = {
      -- Snippet Engine & its associated nvim-cmp source
      'L3MON4D3/LuaSnip',
      'saadparwaiz1/cmp_luasnip',

      -- Adds LSP completion capabilities
      'hrsh7th/cmp-nvim-lsp',

      -- Adds a number of user-friendly snippets
      'rafamadriz/friendly-snippets',
    },
  },

  {'lvimuser/lsp-inlayhints.nvim'},

  -- Useful plugin to show you pending keybinds.
  { 'folke/which-key.nvim', opts = {} },
  {
    -- Adds git releated signs to the gutter, as well as utilities for managing changes
    'lewis6991/gitsigns.nvim',
    opts = {
      -- See `:help gitsigns.txt`
      signs = {
        add = { text = '+' },
        change = { text = '~' },
        delete = { text = '_' },
        topdelete = { text = '‾' },
        changedelete = { text = '~' },
      },
      on_attach = function(bufnr)
        vim.keymap.set('n', '[c', require('gitsigns').prev_hunk, { buffer = bufnr, desc = 'Go to Previous Hunk' })
        vim.keymap.set('n', ']c', require('gitsigns').next_hunk, { buffer = bufnr, desc = 'Go to Next Hunk' })
        vim.keymap.set('n', '<leader>ph', require('gitsigns').preview_hunk, { buffer = bufnr, desc = '[P]review [H]unk' })
      end,
    },
  },

  {
    -- Theme inspired by Atom
    'navarasu/onedark.nvim',
    priority = 1000,
    config = function()
      vim.cmd.colorscheme 'onedark'
    end,
  },

  {
    -- Set lualine as statusline
    'nvim-lualine/lualine.nvim',
    -- See `:help lualine.txt`
    opts = {
      options = {
        icons_enabled = false,
        theme = 'onedark',
        component_separators = '|',
        section_separators = '',
      },
    },
  },

  {
    -- Add indentation guides even on blank lines
    'lukas-reineke/indent-blankline.nvim',
    -- Enable `lukas-reineke/indent-blankline.nvim`
    -- See `:help indent_blankline.txt`
    opts = {
      char = '┊',
      show_trailing_blankline_indent = false,
    },
  },

  -- "gc" to comment visual regions/lines
  { 'numToStr/Comment.nvim', opts = {} },

  -- Fuzzy Finder (files, lsp, etc)
  { 'nvim-telescope/telescope.nvim', branch = '0.1.x', dependencies = { 'nvim-lua/plenary.nvim' } },

  -- Fuzzy Finder Algorithm which requires local dependencies to be built.
  -- Only load if `make` is available. Make sure you have the system
  -- requirements installed.
  {
    'nvim-telescope/telescope-fzf-native.nvim',
    -- NOTE: If you are having trouble with this installation,
    --       refer to the README for telescope-fzf-native for more instructions.
    build = 'make',
    cond = function()
      return vim.fn.executable 'make' == 1
    end,
  },

  {
    -- Highlight, edit, and navigate code
    'nvim-treesitter/nvim-treesitter',
    dependencies = {
      'nvim-treesitter/nvim-treesitter-textobjects',
    },
    build = ':TSUpdate',
  },

  -- NOTE: Next Step on Your Neovim Journey: Add/Configure additional "plugins" for kickstart
  --       These are some example plugins that I've included in the kickstart repository.
  --       Uncomment any of the lines below to enable them.
  -- require 'kickstart.plugins.autoformat',
  -- require 'kickstart.plugins.debug',

  -- NOTE: The import below automatically adds your own plugins, configuration, etc from `lua/custom/plugins/*.lua`
  --    You can use this folder to prevent any conflicts with this init.lua if you're interested in keeping
  --    up-to-date with whatever is in the kickstart repo.
  --
  --    For additional information see: https://github.com/folke/lazy.nvim#-structuring-your-plugins
  -- { import = 'custom.plugins' },
}, {})

-- [[ Setting options ]]
-- See `:help vim.o`
-- NOTE: You can change these options as you wish!

-- Set highlight on search
vim.o.hlsearch = false

-- Make line numbers default
vim.wo.number = true

-- Enable mouse mode
vim.o.mouse = 'a'

-- Sync clipboard between OS and Neovim.
--  Remove this option if you want your OS clipboard to remain independent.
--  See `:help 'clipboard'`
vim.o.clipboard = 'unnamedplus'

-- Enable break indent
vim.o.breakindent = true

-- Save undo history
vim.o.undofile = true

-- Case insensitive searching UNLESS /C or capital in search
vim.o.ignorecase = true
vim.o.smartcase = true

-- Keep signcolumn on by default
vim.wo.signcolumn = 'yes'

-- Decrease update time
vim.o.updatetime = 250
vim.o.timeout = true
vim.o.timeoutlen = 300

-- Set completeopt to have a better completion experience
vim.o.completeopt = 'menuone,noselect'

-- NOTE: You should make sure your terminal supports this
vim.o.termguicolors = true

-- [[ Basic Keymaps ]]

-- Keymaps for better default experience
-- See `:help vim.keymap.set()`
vim.keymap.set({ 'n', 'v' }, '<Space>', '<Nop>', { silent = true })

-- Remap for dealing with word wrap
vim.keymap.set('n', 'k', "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })
vim.keymap.set('n', 'j', "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })

-- [[ Highlight on yank ]]
-- See `:help vim.highlight.on_yank()`
local highlight_group = vim.api.nvim_create_augroup('YankHighlight', { clear = true })
vim.api.nvim_create_autocmd('TextYankPost', {
  callback = function()
    vim.highlight.on_yank()
  end,
  group = highlight_group,
  pattern = '*',
})

-- [[ Configure Telescope ]]
-- See `:help telescope` and `:help telescope.setup()`
require('telescope').setup {
  defaults = {
    mappings = {
      i = {
        ['<C-u>'] = false,
        ['<C-d>'] = false,
      },
    },
  },
}

-- Enable telescope fzf native, if installed
pcall(require('telescope').load_extension, 'fzf')

-- See `:help telescope.builtin`
vim.keymap.set('n', '<leader>?', require('telescope.builtin').oldfiles, { desc = '[?] Find recently opened files' })
vim.keymap.set('n', '<leader><space>', require('telescope.builtin').buffers, { desc = '[ ] Find existing buffers' })
vim.keymap.set('n', '<leader>/', function()
  -- You can pass additional configuration to telescope to change theme, layout, etc.
  require('telescope.builtin').current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
    winblend = 10,
    previewer = false,
  })
end, { desc = '[/] Fuzzily search in current buffer' })

vim.keymap.set('n', '<leader>gf', require('telescope.builtin').git_files, { desc = 'Search [G]it [F]iles' })
vim.keymap.set('n', '<leader>sf', require('telescope.builtin').find_files, { desc = '[S]earch [F]iles' })
vim.keymap.set('n', '<leader>sh', require('telescope.builtin').help_tags, { desc = '[S]earch [H]elp' })
vim.keymap.set('n', '<leader>sw', require('telescope.builtin').grep_string, { desc = '[S]earch current [W]ord' })
vim.keymap.set('n', '<leader>sg', require('telescope.builtin').live_grep, { desc = '[S]earch by [G]rep' })
vim.keymap.set('n', '<leader>sd', require('telescope.builtin').diagnostics, { desc = '[S]earch [D]iagnostics' })

-- [[ Configure Treesitter ]]
-- See `:help nvim-treesitter`
require('nvim-treesitter.configs').setup {
  -- Add languages to be installed here that you want installed for treesitter
  ensure_installed = { 'c', 'cpp', 'go', 'lua', 'python', 'rust', 'tsx', 'typescript', 'vimdoc', 'vim' },

  -- Autoinstall languages that are not installed. Defaults to false (but you can change for yourself!)
  auto_install = false,

  highlight = { enable = true },
  indent = { enable = true, disable = { 'python' } },
  incremental_selection = {
    enable = true,
    keymaps = {
      init_selection = '<c-space>',
      node_incremental = '<c-space>',
      scope_incremental = '<c-s>',
      node_decremental = '<M-space>',
    },
  },
  textobjects = {
    select = {
      enable = true,
      lookahead = true, -- Automatically jump forward to textobj, similar to targets.vim
      keymaps = {
        -- You can use the capture groups defined in textobjects.scm
        ['aa'] = '@parameter.outer',
        ['ia'] = '@parameter.inner',
        ['af'] = '@function.outer',
        ['if'] = '@function.inner',
        ['ac'] = '@class.outer',
        ['ic'] = '@class.inner',
      },
    },
    move = {
      enable = true,
      set_jumps = true, -- whether to set jumps in the jumplist
      goto_next_start = {
        [']m'] = '@function.outer',
        [']]'] = '@class.outer',
      },
      goto_next_end = {
        [']M'] = '@function.outer',
        [']['] = '@class.outer',
      },
      goto_previous_start = {
        ['[m'] = '@function.outer',
        ['[['] = '@class.outer',
      },
      goto_previous_end = {
        ['[M'] = '@function.outer',
        ['[]'] = '@class.outer',
      },
    },
    swap = {
      enable = true,
      swap_next = {
        ['<leader>a'] = '@parameter.inner',
      },
      swap_previous = {
        ['<leader>A'] = '@parameter.inner',
      },
    },
  },
}

-- Diagnostic keymaps
vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, { desc = 'Go to previous diagnostic message' })
vim.keymap.set('n', ']d', vim.diagnostic.goto_next, { desc = 'Go to next diagnostic message' })
vim.keymap.set('n', '<leader>e', vim.diagnostic.open_float, { desc = 'Open floating diagnostic message' })
vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostics list' })

-- [[ Configure LSP ]]
--  This function gets run when an LSP connects to a particular buffer.
local on_attach = function(client, bufnr)
  -- NOTE: Remember that lua is a real programming language, and as such it is possible
  -- to define small helper and utility functions so you don't have to repeat yourself
  -- many times.
  --
  -- In this case, we create a function that lets us more easily define mappings specific
  -- for LSP related items. It sets the mode, buffer and description for us each time.
  require("lsp-inlayhints").on_attach(client, bufnr, false)
  local nmap = function(keys, func, desc)
    if desc then
      desc = 'LSP: ' .. desc
    end

    vim.keymap.set('n', keys, func, { buffer = bufnr, desc = desc })
  end

  nmap('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
  nmap('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')

  nmap('gd', vim.lsp.buf.definition, '[G]oto [D]efinition')
  nmap('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
  nmap('gI', vim.lsp.buf.implementation, '[G]oto [I]mplementation')
  nmap('<leader>D', vim.lsp.buf.type_definition, 'Type [D]efinition')
  nmap('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')
  nmap('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')

  -- See `:help K` for why this keymap
  nmap('K', vim.lsp.buf.hover, 'Hover Documentation')
  nmap('<C-k>', vim.lsp.buf.signature_help, 'Signature Documentation')

  -- Lesser used LSP functionality
  nmap('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
  nmap('<leader>wa', vim.lsp.buf.add_workspace_folder, '[W]orkspace [A]dd Folder')
  nmap('<leader>wr', vim.lsp.buf.remove_workspace_folder, '[W]orkspace [R]emove Folder')
  nmap('<leader>wl', function()
    print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
  end, '[W]orkspace [L]ist Folders')

  -- Create a command `:Format` local to the LSP buffer
  vim.api.nvim_buf_create_user_command(bufnr, 'Format', function(_)
    vim.lsp.buf.format()
  end, { desc = 'Format current buffer with LSP' })
end

-- Enable the following language servers
--  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
--
--  Add any additional override configuration in the following tables. They will be passed to
--  the `settings` field of the server config. You must look up that documentation yourself.
local servers = {
  pylyzer = {},
}

-- Setup neovim lua configuration
require('neodev').setup()

-- nvim-cmp supports additional completion capabilities, so broadcast that to servers
local capabilities = vim.lsp.protocol.make_client_capabilities()
capabilities = require('cmp_nvim_lsp').default_capabilities(capabilities)

-- Ensure the servers above are installed
local mason_lspconfig = require 'mason-lspconfig'

mason_lspconfig.setup {
  ensure_installed = vim.tbl_keys(servers),
}

mason_lspconfig.setup_handlers {
  function(server_name)
    require('lspconfig')[server_name].setup {
      capabilities = capabilities,
      on_attach = on_attach,
      settings = servers[server_name],
    }
  end,
}

-- [[ Configure nvim-cmp ]]
-- See `:help cmp`
local cmp = require 'cmp'
local luasnip = require 'luasnip'
require('luasnip.loaders.from_vscode').lazy_load()
luasnip.config.setup {}

cmp.setup {
  snippet = {
    expand = function(args)
      luasnip.lsp_expand(args.body)
    end,
  },
  mapping = cmp.mapping.preset.insert {
    ['<C-n>'] = cmp.mapping.select_next_item(),
    ['<C-p>'] = cmp.mapping.select_prev_item(),
    ['<C-d>'] = cmp.mapping.scroll_docs(-4),
    ['<C-f>'] = cmp.mapping.scroll_docs(4),
    ['<C-Space>'] = cmp.mapping.complete {},
    ['<CR>'] = cmp.mapping.confirm {
      behavior = cmp.ConfirmBehavior.Replace,
      select = true,
    },
    ['<Tab>'] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_next_item()
      elseif luasnip.expand_or_locally_jumpable() then
        luasnip.expand_or_jump()
      else
        fallback()
      end
    end, { 'i', 's' }),
    ['<S-Tab>'] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_prev_item()
      elseif luasnip.locally_jumpable(-1) then
        luasnip.jump(-1)
      else
        fallback()
      end
    end, { 'i', 's' }),
  },
  sources = {
    { name = 'nvim_lsp' },
    { name = 'luasnip' },
  },
}

-- The line beneath this is called `modeline`. See `:help modeline`
-- vim: ts=2 sts=2 sw=2 et

   Compiling els v0.1.24-nightly.4
error: `char::methods::<impl char>::from_u32` is not yet stable as a const fn
   --> /home/nb/.cargo/registry/src/github.com-1ecc6299db9ec823/els-0.1.24-nightly.4/completion.rs:96:38
    |
96  |       pub const STD_ITEM: char = match char::from_u32(
    |  ______________________________________^
97  | |         CompletionOrder::Normal as u32
98  | |             + CompletionOrder::Builtin as u32
99  | |             + CompletionOrder::OtherNamespace as u32,
100 | |     ) {
    | |_____^

error: could not compile `els` due to previous error
warning: build failed, waiting for other jobs to finish...

module abc not found
similar name python module exits: abc
hint: to import python modules, use pyimport (not import)

Error[#0179]: File tmp.py, line 1, <module>.Mapping

1 | from typing import Mapping
  :                    -----

NotConstExpr: not a constant expression

Error[#0624]: File tmp3.py, line 1, <module>.Mapping

1 | from typing import Mapping
  :                    -------

AttributeError: PyModule("typing") object has no attribute Mapping

pylyzer tmp.py

[ERROR][2023-07-02 01:17:35] .../vim/lsp/rpc.lua:734	"rpc"	"pylyzer"	"stderr"	"thread 'pylyzer' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: \"No such file or directory\" }', /home/adam/.cargo/registry/src/index.crates.io-6f17d22bba15001f/erg_compiler-0.6.16-nightly.3/module/global.rs:44:70\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\nThread panicked: Any { .. }\n"

      Updating `tuna` index
    Installing pylyzer v0.0.27
     Compiling autocfg v1.1.0
     Compiling libc v0.2.144
     Compiling proc-macro2 v1.0.58
     Compiling unicode-ident v1.0.8
     Compiling quote v1.0.27
     Compiling rand_core v0.4.2
     Compiling serde v1.0.163
     Compiling siphasher v0.2.3
     Compiling typenum v1.16.0
     Compiling memchr v2.5.0
     Compiling log v0.4.17
     Compiling erg_common v0.6.13-nightly.4
     Compiling string_cache_shared v0.3.0
     Compiling byteorder v1.4.3
     Compiling byte-tools v0.3.1
     Compiling block-padding v0.1.5
     Compiling lazy_static v1.4.0
     Compiling regex-syntax v0.7.1
     Compiling cfg-if v1.0.0
     Compiling precomputed-hash v0.1.1
     Compiling autocfg v0.1.8
     Compiling rand_core v0.3.1
     Compiling rand_jitter v0.1.4
     Compiling rand_xorshift v0.1.1
     Compiling rand_isaac v0.1.1
     Compiling rand_hc v0.1.0
     Compiling phf_shared v0.7.24
     Compiling tinyvec_macros v0.1.1
     Compiling strsim v0.10.0
     Compiling ordermap v0.3.5
     Compiling bit-vec v0.6.3
     Compiling opaque-debug v0.2.3
     Compiling fixedbitset v0.1.9
     Compiling rand_pcg v0.1.2
     Compiling rand_chacha v0.1.1
     Compiling rand v0.6.5
     Compiling num-traits v0.2.15
     Compiling new_debug_unreachable v1.0.4
     Compiling either v1.8.1
     Compiling fake-simd v0.1.2
     Compiling bit-set v0.5.3
     Compiling itertools v0.8.2
     Compiling ena v0.13.1
     Compiling num-integer v0.1.45
     Compiling petgraph v0.4.13
     Compiling tinyvec v1.6.0
     Compiling regex-syntax v0.6.29
     Compiling lalrpop-util v0.17.2
     Compiling unicode-xid v0.1.0
     Compiling unic-common v0.9.0
     Compiling aho-corasick v1.0.1
     Compiling diff v0.1.13
     Compiling unic-char-range v0.9.0
     Compiling unic-char-property v0.9.0
     Compiling unic-ucd-version v0.9.0
     Compiling num-bigint v0.2.6
     Compiling syn v2.0.16
     Compiling unicode-bidi v0.3.13
     Compiling serde_json v1.0.96
     Compiling rand_os v0.1.3
     Compiling dirs v1.0.5
     Compiling atty v0.2.14
     Compiling term v0.5.2
  error[E0658]: `let...else` statements are unstable
     --> /home/yaowj/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/erg_common-0.6.13-nightly.4/error.rs:368:9
      |
  368 | /         let Some(last_known) = ls.iter().rev().find(|l| !l.loc().is_unknown()) else {
  369 | |             return Self::Unknown;
  370 | |         };
      | |__________^
      |
      = note: see issue #87335 <https://github.com/rust-lang/rust/issues/87335> for more information
  
  error[E0658]: `let...else` statements are unstable
     --> /home/yaowj/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/erg_common-0.6.13-nightly.4/error.rs:365:9
      |
  365 | /         let Some(first_known) = ls.iter().find(|l| !l.loc().is_unknown()) else {
  366 | |             return Self::Unknown;
  367 | |         };
      | |__________^
      |
      = note: see issue #87335 <https://github.com/rust-lang/rust/issues/87335> for more information
  
  error[E0658]: `let...else` statements are unstable
    --> /home/yaowj/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/erg_common-0.6.13-nightly.4/tsort.rs:75:5
     |
  75 | /     let Some(vertex) = g.iter().find(|n| n.id == v) else {
  76 | |         return Err(TopoSortError::KeyNotFound);
  77 | |     };
     | |______^
     |
     = note: see issue #87335 <https://github.com/rust-lang/rust/issues/87335> for more information
  
     Compiling generic-array v0.12.4
     Compiling unicode-xid v0.2.4
     Compiling percent-encoding v2.2.0
     Compiling form_urlencoded v1.1.0
     Compiling unicode-normalization v0.1.22
     Compiling ascii-canvas v2.0.0
     Compiling block-buffer v0.7.3
     Compiling digest v0.8.1
     Compiling sha2 v0.8.2
     Compiling itoa v1.0.6
  For more information about this error, try `rustc --explain E0658`.
  error: could not compile `erg_common` due to 3 previous errors
  warning: build failed, waiting for other jobs to finish...
  error: could not compile `erg_common` due to 3 previous errors
  error: failed to compile `pylyzer v0.0.27`, intermediate artifacts can be found at `/tmp/cargo-installcddxr3`

> pylyzer --help
invalid option: --help

USAGE:
pylyzer [OPTIONS] [SUBCOMMAND] [ARGS]...

For more information try `pylyzer --help`

Start checking: main.py
...
Start checking: common.py
Start checking: getpass.py
Start checking: contextlib.py
thread 'main' panicked at 'internal error: entered unreachable code', /Users/pasteley/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_compiler-0.6.14-nightly.0/declare.rs:299:43
stack backtrace:
   0:        0x100ff1bd8 - <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt::h554558af9dcaf5d8
   1:        0x101008c6c - core::fmt::write::h503a82454aa26fb4
   2:        0x100fd771c - std::io::Write::write_fmt::he97d6853eddb17d2
   3:        0x100ff19e8 - std::sys_common::backtrace::print::h669032be8d7b2a7c
   4:        0x100fdef74 - std::panicking::default_hook::{{closure}}::h974276930a474e6a
   5:        0x100fdec38 - std::panicking::default_hook::hb0d2c45a1e792803
   6:        0x100fdf660 - std::panicking::rust_panic_with_hook::hf3b9a3e44fe5f275
   7:        0x100ff2564 - std::panicking::begin_panic_handler::{{closure}}::ha19c90e1160a0cf9
   8:        0x100ff1d18 - std::sys_common::backtrace::__rust_end_short_backtrace::h3f85ad00ac73ff55
   9:        0x100fdf2c0 - _rust_begin_unwind
  10:        0x1010282f0 - core::panicking::panic_fmt::hb0625f6d6e3c09e4
  11:        0x101028360 - core::panicking::panic::h53789822e3a49a18
  12:        0x100e8785c - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_record::ha20de20df591ac8e
  13:        0x100e8aff4 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_expr::he816d1c4bd79d283
  14:        0x100e84454 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_call::hf734f43d62012ba1
  15:        0x100e8b1a4 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_expr::he816d1c4bd79d283
  16:        0x100e89518 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_params::h28f7bb1ce0b93ae2
  17:        0x100e89c6c - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_lambda::hed460f2cc6e6a353
  18:        0x100e8a8f8 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::fake_lower_expr::he816d1c4bd79d283
  19:        0x100e8f868 - erg_compiler::declare::<impl erg_compiler::lower::ASTLowerer>::declare_chunk::h42d8bcee330b1beb
  20:        0x100eb043c - erg_compiler::lower::ASTLowerer::lower::h3e04e12f3a1abaeb
  21:        0x100cdffb0 - erg_compiler::build_hir::HIRBuilder::check::h922dbb9789094412
  22:        0x100ce0650 - erg_compiler::build_hir::HIRBuilder::build::hcbd850acbd86e40d
  23:        0x100aa964c - erg_compiler::context::register::<impl erg_compiler::context::Context>::import_mod::h2687e447b2540cfe
  24:        0x100a9ac88 - erg_compiler::context::register::<impl erg_compiler::context::Context>::pre_import::h4ae4d60ff811f652
  25:        0x100a9a8d0 - erg_compiler::context::register::<impl erg_compiler::context::Context>::preregister::h8ff905bceed9eff6
  26:        0x100a9aa50 - erg_compiler::context::register::<impl erg_compiler::context::Context>::preregister::h8ff905bceed9eff6
  27:        0x100eaf9dc - erg_compiler::lower::ASTLowerer::lower::h3e04e12f3a1abaeb
  28:        0x100643fc4 - pylyzer::analyze::PythonAnalyzer::analyze::h5c77832e944fb36a
  29:        0x100644590 - pylyzer::analyze::PythonAnalyzer::run::h85da60a830225d40
  30:        0x1005ab174 - pylyzer::run::h2f5214ce5dcb8f89
  31:        0x100635934 - std::sys_common::backtrace::__rust_begin_short_backtrace::hc9c79afbcee17da6
  32:        0x100653fbc - std::rt::lang_start::{{closure}}::h9d9343ced2be4d6a
  33:        0x100fdd9cc - std::rt::lang_start_internal::h2a63b0d73f6d9885
  34:        0x1005ab258 - _main

cannot open '/path/to/project/source/utils/dependency1.py': [Errno 2] No such file or directory (os error 2)
cannot open '/path/to/project/source/utils/dependency2.py': [Errno 2] No such file or directory (os error 2)
cannot open '/path/to/project/source/dependency3.py': [Errno 2] No such file or directory (os error 2)
cannot open '/path/to/project/source/dependency4.py': [Errno 2] No such file or directory (os error 2)
cannot open '/path/to/project/source/dependency5.py': [Errno 2] No such file or directory (os error 2)

thread 'main' has overflowed its stack
fatal runtime error: stack overflow
Aborted (core dumped)

❯ cargo install pylyzer
    Updating crates.io index
  Installing pylyzer v0.0.43
    Updating crates.io index
   Compiling libc v0.2.147
   Compiling proc-macro2 v1.0.66
   Compiling unicode-ident v1.0.11
   Compiling autocfg v1.1.0
   Compiling cfg-if v1.0.0
   Compiling typenum v1.16.0
   Compiling version_check v0.9.4
   Compiling syn v1.0.109
   Compiling parking_lot_core v0.9.8
   Compiling getrandom v0.1.16
   Compiling ryu v1.0.15
   Compiling block-padding v0.2.1
   Compiling erg_common v0.6.20
   Compiling generic-array v0.14.7
   Compiling lock_api v0.4.10
   Compiling either v1.9.0
   Compiling ppv-lite86 v0.2.17
   Compiling once_cell v1.18.0
   Compiling opaque-debug v0.3.0
   Compiling keccak v0.1.4
   Compiling itertools v0.9.0
   Compiling quote v1.0.33
   Compiling rand_core v0.5.1
   Compiling syn v2.0.31
   Compiling smallvec v1.11.0
   Compiling base64 v0.13.1
   Compiling rand_chacha v0.2.2
   Compiling scopeguard v1.2.0
   Compiling rand v0.7.3
   Compiling num-traits v0.2.16
   Compiling tinyvec_macros v0.1.1
   Compiling block-buffer v0.9.0
   Compiling digest v0.9.0
   Compiling siphasher v0.3.11
   Compiling rand_core v0.6.4
   Compiling sha3 v0.9.1
   Compiling crunchy v0.2.2
   Compiling serde v1.0.188
   Compiling thread_local v1.1.7
   Compiling rand v0.8.5
   Compiling phf_shared v0.11.2
   Compiling malachite-base v0.3.2
   Compiling tinyvec v1.6.0
   Compiling parking_lot v0.12.1
   Compiling num-integer v0.1.45
   Compiling anyhow v1.0.75
   Compiling paste v1.0.14
   Compiling tiny-keccak v2.0.2
   Compiling phf_generator v0.11.2
   Compiling unicode-normalization v0.1.22
   Compiling unicode-bidi v0.3.13
   Compiling serde_derive v1.0.188
   Compiling unic-char-range v0.9.0
   Compiling convert_case v0.4.0
   Compiling unic-common v0.9.0
   Compiling percent-encoding v2.3.0
   Compiling pmutil v0.5.3
   Compiling serde_json v1.0.105
   Compiling memchr v2.6.3
   Compiling Inflector v0.11.4
   Compiling form_urlencoded v1.2.0
   Compiling erg_compiler v0.6.20
   Compiling unic-ucd-version v0.9.0
   Compiling unic-char-property v0.9.0
   Compiling rustpython-parser-vendored v0.3.0
   Compiling idna v0.4.0
   Compiling phf_codegen v0.11.2
   Compiling unicode-xid v0.2.4
   Compiling itoa v1.0.9
   Compiling rustpython-parser v0.3.0
   Compiling erg_parser v0.6.20
   Compiling serde_repr v0.1.16
   Compiling static_assertions v1.1.0
   Compiling bitflags v1.3.2
   Compiling phf v0.11.2
   Compiling unic-emoji-char v0.9.0
   Compiling unic-ucd-ident v0.9.0
   Compiling itertools v0.10.5
   Compiling embed-doc-image v0.1.4
   Compiling is-macro v0.2.2
   Compiling derive_more v0.99.17
   Compiling lalrpop-util v0.20.0
   Compiling log v0.4.20
   Compiling rustc-hash v1.1.0
   Compiling unicode_names2 v0.6.0
   Compiling rustpython-parser-core v0.3.0
   Compiling url v2.4.1
   Compiling malachite-nz v0.3.2
   Compiling lsp-types v0.93.2
   Compiling malachite-q v0.3.2
   Compiling malachite v0.3.2
   Compiling malachite-bigint v0.1.0
   Compiling rustpython-ast v0.3.0
   Compiling molc v0.1.0
   Compiling els v0.1.32
   Compiling py2erg v0.0.43
   Compiling pylyzer v0.0.43
error[E0061]: this function takes 2 arguments but 1 argument was supplied
   --> /home/wil/.cargo/registry/src/index.crates.io-6f17d22bba15001f/pylyzer-0.0.43/src/main.rs:13:31
    |
13  |         let mut lang_server = Server::<PythonAnalyzer, SimplePythonParser>::new(cfg);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----- an argument of type `Option<Sender<serde_json::value::Value>>` is missing
    |
note: associated function defined here
   --> /home/wil/.cargo/registry/src/index.crates.io-6f17d22bba15001f/els-0.1.32/server.rs:330:12
    |
330 |     pub fn new(cfg: ErgConfig, stdout_redirect: Option<mpsc::Sender<Value>>) -> Self {
    |            ^^^
help: provide the argument
    |
13  |         let mut lang_server = Server::<PythonAnalyzer, SimplePythonParser>::new(cfg, /* Option<Sender<serde_json::value::Value>> */);
    |                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

❯ cargo --version      
cargo 1.72.0 (103a7ff2e 2023-08-15)

❯ rustup --version
rustup 1.26.0 (2023-05-04)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.72.0 (5680fa18f 2023-08-23)`

2023-03-10T17:37:49.871 helix_lsp [ERROR] failed to initialize language server: server closed the stream
2023-03-10T17:37:49.871 helix_lsp::transport [ERROR] err: <- StreamClosed

❯ tree
.
├── example
│   ├── __init__.py
│   ├── a
│   │   ├── __init__.py
│   │   └── a.py
│   └── b
│       ├── __init__.py
│       └── b.py
└── pyproject.toml

[ERROR][2023-05-02 09:46:30] .../vim/lsp/rpc.lua:734	"rpc"	"pylyzer"	"stderr"	"thread 'main' panicked at 'not yet implemented', /Users/nmadnani/.cargo/registry/src/github.com-1ecc6299db9ec823/erg_compiler-0.6.12-nightly.4/context/eval.rs:1444:53\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n"

─  rustc --version                                                                                                                     1 (0.186s)
rustc 1.69.0 (84c898d65 2023-04-16)

─  rustup --version                                                                                                                    
rustup 1.26.0 (5af9b9484 2023-04-05)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.69.0 (84c898d65 2023-04-16)

─  cargo search pylyzer                                                                                                                0 (0.154s)
pylyzer = "0.0.20"    # A static code analyzer & language server for Python

RUST_BACKTRACE=1 pylyzer grammar_py310.py

thread 'pylyzer' panicked at 'called `Option::unwrap()` on a `None` value', /Users/wookayin/.cargo/registry/src/index.crates.io-6f17d22bba15001f/py2erg-0.0.47/convert.rs:1057:40
stack backtrace:
   0: _rust_begin_unwind
   1: core::panicking::panic_fmt
   2: core::panicking::panic
   3: py2erg::convert::ASTConverter::convert_expr::{{closure}}
   4: <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold
   5: alloc::vec::in_place_collect::<impl alloc::vec::spec_from_iter::SpecFromIter<T,I> for alloc::vec::Vec<T>>::from_iter
   6: py2erg::convert::ASTConverter::convert_expr
   7: py2erg::convert::ASTConverter::convert_statement
   8: py2erg::convert::ASTConverter::convert_block
   9: py2erg::convert::ASTConverter::convert_statement
  10: py2erg::convert::ASTConverter::convert_statement
  11: <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold
  12: alloc::vec::in_place_collect::<impl alloc::vec::spec_from_iter::SpecFromIter<T,I> for alloc::vec::Vec<T>>::from_iter
  13: py2erg::convert::ASTConverter::convert_program
  14: pylyzer::analyze::PythonAnalyzer::analyze
  15: pylyzer::analyze::PythonAnalyzer::run
  16: pylyzer::run
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
Thread panicked: Any { .. }

[Error - 10:19:15 PM] pylyzer client: couldn't create connection to server.
Launching server using command pylyzer failed. Error: spawn pylyzer ENOENT

pyenv local my-fresh-new-env
pyenv shell my-fresh-new-env
pyenv global my-fresh-new-env

cat pyproject.toml
[tool.pyright]
venvPath = "/Users/aa/.pyenv/versions"
venv = "my-fresh-new-env"

Linux <hostname> 5.8.0-63-generic #71~20.04.1-Ubuntu SMP Thu Jul 15 17:46:08 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux

def print_repr(x):
    print(repr(x))

print_repr(int("0x16", base=16))
print_repr(float('1e-003'))
print_repr(str(100))
print_repr(complex(1, 2))
print_repr(list(range(10)))
print_repr(tuple([1, 2, 3]))
print_repr(set([1, 2, 2]))
print_repr(dict([("a", 1), ("b", 2)]))

$ python3 --version
Python 3.10.6

$ python3 testcase.py 
22
0.001
'100'
(1+2j)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
(1, 2, 3)
{1, 2}
{'a': 1, 'b': 2}

$ pylyzer --version
pylyzer 0.0.13

$ pylyzer testcase.py 
Start checking: testcase.py
Found 9 errors: testcase.py
Error[#1075]: File testcase.py, line 4, <module>

4 | print_repr(int("0x16", base=16))
  :            ---
  :              |- expected: Callable
  :              |- but found: ClassType
  :              `- If you want to generate an instance, use .Int.new

TypeError: the type of .Int(qual_name: Int)(: {Int, }) is mismatched

Error[#1075]: File testcase.py, line 5, <module>

5 | print_repr(float('1e-003'))
  :            -----
  :                |- expected: Callable
  :                |- but found: ClassType
  :                `- If you want to generate an instance, use .Float.new

TypeError: the type of .Float(qual_name: Float)(: {Float, }) is mismatched

Error[#1075]: File testcase.py, line 6, <module>

6 | print_repr(str(100))
  :            ---
  :              |- expected: Callable
  :              |- but found: ClassType
  :              `- If you want to generate an instance, use .Str.new

TypeError: the type of .Str(qual_name: Str)(: {Str, }) is mismatched

Error[#0710]: File testcase.py, line 7, <module>

7 | print_repr(complex(1, 2))
  :            -------
  :                  `- exists a similar name public variable: compile

NameError: complex is not defined

Error[#0710]: File testcase.py, line 8, <module>

8 | print_repr(list(range(10)))
  :            ------------

NameError: GenericArray is not defined

Error[#0710]: File testcase.py, line 9, <module>

9 | print_repr(tuple([1, 2, 3]))
  :            ------------
  :                       `- exists a similar name private variable: GenericTuple

NameError: GenericTuple is not defined

Error[#0710]: File testcase.py, line 10, <module>

10 | print_repr(set([1, 2, 2]))
   :            ----------

NameError: GenericSet is not defined

Error[#0230]: File testcase.py, line 11, <module>

11 | print_repr(dict([("a", 1), ("b", 2)]))
   :                             ------
   :                                  `- please specify the type explicitly, e.g. [..., ("b", 2): Tuple([{"a", }, {1, }]) or Tuple([{"b", }, {2, }])]

SyntaxError: all elements of an array must be of the same type

Error[#1075]: File testcase.py, line 11, <module>

11 | print_repr(dict([("a", 1), ("b", 2)]))
   :            -----------
   :                      |- expected: Callable
   :                      |- but found: ClassType
   :                      `- If you want to generate an instance, use .GenericDict.new

TypeError: the type of .GenericDict(qual_name: GenericDict)(: {GenericDict, }) is mismatched

$ pyright testcase.py 
No configuration file found.
No pyproject.toml file found.
stubPath /home/user/work/typechecker/typings is not a valid directory.
Assuming Python platform Linux
Searching for source files
Found 1 source file
pyright 1.1.299
0 errors, 0 warnings, 0 informations 
Completed in 0.775sec

$ pytype testcase.py 
Computing dependencies
Analyzing 1 sources with 0 local dependencies
ninja: Entering directory `.pytype'
ninja: no work to do.
Leaving directory '.pytype'
Success: no errors found

$ pyre
ƛ No watchman binary found. 
To enable pyre incremental, you can install watchman: https://facebook.github.io/watchman/docs/install
ƛ Defaulting to non-incremental check.
ƛ No type errors found

[ERROR][2023-04-23 15:23:48] .../vim/lsp/rpc.lua:734	"rpc"	"pylyzer"	"stderr"	"thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: \"No such file or directory\" }', /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/els-0.1.23-nightly.2/file_cache.rs:170:10\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n"

[ERROR][2023-05-04 10:56:19] .../vim/lsp/rpc.lua:734	"rpc"	"pylyzer"	"stderr"	"thread 'main' panicked at 'called 
`Result::unwrap()` on an `Err` value: RelativeUrlWithoutBase', 
/home/kobzar/.cargo/registry/src/github.com-1ecc6299db9ec823/els-0.1.24-nightly.6/hover.rs:183:77\n
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n"