A fast, customizable, and easy to use JavaScript and TypeScript linter

Overview

RSLint

A fast, customizable, and easy to use JavaScript and TypeScript linter

build status Documentation Status

Guide | Contributing | Website | Linter Rules

⚠️ RSLint is in early development and should not be used in production, expect bugs! 🐛

Installation

Through Cargo

$ cargo install rslint_cli
$ rslint --help

Prebuilt Binaries

We publish prebuilt binaries for Windows, Linux, and MacOS for every release which you can find here.

Build From Source

$ git clone https://github.com/rslint/rslint.git
$ cd rslint
$ cargo run --release -- --help

Usage

To use the linter simply pass files to lint to the CLI:

foo.js $ rslint ./foo.js error[no-prototype-builtins]: do not access the object property `hasOwnProperty` directly from `foo` ┌─ ./foo.js:1:9 │ 1 │ let a = foo.hasOwnProperty('bar'); │ ^^^^^^^^^^^^^^^^^^^^^^^^^ │ help: get the function from the prototype of `Object` and call it │ 1 │ let a = Object.prototype.hasOwnProperty.call(foo, 'bar'); │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ │ ╧ note: the method may be shadowed and cause random bugs and denial of service vulnerabilities Outcome: 1 fail, 0 warn, 0 success help: for more information about the errors try the explain command: `rslint explain `">
$ echo "let a = foo.hasOwnProperty('bar');" > foo.js
$ rslint ./foo.js
error[no-prototype-builtins]: do not access the object property `hasOwnProperty` directly from `foo`
  ┌─ ./foo.js:1:9
  │
1 │ let a = foo.hasOwnProperty('bar');
  │         ^^^^^^^^^^^^^^^^^^^^^^^^^
  │
help: get the function from the prototype of `Object` and call it
  │
1 │ let a = Object.prototype.hasOwnProperty.call(foo, 'bar');
  │         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  │
  ╧ note: the method may be shadowed and cause random bugs and denial of service vulnerabilities

Outcome: 1 fail, 0 warn, 0 success

help: for more information about the errors try the explain command: `rslint explain <rules>`

The RSLint CLI works without a configuration file and will select recommended non-stylistic rules to run.

Features

Speed. RSLint uses parallelism to utilize multiple threads to speed up linting on top of being compiled to native code.

Low memory footprint. RSLint's syntax tree utilizes interning and other ways of drastically reducing memory usage while linting.

Sensible defaults. The CLI assumes recommended non-stylistic rules if no configuration file is specified and ignores directories such as node_modules.

Error recovery. RSLint's custom parser can recover from syntax errors and produce a usable syntax tree even when whole parts of a statement are missing. Allowing accurate on-the-fly linting as you type.

No confusing options. ECMAScript version for the parser does not have to be configured, the parser assumes latest syntax and assumes scripts for *.js and modules for *.mjs.

Native TypeScript support. *.ts files are automatically linted, no configuration for different parsers or rules is required.

Rule groups. Rules are grouped by scope for ease of configuration, understanding, and a cleaner file structure for the project.

Understandable errors. Each error emitted by the linter points out the area in the source code in an understandable and clean manner as well as contains labels, notes, and suggestions to explain how to fix each issue. There is also an alternative formatter similar to ESLint's formatter available using the -F flag or the formatter key in the config.

Strongly typed rule configuration. RSLint ships a JSON schema and links it for rslintrc.json to provide autocompletion for the config file in Visual Studio Code. The JSON Schema describes rule config options in full, allowing easy configuration. Moreover, RSLint's language server protocol implementation provides autocompletion for rslintrc.toml files too.

Powerful directives. Directives (commands through comments) use a parser based around the internal JavaScript lexer with instructions, allowing us to provide:

  • Autocompletion for directives such as // rslint-ignore no-empty in the language server protocol.
  • Hover support for directives to offer information on a command on hover.
  • Understandable errors for incorrect directives.

