22 files changed, 681 insertions, 66 deletions

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 02a3b6228..00f299ff1 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -20,25 +20,14 @@ jobs:
     name: Audit Rust vulnerabilities
     runs-on: ubuntu-latest
     steps:
-    - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        profile: minimal
-        override: true
-
     - name: Checkout repository
       uses: actions/checkout@v2
 
-    - run: sudo chown -R $(whoami):$(id -ng) ~/.cargo/
-
-    - name: Cache cargo
-      uses: actions/cache@v1
+    - uses: actions-rs/[email protected]
       with:
-        path: ~/.cargo/
-        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        crate: cargo-audit
+        use-tool-cache: true
 
-    - run: cargo install cargo-audit
     - run: cargo audit
 
   rust:
diff --git a/Cargo.lock b/Cargo.lock
index 34c535162..975c1aef8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,6 +425,17 @@ dependencies = [
 ]
 
 [[package]]
+name = "goblin"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd5e3132801a1ac34ac53b97acde50c4685414dd2f291b9ea52afa6f07468c8"
+dependencies = [
+ "log",
+ "plain",
+ "scroll",
+]
+
+[[package]]
 name = "heck"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -587,6 +598,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dea0c0405123bba743ee3f91f49b1c7cfb684eef0da0a50110f758ccf24cdff0"
 
 [[package]]
