Make clippy a git subtree instead of a git submodule #70655

@ghost

Rollup of 11 pull requests Successful merges: - rust-lang#5406 (Fix update_lints) - rust-lang#5409 (Downgrade let_unit_value to pedantic) - rust-lang#5410 (Downgrade trivially_copy_pass_by_ref to pedantic) - rust-lang#5412 (Downgrade inefficient_to_string to pedantic) - rust-lang#5415 (Add new lint for `Result<T, E>.map_or(None, Some(T))`) - rust-lang#5417 (Update doc links and mentioned names in docs) - rust-lang#5419 (Downgrade unreadable_literal to pedantic) - rust-lang#5420 (Downgrade new_ret_no_self to pedantic) - rust-lang#5422 (CONTRIBUTING.md: fix broken triage link) - rust-lang#5424 (Incorrect suspicious_op_assign_impl) - rust-lang#5425 (Ehance opt_as_ref_deref lint.) Failed merges: - rust-lang#5345 (Add lint for float in array comparison) - rust-lang#5411 (Downgrade implicit_hasher to pedantic) - rust-lang#5428 (Move cognitive_complexity to nursery) r? @ghost changelog: rollup

When checking for functions that are potential candidates for trait implementations check the function header to make sure modifiers like asyncness, constness and safety match before triggering the lint. Fixes rust-lang#5413, rust-lang#4290

Move cognitive_complexity to nursery As discussed in rust-lang/rust-clippy#5418 (comment); Clippy's current understanding of cognitive complexity is not good enough yet at analyzing code for understandability to have this lint be enabled by default. changelog: Remove cognitive_complexity from default set of enabled lints

Check fn header along with decl when suggesting to implement trait When checking for functions that are potential candidates for trait implementations check the function header to make sure modifiers like asyncness, constness and safety match before triggering the lint. Fixes rust-lang#5413, rust-lang#4290 changelog: check fn header along with decl for should_implement_trait

Downgrade implicit_hasher to pedantic From the [documentation](https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher), this lint is intended to suggest: ```diff - pub fn foo(map: &mut HashMap<i32, i32>) { } + pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { } ``` I think this is pedantic. I get that this lint can benefit core libraries like serde, but that's exactly the use case for pedantic lints; a library like serde will [enable clippy_pedantic](https://github.com/serde-rs/json/blob/fd6741f4b0b3fc90a58a6f578e33a9adc6403f3f/src/lib.rs#L304) and take the time to go through everything possible. Similar for libraries doing a libz blitz style checkup before committing to a 1.0 release; it would make sense to run through all the available pedantic lints then. But otherwise, for most codebases and certainly for industrial codebases, the above suggested change just makes the codebase more obtuse for questionable benefit. changelog: Remove implicit_hasher from default set of enabled lints

Finishes rust-lang#4277

Earlier if arguments to method calls matched the above pattern they were not reported. This patch ensures such arguments are checked as well. Fixes rust-lang#5436

@joshtriplett

…earth Revert "Downgrade new_ret_no_self to pedantic" Reverts rust-lang/rust-clippy#5420 This got through with the big rollup merge, where I didn't recheck every PR of the rollup. Reverting because of the reason given in rust-lang/rust-clippy#5420 (comment) by @joshtriplett changelog: Move new_ret_no_self back to style category

The lint was changed to be more lenient than the documentation implies in PR rust-lang#3338. Related issue rust-lang#3313

Rustup to rust-lang#70913 changelog: none