Standalone. RSLint is compiled to a single standalone binary, it does not require Node, v8, or any other runtime. RSLint can run on any platform which can be targeted by LLVM.

Powerful autofix. Automatic fixes for some errors are provided and can be applied through the --fix flag or actions in the IDE. Fixes can even be applied if the file contains syntax errors through the --dirty flag.

Built-in documentation. RSLint contains rule documentation in its binary, allowing it to show documentation in the terminal through the explain subcommand, e.g. rslint explain no-empty, for-direction.

Internal Features

Clean and clear project layout. The RSLint project is laid out in a monorepo and each crate has a distinct job, each crate can be used in other Rust projects and each crate has good documentation and a good API.

Easy rule declaration. Rules are declared using a declare_lint! macro. The macro accepts doc comments, a struct name, the group name, a rule code, and configuration options. The macro generates a struct definition and a Rule implementation and processes the doc comments into the documentation for the struct as well as into a static string used in the docs() method on each rule. Everything is concise and kept in one place.

Full fidelity syntax tree. Unlike ESTree, RSLint's custom syntax tree retains:

  • All whitespace
  • All comments
  • All tokens

Allowing it to have powerful analysis without having to rely on separate structures such as ESLint's SourceCode.

Untyped Syntax Tree. RSLint's syntax tree is made of untyped nodes and untyped tokens at the low level, this allows for powerful, efficient traversal through the tree, e.g. if_stmt.cons()?.child_with_ast:: () .

Easy APIs. RSLint uses easy to use builders for its complex errors, as well as builders for autofix. Everything is laid out to minimize the effort required to implement rules.

Performance

The benchmarks can be found in the benchmarks directory. You can run them on your machine using deno run -A --quiet benchmarks/bench.ts. They are also run on CI and you can see the latest results if you click on the latest GitHub Actions run.

Project RSLint eslint
engine262 (~42k LOC JavaScript) 414ms 46.9s
Oak (~11k LOC TypeScript) 53ms 399ms

(These benchmarks are run on AMD Ryzen 7 2700x, 8 Cores at 3.9MHz)

License

This project is Licensed under the MIT license.

