lsp_client_multilspy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSP Client implemented with multilspy\n",
    "`multilspy` is proposed in a research by microsoft, the [github repo](https://github.com/microsoft/monitors4codegen#4-multilspy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from monitors4codegen.multilspy import SyncLanguageServer\n",
    "from monitors4codegen.multilspy.multilspy_config import MultilspyConfig\n",
    "from monitors4codegen.multilspy.multilspy_logger import MultilspyLogger\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = MultilspyConfig.from_dict(\n",
    "    {\"code_language\": \"rust\"}\n",
    ")  # Also supports \"python\", \"rust\", \"csharp\"\n",
    "logger = MultilspyLogger()\n",
    "lsp = SyncLanguageServer.create(config, logger, \"/mnt/vm_data/pythonProjects/rust_analyzer_client/rust_example/\")\n",
    "with lsp.start_server():\n",
    "    result = lsp.request_definition(\n",
    "        \"src/main.rs\",  # Filename of location where request is being made\n",
    "        79,  # line number of symbol for which request is being made\n",
    "        8,  # column number of symbol for which request is being made\n",
    "    )\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'uri': 'file:///home/lihuan/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/lib.rs',\n",
       " 'absolutePath': '/home/lihuan/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/lib.rs',\n",
       " 'relativePath': '../../../../../home/lihuan/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/lib.rs',\n",
       " 'range': {'start': {'line': 0, 'character': 0},\n",
       "  'end': {'line': 725, 'character': 0}}}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "//! # The Rust Standard Library\n",
      "//!\n",
      "//! The Rust Standard Library is the foundation of portable Rust software, a\n",
      "//! set of minimal and battle-tested shared abstractions for the [broader Rust\n",
      "//! ecosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n",
      "//! [`Option<T>`], library-defined [operations on language\n",
      "//! primitives](#primitives), [standard macros](#macros), [I/O] and\n",
      "//! [multithreading], among [many other things][other].\n",
      "//!\n",
      "//! `std` is available to all Rust crates by default. Therefore, the\n",
      "//! standard library can be accessed in [`use`] statements through the path\n",
      "//! `std`, as in [`use std::env`].\n",
      "//!\n",
      "//! # How to read this documentation\n",
      "//!\n",
      "//! If you already know the name of what you are looking for, the fastest way to\n",
      "//! find it is to use the <a href=\"#\" onclick=\"window.searchState.focus();\">search\n",
      "//! bar</a> at the top of the page.\n",
      "//!\n",
      "//! Otherwise, you may want to jump to one of these useful sections:\n",
      "//!\n",
      "//! * [`std::*` modules](#modules)\n",
      "//! * [Primitive types](#primitives)\n",
      "//! * [Standard macros](#macros)\n",
      "//! * [The Rust Prelude]\n",
      "//!\n",
      "//! If this is your first time, the documentation for the standard library is\n",
      "//! written to be casually perused. Clicking on interesting things should\n",
      "//! generally lead you to interesting places. Still, there are important bits\n",
      "//! you don't want to miss, so read on for a tour of the standard library and\n",
      "//! its documentation!\n",
      "//!\n",
      "//! Once you are familiar with the contents of the standard library you may\n",
      "//! begin to find the verbosity of the prose distracting. At this stage in your\n",
      "//! development you may want to press the `[-]` button near the top of the\n",
      "//! page to collapse it into a more skimmable view.\n",
      "//!\n",
      "//! While you are looking at that `[-]` button also notice the `source`\n",
      "//! link. Rust's API documentation comes with the source code and you are\n",
      "//! encouraged to read it. The standard library source is generally high\n",
      "//! quality and a peek behind the curtains is often enlightening.\n",
      "//!\n",
      "//! # What is in the standard library documentation?\n",
      "//!\n",
      "//! First of all, The Rust Standard Library is divided into a number of focused\n",
      "//! modules, [all listed further down this page](#modules). These modules are\n",
      "//! the bedrock upon which all of Rust is forged, and they have mighty names\n",
      "//! like [`std::slice`] and [`std::cmp`]. Modules' documentation typically\n",
      "//! includes an overview of the module along with examples, and are a smart\n",
      "//! place to start familiarizing yourself with the library.\n",
      "//!\n",
      "//! Second, implicit methods on [primitive types] are documented here. This can\n",
      "//! be a source of confusion for two reasons:\n",
      "//!\n",
      "//! 1. While primitives are implemented by the compiler, the standard library\n",
      "//!    implements methods directly on the primitive types (and it is the only\n",
      "//!    library that does so), which are [documented in the section on\n",
      "//!    primitives](#primitives).\n",
      "//! 2. The standard library exports many modules *with the same name as\n",
      "//!    primitive types*. These define additional items related to the primitive\n",
      "//!    type, but not the all-important methods.\n",
      "//!\n",
      "//! So for example there is a [page for the primitive type\n",
      "//! `i32`](primitive::i32) that lists all the methods that can be called on\n",
      "//! 32-bit integers (very useful), and there is a [page for the module\n",
      "//! `std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\n",
      "//! useful).\n",
      "//!\n",
      "//! Note the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\n",
      "//! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\n",
      "//! calls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\n",
      "//! coercions][deref-coercions].\n",
      "//!\n",
      "//! Third, the standard library defines [The Rust Prelude], a small collection\n",
      "//! of items - mostly traits - that are imported into every module of every\n",
      "//! crate. The traits in the prelude are pervasive, making the prelude\n",
      "//! documentation a good entry point to learning about the library.\n",
      "//!\n",
      "//! And finally, the standard library exports a number of standard macros, and\n",
      "//! [lists them on this page](#macros) (technically, not all of the standard\n",
      "//! macros are defined by the standard library - some are defined by the\n",
      "//! compiler - but they are documented here the same). Like the prelude, the\n",
      "//! standard macros are imported by default into all crates.\n",
      "//!\n",
      "//! # Contributing changes to the documentation\n",
      "//!\n",
      "//! Check out the rust contribution guidelines [here](\n",
      "//! https://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\n",
      "//! The source for this documentation can be found on\n",
      "//! [GitHub](https://github.com/rust-lang/rust).\n",
      "//! To contribute changes, make sure you read the guidelines first, then submit\n",
      "//! pull-requests for your suggested changes.\n",
      "//!\n",
      "//! Contributions are appreciated! If you see a part of the docs that can be\n",
      "//! improved, submit a PR, or chat with us first on [Discord][rust-discord]\n",
      "//! #docs.\n",
      "//!\n",
      "//! # A Tour of The Rust Standard Library\n",
      "//!\n",
      "//! The rest of this crate documentation is dedicated to pointing out notable\n",
      "//! features of The Rust Standard Library.\n",
      "//!\n",
      "//! ## Containers and collections\n",
      "//!\n",
      "//! The [`option`] and [`result`] modules define optional and error-handling\n",
      "//! types, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\n",
      "//! Rust's iterator trait, [`Iterator`], which works with the [`for`] loop to\n",
      "//! access collections.\n",
      "//!\n",
      "//! The standard library exposes three common ways to deal with contiguous\n",
      "//! regions of memory:\n",
      "//!\n",
      "//! * [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n",
      "//! * [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n",
      "//! * [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n",
      "//!   storage, whether heap-allocated or not.\n",
      "//!\n",
      "//! Slices can only be handled through some kind of *pointer*, and as such come\n",
      "//! in many flavors such as:\n",
      "//!\n",
      "//! * `&[T]` - *shared slice*\n",
      "//! * `&mut [T]` - *mutable slice*\n",
      "//! * [`Box<[T]>`][owned slice] - *owned slice*\n",
      "//!\n",
      "//! [`str`], a UTF-8 string slice, is a primitive type, and the standard library\n",
      "//! defines many methods for it. Rust [`str`]s are typically accessed as\n",
      "//! immutable references: `&str`. Use the owned [`String`] for building and\n",
      "//! mutating strings.\n",
      "//!\n",
      "//! For converting to strings use the [`format!`] macro, and for converting from\n",
      "//! strings use the [`FromStr`] trait.\n",
      "//!\n",
      "//! Data may be shared by placing it in a reference-counted box or the [`Rc`]\n",
      "//! type, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\n",
      "//! as well as shared. Likewise, in a concurrent setting it is common to pair an\n",
      "//! atomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\n",
      "//! effect.\n",
      "//!\n",
      "//! The [`collections`] module defines maps, sets, linked lists and other\n",
      "//! typical collection types, including the common [`HashMap<K, V>`].\n",
      "//!\n",
      "//! ## Platform abstractions and I/O\n",
      "//!\n",
      "//! Besides basic data types, the standard library is largely concerned with\n",
      "//! abstracting over differences in common platforms, most notably Windows and\n",
      "//! Unix derivatives.\n",
      "//!\n",
      "//! Common types of I/O, including [files], [TCP], and [UDP], are defined in\n",
      "//! the [`io`], [`fs`], and [`net`] modules.\n",
      "//!\n",
      "//! The [`thread`] module contains Rust's threading abstractions. [`sync`]\n",
      "//! contains further primitive shared memory types, including [`atomic`] and\n",
      "//! [`mpsc`], which contains the channel types for message passing.\n",
      "//!\n",
      "//! # Use before and after `main()`\n",
      "//!\n",
      "//! Many parts of the standard library are expected to work before and after `main()`;\n",
      "//! but this is not guaranteed or ensured by tests. It is recommended that you write your own tests\n",
      "//! and run them on each platform you wish to support.\n",
      "//! This means that use of `std` before/after main, especially of features that interact with the\n",
      "//! OS or global state, is exempted from stability and portability guarantees and instead only\n",
      "//! provided on a best-effort basis. Nevertheless bug reports are appreciated.\n",
      "//!\n",
      "//! On the other hand `core` and `alloc` are most likely to work in such environments with\n",
      "//! the caveat that any hookable behavior such as panics, oom handling or allocators will also\n",
      "//! depend on the compatibility of the hooks.\n",
      "//!\n",
      "//! Some features may also behave differently outside main, e.g. stdio could become unbuffered,\n",
      "//! some panics might turn into aborts, backtraces might not get symbolicated or similar.\n",
      "//!\n",
      "//! Non-exhaustive list of known limitations:\n",
      "//!\n",
      "//! - after-main use of thread-locals, which also affects additional features:\n",
      "//!   - [`thread::current()`]\n",
      "//!   - [`thread::scope()`]\n",
      "//!   - [`sync::mpsc`]\n",
      "//! - before-main stdio file descriptors are not guaranteed to be open on unix platforms\n",
      "//!\n",
      "//!\n",
      "//! [I/O]: io\n",
      "//! [`MIN`]: i32::MIN\n",
      "//! [`MAX`]: i32::MAX\n",
      "//! [page for the module `std::i32`]: crate::i32\n",
      "//! [TCP]: net::TcpStream\n",
      "//! [The Rust Prelude]: prelude\n",
      "//! [UDP]: net::UdpSocket\n",
      "//! [`Arc`]: sync::Arc\n",
      "//! [owned slice]: boxed\n",
      "//! [`Cell`]: cell::Cell\n",
      "//! [`FromStr`]: str::FromStr\n",
      "//! [`HashMap<K, V>`]: collections::HashMap\n",
      "//! [`Mutex`]: sync::Mutex\n",
      "//! [`Option<T>`]: option::Option\n",
      "//! [`Rc`]: rc::Rc\n",
      "//! [`RefCell`]: cell::RefCell\n",
      "//! [`Result<T, E>`]: result::Result\n",
      "//! [`Vec<T>`]: vec::Vec\n",
      "//! [`atomic`]: sync::atomic\n",
      "//! [`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n",
      "//! [`str`]: prim@str\n",
      "//! [`mpsc`]: sync::mpsc\n",
      "//! [`std::cmp`]: cmp\n",
      "//! [`std::slice`]: mod@slice\n",
      "//! [`use std::env`]: env/index.html\n",
      "//! [`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n",
      "//! [crates.io]: https://crates.io\n",
      "//! [deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n",
      "//! [files]: fs::File\n",
      "//! [multithreading]: thread\n",
      "//! [other]: #what-is-in-the-standard-library-documentation\n",
      "//! [primitive types]: ../book/ch03-02-data-types.html\n",
      "//! [rust-discord]: https://discord.gg/rust-lang\n",
      "//! [array]: prim@array\n",
      "//! [slice]: prim@slice\n",
      "// To run std tests without x.py without ending up with two copies of std, Miri needs to be\n",
      "// able to \"empty\" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.\n",
      "// rustc itself never sets the feature, so this line has no effect there.\n",
      "#![cfg(any(not(feature = \"miri-test-libstd\"), test, doctest))]\n",
      "// miri-test-libstd also prefers to make std use the sysroot versions of the dependencies.\n",
      "#![cfg_attr(feature = \"miri-test-libstd\", feature(rustc_private))]\n",
      "//\n",
      "#![cfg_attr(not(feature = \"restricted-std\"), stable(feature = \"rust1\", since = \"1.0.0\"))]\n",
      "#![cfg_attr(feature = \"restricted-std\", unstable(feature = \"restricted_std\", issue = \"none\"))]\n",
      "#![doc(\n",
      "    html_playground_url = \"https://play.rust-lang.org/\",\n",
      "    issue_tracker_base_url = \"https://github.com/rust-lang/rust/issues/\",\n",
      "    test(no_crate_inject, attr(deny(warnings))),\n",
      "    test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))\n",
      ")]\n",
      "#![cfg_attr(not(bootstrap), doc(rust_logo))]\n",
      "#![doc(cfg_hide(\n",
      "    not(test),\n",
      "    not(any(test, bootstrap)),\n",
      "    no_global_oom_handling,\n",
      "    not(no_global_oom_handling)\n",
      "))]\n",
      "// Don't link to std. We are std.\n",
      "#![no_std]\n",
      "// Tell the compiler to link to either panic_abort or panic_unwind\n",
      "#![needs_panic_runtime]\n",
      "//\n",
      "// Lints:\n",
      "#![warn(deprecated_in_future)]\n",
      "#![warn(missing_docs)]\n",
      "#![warn(missing_debug_implementations)]\n",
      "#![allow(explicit_outlives_requirements)]\n",
      "#![allow(unused_lifetimes)]\n",
      "#![allow(internal_features)]\n",
      "#![deny(rustc::existing_doc_keyword)]\n",
      "#![deny(fuzzy_provenance_casts)]\n",
      "#![allow(rustdoc::redundant_explicit_links)]\n",
      "// Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`\n",
      "#![deny(ffi_unwind_calls)]\n",
      "// std may use features in a platform-specific way\n",
      "#![allow(unused_features)]\n",
      "//\n",
      "// Features:\n",
      "#![cfg_attr(test, feature(internal_output_capture, print_internals, update_panic_count, rt))]\n",
      "#![cfg_attr(\n",
      "    all(target_vendor = \"fortanix\", target_env = \"sgx\"),\n",
      "    feature(slice_index_methods, coerce_unsized, sgx_platform)\n",
      ")]\n",
      "#![cfg_attr(any(windows, target_os = \"uefi\"), feature(round_char_boundary))]\n",
      "#![cfg_attr(target_os = \"xous\", feature(slice_ptr_len))]\n",
      "//\n",
      "// Language features:\n",
      "// tidy-alphabetical-start\n",
      "#![feature(alloc_error_handler)]\n",
      "#![feature(allocator_internals)]\n",
      "#![feature(allow_internal_unsafe)]\n",
      "#![feature(allow_internal_unstable)]\n",
      "#![feature(c_unwind)]\n",
      "#![feature(cfg_target_thread_local)]\n",
      "#![feature(cfi_encoding)]\n",
      "#![feature(concat_idents)]\n",
      "#![feature(const_mut_refs)]\n",
      "#![feature(const_trait_impl)]\n",
      "#![feature(decl_macro)]\n",
      "#![feature(deprecated_suggestion)]\n",
      "#![feature(doc_cfg)]\n",
      "#![feature(doc_cfg_hide)]\n",
      "#![feature(doc_masked)]\n",
      "#![feature(doc_notable_trait)]\n",
      "#![feature(dropck_eyepatch)]\n",
      "#![feature(exhaustive_patterns)]\n",
      "#![feature(if_let_guard)]\n",
      "#![feature(intra_doc_pointers)]\n",
      "#![feature(lang_items)]\n",
      "#![feature(let_chains)]\n",
      "#![feature(link_cfg)]\n",
      "#![feature(linkage)]\n",
      "#![feature(min_specialization)]\n",
      "#![feature(must_not_suspend)]\n",
      "#![feature(needs_panic_runtime)]\n",
      "#![feature(negative_impls)]\n",
      "#![feature(never_type)]\n",
      "#![feature(no_sanitize)]\n",
      "#![feature(platform_intrinsics)]\n",
      "#![feature(prelude_import)]\n",
      "#![feature(rustc_attrs)]\n",
      "#![feature(rustdoc_internals)]\n",
      "#![feature(staged_api)]\n",
      "#![feature(thread_local)]\n",
      "#![feature(try_blocks)]\n",
      "#![feature(type_alias_impl_trait)]\n",
      "#![feature(utf8_chunks)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "// Library features (core):\n",
      "// tidy-alphabetical-start\n",
      "#![feature(char_internals)]\n",
      "#![feature(core_intrinsics)]\n",
      "#![feature(core_io_borrowed_buf)]\n",
      "#![feature(duration_constants)]\n",
      "#![feature(error_generic_member_access)]\n",
      "#![feature(error_in_core)]\n",
      "#![feature(error_iter)]\n",
      "#![feature(exact_size_is_empty)]\n",
      "#![feature(exclusive_wrapper)]\n",
      "#![feature(extend_one)]\n",
      "#![feature(float_gamma)]\n",
      "#![feature(float_minimum_maximum)]\n",
      "#![feature(float_next_up_down)]\n",
      "#![feature(hasher_prefixfree_extras)]\n",
      "#![feature(hashmap_internals)]\n",
      "#![feature(ip)]\n",
      "#![feature(ip_in_core)]\n",
      "#![feature(maybe_uninit_slice)]\n",
      "#![feature(maybe_uninit_uninit_array)]\n",
      "#![feature(maybe_uninit_write_slice)]\n",
      "#![feature(offset_of)]\n",
      "#![feature(panic_can_unwind)]\n",
      "#![feature(panic_info_message)]\n",
      "#![feature(panic_internals)]\n",
      "#![feature(pointer_is_aligned)]\n",
      "#![feature(portable_simd)]\n",
      "#![feature(prelude_2024)]\n",
      "#![feature(ptr_as_uninit)]\n",
      "#![feature(raw_os_nonzero)]\n",
      "#![feature(round_ties_even)]\n",
      "#![feature(slice_internals)]\n",
      "#![feature(slice_ptr_get)]\n",
      "#![feature(std_internals)]\n",
      "#![feature(str_internals)]\n",
      "#![feature(strict_provenance)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "// Library features (alloc):\n",
      "// tidy-alphabetical-start\n",
      "#![feature(alloc_layout_extra)]\n",
      "#![feature(allocator_api)]\n",
      "#![feature(get_mut_unchecked)]\n",
      "#![feature(map_try_insert)]\n",
      "#![feature(new_uninit)]\n",
      "#![feature(slice_concat_trait)]\n",
      "#![feature(thin_box)]\n",
      "#![feature(try_reserve_kind)]\n",
      "#![feature(vec_into_raw_parts)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "// Library features (unwind):\n",
      "// tidy-alphabetical-start\n",
      "#![feature(panic_unwind)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "// Only for re-exporting:\n",
      "// tidy-alphabetical-start\n",
      "#![feature(assert_matches)]\n",
      "#![feature(async_iterator)]\n",
      "#![feature(c_variadic)]\n",
      "#![feature(cfg_accessible)]\n",
      "#![feature(cfg_eval)]\n",
      "#![feature(concat_bytes)]\n",
      "#![feature(const_format_args)]\n",
      "#![feature(core_panic)]\n",
      "#![feature(custom_test_frameworks)]\n",
      "#![feature(edition_panic)]\n",
      "#![feature(format_args_nl)]\n",
      "#![feature(get_many_mut)]\n",
      "#![feature(lazy_cell)]\n",
      "#![feature(log_syntax)]\n",
      "#![feature(stdsimd)]\n",
      "#![feature(test)]\n",
      "#![feature(trace_macros)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "// Only used in tests/benchmarks:\n",
      "//\n",
      "// Only for const-ness:\n",
      "// tidy-alphabetical-start\n",
      "#![feature(const_collections_with_hasher)]\n",
      "#![feature(const_hash)]\n",
      "#![feature(const_io_structs)]\n",
      "#![feature(const_ip)]\n",
      "#![feature(const_ipv4)]\n",
      "#![feature(const_ipv6)]\n",
      "#![feature(const_maybe_uninit_uninit_array)]\n",
      "#![feature(const_waker)]\n",
      "#![feature(thread_local_internals)]\n",
      "// tidy-alphabetical-end\n",
      "//\n",
      "#![default_lib_allocator]\n",
      "\n",
      "// Explicitly import the prelude. The compiler uses this same unstable attribute\n",
      "// to import the prelude implicitly when building crates that depend on std.\n",
      "#[prelude_import]\n",
      "#[allow(unused)]\n",
      "use prelude::rust_2021::*;\n",
      "\n",
      "// Access to Bencher, etc.\n",
      "#[cfg(test)]\n",
      "extern crate test;\n",
      "\n",
      "#[allow(unused_imports)] // macros from `alloc` are not used on all platforms\n",
      "#[macro_use]\n",
      "extern crate alloc as alloc_crate;\n",
      "#[doc(masked)]\n",
      "#[allow(unused_extern_crates)]\n",
      "extern crate libc;\n",
      "\n",
      "// We always need an unwinder currently for backtraces\n",
      "#[doc(masked)]\n",
      "#[allow(unused_extern_crates)]\n",
      "extern crate unwind;\n",
      "\n",
      "// FIXME: #94122 this extern crate definition only exist here to stop\n",
      "// miniz_oxide docs leaking into std docs. Find better way to do it.\n",
      "// Remove exclusion from tidy platform check when this removed.\n",
      "#[doc(masked)]\n",
      "#[allow(unused_extern_crates)]\n",
      "#[cfg(all(\n",
      "    not(all(windows, target_env = \"msvc\", not(target_vendor = \"uwp\"))),\n",
      "    feature = \"miniz_oxide\"\n",
      "))]\n",
      "extern crate miniz_oxide;\n",
      "\n",
      "// During testing, this crate is not actually the \"real\" std library, but rather\n",
      "// it links to the real std library, which was compiled from this same source\n",
      "// code. So any lang items std defines are conditionally excluded (or else they\n",
      "// would generate duplicate lang item errors), and any globals it defines are\n",
      "// _not_ the globals used by \"real\" std. So this import, defined only during\n",
      "// testing gives test-std access to real-std lang items and globals. See #2912\n",
      "#[cfg(test)]\n",
      "extern crate std as realstd;\n",
      "\n",
      "// The standard macros that are not built-in to the compiler.\n",
      "#[macro_use]\n",
      "mod macros;\n",
      "\n",
      "// The runtime entry point and a few unstable public functions used by the\n",
      "// compiler\n",
      "#[macro_use]\n",
      "pub mod rt;\n",
      "\n",
      "// The Rust prelude\n",
      "pub mod prelude;\n",
      "\n",
      "// Public module declarations and re-exports\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::borrow;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::boxed;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::fmt;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::format;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::rc;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::slice;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::str;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::string;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use alloc_crate::vec;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::any;\n",
      "#[stable(feature = \"core_array\", since = \"1.36.0\")]\n",
      "pub use core::array;\n",
      "#[unstable(feature = \"async_iterator\", issue = \"79024\")]\n",
      "pub use core::async_iter;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::cell;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::char;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::clone;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::cmp;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::convert;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::default;\n",
      "#[stable(feature = \"futures_api\", since = \"1.36.0\")]\n",
      "pub use core::future;\n",
      "#[stable(feature = \"core_hint\", since = \"1.27.0\")]\n",
      "pub use core::hint;\n",
      "#[stable(feature = \"i128\", since = \"1.26.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::i128;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::i16;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::i32;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::i64;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::i8;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::intrinsics;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::isize;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::iter;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::marker;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::mem;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::ops;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::option;\n",
      "#[stable(feature = \"pin\", since = \"1.33.0\")]\n",
      "pub use core::pin;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::ptr;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "pub use core::result;\n",
      "#[stable(feature = \"i128\", since = \"1.26.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::u128;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::u16;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::u32;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::u64;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::u8;\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::usize;\n",
      "\n",
      "pub mod f32;\n",
      "pub mod f64;\n",
      "\n",
      "#[macro_use]\n",
      "pub mod thread;\n",
      "pub mod ascii;\n",
      "pub mod backtrace;\n",
      "pub mod collections;\n",
      "pub mod env;\n",
      "pub mod error;\n",
      "pub mod ffi;\n",
      "pub mod fs;\n",
      "pub mod hash;\n",
      "pub mod io;\n",
      "pub mod net;\n",
      "pub mod num;\n",
      "pub mod os;\n",
      "pub mod panic;\n",
      "pub mod path;\n",
      "pub mod process;\n",
      "pub mod sync;\n",
      "pub mod time;\n",
      "\n",
      "// Pull in `std_float` crate  into std. The contents of\n",
      "// `std_float` are in a different repository: rust-lang/portable-simd.\n",
      "#[path = \"../../portable-simd/crates/std_float/src/lib.rs\"]\n",
      "#[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn)]\n",
      "#[allow(rustdoc::bare_urls)]\n",
      "#[unstable(feature = \"portable_simd\", issue = \"86656\")]\n",
      "mod std_float;\n",
      "\n",
      "#[doc = include_str!(\"../../portable-simd/crates/core_simd/src/core_simd_docs.md\")]\n",
      "#[unstable(feature = \"portable_simd\", issue = \"86656\")]\n",
      "pub mod simd {\n",
      "    #[doc(inline)]\n",
      "    pub use crate::std_float::StdFloat;\n",
      "    #[doc(inline)]\n",
      "    pub use core::simd::*;\n",
      "}\n",
      "\n",
      "#[stable(feature = \"futures_api\", since = \"1.36.0\")]\n",
      "pub mod task {\n",
      "    //! Types and Traits for working with asynchronous tasks.\n",
      "\n",
      "    #[doc(inline)]\n",
      "    #[stable(feature = \"futures_api\", since = \"1.36.0\")]\n",
      "    pub use core::task::*;\n",
      "\n",
      "    #[doc(inline)]\n",
      "    #[stable(feature = \"wake_trait\", since = \"1.51.0\")]\n",
      "    pub use alloc::task::*;\n",
      "}\n",
      "\n",
      "#[doc = include_str!(\"../../stdarch/crates/core_arch/src/core_arch_docs.md\")]\n",
      "#[stable(feature = \"simd_arch\", since = \"1.27.0\")]\n",
      "pub mod arch {\n",
      "    #[stable(feature = \"simd_arch\", since = \"1.27.0\")]\n",
      "    // The `no_inline`-attribute is required to make the documentation of all\n",
      "    // targets available.\n",
      "    // See https://github.com/rust-lang/rust/pull/57808#issuecomment-457390549 for\n",
      "    // more information.\n",
      "    #[doc(no_inline)] // Note (#82861): required for correct documentation\n",
      "    pub use core::arch::*;\n",
      "\n",
      "    #[stable(feature = \"simd_aarch64\", since = \"1.60.0\")]\n",
      "    pub use std_detect::is_aarch64_feature_detected;\n",
      "    #[stable(feature = \"simd_x86\", since = \"1.27.0\")]\n",
      "    pub use std_detect::is_x86_feature_detected;\n",
      "    #[unstable(feature = \"stdsimd\", issue = \"48556\")]\n",
      "    pub use std_detect::{\n",
      "        is_arm_feature_detected, is_mips64_feature_detected, is_mips_feature_detected,\n",
      "        is_powerpc64_feature_detected, is_powerpc_feature_detected, is_riscv_feature_detected,\n",
      "    };\n",
      "}\n",
      "\n",
      "// This was stabilized in the crate root so we have to keep it there.\n",
      "#[stable(feature = \"simd_x86\", since = \"1.27.0\")]\n",
      "pub use std_detect::is_x86_feature_detected;\n",
      "\n",
      "// Platform-abstraction modules\n",
      "mod sys;\n",
      "mod sys_common;\n",
      "\n",
      "pub mod alloc;\n",
      "\n",
      "// Private support modules\n",
      "mod panicking;\n",
      "\n",
      "#[path = \"../../backtrace/src/lib.rs\"]\n",
      "#[allow(dead_code, unused_attributes, fuzzy_provenance_casts)]\n",
      "mod backtrace_rs;\n",
      "\n",
      "// Re-export macros defined in core.\n",
      "#[stable(feature = \"rust1\", since = \"1.0.0\")]\n",
      "#[allow(deprecated, deprecated_in_future)]\n",
      "pub use core::{\n",
      "    assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, matches, todo, r#try,\n",
      "    unimplemented, unreachable, write, writeln,\n",
      "};\n",
      "\n",
      "// Re-export built-in macros defined through core.\n",
      "#[stable(feature = \"builtin_macro_prelude\", since = \"1.38.0\")]\n",
      "#[allow(deprecated)]\n",
      "pub use core::{\n",
      "    assert, assert_matches, cfg, column, compile_error, concat, concat_idents, const_format_args,\n",
      "    env, file, format_args, format_args_nl, include, include_bytes, include_str, line, log_syntax,\n",
      "    module_path, option_env, stringify, trace_macros,\n",
      "};\n",
      "\n",
      "#[unstable(\n",
      "    feature = \"concat_bytes\",\n",
      "    issue = \"87555\",\n",
      "    reason = \"`concat_bytes` is not stable enough for use and is subject to change\"\n",
      ")]\n",
      "pub use core::concat_bytes;\n",
      "\n",
      "#[unstable(feature = \"cfg_match\", issue = \"115585\")]\n",
      "pub use core::cfg_match;\n",
      "\n",
      "#[stable(feature = \"core_primitive\", since = \"1.43.0\")]\n",
      "pub use core::primitive;\n",
      "\n",
      "// Include a number of private modules that exist solely to provide\n",
      "// the rustdoc documentation for primitive types. Using `include!`\n",
      "// because rustdoc only looks for these modules at the crate level.\n",
      "include!(\"../../core/src/primitive_docs.rs\");\n",
      "\n",
      "// Include a number of private modules that exist solely to provide\n",
      "// the rustdoc documentation for the existing keywords. Using `include!`\n",
      "// because rustdoc only looks for these modules at the crate level.\n",
      "include!(\"keyword_docs.rs\");\n",
      "\n",
      "// This is required to avoid an unstable error when `restricted-std` is not\n",
      "// enabled. The use of #![feature(restricted_std)] in rustc-std-workspace-std\n",
      "// is unconditional, so the unstable feature needs to be defined somewhere.\n",
      "#[unstable(feature = \"restricted_std\", issue = \"none\")]\n",
      "mod __restricted_std_workaround {}\n",
      "\n",
      "mod sealed {\n",
      "    /// This trait being unreachable from outside the crate\n",
      "    /// prevents outside implementations of our extension traits.\n",
      "    /// This allows adding more trait methods in the future.\n",
      "    #[unstable(feature = \"sealed\", issue = \"none\")]\n",
      "    pub trait Sealed {}\n",
      "}\n",
      "\n",
      "#[cfg(test)]\n",
      "#[allow(dead_code)] // Not used in all configurations.\n",
      "pub(crate) mod test_helpers {\n",
      "    /// Test-only replacement for `rand::thread_rng()`, which is unusable for\n",
      "    /// us, as we want to allow running stdlib tests on tier-3 targets which may\n",
      "    /// not have `getrandom` support.\n",
      "    ///\n",
      "    /// Does a bit of a song and dance to ensure that the seed is different on\n",
      "    /// each call (as some tests sadly rely on this), but doesn't try that hard.\n",
      "    ///\n",
      "    /// This is duplicated in the `core`, `alloc` test suites (as well as\n",
      "    /// `std`'s integration tests), but figuring out a mechanism to share these\n",
      "    /// seems far more painful than copy-pasting a 7 line function a couple\n",
      "    /// times, given that even under a perma-unstable feature, I don't think we\n",
      "    /// want to expose types from `rand` from `std`.\n",
      "    #[track_caller]\n",
      "    pub(crate) fn test_rng() -> rand_xorshift::XorShiftRng {\n",
      "        use core::hash::{BuildHasher, Hash, Hasher};\n",
      "        let mut hasher = crate::hash::RandomState::new().build_hasher();\n",
      "        core::panic::Location::caller().hash(&mut hasher);\n",
      "        let hc64 = hasher.finish();\n",
      "        let seed_vec = hc64.to_le_bytes().into_iter().chain(0u8..8).collect::<Vec<u8>>();\n",
      "        let seed: [u8; 16] = seed_vec.as_slice().try_into().unwrap();\n",
      "        rand::SeedableRng::from_seed(seed)\n",
      "    }\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(result[0][\"absolutePath\"]) as fp:\n",
    "    lines = fp.readlines()\n",
    "    start = result[0][\"range\"][\"start\"][\"line\"]\n",
    "    end = result[0][\"range\"][\"end\"][\"line\"]\n",
    "    target_lines = lines[start: end  + 1]\n",
    "    content = \"\".join(target_lines)\n",
    "    \n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with lsp.start_server():\n",
    "    result2 = lsp.request_completions(...)\n",
    "    result3 = lsp.request_references(...)\n",
    "    result4 = lsp.request_document_symbols(...)\n",
    "    result5 = lsp.request_hover(...)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lsp_client",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}