mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove last traces of nameres from hir

Browse Source
This commit is contained in:
Aleksey Kladov 2019-11-03 23:49:44 +03:00
parent 73fcf9a2d6
commit f0eb9cc6e6
8 changed files with 59 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
crates/ra_hir/src/code_model.rs
View File

@ -28,11 +28,10 @@
TypeAliasId,
},
impl_block::ImplBlock,
nameres::{ImportId, Namespace},
resolve::{Resolver, Scope, TypeNs},
traits::TraitData,
ty::{InferenceResult, TraitRef},
Either, HasSource, Name, ScopeDef, Ty,
Either, HasSource, Name, ScopeDef, Ty, {ImportId, Namespace},
};
/// hir::Crate describes a single crate. It's the main interface with which

3
crates/ra_hir/src/db.rs
View File

@ -11,14 +11,13 @@
ids,
impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
lang_item::{LangItemTarget, LangItems},
nameres::Namespace,
traits::TraitData,
ty::{
method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate,
InferenceResult, Substs, Ty, TypableDef, TypeCtor,
},
type_alias::TypeAliasData,
Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Static,
Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Namespace, Static,
StructField, Trait, TypeAlias,
};

6
crates/ra_hir/src/lib.rs
View File

@ -34,7 +34,6 @@ fn from(it: $sv) -> $e {
pub mod source_binder;
mod ids;
mod nameres;
mod adt;
mod traits;
mod type_alias;
@ -73,7 +72,6 @@ fn from(it: $sv) -> $e {
generics::{GenericDef, GenericParam, GenericParams, HasGenericParams},
ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
impl_block::ImplBlock,
nameres::{ImportId, Namespace, PerNs},
resolve::ScopeDef,
source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
ty::{
@ -83,6 +81,10 @@ fn from(it: $sv) -> $e {
pub use hir_def::{
builtin_type::BuiltinType,
nameres::{
per_ns::{Namespace, PerNs},
raw::ImportId,
},
path::{Path, PathKind},
type_ref::Mutability,
};

53
crates/ra_hir/src/nameres.rs
View File

@ -1,53 +0,0 @@
//! This module implements import-resolution/macro expansion algorithm.
//!
//! The result of this module is `CrateDefMap`: a data structure which contains:
//!
//! * a tree of modules for the crate
//! * for each module, a set of items visible in the module (directly declared
//! or imported)
//!
//! Note that `CrateDefMap` contains fully macro expanded code.
//!
//! Computing `CrateDefMap` can be partitioned into several logically
//! independent "phases". The phases are mutually recursive though, there's no
//! strict ordering.
//!
//! ## Collecting RawItems
//!
//! This happens in the `raw` module, which parses a single source file into a
//! set of top-level items. Nested imports are desugared to flat imports in
//! this phase. Macro calls are represented as a triple of (Path, Option<Name>,
//! TokenTree).
//!
//! ## Collecting Modules
//!
//! This happens in the `collector` module. In this phase, we recursively walk
//! tree of modules, collect raw items from submodules, populate module scopes
//! with defined items (so, we assign item ids in this phase) and record the set
//! of unresolved imports and macros.
//!
//! While we walk tree of modules, we also record macro_rules definitions and
//! expand calls to macro_rules defined macros.
//!
//! ## Resolving Imports
//!
//! We maintain a list of currently unresolved imports. On every iteration, we
//! try to resolve some imports from this list. If the import is resolved, we
//! record it, by adding an item to current module scope and, if necessary, by
//! recursively populating glob imports.
//!
//! ## Resolving Macros
//!
//! macro_rules from the same crate use a global mutable namespace. We expand
//! them immediately, when we collect modules.
//!
//! Macros from other crates (including proc-macros) can be used with
//! `foo::bar!` syntax. We handle them similarly to imports. There's a list of
//! unexpanded macros. On every iteration, we try to resolve each macro call
//! path and, upon success, we run macro expansion and "collect module" phase
//! on the result
pub use hir_def::nameres::{
per_ns::{Namespace, PerNs},
raw::ImportId,
};

4
crates/ra_hir/src/resolve.rs
View File

@ -19,8 +19,8 @@
},
generics::GenericParams,
impl_block::ImplBlock,
nameres::PerNs,
Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias,
Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, PerNs, Static, Struct, Trait,
TypeAlias,
};
#[derive(Debug, Clone, Default)]

3
crates/ra_hir/src/ty/infer/expr.rs
View File

@ -11,12 +11,11 @@
db::HirDatabase,
expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
generics::{GenericParams, HasGenericParams},
nameres::Namespace,
ty::{
autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Obligation,
ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
},
Adt, Name,
Adt, Name, Namespace,
};
impl<'a, D: HirDatabase> InferenceContext<'a, D> {

5
crates/ra_hir/src/ty/lower.rs
View File

@ -23,15 +23,14 @@
db::HirDatabase,
generics::HasGenericParams,
generics::{GenericDef, WherePredicate},
nameres::Namespace,
resolve::{Resolver, TypeNs},
ty::{
primitive::{FloatTy, IntTy},
Adt,
},
util::make_mut_slice,
Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField, Trait,
TypeAlias, Union,
Const, Enum, EnumVariant, Function, ModuleDef, Namespace, Path, Static, Struct, StructField,
Trait, TypeAlias, Union,
};
impl Ty {

49
crates/ra_hir_def/src/nameres.rs
View File

@ -1,4 +1,51 @@
//! FIXME: write short doc here
//! This module implements import-resolution/macro expansion algorithm.
//!
//! The result of this module is `CrateDefMap`: a data structure which contains:
//!
//! * a tree of modules for the crate
//! * for each module, a set of items visible in the module (directly declared
//! or imported)
//!
//! Note that `CrateDefMap` contains fully macro expanded code.
//!
//! Computing `CrateDefMap` can be partitioned into several logically
//! independent "phases". The phases are mutually recursive though, there's no
//! strict ordering.
//!
//! ## Collecting RawItems
//!
//! This happens in the `raw` module, which parses a single source file into a
//! set of top-level items. Nested imports are desugared to flat imports in
//! this phase. Macro calls are represented as a triple of (Path, Option<Name>,
//! TokenTree).
//!
//! ## Collecting Modules
//!
//! This happens in the `collector` module. In this phase, we recursively walk
//! tree of modules, collect raw items from submodules, populate module scopes
//! with defined items (so, we assign item ids in this phase) and record the set
//! of unresolved imports and macros.
//!
//! While we walk tree of modules, we also record macro_rules definitions and
//! expand calls to macro_rules defined macros.
//!
//! ## Resolving Imports
//!
//! We maintain a list of currently unresolved imports. On every iteration, we
//! try to resolve some imports from this list. If the import is resolved, we
//! record it, by adding an item to current module scope and, if necessary, by
//! recursively populating glob imports.
//!
//! ## Resolving Macros
//!
//! macro_rules from the same crate use a global mutable namespace. We expand
//! them immediately, when we collect modules.
//!
//! Macros from other crates (including proc-macros) can be used with
//! `foo::bar!` syntax. We handle them similarly to imports. There's a list of
//! unexpanded macros. On every iteration, we try to resolve each macro call
//! path and, upon success, we run macro expansion and "collect module" phase
//! on the result
// FIXME: review privacy of submodules
pub mod raw;