language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-29 13:25:09 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

clippy: type_complexity

Browse source
This commit is contained in:
Alan Du 2018-10-16 14:08:52 -04:00
parent bc774fe6cf
commit fc8024de51
2 changed files with 11 additions and 8 deletions
Download patch file Download diff file Expand all files Collapse all files

10
crates/ra_lsp_server/src/thread_watcher.rs
View file

@ -16,8 +16,7 @@ impl<I, O> Worker<I, O> {
I: Send + 'static, I: Send + 'static,
O: Send + 'static, O: Send + 'static,
{ {
let ((inp, out), inp_r, out_s) = worker_chan(buf); let (worker, inp_r, out_s) = worker_chan(buf);
let worker = Worker { inp, out };
let watcher = ThreadWatcher::spawn(name, move || f(inp_r, out_s)); let watcher = ThreadWatcher::spawn(name, move || f(inp_r, out_s));
(worker, watcher) (worker, watcher)
} }
@ -66,11 +65,14 @@ impl ThreadWatcher {
/// Sets up worker channels in a deadlock-avoind way. /// Sets up worker channels in a deadlock-avoind way.
/// If one sets both input and output buffers to a fixed size, /// If one sets both input and output buffers to a fixed size,
/// a worker might get stuck. /// a worker might get stuck.
fn worker_chan<I, O>(buf: usize) -> ((Sender<I>, Receiver<O>), Receiver<I>, Sender<O>) { fn worker_chan<I, O>(buf: usize) -> (Worker<I, O>, Receiver<I>, Sender<O>) {
let (input_sender, input_receiver) = bounded::<I>(buf); let (input_sender, input_receiver) = bounded::<I>(buf);
let (output_sender, output_receiver) = unbounded::<O>(); let (output_sender, output_receiver) = unbounded::<O>();
( (
(input_sender, output_receiver), Worker {
inp: input_sender,
out: output_receiver,
},
input_receiver, input_receiver,
output_sender, output_sender,
) )

9
crates/ra_syntax/src/reparsing.rs
View file

@ -98,17 +98,18 @@ fn is_contextual_kw(text: &str) -> bool {
} }
} }
fn find_reparsable_node<'node>( type ParseFn = fn(&mut Parser);
node: SyntaxNodeRef<'node>, fn find_reparsable_node(
node: SyntaxNodeRef<'_>,
range: TextRange, range: TextRange,
) -> Option<(SyntaxNodeRef<'node>, fn(&mut Parser))> { ) -> Option<(SyntaxNodeRef<'_>, ParseFn)> {
let node = algo::find_covering_node(node, range); let node = algo::find_covering_node(node, range);
return node return node
.ancestors() .ancestors()
.filter_map(|node| reparser(node).map(|r| (node, r))) .filter_map(|node| reparser(node).map(|r| (node, r)))
.next(); .next();
fn reparser(node: SyntaxNodeRef) -> Option<fn(&mut Parser)> { fn reparser(node: SyntaxNodeRef) -> Option<ParseFn> {
let res = match node.kind() { let res = match node.kind() {
BLOCK => grammar::block, BLOCK => grammar::block,
NAMED_FIELD_DEF_LIST => grammar::named_field_def_list, NAMED_FIELD_DEF_LIST => grammar::named_field_def_list,