+name = "libloading"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c979a19ffb457f0273965c333053f3d586bf759bf7b683fbebc37f9a9ebedc4"
+dependencies = [
+ "winapi 0.3.8",
+]
+
+[[package]]
 name = "linked-hash-map"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -826,6 +846,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad1f1b834a05d42dae330066e9699a173b28185b3bdc3dbf14ca239585de8cc"
 
 [[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
 name = "ppv-lite86"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1082,10 +1108,13 @@ version = "0.1.0"
 dependencies = [
  "cargo_metadata",
  "difference",
+ "goblin",
+ "libloading",
  "ra_mbe",
  "ra_proc_macro",
  "ra_tt",
  "serde_derive",
+ "test_utils",
 ]
 
 [[package]]
@@ -1404,6 +1433,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
+name = "scroll"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb2332cb595d33f7edd5700f4cbf94892e680c7f0ae56adab58a35190b66cb1"
+dependencies = [
+ "scroll_derive",
+]
+
+[[package]]
+name = "scroll_derive"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8584eea9b9ff42825b46faf46a8c24d2cff13ec152fa2a50df788b87c07ee28"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "semver"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 5f9d53ecb..e09996c6f 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -236,7 +236,7 @@ impl Index<PatId> for Body {
 
 impl BodySourceMap {
     pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
-        self.expr_map_back[expr]
+        self.expr_map_back[expr].clone()
     }
 
     pub fn node_expr(&self, node: InFile<&ast::Expr>) -> Option<ExprId> {
@@ -255,7 +255,7 @@ impl BodySourceMap {
     }
 
     pub fn pat_syntax(&self, pat: PatId) -> Result<PatSource, SyntheticSyntax> {
-        self.pat_map_back[pat]
+        self.pat_map_back[pat].clone()
     }
 
     pub fn node_pat(&self, node: InFile<&ast::Pat>) -> Option<PatId> {
@@ -264,6 +264,6 @@ impl BodySourceMap {
     }
 
     pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {
-        self.field_map[&(expr, field)]
+        self.field_map[&(expr, field)].clone()
     }
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 0855c1d3a..9d6ee095e 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -106,7 +106,7 @@ impl ExprCollector<'_> {
     fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
         let ptr = Either::Left(ptr);
         let src = self.expander.to_source(ptr);
-        let id = self.make_expr(expr, Ok(src));
+        let id = self.make_expr(expr, Ok(src.clone()));
         self.source_map.expr_map.insert(src, id);
         id
     }
@@ -118,7 +118,7 @@ impl ExprCollector<'_> {
     fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId {
         let ptr = Either::Right(ptr);
         let src = self.expander.to_source(ptr);
-        let id = self.make_expr(expr, Ok(src));
+        let id = self.make_expr(expr, Ok(src.clone()));
         self.source_map.expr_map.insert(src, id);
         id
     }
@@ -136,7 +136,7 @@ impl ExprCollector<'_> {
 
     fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
         let src = self.expander.to_source(ptr);
-        let id = self.make_pat(pat, Ok(src));
+        let id = self.make_pat(pat, Ok(src.clone()));
         self.source_map.pat_map.insert(src, id);
         id
     }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 095498429..cfa0f2f76 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -20,7 +20,7 @@ impl Diagnostic for UnresolvedModule {
         "unresolved module".to_string()
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.decl.into() }
+        InFile { file_id: self.file, value: self.decl.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs
index 5643ecdce..a3ca302c2 100644
--- a/crates/ra_hir_expand/src/ast_id_map.rs
+++ b/crates/ra_hir_expand/src/ast_id_map.rs
@@ -90,7 +90,7 @@ impl AstIdMap {
     }
 
     pub(crate) fn get<N: AstNode>(&self, id: FileAstId<N>) -> AstPtr<N> {
-        self.arena[id.raw].cast::<N>().unwrap()
+        self.arena[id.raw].clone().cast::<N>().unwrap()
     }
 
     fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId {
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index 3f18acf1d..927896d6f 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -21,7 +21,7 @@ impl Diagnostic for NoSuchField {
     }
 
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.field.into() }
+        InFile { file_id: self.file, value: self.field.clone().into() }
     }
 
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
@@ -45,7 +45,7 @@ impl Diagnostic for MissingFields {
         buf
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.field_list.into() }
+        InFile { file_id: self.file, value: self.field_list.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
@@ -78,7 +78,7 @@ impl Diagnostic for MissingPatFields {
         buf
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.field_list.into() }
+        InFile { file_id: self.file, value: self.field_list.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
@@ -97,7 +97,7 @@ impl Diagnostic for MissingMatchArms {
         String::from("Missing match arm")
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.match_expr.into() }
+        InFile { file_id: self.file, value: self.match_expr.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
@@ -115,7 +115,7 @@ impl Diagnostic for MissingOkInTailExpr {
         "wrap return expression in Ok".to_string()
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.expr.into() }
+        InFile { file_id: self.file, value: self.expr.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
index a7c8d74ab..827b687de 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/expr.rs
@@ -89,7 +89,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         let (_, source_map) = db.body_with_source_map(self.func.into());
 
         if let Ok(source_ptr) = source_map.expr_syntax(id) {
-            if let Some(expr) = source_ptr.value.left() {
+            if let Some(expr) = source_ptr.value.as_ref().left() {
                 let root = source_ptr.file_syntax(db.upcast());
                 if let ast::Expr::RecordLit(record_lit) = expr.to_node(&root) {
                     if let Some(field_list) = record_lit.record_field_list() {
@@ -120,7 +120,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         let (_, source_map) = db.body_with_source_map(self.func.into());
 
         if let Ok(source_ptr) = source_map.pat_syntax(id) {
-            if let Some(expr) = source_ptr.value.left() {
+            if let Some(expr) = source_ptr.value.as_ref().left() {
                 let root = source_ptr.file_syntax(db.upcast());
                 if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) {
                     if let Some(field_list) = record_pat.record_field_pat_list() {
@@ -205,7 +205,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         }
 
         if let Ok(source_ptr) = source_map.expr_syntax(id) {
-            if let Some(expr) = source_ptr.value.left() {
+            if let Some(expr) = source_ptr.value.as_ref().left() {
                 let root = source_ptr.file_syntax(db.upcast());
                 if let ast::Expr::MatchExpr(match_expr) = expr.to_node(&root) {
                     if let (Some(match_expr), Some(arms)) =
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 47a7b9ffd..54e31602f 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -87,7 +87,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                 }
                 Err(SyntheticSyntax) => continue,
             };
-            types.push((syntax_ptr, ty));
+            types.push((syntax_ptr.clone(), ty));
             if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr) {
                 mismatches.push((syntax_ptr, mismatch));
             }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index da9f55a69..45b9f7802 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -235,7 +235,10 @@ fn should_show_param_hint(
     param_name: &str,
     argument: &ast::Expr,
 ) -> bool {
-    if param_name.is_empty() || is_argument_similar_to_param(argument, param_name) {
+    if param_name.is_empty()
+        || is_argument_similar_to_param(argument, param_name)
+        || Some(param_name) == fn_signature.name.as_ref().map(String::as_str)
+    {
         return false;
     }
 
@@ -247,10 +250,7 @@ fn should_show_param_hint(
 
     // avoid displaying hints for common functions like map, filter, etc.
     // or other obvious words used in std
-    if parameters_len == 1 && is_obvious_param(param_name) {
-        return false;
-    }
-    true
+    parameters_len != 1 || !is_obvious_param(param_name)
 }
 
 fn is_argument_similar_to_param(argument: &ast::Expr, param_name: &str) -> bool {
@@ -1086,6 +1086,8 @@ impl Test {
     }
 
     fn no_hints_expected(&self, _: i32, test_var: i32) {}
+
+    fn frob(&self, frob: bool) {}
 }
 
 struct Param {}
@@ -1093,6 +1095,8 @@ struct Param {}
 fn different_order(param: &Param) {}
 fn different_order_mut(param: &mut Param) {}
 
+fn twiddle(twiddle: bool) {}
+
 fn main() {
     let container: TestVarContainer = TestVarContainer { test_var: 42 };
     let test: Test = Test {};
@@ -1105,6 +1109,9 @@ fn main() {
     let test_var: i32 = 55;
     test_processed.no_hints_expected(22, test_var);
     test_processed.no_hints_expected(33, container.test_var);
+    test_processed.frob(false);
+
+    twiddle(true);
 
     let param_begin: Param = Param {};
     different_order(&param_begin);
diff --git a/crates/ra_proc_macro_srv/Cargo.toml b/crates/ra_proc_macro_srv/Cargo.toml
index f08de5fc7..1e0f50339 100644
--- a/crates/ra_proc_macro_srv/Cargo.toml
+++ b/crates/ra_proc_macro_srv/Cargo.toml
@@ -12,9 +12,12 @@ doctest = false
 ra_tt = { path = "../ra_tt" }
 ra_mbe = { path = "../ra_mbe" }
 ra_proc_macro = { path = "../ra_proc_macro" }
+goblin = "0.2.1"
+libloading = "0.6.0"
+test_utils = { path = "../test_utils" }
 
 [dev-dependencies]
 cargo_metadata = "0.9.1"
 difference = "2.0.0"
 # used as proc macro test target
-serde_derive = "=1.0.104"
\ No newline at end of file
+serde_derive = "=1.0.104"
diff --git a/crates/ra_proc_macro_srv/src/dylib.rs b/crates/ra_proc_macro_srv/src/dylib.rs
new file mode 100644
index 000000000..ec63d587b
--- /dev/null
+++ b/crates/ra_proc_macro_srv/src/dylib.rs
@@ -0,0 +1,211 @@
+//! Handles dynamic library loading for proc macro
+
+use crate::{proc_macro::bridge, rustc_server::TokenStream};
+use std::path::Path;
+
+use goblin::{mach::Mach, Object};
+use libloading::Library;
+use ra_proc_macro::ProcMacroKind;
+
+use std::io::Error as IoError;
+use std::io::ErrorKind as IoErrorKind;
+
+const NEW_REGISTRAR_SYMBOL: &str = "_rustc_proc_macro_decls_";
+
+fn invalid_data_err(e: impl Into<Box<dyn std::error::Error + Send + Sync>>) -> IoError {
+    IoError::new(IoErrorKind::InvalidData, e)
+}
+
+fn get_symbols_from_lib(file: &Path) -> Result<Vec<String>, IoError> {
+    let buffer = std::fs::read(file)?;
+    let object = Object::parse(&buffer).map_err(invalid_data_err)?;
+
+    match object {
+        Object::Elf(elf) => {
+            let symbols = elf.dynstrtab.to_vec().map_err(invalid_data_err)?;
+            let names = symbols.iter().map(|s| s.to_string()).collect();
+            Ok(names)
+        }
+        Object::PE(pe) => {
+            let symbol_names =
+                pe.exports.iter().flat_map(|s| s.name).map(|n| n.to_string()).collect();
+            Ok(symbol_names)
+        }
+        Object::Mach(mach) => match mach {
+            Mach::Binary(binary) => {
+                let exports = binary.exports().map_err(invalid_data_err)?;
+                let names = exports
+                    .into_iter()
+                    .map(|s| {
+                        // In macos doc:
+                        // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
+                        // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
+                        // prepended with an underscore.
+                        if s.name.starts_with("_") {
+                            s.name[1..].to_string()
+                        } else {
+                            s.name
+                        }
+                    })
+                    .collect();
+                Ok(names)
+            }
+            Mach::Fat(_) => Ok(vec![]),
+        },
+        Object::Archive(_) | Object::Unknown(_) => Ok(vec![]),
+    }
+}
+
+fn is_derive_registrar_symbol(symbol: &str) -> bool {
+    symbol.contains(NEW_REGISTRAR_SYMBOL)
+}
+
+fn find_registrar_symbol(file: &Path) -> Result<Option<String>, IoError> {
+    let symbols = get_symbols_from_lib(file)?;
+    Ok(symbols.into_iter().find(|s| is_derive_registrar_symbol(s)))
+}
+
+/// Loads dynamic library in platform dependent manner.
+///
+/// For unix, you have to use RTLD_DEEPBIND flag to escape problems described
+/// [here](https://github.com/fedochet/rust-proc-macro-panic-inside-panic-expample)
+/// and [here](https://github.com/rust-lang/rust/issues/60593).
+///
+/// Usage of RTLD_DEEPBIND
+/// [here](https://github.com/fedochet/rust-proc-macro-panic-inside-panic-expample/issues/1)
+///
+/// It seems that on Windows that behaviour is default, so we do nothing in that case.
+#[cfg(windows)]
+fn load_library(file: &Path) -> Result<Library, libloading::Error> {
+    Library::new(file)
+}
+
+#[cfg(unix)]
+fn load_library(file: &Path) -> Result<Library, libloading::Error> {
+    use libloading::os::unix::Library as UnixLibrary;
+    use std::os::raw::c_int;
+
+    const RTLD_NOW: c_int = 0x00002;
+    const RTLD_DEEPBIND: c_int = 0x00008;
+
+    UnixLibrary::open(Some(file), RTLD_NOW | RTLD_DEEPBIND).map(|lib| lib.into())
+}
+
+struct ProcMacroLibraryLibloading {
+    // Hold the dylib to prevent it for unloadeding
+    _lib: Library,
+    exported_macros: Vec<bridge::client::ProcMacro>,
+}
+
+impl ProcMacroLibraryLibloading {
+    fn open(file: &Path) -> Result<Self, IoError> {
+        let symbol_name = find_registrar_symbol(file)?
+            .ok_or(invalid_data_err(format!("Cannot find registrar symbol in file {:?}", file)))?;
+
+        let lib = load_library(file).map_err(invalid_data_err)?;
+        let exported_macros = {
+            let macros: libloading::Symbol<&&[bridge::client::ProcMacro]> =
+                unsafe { lib.get(symbol_name.as_bytes()) }.map_err(invalid_data_err)?;
+            macros.to_vec()
+        };
+
+        Ok(ProcMacroLibraryLibloading { _lib: lib, exported_macros })
+    }
+}
+
+type ProcMacroLibraryImpl = ProcMacroLibraryLibloading;
+
+pub struct Expander {
+    libs: Vec<ProcMacroLibraryImpl>,
+}
+
+impl Expander {
+    pub fn new<P: AsRef<Path>>(lib: &P) -> Result<Expander, String> {
+        let mut libs = vec![];
+        /* Some libraries for dynamic loading require canonicalized path (even when it is
+        already absolute
+        */
+        let lib =
+            lib.as_ref().canonicalize().expect(&format!("Cannot canonicalize {:?}", lib.as_ref()));
+
+        let library = ProcMacroLibraryImpl::open(&lib).map_err(|e| e.to_string())?;
+        libs.push(library);
+
+        Ok(Expander { libs })
+    }
+
+    pub fn expand(
+        &self,
+        macro_name: &str,
+        macro_body: &ra_tt::Subtree,
+        attributes: Option<&ra_tt::Subtree>,
+    ) -> Result<ra_tt::Subtree, bridge::PanicMessage> {
+        let parsed_body = TokenStream::with_subtree(macro_body.clone());
+
+        let parsed_attributes = attributes
+            .map_or(crate::rustc_server::TokenStream::new(), |attr| {
+                TokenStream::with_subtree(attr.clone())
+            });
+
+        for lib in &self.libs {
+            for proc_macro in &lib.exported_macros {
+                match proc_macro {
+                    bridge::client::ProcMacro::CustomDerive { trait_name, client, .. }
+                        if *trait_name == macro_name =>
+                    {
+                        let res = client.run(
+                            &crate::proc_macro::bridge::server::SameThread,
+                            crate::rustc_server::Rustc::default(),
+                            parsed_body,
+                        );
+                        return res.map(|it| it.subtree);
+                    }
+                    bridge::client::ProcMacro::Bang { name, client } if *name == macro_name => {
+                        let res = client.run(
+                            &crate::proc_macro::bridge::server::SameThread,
+                            crate::rustc_server::Rustc::default(),
+                            parsed_body,
+                        );
+                        return res.map(|it| it.subtree);
+                    }
+                    bridge::client::ProcMacro::Attr { name, client } if *name == macro_name => {
+                        let res = client.run(
+                            &crate::proc_macro::bridge::server::SameThread,
+                            crate::rustc_server::Rustc::default(),
+                            parsed_attributes,
+                            parsed_body,
+                        );
+
+                        return res.map(|it| it.subtree);
+                    }
+                    _ => continue,
+                }
+            }
+        }
+
+        Err(bridge::PanicMessage::String("Nothing to expand".to_string()))
+    }
+
+    pub fn list_macros(&self) -> Result<Vec<(String, ProcMacroKind)>, bridge::PanicMessage> {
+        let mut result = vec![];
+
+        for lib in &self.libs {
+            for proc_macro in &lib.exported_macros {
+                let res = match proc_macro {
+                    bridge::client::ProcMacro::CustomDerive { trait_name, .. } => {
+                        (trait_name.to_string(), ProcMacroKind::CustomDerive)
+                    }
+                    bridge::client::ProcMacro::Bang { name, .. } => {
+                        (name.to_string(), ProcMacroKind::FuncLike)
+                    }
+                    bridge::client::ProcMacro::Attr { name, .. } => {
+                        (name.to_string(), ProcMacroKind::Attr)
+                    }
+                };
+                result.push(res);
+            }
+        }
+
+        Ok(result)
+    }
+}
diff --git a/crates/ra_proc_macro_srv/src/lib.rs b/crates/ra_proc_macro_srv/src/lib.rs
index f376df236..59716cbb3 100644
--- a/crates/ra_proc_macro_srv/src/lib.rs
+++ b/crates/ra_proc_macro_srv/src/lib.rs
@@ -17,13 +17,41 @@ mod proc_macro;
 #[doc(hidden)]
 mod rustc_server;
 
+mod dylib;
+
 use proc_macro::bridge::client::TokenStream;
 use ra_proc_macro::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask};
 
-pub fn expand_task(_task: &ExpansionTask) -> Result<ExpansionResult, String> {
-    unimplemented!()
+pub fn expand_task(task: &ExpansionTask) -> Result<ExpansionResult, String> {
+    let expander = dylib::Expander::new(&task.lib)
+        .expect(&format!("Cannot expand with provided libraries: ${:?}", &task.lib));
+
+    match expander.expand(&task.macro_name, &task.macro_body, task.attributes.as_ref()) {
+        Ok(expansion) => Ok(ExpansionResult { expansion }),
+        Err(msg) => {
+            let reason = format!(
+                "Cannot perform expansion for {}: error {:?}!",
+                &task.macro_name,
+                msg.as_str()
+            );
+            Err(reason)
+        }
+    }
 }
 
-pub fn list_macros(_task: &ListMacrosTask) -> Result<ListMacrosResult, String> {
-    unimplemented!()
+pub fn list_macros(task: &ListMacrosTask) -> Result<ListMacrosResult, String> {
+    let expander = dylib::Expander::new(&task.lib)
+        .expect(&format!("Cannot expand with provided libraries: ${:?}", &task.lib));
+
+    match expander.list_macros() {
+        Ok(macros) => Ok(ListMacrosResult { macros }),
+        Err(msg) => {
+            let reason =
+                format!("Cannot perform expansion for {:?}: error {:?}!", &task.lib, msg.as_str());
+            Err(reason)
+        }
+    }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ra_proc_macro_srv/src/rustc_server.rs b/crates/ra_proc_macro_srv/src/rustc_server.rs
index 92d1fd989..ec0d35692 100644
--- a/crates/ra_proc_macro_srv/src/rustc_server.rs
+++ b/crates/ra_proc_macro_srv/src/rustc_server.rs
@@ -34,6 +34,10 @@ impl TokenStream {
         TokenStream { subtree: Default::default() }
     }
 
+    pub fn with_subtree(subtree: tt::Subtree) -> Self {
+        TokenStream { subtree }
+    }
+
     pub fn is_empty(&self) -> bool {
         self.subtree.token_trees.is_empty()
     }
diff --git a/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
new file mode 100644
index 000000000..24507d98d
--- /dev/null
+++ b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
@@ -0,0 +1,188 @@
+SUBTREE $
+  PUNCH   # [alone] 4294967295
+  SUBTREE [] 4294967295
+    IDENT   allow 4294967295
+    SUBTREE () 4294967295
+      IDENT   non_upper_case_globals 4294967295
+      PUNCH   , [alone] 4294967295
+      IDENT   unused_attributes 4294967295
+      PUNCH   , [alone] 4294967295
+      IDENT   unused_qualifications 4294967295
+  IDENT   const 4294967295
+  IDENT   _IMPL_SERIALIZE_FOR_Foo 4294967295
+  PUNCH   : [alone] 4294967295
+  SUBTREE () 4294967295
+  PUNCH   = [alone] 4294967295
+  SUBTREE {} 4294967295
+    PUNCH   # [alone] 4294967295
+    SUBTREE [] 4294967295
+      IDENT   allow 4294967295
+      SUBTREE () 4294967295
+        IDENT   unknown_lints 4294967295
+    PUNCH   # [alone] 4294967295
+    SUBTREE [] 4294967295
+      IDENT   cfg_attr 4294967295
+      SUBTREE () 4294967295
+        IDENT   feature 4294967295
+        PUNCH   = [alone] 4294967295
+        SUBTREE $
+          LITERAL "cargo-clippy" 0
+        PUNCH   , [alone] 4294967295
+        IDENT   allow 4294967295
+        SUBTREE () 4294967295
+          IDENT   useless_attribute 4294967295
+    PUNCH   # [alone] 4294967295
+    SUBTREE [] 4294967295
+      IDENT   allow 4294967295
+      SUBTREE () 4294967295
+        IDENT   rust_2018_idioms 4294967295
+    IDENT   extern 4294967295
+    IDENT   crate 4294967295
+    IDENT   serde 4294967295
+    IDENT   as 4294967295
+    IDENT   _serde 4294967295
+    PUNCH   ; [alone] 4294967295
+    PUNCH   # [alone] 4294967295
+    SUBTREE [] 4294967295
+      IDENT   allow 4294967295
+      SUBTREE () 4294967295
+        IDENT   unused_macros 4294967295
+    IDENT   macro_rules 4294967295
+    PUNCH   ! [alone] 4294967295
+    IDENT   try 4294967295
+    SUBTREE {} 4294967295
+      SUBTREE () 4294967295
+        PUNCH   $ [alone] 4294967295
+        IDENT   __expr 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   expr 4294967295
+      PUNCH   = [joint] 4294967295
+      PUNCH   > [alone] 4294967295
+      SUBTREE {} 4294967295
+        IDENT   match 4294967295
+        PUNCH   $ [alone] 4294967295
+        IDENT   __expr 4294967295
+        SUBTREE {} 4294967295
+          IDENT   _serde 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   export 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   Ok 4294967295
+          SUBTREE () 4294967295
+            IDENT   __val 4294967295
+          PUNCH   = [joint] 4294967295
+          PUNCH   > [alone] 4294967295
+          IDENT   __val 4294967295
+          PUNCH   , [alone] 4294967295
+          IDENT   _serde 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   export 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   Err 4294967295
+          SUBTREE () 4294967295
+            IDENT   __err 4294967295
+          PUNCH   = [joint] 4294967295
+          PUNCH   > [alone] 4294967295
+          SUBTREE {} 4294967295
+            IDENT   return 4294967295
+            IDENT   _serde 4294967295
+            PUNCH   : [joint] 4294967295
+            PUNCH   : [alone] 4294967295
+            IDENT   export 4294967295
+            PUNCH   : [joint] 4294967295
+            PUNCH   : [alone] 4294967295
+            IDENT   Err 4294967295
+            SUBTREE () 4294967295
+              IDENT   __err 4294967295
+            PUNCH   ; [alone] 4294967295
+    PUNCH   # [alone] 4294967295
+    SUBTREE [] 4294967295
+      IDENT   automatically_derived 4294967295
+    IDENT   impl 4294967295
+    IDENT   _serde 4294967295
+    PUNCH   : [joint] 4294967295
+    PUNCH   : [alone] 4294967295
+    IDENT   Serialize 4294967295
+    IDENT   for 4294967295
+    IDENT   Foo 1
+    SUBTREE {} 4294967295
+      IDENT   fn 4294967295
+      IDENT   serialize 4294967295
+      PUNCH   < [alone] 4294967295
+      IDENT   __S 4294967295
+      PUNCH   > [alone] 4294967295
+      SUBTREE () 4294967295
+        PUNCH   & [alone] 4294967295
+        IDENT   self 4294967295
+        PUNCH   , [alone] 4294967295
+        IDENT   __serializer 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   __S 4294967295
+      PUNCH   - [joint] 4294967295
+      PUNCH   > [alone] 4294967295
+      IDENT   _serde 4294967295
+      PUNCH   : [joint] 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   export 4294967295
+      PUNCH   : [joint] 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   Result 4294967295
+      PUNCH   < [alone] 4294967295
+      IDENT   __S 4294967295
+      PUNCH   : [joint] 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   Ok 4294967295
+      PUNCH   , [alone] 4294967295
+      IDENT   __S 4294967295
+      PUNCH   : [joint] 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   Error 4294967295
+      PUNCH   > [alone] 4294967295
+      IDENT   where 4294967295
+      IDENT   __S 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   _serde 4294967295
+      PUNCH   : [joint] 4294967295
+      PUNCH   : [alone] 4294967295
+      IDENT   Serializer 4294967295
+      PUNCH   , [alone] 4294967295
+      SUBTREE {} 4294967295
+        IDENT   let 4294967295
+        IDENT   __serde_state 4294967295
+        PUNCH   = [alone] 4294967295
+        IDENT   try 4294967295
+        PUNCH   ! [alone] 4294967295
+        SUBTREE () 4294967295
+          IDENT   _serde 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   Serializer 4294967295
+          PUNCH   : [joint] 4294967295
+          PUNCH   : [alone] 4294967295
+          IDENT   serialize_struct 4294967295
+          SUBTREE () 4294967295
+            IDENT   __serializer 4294967295
+            PUNCH   , [alone] 4294967295
+            LITERAL "Foo" 4294967295
+            PUNCH   , [alone] 4294967295
+            IDENT   false 4294967295
+            IDENT   as 4294967295
+            IDENT   usize 4294967295
+        PUNCH   ; [alone] 4294967295
+        IDENT   _serde 4294967295
+        PUNCH   : [joint] 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   ser 4294967295
+        PUNCH   : [joint] 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   SerializeStruct 4294967295
+        PUNCH   : [joint] 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   end 4294967295
+        SUBTREE () 4294967295
+          IDENT   __serde_state 4294967295
+  PUNCH   ; [alone] 4294967295
\ No newline at end of file
diff --git a/crates/ra_proc_macro_srv/src/tests/mod.rs b/crates/ra_proc_macro_srv/src/tests/mod.rs
new file mode 100644
index 000000000..03f79bc5d
--- /dev/null
+++ b/crates/ra_proc_macro_srv/src/tests/mod.rs
@@ -0,0 +1,47 @@
+//! proc-macro tests
+
+#[macro_use]
+mod utils;
+use test_utils::assert_eq_text;
+use utils::*;
+
+#[test]
+fn test_derive_serialize_proc_macro() {
+    assert_expand(
+        "serde_derive",
+        "Serialize",
+        "1.0.104",
+        r##"struct Foo {}"##,
+        include_str!("fixtures/test_serialize_proc_macro.txt"),
+    );
+}
+
+#[test]
+fn test_derive_serialize_proc_macro_failed() {
+    assert_expand(
+        "serde_derive",
+        "Serialize",
+        "1.0.104",
+        r##"
+    struct {}
+"##,
+        r##"
+SUBTREE $
+  IDENT   compile_error 4294967295
+  PUNCH   ! [alone] 4294967295
+  SUBTREE {} 4294967295
+    LITERAL "expected identifier" 4294967295
+"##,
+    );
+}
+
+#[test]
+fn test_derive_proc_macro_list() {
+    let res = list("serde_derive", "1.0.104").join("\n");
+
+    assert_eq_text!(
+        &res,
+        r#"Serialize [CustomDerive]
+Deserialize [CustomDerive]"#
+    );
+}
diff --git a/crates/ra_proc_macro_srv/src/tests/utils.rs b/crates/ra_proc_macro_srv/src/tests/utils.rs
new file mode 100644
index 000000000..1ee409449
--- /dev/null
+++ b/crates/ra_proc_macro_srv/src/tests/utils.rs
@@ -0,0 +1,65 @@
+//! utils used in proc-macro tests
+
+use crate::dylib;
+use crate::list_macros;
+pub use difference::Changeset as __Changeset;
+use ra_proc_macro::ListMacrosTask;
+use std::str::FromStr;
+use test_utils::assert_eq_text;
+
+mod fixtures {
+    use cargo_metadata::{parse_messages, Message};
+    use std::process::Command;
+
+    // Use current project metadata to get the proc-macro dylib path
+    pub fn dylib_path(crate_name: &str, version: &str) -> std::path::PathBuf {
+        let command = Command::new("cargo")
+            .args(&["check", "--message-format", "json"])
+            .output()
+            .unwrap()
+            .stdout;
+
+        for message in parse_messages(command.as_slice()) {
+            match message.unwrap() {
+                Message::CompilerArtifact(artifact) => {
+                    if artifact.target.kind.contains(&"proc-macro".to_string()) {
+                        let repr = format!("{} {}", crate_name, version);
+                        if artifact.package_id.repr.starts_with(&repr) {
+                            return artifact.filenames[0].clone();
+                        }
+                    }
+                }
+                _ => (), // Unknown message
+            }
+        }
+
+        panic!("No proc-macro dylib for {} found!", crate_name);
+    }
+}
+
+fn parse_string(code: &str) -> Option<crate::rustc_server::TokenStream> {
+    Some(crate::rustc_server::TokenStream::from_str(code).unwrap())
+}
+
+pub fn assert_expand(
+    crate_name: &str,
+    macro_name: &str,
+    version: &str,
+    fixture: &str,
+    expect: &str,
+) {
+    let path = fixtures::dylib_path(crate_name, version);
+    let expander = dylib::Expander::new(&path).unwrap();
+    let fixture = parse_string(fixture).unwrap();
+
+    let res = expander.expand(macro_name, &fixture.subtree, None).unwrap();
+    assert_eq_text!(&format!("{:?}", res), &expect.trim());
+}
+
+pub fn list(crate_name: &str, version: &str) -> Vec<String> {
+    let path = fixtures::dylib_path(crate_name, version);
+    let task = ListMacrosTask { lib: path };
+
+    let res = list_macros(&task).unwrap();
+    res.macros.into_iter().map(|(name, kind)| format!("{} [{:?}]", name, kind)).collect()
+}
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index db6230aab..bc48a2e71 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -10,7 +10,7 @@ use crate::{AstNode, SyntaxKind, SyntaxNode, TextRange};
 
 /// A pointer to a syntax node inside a file. It can be used to remember a
 /// specific node across reparses of the same file.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxNodePtr {
     pub(crate) range: TextRange,
     kind: SyntaxKind,
@@ -21,7 +21,7 @@ impl SyntaxNodePtr {
         SyntaxNodePtr { range: node.text_range(), kind: node.kind() }
     }
 
-    pub fn to_node(self, root: &SyntaxNode) -> SyntaxNode {
+    pub fn to_node(&self, root: &SyntaxNode) -> SyntaxNode {
         assert!(root.parent().is_none());
         successors(Some(root.clone()), |node| {
             node.children().find(|it| self.range.is_subrange(&it.text_range()))
@@ -30,11 +30,11 @@ impl SyntaxNodePtr {
         .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
     }
 
-    pub fn range(self) -> TextRange {
+    pub fn range(&self) -> TextRange {
         self.range
     }
 
-    pub fn kind(self) -> SyntaxKind {
+    pub fn kind(&self) -> SyntaxKind {
         self.kind
     }
 
@@ -53,10 +53,9 @@ pub struct AstPtr<N: AstNode> {
     _ty: PhantomData<fn() -> N>,
 }
 
-impl<N: AstNode> Copy for AstPtr<N> {}
 impl<N: AstNode> Clone for AstPtr<N> {
     fn clone(&self) -> AstPtr<N> {
-        *self
+        AstPtr { raw: self.raw.clone(), _ty: PhantomData }
     }
 }
 
@@ -79,13 +78,13 @@ impl<N: AstNode> AstPtr<N> {
         AstPtr { raw: SyntaxNodePtr::new(node.syntax()), _ty: PhantomData }
     }
 
-    pub fn to_node(self, root: &SyntaxNode) -> N {
+    pub fn to_node(&self, root: &SyntaxNode) -> N {
         let syntax_node = self.raw.to_node(root);
         N::cast(syntax_node).unwrap()
     }
 
-    pub fn syntax_node_ptr(self) -> SyntaxNodePtr {
-        self.raw
+    pub fn syntax_node_ptr(&self) -> SyntaxNodePtr {
+        self.raw.clone()
     }
 
     pub fn cast<U: AstNode>(self) -> Option<AstPtr<U>> {
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 69133e4e4..43062ea10 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -152,7 +152,9 @@ pub(crate) fn load(
         &extern_source_roots,
         proc_macro_client,
         &mut |path: &Path| {
-            let vfs_file = vfs.load(path);
+            // Some path from metadata will be non canonicalized, e.g. /foo/../bar/lib.rs
+            let path = path.canonicalize().ok()?;
+            let vfs_file = vfs.load(&path);
             log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
             vfs_file.map(vfs_file_to_id)
         },
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 365f57d8c..6c42e1d76 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -139,7 +139,9 @@ impl WorldState {
         // Create crate graph from all the workspaces
         let mut crate_graph = CrateGraph::default();
         let mut load = |path: &std::path::Path| {
-            let vfs_file = vfs.load(path);
+            // Some path from metadata will be non canonicalized, e.g. /foo/../bar/lib.rs
+            let path = path.canonicalize().ok()?;
+            let vfs_file = vfs.load(&path);
             vfs_file.map(|f| FileId(f.0))
         };
 
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 21c1c9f23..35a05131c 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -66,23 +66,44 @@ export class Config {
         return vscode.workspace.getConfiguration(this.rootSection);
     }
 
-    get serverPath() { return this.cfg.get<null | string>("serverPath")!; }
-    get channel() { return this.cfg.get<UpdatesChannel>("updates.channel")!; }
-    get askBeforeDownload() { return this.cfg.get<boolean>("updates.askBeforeDownload")!; }
-    get traceExtension() { return this.cfg.get<boolean>("trace.extension")!; }
+    /**
+     * Beware that postfix `!` operator erases both `null` and `undefined`.
+     * This is why the following doesn't work as expected:
+     *
+     * ```ts
+     * const nullableNum = vscode
+     *  .workspace
+     *  .getConfiguration
+     *  .getConfiguration("rust-analyer")
+     *  .get<number | null>(path)!;
+     *
+     * // What happens is that type of `nullableNum` is `number` but not `null | number`:
+     * const fullFledgedNum: number = nullableNum;
+     * ```
+     * So this getter handles this quirk by not requiring the caller to use postfix `!`
+     */
+    private get<T>(path: string): T {
+        return this.cfg.get<T>(path)!;
+    }
+
+    get serverPath() { return this.get<null | string>("serverPath"); }
+    get channel() { return this.get<UpdatesChannel>("updates.channel"); }
+    get askBeforeDownload() { return this.get<boolean>("updates.askBeforeDownload"); }
+    get traceExtension() { return this.get<boolean>("trace.extension"); }
+
 
     get inlayHints() {
         return {
-            typeHints: this.cfg.get<boolean>("inlayHints.typeHints")!,
-            parameterHints: this.cfg.get<boolean>("inlayHints.parameterHints")!,
-            chainingHints: this.cfg.get<boolean>("inlayHints.chainingHints")!,
-            maxLength: this.cfg.get<null | number>("inlayHints.maxLength")!,
+            typeHints: this.get<boolean>("inlayHints.typeHints"),
+            parameterHints: this.get<boolean>("inlayHints.parameterHints"),
+            chainingHints: this.get<boolean>("inlayHints.chainingHints"),
+            maxLength: this.get<null | number>("inlayHints.maxLength"),
         };
     }
 
     get checkOnSave() {
         return {
-            command: this.cfg.get<string>("checkOnSave.command")!,
+            command: this.get<string>("checkOnSave.command"),
         };
     }
 }
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 6a8bd942e..da74f03d2 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -229,13 +229,13 @@ interface InlaysDecorations {
 }
 
 interface RustSourceFile {
-    /*
-    * Source of the token to cancel in-flight inlay hints request if any.
-    */
+    /**
+     * Source of the token to cancel in-flight inlay hints request if any.
+     */
     inlaysRequest: null | vscode.CancellationTokenSource;
     /**
-    * Last applied decorations.
-    */
+     * Last applied decorations.
+     */
     cachedDecorations: null | InlaysDecorations;
 
     document: RustDocument;