From 0b8fbb4fad97d2980f0070a23f5365a5ed887e2a Mon Sep 17 00:00:00 2001 From: Marcus Klaas de Vries Date: Wed, 9 Jan 2019 00:47:12 +0100 Subject: Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir --- crates/ra_hir/src/code_model_api.rs | 20 ++++++++++++++++---- crates/ra_hir/src/db.rs | 3 +++ crates/ra_hir/src/expr.rs | 8 ++++++-- crates/ra_hir/src/ids.rs | 12 ++++++------ crates/ra_hir/src/impl_block.rs | 12 ++++++------ crates/ra_hir/src/lib.rs | 6 +++--- crates/ra_hir/src/macros.rs | 6 +++--- crates/ra_hir/src/module_tree.rs | 4 ++-- crates/ra_hir/src/name.rs | 2 +- crates/ra_hir/src/nameres.rs | 24 ++++++++++++------------ crates/ra_hir/src/source_binder.rs | 2 +- crates/ra_hir/src/ty.rs | 4 ++-- crates/ra_hir/src/ty/autoderef.rs | 2 +- crates/ra_hir/src/ty/tests.rs | 2 +- 14 files changed, 63 insertions(+), 44 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 343d06a5b..66c016180 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -13,8 +13,8 @@ use crate::{ ty::InferenceResult, }; -/// hir::Crate describes a single crate. It's the main inteface with which -/// crate's dependencies interact. Mostly, it should be just a proxy for the +/// hir::Crate describes a single crate. It's the main interface with which +/// a crate's dependencies interact. Mostly, it should be just a proxy for the /// root module. #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Crate { @@ -78,6 +78,7 @@ impl Module { pub fn definition_source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, ModuleSource)> { self.definition_source_impl(db) } + /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`. /// `None` for the crate root. pub fn declaration_source( @@ -91,20 +92,24 @@ impl Module { pub fn krate(&self, db: &impl HirDatabase) -> Cancelable> { self.krate_impl(db) } + /// Topmost parent of this module. Every module has a `crate_root`, but some - /// might miss `krate`. This can happen if a module's file is not included - /// into any module tree of any target from Cargo.toml. + /// might be missing `krate`. This can happen if a module's file is not included + /// in the module tree of any target in Cargo.toml. pub fn crate_root(&self, db: &impl HirDatabase) -> Cancelable { self.crate_root_impl(db) } + /// Finds a child module with the specified name. pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { self.child_impl(db, name) } + /// Finds a parent module. pub fn parent(&self, db: &impl HirDatabase) -> Cancelable> { self.parent_impl(db) } + pub fn path_to_root(&self, db: &impl HirDatabase) -> Cancelable> { let mut res = vec![self.clone()]; let mut curr = self.clone(); @@ -114,13 +119,16 @@ impl Module { } Ok(res) } + /// Returns a `ModuleScope`: a set of items, visible in this module. pub fn scope(&self, db: &impl HirDatabase) -> Cancelable { self.scope_impl(db) } + pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable> { self.resolve_path_impl(db, path) } + pub fn problems( &self, db: &impl HirDatabase, @@ -140,6 +148,7 @@ impl StructField { pub fn name(&self) -> &Name { &self.name } + pub fn type_ref(&self) -> &TypeRef { &self.type_ref } @@ -160,18 +169,21 @@ impl VariantData { _ => &[], } } + pub fn is_struct(&self) -> bool { match self { VariantData::Struct(..) => true, _ => false, } } + pub fn is_tuple(&self) -> bool { match self { VariantData::Tuple(..) => true, _ => false, } } + pub fn is_unit(&self) -> bool { match self { VariantData::Unit => true, diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 07cf0d10a..7dbe93f2b 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -26,6 +26,7 @@ pub trait HirDatabase: SyntaxDatabase type HirSourceFileQuery; use fn HirFileId::hir_source_file; } + fn expand_macro_invocation(invoc: MacroCallId) -> Option> { type ExpandMacroCallQuery; use fn crate::macros::expand_macro_invocation; @@ -80,10 +81,12 @@ pub trait HirDatabase: SyntaxDatabase type InputModuleItemsQuery; use fn query_definitions::input_module_items; } + fn item_map(source_root_id: SourceRootId) -> Cancelable> { type ItemMapQuery; use fn query_definitions::item_map; } + fn module_tree(source_root_id: SourceRootId) -> Cancelable> { type ModuleTreeQuery; use fn crate::module_tree::ModuleTree::module_tree_query; diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index a31f086f7..ebb83d084 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -33,8 +33,7 @@ pub struct Body { /// IDs. This is needed to go from e.g. a position in a file to the HIR /// expression containing it; but for type inference etc., we want to operate on /// a structure that is agnostic to the actual positions of expressions in the -/// file, so that we don't recompute the type inference whenever some whitespace -/// is typed. +/// file, so that we don't recompute types whenever some whitespace is typed. #[derive(Debug, Eq, PartialEq)] pub struct BodySyntaxMapping { body: Arc, @@ -74,20 +73,25 @@ impl BodySyntaxMapping { pub fn expr_syntax(&self, expr: ExprId) -> Option { self.expr_syntax_mapping_back.get(expr).cloned() } + pub fn syntax_expr(&self, ptr: LocalSyntaxPtr) -> Option { self.expr_syntax_mapping.get(&ptr).cloned() } + pub fn node_expr(&self, node: &ast::Expr) -> Option { self.expr_syntax_mapping .get(&LocalSyntaxPtr::new(node.syntax())) .cloned() } + pub fn pat_syntax(&self, pat: PatId) -> Option { self.pat_syntax_mapping_back.get(pat).cloned() } + pub fn syntax_pat(&self, ptr: LocalSyntaxPtr) -> Option { self.pat_syntax_mapping.get(&ptr).cloned() } + pub fn node_pat(&self, node: &ast::Pat) -> Option { self.pat_syntax_mapping .get(&LocalSyntaxPtr::new(node.syntax())) diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 3db757778..2e10e5516 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -9,25 +9,25 @@ use crate::{ use crate::code_model_api::Module; -/// hir makes a heavy use of ids: integer (u32) handlers to various things. You +/// hir makes heavy use of ids: integer (u32) handlers to various things. You /// can think of id as a pointer (but without a lifetime) or a file descriptor /// (but for hir objects). /// /// This module defines a bunch of ids we are using. The most important ones are /// probably `HirFileId` and `DefId`. -/// Input to the analyzer is a set of file, where each file is indetified by +/// Input to the analyzer is a set of files, where each file is indentified by /// `FileId` and contains source code. However, another source of source code in /// Rust are macros: each macro can be thought of as producing a "temporary -/// file". To assign id to such file, we use the id of a macro call that +/// file". To assign an id to such a file, we use the id of the macro call that /// produced the file. So, a `HirFileId` is either a `FileId` (source code /// written by user), or a `MacroCallId` (source code produced by macro). /// /// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file containin /// the call plus the offset of the macro call in the file. Note that this is a -/// recursive definition! Nethetheless, size_of of `HirFileId` is finite +/// recursive definition! However, the size_of of `HirFileId` is finite /// (because everything bottoms out at the real `FileId`) and small -/// (`MacroCallId` uses location interner). +/// (`MacroCallId` uses the location interner). #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct HirFileId(HirFileIdRepr); @@ -235,7 +235,7 @@ pub struct SourceItemId { pub(crate) item_id: Option, } -/// Maps item's `SyntaxNode`s to `SourceFileItemId` and back. +/// Maps items' `SyntaxNode`s to `SourceFileItemId`s and back. #[derive(Debug, PartialEq, Eq)] pub struct SourceFileItems { file_id: HirFileId, diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 0fbbdc8eb..4acda9af3 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -128,13 +128,13 @@ impl ImplItem { pub struct ImplId(pub RawId); impl_arena_id!(ImplId); -/// Collection of impl blocks is a two-step process: First we collect the blocks -/// per-module; then we build an index of all impl blocks in the crate. This -/// way, we avoid having to do this process for the whole crate whenever someone -/// types in any file; as long as the impl blocks in the file don't change, we -/// don't need to do the second step again. +/// The collection of impl blocks is a two-step process: first we collect the +/// blocks per-module; then we build an index of all impl blocks in the crate. +/// This way, we avoid having to do this process for the whole crate whenever +/// a file is changed; as long as the impl blocks in the file don't change, +/// we don't need to do the second step again. /// -/// (The second step does not yet exist currently.) +/// (The second step does not yet exist.) #[derive(Debug, PartialEq, Eq)] pub struct ModuleImplBlocks { impls: Arena, diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index eb19d8be1..ca7f395a8 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -1,9 +1,9 @@ -//! HIR (previsouly known as descriptors) provides a high-level OO acess to Rust -//! code. +//! HIR (previously known as descriptors) provides a high-level object oriented +//! access to Rust code. //! //! The principal difference between HIR and syntax trees is that HIR is bound //! to a particular crate instance. That is, it has cfg flags and features -//! applied. So, there relation between syntax and HIR is many-to-one. +//! applied. So, the relation between syntax and HIR is many-to-one. macro_rules! ctry { ($expr:expr) => { diff --git a/crates/ra_hir/src/macros.rs b/crates/ra_hir/src/macros.rs index eb1c86091..e455b2ad5 100644 --- a/crates/ra_hir/src/macros.rs +++ b/crates/ra_hir/src/macros.rs @@ -4,9 +4,9 @@ /// that is produced after expansion. See `HirFileId` and `MacroCallId` for how /// do we do that. /// -/// When file-management question is resolved, all that is left is a token tree -/// to token tree transformation plus hygent. We don't have either of thouse -/// yet, so all macros are string based at the moment! +/// When the file-management question is resolved, all that is left is a +/// token-tree-to-token-tree transformation plus hygiene. We don't have either of +/// those yet, so all macros are string based at the moment! use std::sync::Arc; use ra_db::LocalSyntaxPtr; diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs index 91aab5c74..d2c92f150 100644 --- a/crates/ra_hir/src/module_tree.rs +++ b/crates/ra_hir/src/module_tree.rs @@ -85,9 +85,9 @@ impl_arena_id!(LinkId); /// Physically, rust source is organized as a set of files, but logically it is /// organized as a tree of modules. Usually, a single file corresponds to a -/// single module, but it is not nessary the case. +/// single module, but it is not neccessarily always the case. /// -/// Module encapsulate the logic of transitioning from the fuzzy world of files +/// `ModuleTree` encapsulates the logic of transitioning from the fuzzy world of files /// (which can have multiple parents) to the precise world of modules (which /// always have one parent). #[derive(Default, Debug, PartialEq, Eq)] diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs index 3e6ce8b95..d9683549c 100644 --- a/crates/ra_hir/src/name.rs +++ b/crates/ra_hir/src/name.rs @@ -3,7 +3,7 @@ use std::fmt; use ra_syntax::{ast, SmolStr}; /// `Name` is a wrapper around string, which is used in hir for both references -/// and declarations. In theory, names should also carry hygene info, but we are +/// and declarations. In theory, names should also carry hygiene info, but we are /// not there yet! #[derive(Clone, PartialEq, Eq, Hash)] pub struct Name { diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs index 20adc9ec4..6bf949654 100644 --- a/crates/ra_hir/src/nameres.rs +++ b/crates/ra_hir/src/nameres.rs @@ -1,18 +1,18 @@ -//! Name resolution algorithm. The end result of the algorithm is `ItemMap`: a -//! map with maps each module to it's scope: the set of items, visible in the +//! Name resolution algorithm. The end result of the algorithm is an `ItemMap`: +//! a map which maps each module to its scope: the set of items visible in the //! module. That is, we only resolve imports here, name resolution of item //! bodies will be done in a separate step. //! -//! Like Rustc, we use an interative per-crate algorithm: we start with scopes +//! Like Rustc, we use an interactive per-crate algorithm: we start with scopes //! containing only directly defined items, and then iteratively resolve //! imports. //! -//! To make this work nicely in the IDE scenarios, we place `InputModuleItems` +//! To make this work nicely in the IDE scenario, we place `InputModuleItems` //! in between raw syntax and name resolution. `InputModuleItems` are computed //! using only the module's syntax, and it is all directly defined items plus -//! imports. The plain is to make `InputModuleItems` independent of local -//! modifications (that is, typing inside a function shold not change IMIs), -//! such that the results of name resolution can be preserved unless the module +//! imports. The plan is to make `InputModuleItems` independent of local +//! modifications (that is, typing inside a function should not change IMIs), +//! so that the results of name resolution can be preserved unless the module //! structure itself is modified. use std::sync::Arc; @@ -34,7 +34,7 @@ use crate::{ module_tree::{ModuleId, ModuleTree}, }; -/// Item map is the result of the name resolution. Item map contains, for each +/// `ItemMap` is the result of name resolution. It contains, for each /// module, the set of visible items. // FIXME: currenty we compute item map per source-root. We should do it per crate instead. #[derive(Default, Debug, PartialEq, Eq)] @@ -59,9 +59,9 @@ impl ModuleScope { /// A set of items and imports declared inside a module, without relation to /// other modules. /// -/// This stands in-between raw syntax and name resolution and alow us to avoid -/// recomputing name res: if `InputModuleItems` are the same, we can avoid -/// running name resolution. +/// This sits in-between raw syntax and name resolution and allows us to avoid +/// recomputing name res: if two instance of `InputModuleItems` are the same, we +/// can avoid redoing name resolution. #[derive(Debug, Default, PartialEq, Eq)] pub struct InputModuleItems { pub(crate) items: Vec, @@ -114,7 +114,7 @@ enum ImportKind { Named(NamedImport), } -/// Resolution is basically `DefId` atm, but it should account for stuff like +/// `Resolution` is basically `DefId` atm, but it should account for stuff like /// multiple namespaces, ambiguity and errors. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Resolution { diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index 4b0400cd0..1f149a366 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -1,4 +1,4 @@ -/// Lookup hir elements using position in the source code. This is a lossy +/// Lookup hir elements using positions in the source code. This is a lossy /// transformation: in general, a single source might correspond to several /// modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on /// modules. diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index 90ba393ce..3b2bfd67a 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -144,7 +144,7 @@ pub enum Ty { Bool, /// The primitive character type; holds a Unicode scalar value - /// (a non-surrogate code point). Written as `char`. + /// (a non-surrogate code point). Written as `char`. Char, /// A primitive signed integer type. For example, `i32`. @@ -204,7 +204,7 @@ pub enum Ty { // `|a| yield a`. // Generator(DefId, GeneratorSubsts<'tcx>, hir::GeneratorMovability), - // A type representin the types stored inside a generator. + // A type representing the types stored inside a generator. // This should only appear in GeneratorInteriors. // GeneratorWitness(Binder<&'tcx List>>), /// The never type `!`. diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs index 24a386558..d95879e46 100644 --- a/crates/ra_hir/src/ty/autoderef.rs +++ b/crates/ra_hir/src/ty/autoderef.rs @@ -1,4 +1,4 @@ -//! In certain situations, rust automatically inserts derefs as necessary: For +//! In certain situations, rust automatically inserts derefs as necessary: for //! example, field accesses `foo.bar` still work when `foo` is actually a //! reference to a type with the field `bar`. This is an approximation of the //! logic in rustc (which lives in librustc_typeck/check/autoderef.rs). diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs index 2749d740c..ba2a44474 100644 --- a/crates/ra_hir/src/ty/tests.rs +++ b/crates/ra_hir/src/ty/tests.rs @@ -15,7 +15,7 @@ use crate::{ }; // These tests compare the inference results for all expressions in a file -// against snapshots of the current results. If you change something and these +// against snapshots of the expected results. If you change something and these // tests fail expectedly, you can update the comparison files by deleting them // and running the tests again. Similarly, to add a new test, just write the // test here in the same pattern and it will automatically write the snapshot. -- cgit v1.2.3