Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into feature/themes

crates/ra_hir/src/code_model.rs

@@ -2,6 +2,7 @@
 
 pub(crate) mod src;
 pub(crate) mod docs;
+pub(crate) mod attrs;
 
 use std::sync::Arc;
 

crates/ra_hir/src/code_model/attrs.rs

@@ -0,0 +1,92 @@
+//! FIXME: write short doc here
+
+use crate::{
+    db::{AstDatabase, DefDatabase, HirDatabase},
+    Adt, Const, Enum, EnumVariant, FieldSource, Function, HasSource, MacroDef, Module, Static,
+    Struct, StructField, Trait, TypeAlias, Union,
+};
+use hir_def::attr::Attr;
+use hir_expand::hygiene::Hygiene;
+use ra_syntax::ast;
+use std::sync::Arc;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AttrDef {
+    Module(Module),
+    StructField(StructField),
+    Adt(Adt),
+    Function(Function),
+    EnumVariant(EnumVariant),
+    Static(Static),
+    Const(Const),
+    Trait(Trait),
+    TypeAlias(TypeAlias),
+    MacroDef(MacroDef),
+}
+
+impl_froms!(
+    AttrDef: Module,
+    StructField,
+    Adt(Struct, Enum, Union),
+    EnumVariant,
+    Static,
+    Const,
+    Function,
+    Trait,
+    TypeAlias,
+    MacroDef
+);
+
+pub trait Attrs {
+    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>>;
+}
+
+pub(crate) fn attributes_query(
+    db: &(impl DefDatabase + AstDatabase),
+    def: AttrDef,
+) -> Option<Arc<[Attr]>> {
+    match def {
+        AttrDef::Module(it) => {
+            let src = it.declaration_source(db)?;
+            let hygiene = Hygiene::new(db, src.file_id);
+            Attr::from_attrs_owner(&src.ast, &hygiene)
+        }
+        AttrDef::StructField(it) => match it.source(db).ast {
+            FieldSource::Named(named) => {
+                let src = it.source(db);
+                let hygiene = Hygiene::new(db, src.file_id);
+                Attr::from_attrs_owner(&named, &hygiene)
+            }
+            FieldSource::Pos(..) => None,
+        },
+        AttrDef::Adt(it) => match it {
+            Adt::Struct(it) => attrs_from_ast(it, db),
+            Adt::Enum(it) => attrs_from_ast(it, db),
+            Adt::Union(it) => attrs_from_ast(it, db),
+        },
+        AttrDef::EnumVariant(it) => attrs_from_ast(it, db),
+        AttrDef::Static(it) => attrs_from_ast(it, db),
+        AttrDef::Const(it) => attrs_from_ast(it, db),
+        AttrDef::Function(it) => attrs_from_ast(it, db),
+        AttrDef::Trait(it) => attrs_from_ast(it, db),
+        AttrDef::TypeAlias(it) => attrs_from_ast(it, db),
+        AttrDef::MacroDef(it) => attrs_from_ast(it, db),
+    }
+}
+
+fn attrs_from_ast<T, D>(node: T, db: &D) -> Option<Arc<[Attr]>>
+where
+    T: HasSource,
+    T::Ast: ast::AttrsOwner,
+    D: DefDatabase + AstDatabase,
+{
+    let src = node.source(db);
+    let hygiene = Hygiene::new(db, src.file_id);
+    Attr::from_attrs_owner(&src.ast, &hygiene)
+}
+
+impl<T: Into<AttrDef> + Copy> Attrs for T {
+    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>> {
+        db.attrs((*self).into())
+    }
+}

crates/ra_hir/src/db.rs

@@ -2,6 +2,7 @@
 
 use std::sync::Arc;
 
+use hir_def::attr::Attr;
 use ra_db::salsa;
 use ra_syntax::SmolStr;
 
@@ -75,6 +76,9 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
 
     #[salsa::invoke(crate::code_model::docs::documentation_query)]
     fn documentation(&self, def: crate::DocDef) -> Option<crate::Documentation>;
+
+    #[salsa::invoke(crate::code_model::attrs::attributes_query)]
+    fn attrs(&self, def: crate::AttrDef) -> Option<Arc<[Attr]>>;
 }
 
 #[salsa::query_group(HirDatabaseStorage)]

crates/ra_hir/src/lib.rs

