clippy: type_complexity

Author: alanhdu

crates/ra_lsp_server/src/thread_watcher.rs

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

crates/ra_syntax/src/reparsing.rs

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