Comments
  • Switch from `codespan-reporting` to a custom crate based on codespan

    Switch from `codespan-reporting` to a custom crate based on codespan

    This PR replaces codespan-reporting with annotate-snippets. To actually use annotate-snippets in a nice manner and to make the switch easier, a new module, rslint_errors, is introduced to provide an API similair to codespan-reporting but build on top of annotate-snippets.

    Resolves #29

    C-enhancement A-errors 
    opened by Stupremee 33
  • Does rslint already support TypeScript?

    Does rslint already support TypeScript?

    Hi,

    I was testing rslint to see the difference with my eyes, but when I run rslint ***.ts it is throwing error: No matching files found.

    This confused me because the description of this repo was saying:

    A (WIP) Extremely fast JavaScript and TypeScript linter and Rust crate

    After that error, I tried to lint some javascript files and it seems that there is no error.

    Is this a bug or I need to do some other steps to lint typescript files?

    Thanks!

    opened by zero734kr 16
  • Get Diagnostic Line Number

    Get Diagnostic Line Number

    So I was wondering if there way any way to get the line number of the error (which line the error occured in).

    Nodejs shows you the error like so: image

    So i was wondering if there was any field in Diagnostic that gives you the line number.

    opened by suptejas 15
  • (WIP) TypeScript support

    (WIP) TypeScript support

    This WIP pull request adds support for TypeScript. Most of this work is simply parser work, there is little runner and lexer work to support typescript. I will be adding TS in distinct steps:

    • [x] Type parsing
    • [x] Expr changes
    • [x] Stmt changes
    • [x] Decl changes
    • [x] Misc integration/parsing work
    • [x] Tests

    Every single runner rule should work since TypeScript support simply adds new properties to existing nodes.

    C-enhancement T-Parser A-typescript 
    opened by RDambrosio016 12
  • The linter panicked unexpectedly

    The linter panicked unexpectedly

    hi! i saw your post on r/rust. i write a lot of typescript, but tried running this on some plain JS.

    i ran it on this file and was told everything's good:

    $ rslint_cli index.js
    
    Outcome: 0 fail, 0 warn, 1 success
    

    i wanted to run it on this project, but i ran into an unexpected panic.

    $ rslint_cli 'src/*.js' 
    error[]: The linter panicked unexpectedly. this is a bug.
    
    We would appreciate a bug report: https://github.com/RDambrosio016/RSLint/issues/new?labels=ILE%2C+bug&template=internal-linter-error.md
    
    note[]: Please include the following info: 
    
    message: 
    location: /Users/brandly/.cargo/registry/src/github.com-1ecc6299db9ec823/rslint_parser-0.1.2/src/parser.rs:158:9
    

    i'm wrapping the glob in quotes because i'm on zsh, and it'll expand the glob otherwise e.g.:

    $ rslint_cli src/*.js  
    error: Found argument 'src/api.test.js' which wasn't expected, or isn't valid in this context
    
    USAGE:
        rslint_cli [FLAGS] [files] [SUBCOMMAND]
    
    For more information try --help
    

    if i'm running this incorrectly, the feedback could be improved. otherwise, something might be broken.

    thanks again. i'm looking forward to fast JS tooling.

    T-Parser T-Lexer ILE A-error-recovery 
    opened by brandly 11
  • Discussion: ways of implementing autofix and issues

    Discussion: ways of implementing autofix and issues

    This issue is meant for housing any discussions and implementations of autofix. I believe we should implement autofix relatively soon, this way we won't have a huge burden to add autofix to every rule once there are way more rules. As far as i see it, there are two ways of doing autofix:

    • Purely text based (eslint)
    • AST transformation based (rome)

    Purely text based has the issue of often not being very flexible (i personally disagree), and AST transformation based has the issue of not being flexible for minor text based fixes and needing AST serialization. Collectively autofix has fundamental issues which must be overcome:

    • All/Some rules need to be rerun after, i propose we add the ability to mark rules as fix-unsafe which will rerun only them, instead of needing all rules to rerun, which is expensive. This is absolutely required for stylistic rules, a fix cannot always conform to style and it should not either ways.

    • How do we choose what rule's fixes take precedence, if a rule wants to delete a node but another wants to change something in the node, which one do we trust?

    Im not an expert in autofix so i would love some other ideas. RSLint's syntax again shines in this because it allows us to:

    • Incrementally reparse only the changed bits of code extremely fast and efficiently (linting is 60%+ parsing in RSLint's case), i am working on incremental reparsing but its not a top priority, but it will be widely used for vsc, file watching, and autofix.
    • Make changes on individual tokens or nodes and delegate them to a rewriter which converts them to text edits

    I for one think text based is the way to go, it allows for a wider range of edits, it provides a familiar UI to people who have used ESLint, and rslint's immutable tree makes it a little bit more difficult to apply AST transformations, moreover, RSLint does not have a way to make new nodes without the parser and serialize them.

    As for implementation, i believe we should add a field to RuleCtx which is fixer: Option<Fixer>, rules can make a new fixer (similar to ESLint) and add it, then the linter can simply collect the fixers and apply them. I also thought about making a new provided method on RuleCtx but ended up scrapping it because rules will 100% want to know about context when fixing, so making it a separate method would mean that some of the linting logic would have to be repeated, this is very very ugly and i would rather not do that.

    I for one am not sure how to get over the issue of "which rule do we trust when it comes to a fix, do we trust the one who wants to change the node or the one who wants to delete it?". I also believe we should not try applying fixes if the parser returned errors, that can cause an absolute ton of confusing errors which i would rather not meddle in, error tolerance is great for linting but as soon as you try changing the AST produced (which is potentially semantically wrong) you end up with confusion.

    T-Runner C-discussion 
    opened by RDambrosio016 11
  • no-inner-declarations wrongfully fails on exports after the first statement

    no-inner-declarations wrongfully fails on exports after the first statement

    I tried this code:

    export const foo = [];
    export function bar() {}
    

    I expected this to happen: linting passes

    Instead this happened::

    error[no-inner-declarations]: move this function declaration to program's root
      ┌─ tests\main.mjs:2:8
      │
    2 │ export function bar() {}
      │        ^^^^^^^^^^^^^^^^^
      │
      = help: move the declaration to the program root
    

    Meta

    rslint -V: rslint 0.1.0

    If building from source: rustc --version --verbose:

    rustc 1.48.0-nightly (f68e08933 2020-09-19)
    binary: rustc
    commit-hash: f68e08933d8f519a9655934fedebbc509661b219
    commit-date: 2020-09-19
    host: x86_64-pc-windows-msvc
    release: 1.48.0-nightly
    LLVM version: 11.0
    

    **If Additional context Add any other context about the problem here.

    C-bug E-easy T-Runner 
    opened by RDambrosio016 10
  • Tracking issue for version 0.1

    Tracking issue for version 0.1

    Just a brief list of things id like to add before 0.1: Rules:

    • [x] no-extra-boolean-cast - (#15) - finished
    • [x] no-prototype-builtins - finished
    • [x] no-setter-return (#9) - finished
    • [x] no-sparse-arrays - finished
    • [x] no-unexpected-multiline finished
    • [x] use-isnan (#13) - finished
    • [x] valid-typeof (#8) - finished

    These are most of the eslint-reccomended rules for errors which dont rely on regex parsing, scope analysis, and code flow analysis, id like all those tools to be developed as individual analyzers instead of rushing them for rules.

    Fixes:

    • [x] rslint_parser::numbers::parse_js_num needs to account for legacy octal literals and needs tests - finished
    • [x] no-inner-declaration wrongfully fails (#12) - finished

    Misc:

    • [x] Add a changelog to keep track of features and fixed bugs (starting from 0.1) - finished

    @magurotuna if you'd like to do more in depth stuff with rules then working on any of these rules or fixes is a great start! 😄 although if you start work on a rule please put a comment saying which rule just so we don't accidentally work on the same things.

    C-enhancement T-Parser T-Runner 
    opened by RDambrosio016 9
  • Deadlock in rslint-lsp

    Deadlock in rslint-lsp

    I tried this code:

    $ cat >generate.sh <<'EOF'
    #!/bin/sh
    printf 'Content-Length: 404\r\n\r\n{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"rootPath":"/home/strager/Projects/quicklint-js/tools/benchmark-lsp/.","rootUri":"file:///home/strager/Projects/quicklint-js/tools/benchmark-lsp","initializationOptions":{"unstable":false,"enable":true,"lint":true},"workspaceFolders":[{"uri":"file:///home/strager/Projects/quicklint-js/tools/benchmark-lsp","name":"benchmarks"}],"capabilities":{}}}'
    printf 'Content-Length: 52\r\n\r\n{"jsonrpc":"2.0","method":"initialized","params":{}}'
    for i in $(seq 0 999) ; do
      printf 'Content-Length: 207\r\n\r\n{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///home/strager/Projects/quicklint-js/tools/benchmark-lsp/test%03d.js","languageId":"javascript","version":0,"text":""}}}' "${i}"
    done
    EOF 
    $ sh generate.sh | rslint-lsp
    

    I expected this to happen: rslint-lsp responds to initialize, then optionally prints a bunch of empty textDocument/publishDiagnostics messages, then exits.

    Instead this happened: rslint-lsp hangs.

    Meta

    $ rslint_cli -V 
    rslint 0.2.1
    $ git rev-parse HEAD
    b7a4eeb69dc00fedfee81eaed3cf2ad36bcb2e2e
    $ rustc --version --verbose
    rustc 1.50.0-nightly (1c389ffef 2020-11-24)
    binary: rustc
    commit-hash: 1c389ffeff814726dec325f0f2b0c99107df2673
    commit-date: 2020-11-24
    host: x86_64-unknown-linux-gnu
    release: 1.50.0-nightly
    

    Additional context I am writing benchmarks for LSP servers. RSLint often hangs when I run my benchmarks.

    C-bug T-LSP 
    opened by strager 8
  • Feature: add `rslint-ignore <rules> until <line>`

    Feature: add `rslint-ignore until `

    Currently rslint's ignore command is either scoped to the entire file or its scoped to the statement or declaration its on top of. This does not seem to be the norm apparently, i would like to keep scoping as it is and instead add a more explicit modifier to the ignore command as such:

    ignoring an entire statement:

    // rslint-ignore no-empty
    if (foo) {}
    else {} // no error
    

    ignoring a block of code until another line:

    // rslint-ignore no-empty until 5
    {}
    {}
    {}
    {}
    {} // error
    

    Perhaps we could also add rslint-ignore <rules> until eof? i really prefer an explicit command such as this over weird scoping you cannot make sense of, which is the case with eslint (in my opinion)

    Mentoring instructions

    To add this you will need to modify the directive parser which is found here, ignore commands are parsed here. What i would personally do is add two more variants to the commands enum called IgnoreRulesUntil(Vec<Box<dyn CstRule>>, Range<usize>) and IgnoreUntil(Range<usize>) where the ranges are start and end byte indices. You will need to cache the byte indices of line starts in the directive parser which is very easy, you can simply do it once when the directive parser is created, you can get the source code text through root_node.text().to_string(). To parse the actual directive you can simply peek the lexer to see if the next token's text is until and then further peek to see if its a number or eof. Then to enforce the directives you can simply add something to the place where rules are run, run through all of the directives, if any directive applies to the rule (ignoreUntil applies to all rules, IgnoreRulesUntil only applies if the rule is contained) then go through all of the diagnostics returned, if the first primary label of the diagnostic's range start is included in the directive's range then simply remove the diagnostic (Vec::retain can do this easily).

    You will also need to update the docs here to document this.

    C-enhancement T-Runner E-mentor E-medium 
    opened by RDambrosio016 8
  • Allow linting JS as modules

    Allow linting JS as modules

    In most projects I've seen people using .js for modules and almost never .mjs. Being unable to configure this requires entire codebase refactor just to try rslint so making this configurable should make adoption by the community much faster.

    opened by DVLP 7
  • Chore(deps): Bump minimatch from 3.0.4 to 3.1.2 in /editors/vscode

    Chore(deps): Bump minimatch from 3.0.4 to 3.1.2 in /editors/vscode

    Bumps minimatch from 3.0.4 to 3.1.2.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies javascript 
    opened by dependabot[bot] 0
  • Internal Linter Error on rslint_parser/src/lossless_tree_sink.rs

    Internal Linter Error on rslint_parser/src/lossless_tree_sink.rs

    Code

    
    
    //
    //★?
    0
    

    (NOTE: GitHub doesn't render this code properly. you should prepend two blank-lines to right before a first //)

    (or, just decode this base64 string: CgovLwovL+KYhT8KMA==)

    Meta

    rslint -V: v0.3.2

    if building from source: rustc --version --verbose:

    rustc 1.62.1 (e092d0b6b 2022-07-16)
    binary: rustc
    commit-hash: e092d0b6b43f2de967af0887873151bb1c0b18d3
    commit-date: 2022-07-16
    host: x86_64-pc-windows-gnu
    release: 1.62.1
    LLVM version: 14.0.5
    

    Error Output

    thread 'rslint-worker-2' panicked at 'called `Option::unwrap()` on a `None` value', crates\rslint_parser\src\lossless_tree_sink.rs:103:74
    stack backtrace:
       0: rust_begin_unwind
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library\std\src/panicking.rs:584:5
       1: core::panicking::panic_fmt
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library\core\src/panicking.rs:142:14
       2: core::panicking::panic
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library\core\src/panicking.rs:48:5
       3: core::option::Option<T>::unwrap
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src/option.rs:755:21
       4: <rslint_parser::lossless_tree_sink::LosslessTreeSink as rslint_parser::TreeSink>::start_node::{{closure}}::{{closure}}
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\lossless_tree_sink.rs:103:44
       5: core::option::Option<T>::unwrap_or_else
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src/option.rs:805:21
       6: <rslint_parser::lossless_tree_sink::LosslessTreeSink as rslint_parser::TreeSink>::start_node::{{closure}}
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\lossless_tree_sink.rs:101:21
       7: core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\ops/function.rs:301:13
       8: core::option::Option<T>::map
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src/option.rs:909:29
       9: <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\iter\adapters/map.rs:145:9
      10: <core::iter::adapters::rev::Rev<I> as core::iter::traits::iterator::Iterator>::next
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\iter\adapters/rev.rs:33:9
      11: <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\iter\adapters/enumerate.rs:46:17
      12: core::iter::adapters::peekable::Peekable<I>::peek::{{closure}}
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\iter\adapters/peekable.rs:216:43
      13: core::option::Option<T>::get_or_insert_with
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src/option.rs:1524:49
      14: core::iter::adapters::peekable::Peekable<I>::peek
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\iter\adapters/peekable.rs:216:9
      15: rslint_parser::lossless_tree_sink::n_attached_trivias
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\lossless_tree_sink.rs:214:31
      16: <rslint_parser::lossless_tree_sink::LosslessTreeSink as rslint_parser::TreeSink>::start_node
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\lossless_tree_sink.rs:106:13
      17: rslint_parser::event::process
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\event.rs:103:21
      18: rslint_parser::parse::parse_with_syntax
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_parser\src\parse.rs:261:5
      19: rslint_core::file::File::parse_with_errors
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_core\src\file.rs:118:21
      20: rslint_core::lint_file
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_core\src\lib.rs:115:31
      21: rslint_cli::run_inner::{{closure}}::{{closure}}
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_cli\src\lib.rs:122:25
      22: yastl::scope::Scope::recurse::{{closure}}
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\scope.rs:62:30
      23: <F as yastl::FnBox>::call_box
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\lib.rs:223:9
      24: yastl::Pool::run_thread
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\lib.rs:141:21
      25: yastl::Pool::with_config::{{closure}}
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\lib.rs:87:32
    note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
    thread 'main' panicked at 'Worker Pool was poisoned', C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\wait.rs:50:13
    stack backtrace:
       0: std::panicking::begin_panic
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\std\src/panicking.rs:616:12
       1: yastl::wait::WaitGroup::join
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\wait.rs:50:13
       2: yastl::scope::Scope::join
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\scope.rs:71:9
       3: yastl::scope::Scope::zoom::{{closure}}
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\scope.rs:85:28
       4: <scopeguard::ScopeGuard<T,F,S> as core::ops::drop::Drop>::drop
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\scopeguard-1.1.0\src\lib.rs:459:13
       5: core::ptr::drop_in_place<scopeguard::ScopeGuard<(),yastl::scope::Scope::zoom<rslint_cli::run_inner::{{closure}},()>::{{closure}}>>
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\ptr/mod.rs:486:1
       6: yastl::scope::Scope::zoom
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\scope.rs:88:5
       7: yastl::Pool::scoped
                 at C:\Users\aeiou\scoop\persist\rustup-msvc\.cargo\registry\src\github.com-1ecc6299db9ec823\yastl-0.1.2\src\lib.rs:107:9
       8: rslint_cli::run_inner
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_cli\src\lib.rs:116:5
       9: rslint_cli::run
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_cli\src\lib.rs:42:21
      10: rslint::execute
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_cli\src\main.rs:95:22
      11: rslint::main
                 at .\Workspaces\BuildMe\___non-active\rslint\crates\rslint_cli\src\main.rs:83:5
      12: core::ops::function::FnOnce::call_once
                 at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3\library\core\src\ops/function.rs:248:5
    note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
    
    ILE 
    opened by gaeulbyul 0
  • Chore(deps): Bump thread_local from 1.1.3 to 1.1.4

    Chore(deps): Bump thread_local from 1.1.3 to 1.1.4

    Bumps thread_local from 1.1.3 to 1.1.4.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies rust 
    opened by dependabot[bot] 0
  • Chore(deps): Bump regex from 1.5.4 to 1.5.5

    Chore(deps): Bump regex from 1.5.4 to 1.5.5

    Bumps regex from 1.5.4 to 1.5.5.

    Changelog

    Sourced from regex's changelog.

    1.5.5 (2022-03-08)

    This releases fixes a security bug in the regex compiler. This bug permits a vector for a denial-of-service attack in cases where the regex being compiled is untrusted. There are no known problems where the regex is itself trusted, including in cases of untrusted haystacks.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies rust 
    opened by dependabot[bot] 0
  • Chore(deps): Bump crossbeam-utils from 0.8.5 to 0.8.8

    Chore(deps): Bump crossbeam-utils from 0.8.5 to 0.8.8

    Bumps crossbeam-utils from 0.8.5 to 0.8.8.

    Release notes

    Sourced from crossbeam-utils's releases.

    crossbeam-utils 0.8.8

    • Fix a bug when unstable loom support is enabled. (#787)

    crossbeam-utils 0.8.7

    • Add AtomicCell<{i*,u*}>::{fetch_max,fetch_min}. (#785)
    • Add AtomicCell<{i*,u*,bool}>::fetch_nand. (#785)
    • Fix unsoundness of AtomicCell<{i,u}64> arithmetics on 32-bit targets that support Atomic{I,U}64 (#781)

    crossbeam-utils 0.8.6

    • Re-add AtomicCell<{i,u}64>::{fetch_add,fetch_sub,fetch_and,fetch_or,fetch_xor} that were accidentally removed in 0.8.0 0.7.1 on targets that do not support Atomic{I,U}64. (#767)
    • Re-add AtomicCell<{i,u}128>::{fetch_add,fetch_sub,fetch_and,fetch_or,fetch_xor} that were accidentally removed in 0.8.0 0.7.1. (#767)
    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies rust 
    opened by dependabot[bot] 0
Releases(v0.3.2)
Owner
RSLint
Extremely fast work in progress JavaScript and TypeScript linter
RSLint
Detects usage of unsafe Rust in a Rust crate and its dependencies.

cargo-geiger ☢️ A program that lists statistics related to the usage of unsafe Rust code in a Rust crate and all its dependencies. This cargo plugin w

Rust Secure Code Working Group 1.1k Jan 8, 2023
⚙️ A curated list of dynamic analysis tools for all programming languages, binaries, and more.

This repository lists dynamic analysis tools for all programming languages, build tools, config files and more. The official website, analysis-tools.d

Analysis Tools 650 Jan 4, 2023
Scans a given directory for software of unknown provinence (SOUP) and dumps them in a json-file

souper Scans a given directory for potential software of unknown provinence (SOUP) and writes them to a json-file. The json-file contains name, versio

Devies 2 Aug 26, 2022
Blazing fast linter for JavaScript and TypeScript written in Rust

deno_lint A Rust crate for writing fast JavaScript and TypeScript linters. This crate powers deno lint, but is not Deno specific and can be used to wr

Deno Land 1.3k Dec 29, 2022
Tools - The Rome Toolchain. A linter, compiler, bundler, and more for JavaScript, TypeScript, HTML, Markdown, and CSS.

Rome is currently being rewritten in Rust. Read more about it in our latest blog post. The documentation below is out of date and available for poster

Rome 22k Jan 3, 2023
A Faster(⚡) formatter, linter, bundler, and more for JavaScript, TypeScript, JSON, HTML, Markdown, and CSS Lapce Plugin

Lapce Plugin for Rome Lapce-rome is a Lapce plugin for rome, The Rome is faster ⚡ , A formatter, linter, compiler, bundler, and more for JavaScript, T

xiaoxin 7 Dec 16, 2022
A robust, customizable, blazingly-fast, efficient and easy-to-use command line application to uwu'ify your text!

uwuifyy A robust, customizable, blazingly-fast, efficient and easy-to-use command line application to uwu'ify your text! Logo Credits: Jade Nelson Tab

Hamothy 43 Dec 12, 2022
The JavaScript Oxidation Compiler -> Linter / Prettier

The JavaScript Oxidation Compiler (oxc) Why this project? The goal of this project is to: Create a blazingly fast JavaScript Compiler written in Rust.

Boshen 125 Feb 22, 2023
Opinionated, zero-config linter for JavaScript monorepos

Sherif: Opinionated, zero-config linter for JavaScript monorepos About Sherif is an opinionated, zero-config linter for JavaScript monorepos. It runs

Tom Lienard 219 Oct 10, 2023
swc is a super-fast compiler written in rust; producing widely-supported javascript from modern standards and typescript.

Make the web (development) faster. SWC (stands for Speedy Web Compiler) is a super-fast TypeScript / JavaScript compiler written in Rust. It's a libra

swc 25.4k Dec 31, 2022
A customizable, simple and easy to use json REST API consumer

JACK is a generic JSON API client. It is useful to interact with APIs from multiple services such as Google and Twitter

Mente Binária 6 May 22, 2022
Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust.

Deno Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Features Secure by default. No file,

Derek Jones 2 Aug 13, 2022
A utility that can download JavaScript and TypeScript module graphs and store them locally in a special zip file.

eszip A utility that can download JavaScript and TypeScript module graphs and store them locally in a special zip file. To create a new archive: > esz

Deno Land 162 Dec 24, 2022
A secure JavaScript and TypeScript runtime

Deno Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Features Secure by default. No file,

Deno Land 87.1k Jan 5, 2023
A node API for the dprint TypeScript and JavaScript code formatter

dprint-node A node API for the dprint TypeScript and JavaScript code formatter. It's written in Rust for blazing fast speed. Usage Pass a file path an

Devon Govett 431 Dec 24, 2022
Livny is a modern JavaScript and TypeScript runtime built on top of Rust

Livny is a modern JavaScript and TypeScript runtime built on top of Rust, Golang and the GraalVM Polyglot infrastructure that can run all of Deno and Node.jS applications. It is fine-tuned for user satisfaction, performance and security.

LivnyJS 1 Mar 2, 2022
Js-macros - Quickly prototype Rust procedural macros using JavaScript or TypeScript!

js-macros Quickly prototype Rust procedural macros using JavaScript or TypeScript! Have you ever thought "this would be a great use case for a procedu

null 15 Jun 17, 2022
Resolve JavaScript/TypeScript module with Rust

ES Resolve JavaScript/TypeScript module resolution in Rust Installation cargo add es_resolve Get Started use std::path::{Path, PathBuf}; use es_resolv

wang chenyu 2 Oct 12, 2022
compile TypeScript or JavaScript to binaries

the powr project Development is paused until 2023. ?? powr aims to be a javascript/typescript engine to power serverless functions over the web. the j

powr.js 18 Dec 29, 2022
JavaScript/TypeScript runtime Deno was meant to be.

Project Bueno (temporary name) Bueno is a web-standards focused JS/TS runtime with as much tooling built-in as possible. It is meant to be both a lear

Bueno 22 Sep 3, 2023