@@ -61,6 +61,7 @@ use crate::{ids::MacroFileKind, resolve::Resolver};
 pub use crate::{
     adt::VariantDef,
     code_model::{
+        attrs::{AttrDef, Attrs},
         docs::{DocDef, Docs, Documentation},
         src::{HasBodySource, HasSource},
         Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum,

crates/ra_ide_api/src/completion/complete_postfix.rs

@@ -1,5 +1,9 @@
 //! FIXME: write short doc here
 
+use hir::{Ty, TypeCtor};
+use ra_syntax::{ast::AstNode, TextRange, TextUnit};
+use ra_text_edit::TextEdit;
+
 use crate::{
     completion::{
         completion_context::CompletionContext,
@@ -7,9 +11,53 @@ use crate::{
     },
     CompletionItem,
 };
-use hir::{Ty, TypeCtor};
+
-use ra_syntax::{ast::AstNode, TextRange, TextUnit};
+pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-use ra_text_edit::TextEdit;
+    let dot_receiver = match &ctx.dot_receiver {
+        Some(it) => it,
+        None => return,
+    };
+
+    let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
+        let text = dot_receiver.syntax().text();
+        let without_dot = ..text.len() - TextUnit::of_char('.');
+        text.slice(without_dot).to_string()
+    } else {
+        dot_receiver.syntax().text().to_string()
+    };
+
+    let receiver_ty = ctx.analyzer.type_of(ctx.db, &dot_receiver);
+
+    if is_bool_or_unknown(receiver_ty) {
+        postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
+            .add_to(acc);
+        postfix_snippet(
+            ctx,
+            "while",
+            "while expr {}",
+            &format!("while {} {{\n$0\n}}", receiver_text),
+        )
+        .add_to(acc);
+    }
+
+    postfix_snippet(ctx, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
+
+    postfix_snippet(ctx, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, "refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
+
+    postfix_snippet(
+        ctx,
+        "match",
+        "match expr {}",
+        &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+    )
+    .add_to(acc);
+
+    postfix_snippet(ctx, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
+
+    postfix_snippet(ctx, "box", "Box::new(expr)", &format!("Box::new({})", receiver_text))
+        .add_to(acc);
+}
 
 fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
     let edit = {
@@ -24,62 +72,19 @@ fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet:
 }
 
 fn is_bool_or_unknown(ty: Option<Ty>) -> bool {
-    if let Some(ty) = ty {
+    match &ty {
-        match ty {
+        Some(Ty::Apply(app)) if app.ctor == TypeCtor::Bool => true,
-            Ty::Apply(at) => match at.ctor {
+        Some(Ty::Unknown) | None => true,
-                TypeCtor::Bool => true,
+        Some(_) => false,
-                _ => false,
-            },
-            Ty::Unknown => true,
-            _ => false,
-        }
-    } else {
-        true
-    }
-}
-
-pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if let Some(dot_receiver) = &ctx.dot_receiver {
-        let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
-            let text = dot_receiver.syntax().text();
-            let without_dot = ..text.len() - TextUnit::of_char('.');
-            text.slice(without_dot).to_string()
-        } else {
-            dot_receiver.syntax().text().to_string()
-        };
-        let receiver_ty = ctx.analyzer.type_of(ctx.db, &dot_receiver);
-        if is_bool_or_unknown(receiver_ty) {
-            postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
-                .add_to(acc);
-            postfix_snippet(
-                ctx,
-                "while",
-                "while expr {}",
-                &format!("while {} {{\n$0\n}}", receiver_text),
-            )
-            .add_to(acc);
-        }
-        postfix_snippet(ctx, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
-        postfix_snippet(ctx, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
-        postfix_snippet(ctx, "refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
-        postfix_snippet(
-            ctx,
-            "match",
-            "match expr {}",
-            &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
-        )
-        .add_to(acc);
-        postfix_snippet(ctx, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
-        postfix_snippet(ctx, "box", "Box::new(expr)", &format!("Box::new({})", receiver_text))
-            .add_to(acc);
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
     use insta::assert_debug_snapshot;
 
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+
     fn do_postfix_completion(code: &str) -> Vec<CompletionItem> {
         do_completion(code, CompletionKind::Postfix)
     }

crates/ra_ide_api/src/completion/presentation.rs

@@ -1,8 +1,8 @@
 //! This modules takes care of rendering various definitions as completion items.
 
-use hir::{db::HirDatabase, Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
+use hir::{db::HirDatabase, Attrs, Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
 use join_to_string::join;
-use ra_syntax::ast::{AttrsOwner, NameOwner};
+use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
 
 use crate::completion::{
@@ -18,11 +18,7 @@ impl Completions {
         field: hir::StructField,
         substs: &hir::Substs,
     ) {
-        let ast_node = field.source(ctx.db).ast;
+        let is_deprecated = is_deprecated(field, ctx.db);
-        let is_deprecated = match ast_node {
-            hir::FieldSource::Named(m) => is_deprecated(m),
-            hir::FieldSource::Pos(m) => is_deprecated(m),
-        };
         CompletionItem::new(
             CompletionKind::Reference,
             ctx.source_range(),
@@ -185,7 +181,7 @@ impl Completions {
             CompletionItem::new(CompletionKind::Reference, ctx.source_range(), &macro_declaration)
                 .kind(CompletionItemKind::Macro)
                 .set_documentation(docs.clone())
-                .set_deprecated(is_deprecated(ast_node))
+                .set_deprecated(is_deprecated(macro_, ctx.db))
                 .detail(detail);
 
         builder = if ctx.use_item_syntax.is_some() {
@@ -218,7 +214,7 @@ impl Completions {
                     CompletionItemKind::Function
                 })
                 .set_documentation(func.docs(ctx.db))
-                .set_deprecated(is_deprecated(ast_node))
+                .set_deprecated(is_deprecated(func, ctx.db))
                 .detail(detail);
 
         // Add `<>` for generic types
@@ -250,7 +246,7 @@ impl Completions {
         CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string())
             .kind(CompletionItemKind::Const)
             .set_documentation(constant.docs(ctx.db))
-            .set_deprecated(is_deprecated(ast_node))
+            .set_deprecated(is_deprecated(constant, ctx.db))
             .detail(detail)
             .add_to(self);
     }
@@ -266,13 +262,13 @@ impl Completions {
         CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string())
             .kind(CompletionItemKind::TypeAlias)
             .set_documentation(type_alias.docs(ctx.db))
-            .set_deprecated(is_deprecated(type_def))
+            .set_deprecated(is_deprecated(type_alias, ctx.db))
             .detail(detail)
             .add_to(self);
     }
 
     pub(crate) fn add_enum_variant(&mut self, ctx: &CompletionContext, variant: hir::EnumVariant) {
-        let is_deprecated = is_deprecated(variant.source(ctx.db).ast);
+        let is_deprecated = is_deprecated(variant, ctx.db);
         let name = match variant.name(ctx.db) {
             Some(it) => it,
             None => return,
@@ -291,8 +287,11 @@ impl Completions {
     }
 }
 
-fn is_deprecated(node: impl AttrsOwner) -> bool {
+fn is_deprecated(node: impl Attrs, db: &impl HirDatabase) -> bool {
-    node.attrs().filter_map(|x| x.simple_name()).any(|x| x == "deprecated")
+    match node.attrs(db) {
+        None => false,
+        Some(attrs) => attrs.iter().any(|x| x.is_simple_atom("deprecated")),
+    }
 }
 
 fn has_non_default_type_params(def: hir::GenericDef, db: &db::RootDatabase) -> bool {

crates/ra_parser/src/grammar/types.rs

@@ -28,7 +28,7 @@ fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
         T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p),
         T![for] => for_type(p),
         T![impl] => impl_trait_type(p),
-        T![dyn ] => dyn_trait_type(p),
+        T![dyn] => dyn_trait_type(p),
         // Some path types are not allowed to have bounds (no plus)
         T![<] => path_type_(p, allow_bounds),
         _ if paths::is_use_path_start(p) => path_or_macro_type_(p, allow_bounds),
@@ -234,9 +234,9 @@ fn impl_trait_type(p: &mut Parser) {
 // test dyn_trait_type
 // type A = dyn Iterator<Item=Foo<'a>> + 'a;
 fn dyn_trait_type(p: &mut Parser) {
-    assert!(p.at(T![dyn ]));
+    assert!(p.at(T![dyn]));
     let m = p.start();
-    p.bump(T![dyn ]);
+    p.bump(T![dyn]);
     type_params::bounds_without_colon(p);
     m.complete(p, DYN_TRAIT_TYPE);
 }

xtask/src/codegen.rs

@@ -46,7 +46,7 @@ pub enum Mode {
 /// With verify = false,
 fn update(path: &Path, contents: &str, mode: Mode) -> Result<()> {
     match fs::read_to_string(path) {
-        Ok(ref old_contents) if old_contents == contents => {
+        Ok(ref old_contents) if normalize(old_contents) == normalize(contents) => {
             return Ok(());
         }
         _ => (),
@@ -56,7 +56,11 @@ fn update(path: &Path, contents: &str, mode: Mode) -> Result<()> {
     }
     eprintln!("updating {}", path.display());
     fs::write(path, contents)?;
-    Ok(())
+    return Ok(());
+
+    fn normalize(s: &str) -> String {
+        s.replace("\r\n", "\n")
+    }
 }
 
 fn reformat(text: impl std::fmt::Display) -> Result<String> {