compare with the second largest instead of the smallest variant This should make the lint less noisy for now. See [my comment](rust-lang/rust-clippy#5418 (comment)) to issue rust-lang#5418. --- changelog: none

Check for clone-on-copy in argument positions Earlier if arguments to method calls matched the above pattern they were not reported. This patch ensures such arguments are checked as well. Fixes rust-lang#5436 changelog: apply clone_on_copy lint to func args as well

rustup rust-lang#69745 changelog: none

This change adds a check to the `inconsistent_digit_grouping` to add a check for NumericLiterals that follow the UUID format of 8-4-4-4-12. If the NumericLiteral matches the UUID format, no further inconsistent grouping checks will be performed. Closes rust-lang#5431

… r=phansch Allow UUID style formatting for `inconsistent_digit_grouping` lint This change adds a check to the `inconsistent_digit_grouping` to add a check for NumericLiterals that follow the UUID format of 8-4-4-4-12. If the NumericLiteral matches the UUID format, no further inconsistent grouping checks will be performed. Closes rust-lang#5431 changelog: Allow UUID style formatting for `inconsistent_digit_grouping` lint

Change the existing hex bit mask (`0x1111`) to a binary one (`0b1111`). The former does not seem to have anything to do with trailing zeros and is probably a typo.

verbose_bit_mask: fix bit mask used in docs changelog: fixes verbose_bit_mask docs

With this change, the lint checks all operations that are defined as being capable of overflow in the Rust Reference.

Check whether slice elements implement Copy before suggesting to drop the clone method

It's much shorter that Symbol::intern and the result should still be clear.

It's doing exactly the same: https://doc.rust-lang.org/nightly/nightly-rustc/src/rustc_ast/expand/mod.rs.html#8-12

`x` and the `HasResult` struct were missing in this file.

Running rustfmt from master is currently broken: rust-lang#71077

…st, r=matthiaskrgr Temporarily disable rustfmt integration test Running rustfmt from master is currently broken and [fails our bors build](https://github.com/rust-lang/rust-clippy/runs/582066368#step:10:19): rust-lang#71077 changelog: none

…, r=phansch Update documentation for new_ret_no_self changelog: Update documentation for lint new_ret_no_self to reflect that the return type must only contain `Self`, not be `Self` The lint was changed to be more lenient than the documentation implies in PR rust-lang#3338 (Related issue rust-lang#3313)

…krgr Cleanup: Use rustc's is_proc_macro_attr It's doing exactly the same: https://doc.rust-lang.org/nightly/nightly-rustc/src/rustc_ast/expand/mod.rs.html#8-12 changelog: none

Fixes rust-lang#5405: redundant clone false positive with arrays Check whether slice elements implement Copy before suggesting to drop the clone method changelog: add a check for slice indexing on redundant_clone lint

rustup rust-lang#70643 changelog: none

Cleanup: Use our `sym!` macro more It's much shorter than Symbol::intern and the effect should still be clear --- changelog: none

…skrgr result_map_unit_fn: Fix incorrect UI tests `x` and the `HasResult` struct were missing in this file. changelog: none

Make use of more diagnostic items This makes use of some (not all) already existing diagnostic items. Specifically: * 79982a2: `core::mem::uninitialized`, `core::mem::zeroed`, `alloc::sync::Arc`, `alloc::sync::Rc` * 83874d0: `Option` and `Result` cc rust-lang#5393 changelog: none

This replaces our match_def_path implementation with the rustc one. Note that we can't just use it in all call sites because of the `&[&str]` / `&[Symbol]` difference in Clippy/rustc.

…thiaskrgr Refactor: Use rustc's `match_def_path` This replaces our match_def_path implementation with the rustc one. Note that we can't just use it in all call sites because of the `&[&str]` / `&[Symbol]` difference in Clippy/rustc. changelog: none

…mparison, r=flip1995 Add lint for float in array comparison Fixes rust-lang#4277 changelog: - Added new handler for expression of index kind (e.g. `arr[i]`). It returns a constant when both array and index are constant, or when the array is constant and all values are equal. - Trigger float_cmp and float_cmp_const lint when comparing arrays. Allow for comparison when one of the arrays contains only zeros or infinities. - Added appropriate tests for such cases.

deps: bump compiletest-rs from 0.4 to 0.5 changelog: none

This reports the sizes of the largest and second-largest variants.

rustup rust-lang#71116 changelog: none

Add lint for explicit deref and deref_mut method calls This PR adds the lint `explicit_deref_method` that suggests replacing `deref()` and `deref_mut()` with `&*a` and `&mut *a`. It doesn't lint inside macros. This PR is the continuation of rust-lang#3258. changelog: Add lint `explicit_deref_method`. Fixes: rust-lang#1566

Add lint on large non scalar const This PR adds the new lint `non_scalar_const` that aims to warn against `const` declaration of large arrays. For performance, because of inlining, large arrays should be preferably declared as `static`. Note: i made this one to warn on all const arrays, whether they are in a body function or not. I don't know if this is really necessary, i could just reduce this lint to variables out of function scope. Fixes: rust-lang#400 changelog: add new lint for large non-scalar types declared as const

…flip1995 Disallow bit-shifting in integer_arithmetic Make the `integer_arithmetic` lint detect all the operations that are defined as being capable of overflow in the [Rust Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow), by also linting for bit-shifting operations (`<<`, `>>`). changelog: Disallow bit-shifting in `integer_arithmetic`

…=flip1995 large_enum_variant: Report sizes of variants This reports the sizes of the largest and second-largest variants. Closes rust-lang#5459 changelog: `large_enum_variant`: Report the sizes of the largest and second-largest variants.

…ip1995 Zero single char names Fixes: rust-lang#4086 changelog: - Make the inequality strict

@ghost

Rollup of 5 pull requests Successful merges: - rust-lang#5226 (Add lint for explicit deref and deref_mut method calls) - rust-lang#5248 (Add lint on large non scalar const) - rust-lang#5430 (Disallow bit-shifting in integer_arithmetic) - rust-lang#5466 (large_enum_variant: Report sizes of variants) - rust-lang#5468 (Zero single char names) Failed merges: r? @ghost changelog: rollup

Co-Authored-By: Philipp Krones <hello@philkrones.com>

add --fix support to `cargo-clippy` Prior to this we had started work on integrating clippy as a subcommand directly into cargo in the form of `cargo clippy-preview` and `cargo fix --clippy`. In the course of that work it was decided that the best approach would be to strictly add the features clippy needed to cargo in order to insert `clippy-driver` only for workspace crates. This was accomplished by adding a `RUSTC_WORKSPACE_WRAPPER` env variable to cargo that will override the normal `RUSTC_WRAPPER` when both are present and the current crate is a workspace crate. This change adds support to clippy to use this by setting the `RUSTC_WORKSPACE_WRAPPER` env variable instead `RUSTC_WRAPPER` and by detecting `--fix` as an arg and swapping out the `check` cargo command for `fix` when it is present. WIP, here are the current issues that I still need to resolve - [x] Detect if we're running on nightly rust - [x] Set `RUSTC_WORKSPACE_WRAPPER` on nightly, and `RUSTC_WRAPPER` on stable - [x] Error out on stable when `--fix` is specified, because stable currently hasn't landed the PR for `RUSTC_WORKSPACE_WRAPPER` so if we set this it just runs check and silently fails - [ ] Update the help text - [ ] The current plan is to shell out to `cargo check --help` and then postprocess the output to mention clippy instead of check where appropriate and to add the extra info about `--fix` and the `-- -A lint` options. - [x] tests? changelog: add `--fix` arg to `cargo-clippy`

See rust-lang#5477 for details

…sch,flip1995 perform system upgrade fixes ci issue Perhaps doing a system upgrade magically solves the problem? changelog: none

Reenable rustfmt integration test changelog: none

…1995 Map flatten for option Fixes rust-lang#5175 changelog: - Trigger the map_flatten lint when map is called on an option - Add test for such case

[fix] Minor typo in GH Actions 'clippy_dev' changelog: minor: fixes file name in Github Actions workflow `clippy_dev.yml` I was looking for something else and ended up on that typo, just thought I would fix it.

…lip1995 Do not lint in macros for match lints Don't lint in macros for match lints, more precisely in `check_pat` and `check_local` where it was not the case. changelog: none fixes: rust-lang#5362

readme: update to cargo clippy --fix command changelog: none

unit_arg suggestion is not really machine-applicable This lint suggests replacing any code returining `()`-type with `()` literal, which can change the behavior. e.g. `Ok(do_something())` -> `OK(())`. --- changelog: none

question_mark: don't add `as_ref()` for a call expression If a call returns a `!Copy` value, it does so regardless of whether `as_ref()` is added. For example, `foo.into_option().as_ref()?` can be simplified to `foo.into_option()?`. --- changelog: Improved `question_mark` lint suggestion so that it doesn't add redundant `as_ref()`

Cleanup: Rename 'db' variables to 'diag' Did the same in rustc a while ago: rust-lang#65428 changelog: none

Fixes issue rust-lang#4892. First contribution here 😊 ! Do not hesitate to correct me. This PR is related to issue rust-lang#4892 . # Summary ```rust -literal.method_call(args) ``` The main idea is to not trigger `clippy::precedence` when the method call is an odd function. # Example ```rust // should trigger lint let _ = -1.0_f64.abs() //precedence of method call abs() and neg ('-') is ambiguous // should not trigger lint let _ = -1.0_f64.sin() // sin is an odd function => -sin(x) = sin(-x) ``` # Theory Rust allows following literals: - char - string - integers - floats - byte - bool Only integers/floats implements the relevant `std::ops::Neg`. Following odd functions are implemented on i[8-128] and/or f[32-64]: - `asin` - `asinh` - `atan` - `atanh` - `cbrt` - `fract` - `round` - `signum` - `sin` - `sinh` - `tan` - `tanh ` - `to_degrees` - `to_radians` # Implementation As suggested by `flip1995` in [comment](rust-lang/rust-clippy#4892 (comment)), this PR add a whitelist of odd functions and compare method call to the the whitelist before triggering lint. changelog: Don't trigger [`clippy::precedence`] on odd functions.

add lint futures_not_send changelog: add lint futures_not_send fixes rust-lang#5379 ~Remark: one thing that can (should?) still be improved is to directly include the error message from the `Send` check so that the programmer stays in the flow. Currently, getting the actual error message requires a restructuring of the code to make the `Send` constraint explicit.~ It now shows all unmet constraints for allowing the Future to be Send.

- now it handles `while let` case - better suggestions in `if let` case

…g, r=flip1995 fix redundant_pattern_matching lint - now it handles `while let` case (related to rust-lang#5462) - better suggestions in `if let` case changelog: Fix suggestion in `redundant_pattern_matching` and also apply this lint to the `while let` case

Add lint named implicit_saturating_sub Fixes: rust-lang#5399 I've made a basic skeleton of the lint, would love more feedback on how to make it better. changelog: Add lint [`implicit_saturating_sub`]

Remove badge FIXME from Cargo.toml cc rust-lang/crates.io#2436 changelog: none

Update the "borrow box" lint to avoid recommending the following conversion: ``` // Old pub fn f(&mut Box<T>) {...} // New pub fn f(&mut T) {...} ``` Given a mutable reference to a box, functions may want to change "which" object the Box is pointing at. This change avoids recommending removing the "Box" parameter for mutable references.

Don't trigger toplevel_ref_arg for `for` loops The lint suggests turning `for ref x in 0..10 {` into `for ref x in let x = &0..10; {`. --- changelog: none

…1995 Cleanup: future_not_send: use `utils::return_ty` function changelog: none

Cleanup: `node_id` -> `hir_id` This removes some more `node_id` terminology from Clippy and replaces one occurrence of `as_local_node_id` with `as_local_hir_id`, which should be doing the same for that particular case. changelog: none

Fix issue rust-lang#2907. Update the "borrow box" lint to avoid recommending the following conversion: ``` // Old pub fn f(&mut Box<T>) {...} // New pub fn f(&mut T) {...} ``` Given a mutable reference to a box, functions may want to change "which" object the Box is pointing at. This change avoids recommending removing the "Box" parameter for mutable references. changelog: Don't trigger [`borrow_box`] lint on `&mut Box` references

Fixes issue 5095 fixes rust-lang#5095. - [x] Followed [lint naming conventions][lint_naming] - [x] Added passing UI tests (including committed `.stderr` file) - [x] `cargo test` passes locally - [x] Executed `cargo dev update_lints` - [x] Added lint documentation - [x] Run `cargo dev fmt` [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints changelog: (internal) warn about collapsible `span_lint_and_then` calls.

* Move the lint to pedantic * Import used types instead of prefixing with `hir::`

…ip1995 Implement unsafe_derive_deserialize lint Added `unsafe_derive_deserialize` lint to check for cases when automatically deriving `serde::Deserialize` can be problematic, i.e. with types that have methods using `unsafe`. Closes rust-lang#5471 changelog: Add lint [`unsafe_derive_deserialize`]

This can then be easily copy/pasted into the changelog 💙

If let else mutex changelog: Adds lint to catch incorrect use of `Mutex::lock` in `if let` expressions with lock calls in any of the blocks. closes: rust-lang#5219

@flip1995

Update the changelog update documentation I just started working on updating the changelog. Hopefully the docs are a bit clearer now? r? @flip1995 changelog: none

util/fetch_prs_between.sh: Add Markdown formatted link This can then be easily copy/pasted into the changelog 💙 changelog: none

Fixes rust-lang#5497

fix crash on issue-69020-assoc-const-arith-overflow.rs Fixes rust-lang#5497 changelog: fix crash on rustc test issue-69020-assoc-const-arith-overflow.rs

Fixes rust-lang#4226 This introduces the lint await_holding_lock. For async functions, we iterate over all types in generator_interior_types and look for types named MutexGuard, RwLockReadGuard, or RwLockWriteGuard. If we find one then we emit a lint.

…t of the path

…n other mutex types

…d of just a span

Lint for holding locks across await points Fixes rust-lang#4226 This introduces the lint await_holding_lock. For async functions, we iterate over all types in generator_interior_types and look for types named MutexGuard, RwLockReadGuard, or RwLockWriteGuard. If we find one then we emit a lint. changelog: introduce the await_holding_lock lint

Co-Authored-By: ecstatic-morse <ecstaticmorse@gmail.com>

Rustup "Remove `BodyAndCache`" cc rust-lang#71044 changelog: none

… not match Fixes rust-lang#5510

It looks like after changing to "there are more than 120 lints", an older PR was merged and resolving merge conflicts this was changed back to "there are 123 lints" causing the update-script to silently fail. Changed back the README.md back to the new format fixes the problem.

Update CHANGELOG.md for Rust 1.43 and 1.44 [Rendered](https://github.com/phansch/rust-clippy/blob/update_changelog/CHANGELOG.md) changelog: none

@phansch

fix clippy_dev exit status and make regex match again changelog: none Fixes rust-lang#5510 r? @phansch

…nsch rustup rust-lang#71215 There's currently an crash in `ui/new_without_default.rs` that I need to figure out how to avoid. changelog: none

…ery iteration

Downgrade match_bool to pedantic I don't quite buy the justification in https://rust-lang.github.io/rust-clippy/. The justification is: > It makes the code less readable. In the Rust codebases I've worked in, I have found people were comfortable using `match bool` (selectively) to make code more readable. For example, initializing struct fields is a place where the indentation of `match` can work better than the indentation of `if`: ```rust let _ = Struct { v: { ... }, w: match doing_w { true => ..., false => ..., }, x: Nested { c: ..., b: ..., a: ..., }, y: if doing_y { ... } else { // :( ... }, z: ..., }; ``` Or sometimes people prefer something a bit less pithy than `if` when the meaning of the bool doesn't read off clearly from the condition: ```rust if set.insert(...) { ... // ??? } else { ... } match set.insert(...) { // set.insert returns false if already present false => ..., true => ..., } ``` Or `match` can be a better fit when the bool is playing the role more of a value than a branch condition: ```rust impl ErrorCodes { pub fn from(b: bool) -> Self { match b { true => ErrorCodes::Yes, false => ErrorCodes::No, } } } ``` And then there's plain old it's-1-line-shorter, which means we get 25% more content on a screen when stacking a sequence of conditions: ```rust let old_noun = match old_binding.is_import() { true => "import", false => "definition", }; let new_participle = match new_binding.is_import() { true => "imported", false => "defined", }; ``` Bottom line is I think this lint fits the bill better as a pedantic lint; I don't think linting on this by default is justified. changelog: Remove match_bool from default set of enabled lints

@matthiaskrgr

…hiaskrgr Avoid running cargo+internal lints when not enabled r? @matthiaskrgr changelog: none

Add a note to the beta sections of release.md changelog: none

…hearth Deploy time travel Since not only commits to the master branch, but also tags and the beta branch are deployed, we have to be cautious which version of the deploy script is used. GHA always runs the workflow that is commited on the `ref`, that gets tested. For tagged commits. this is 6 weeks outdated workflows/scripts. To prevent this, this workflow first checks out the deploy.sh script, the website templates and all python scripts generating files for the website. changelog: none

…, r=flip1995 Add lifetime test case for `new_ret_no_self` cc rust-lang/rust-clippy#734 (comment) changelog: none

@ghost

Rollup of 5 pull requests Successful merges: - rust-lang#5408 (Downgrade match_bool to pedantic) - rust-lang#5505 (Avoid running cargo+internal lints when not enabled) - rust-lang#5516 (Add a note to the beta sections of release.md) - rust-lang#5517 (Deploy time travel) - rust-lang#5523 (Add lifetime test case for `new_ret_no_self`) Failed merges: r? @ghost changelog: rollup

- now it gives correct suggestion in case of macros - better tests - remove a couple of non-relevant tests

map_clone: avoid suggesting `copied()` for &mut changelog: map_clone: avoid suggesting `copied()` for &mut Fixes rust-lang#5524

@phansch

Don't trigger while_let_on_iterator when the iterator is recreated every iteration r? @phansch Fixes rust-lang#1654 changelog: Fix false positive in [`while_let_on_iterator`]

…g, r=flip1995 Fix redundant_pattern_matching lint fixes rust-lang#5504 changelog: Fix suggestion in `redundant_pattern_matching` for macros.

rustup to rust-lang#70043 changelog: none

In particular for: * `VecDeque` * `String` * `Mutex` * `HashMap` * `HashSet` cc rust-lang#71414 rust-lang/rust-clippy#5393

`cargo dev` has been the replacement for a while, so I think we can remove it now. cc rust-lang#5394

…hiaskrgr Use more diagnostic items In particular for: * `VecDeque` * `String` * `Mutex` * `HashMap` * `HashSet` cc rust-lang#71414 rust-lang#5393 --- changelog: none

Remove util/dev script `cargo dev` has been the replacement for a while, so I think we can remove it now. cc rust-lang#5394 changelog: none

- Changed lint category to `correctness` - Moved main function to bottom in test file - Added `FIXME` comment to `span_lint_and_sugg` to improve later

- Show just one error message with multiple suggestions in case of using multiple times an OS in target family position - Only suggest #[cfg(unix)] when the OS is in the Unix family - Test all the operating systems

Implement mismatched_target_os lint I've extended the check suggested in the issue to all the currently supported operating systems instead of limiting it to `linux` and `macos`, let me know if we want to do this. Also, I've restored the text `There are over XXX lints ...` in the README as it was matched against by `cargo dev new_lint`. changelog: Added `mismatched_target_os` lint to warn when an operating system is used in target family position in a #[cfg] attribute Closes rust-lang#3949

New lint `match_vec_item` Added new lint to warn a match on index item which can panic. It's always better to use `get(..)` instead. Closes rust-lang#5500 changelog: New lint `match_on_vec_items`

rustup: rust-lang#71628 cc rust-lang#71608 changelog: none

used_underscore_binding: do not lint on `await` desugaring changelog: used_underscore_binding: do not lint on `await` desugaring Fixes rust-lang#5360

rustup rust-lang#71292 cc rust-lang#71608 --- changelog: none

Rustup to rust-lang#71518 changelog: none

- Added `<_>` to suggestion - Changed help message

…ion, r=flip1995 Fixed incorrect suggestion of `clone_double_ref` lint - Added `<_>` to suggestion - Changed help message - Added new tests Closes rust-lang#5494 changelog: Improve suggestion of [`clone_double_ref`]

mismatched_target_os: link to respective section in rust reference changelog: none

…a96cd369' git-subtree-dir: src/tools/clippy git-subtree-mainline: 06c4481 git-subtree-split: d270887

Commits on Apr 21, 2020

Also mention --fix for nightly users

phansch committed Apr 21, 2020

Configuration menu

View commit details

Copy full SHA for 30c28a7

Browse repository at this point

Copy the full SHA

30c28a7 View commit details

Browse the repository at this point in the history

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Make clippy a git subtree instead of a git submodule #70655

Make clippy a git subtree instead of a git submodule #70655

Commits on Apr 8, 2020

Commits on Apr 9, 2020

Commits on Apr 10, 2020

Commits on Apr 11, 2020

Commits on Apr 12, 2020

Commits on Apr 13, 2020

Commits on Apr 14, 2020

Commits on Apr 15, 2020

Commits on Apr 16, 2020

Commits on Apr 17, 2020

Commits on Apr 18, 2020

Commits on Apr 19, 2020

Commits on Apr 20, 2020

Commits on Apr 21, 2020

Commits on Apr 22, 2020

Commits on Apr 23, 2020

Commits on Apr 24, 2020

Commits on Apr 25, 2020

Commits on Apr 26, 2020

Commits on Apr 27, 2020

Commits on Apr 28, 2020

Commits on Apr 29, 2020

Commits on Apr 30, 2020

Commits on May 1, 2020

Commits on May 2, 2020