2014-05-14 15:31:30 -04:00
|
|
|
|
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
|
//
|
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
2016-03-29 12:54:26 +03:00
|
|
|
|
use hir::def_id::DefId;
|
2017-09-08 13:51:57 -07:00
|
|
|
|
use util::nodemap::{NodeMap, DefIdMap};
|
2014-05-14 15:31:30 -04:00
|
|
|
|
use syntax::ast;
|
2017-02-23 20:12:33 +10:30
|
|
|
|
use syntax::ext::base::MacroKind;
|
2017-03-14 05:16:54 +00:00
|
|
|
|
use syntax_pos::Span;
|
2016-03-29 08:50:44 +03:00
|
|
|
|
use hir;
|
2017-11-29 11:20:49 -08:00
|
|
|
|
use ty;
|
2014-05-14 15:31:30 -04:00
|
|
|
|
|
2018-06-13 11:44:06 -05:00
|
|
|
|
use self::Namespace::*;
|
|
|
|
|
|
2016-09-15 00:51:46 +03:00
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
|
|
|
|
pub enum CtorKind {
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// Constructor function automatically created by a tuple struct/variant.
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Fn,
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// Constructor constant automatically created by a unit struct/variant.
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Const,
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// Unusable name in value namespace created by a struct variant.
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Fictive,
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-28 08:34:18 -05:00
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
2014-05-14 15:31:30 -04:00
|
|
|
|
pub enum Def {
|
2016-09-15 00:51:46 +03:00
|
|
|
|
// Type namespace
|
2016-01-20 22:31:10 +03:00
|
|
|
|
Mod(DefId),
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Struct(DefId), // DefId refers to NodeId of the struct itself
|
|
|
|
|
Union(DefId),
|
2016-01-20 22:31:10 +03:00
|
|
|
|
Enum(DefId),
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Variant(DefId),
|
|
|
|
|
Trait(DefId),
|
2018-05-22 14:31:56 +02:00
|
|
|
|
Existential(DefId),
|
2016-01-20 22:31:10 +03:00
|
|
|
|
TyAlias(DefId),
|
2017-09-03 19:53:58 +01:00
|
|
|
|
TyForeign(DefId),
|
2017-10-02 12:28:16 +00:00
|
|
|
|
TraitAlias(DefId),
|
2016-09-08 19:05:50 +03:00
|
|
|
|
AssociatedTy(DefId),
|
2016-01-20 22:31:10 +03:00
|
|
|
|
PrimTy(hir::PrimTy),
|
2016-08-15 01:07:09 +03:00
|
|
|
|
TyParam(DefId),
|
2016-09-15 00:51:46 +03:00
|
|
|
|
SelfTy(Option<DefId> /* trait */, Option<DefId> /* impl */),
|
|
|
|
|
|
|
|
|
|
// Value namespace
|
|
|
|
|
Fn(DefId),
|
|
|
|
|
Const(DefId),
|
|
|
|
|
Static(DefId, bool /* is_mutbl */),
|
|
|
|
|
StructCtor(DefId, CtorKind), // DefId refers to NodeId of the struct's constructor
|
|
|
|
|
VariantCtor(DefId, CtorKind),
|
|
|
|
|
Method(DefId),
|
|
|
|
|
AssociatedConst(DefId),
|
2017-04-29 14:39:47 +03:00
|
|
|
|
|
|
|
|
|
Local(ast::NodeId),
|
|
|
|
|
Upvar(ast::NodeId, // node id of closed over local
|
2016-09-15 00:51:46 +03:00
|
|
|
|
usize, // index in the freevars list of the closure
|
|
|
|
|
ast::NodeId), // expr node that creates the closure
|
2016-01-20 22:31:10 +03:00
|
|
|
|
Label(ast::NodeId),
|
2016-09-15 00:51:46 +03:00
|
|
|
|
|
2016-10-25 22:05:02 +00:00
|
|
|
|
// Macro namespace
|
2017-02-23 20:12:33 +10:30
|
|
|
|
Macro(DefId, MacroKind),
|
2016-10-25 22:05:02 +00:00
|
|
|
|
|
2017-03-15 21:27:40 -05:00
|
|
|
|
GlobalAsm(DefId),
|
|
|
|
|
|
2016-09-15 00:51:46 +03:00
|
|
|
|
// Both namespaces
|
2016-01-20 22:31:10 +03:00
|
|
|
|
Err,
|
2014-05-14 15:31:30 -04:00
|
|
|
|
}
|
|
|
|
|
|
2017-02-18 22:11:42 +03:00
|
|
|
|
/// The result of resolving a path before lowering to HIR.
|
|
|
|
|
/// `base_def` is definition of resolved part of the
|
|
|
|
|
/// path, `unresolved_segments` is the number of unresolved
|
|
|
|
|
/// segments.
|
2015-02-05 13:20:48 +02:00
|
|
|
|
///
|
2017-12-31 17:17:01 +01:00
|
|
|
|
/// ```text
|
|
|
|
|
/// module::Type::AssocX::AssocY::MethodOrAssocType
|
|
|
|
|
/// ^~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
/// base_def unresolved_segments = 3
|
|
|
|
|
///
|
|
|
|
|
/// <T as Trait>::AssocX::AssocY::MethodOrAssocType
|
|
|
|
|
/// ^~~~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
/// base_def unresolved_segments = 2
|
|
|
|
|
/// ```
|
2015-03-30 12:21:20 +13:00
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
2015-02-17 06:44:23 +02:00
|
|
|
|
pub struct PathResolution {
|
2017-02-18 22:11:42 +03:00
|
|
|
|
base_def: Def,
|
|
|
|
|
unresolved_segments: usize,
|
2015-02-17 06:44:23 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl PathResolution {
|
2017-02-18 22:11:42 +03:00
|
|
|
|
pub fn new(def: Def) -> Self {
|
|
|
|
|
PathResolution { base_def: def, unresolved_segments: 0 }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn with_unresolved_segments(def: Def, mut unresolved_segments: usize) -> Self {
|
|
|
|
|
if def == Def::Err { unresolved_segments = 0 }
|
|
|
|
|
PathResolution { base_def: def, unresolved_segments: unresolved_segments }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn base_def(&self) -> Def {
|
|
|
|
|
self.base_def
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn unresolved_segments(&self) -> usize {
|
|
|
|
|
self.unresolved_segments
|
2016-06-03 23:15:00 +03:00
|
|
|
|
}
|
|
|
|
|
|
2016-06-03 23:15:00 +03:00
|
|
|
|
pub fn kind_name(&self) -> &'static str {
|
2017-02-18 22:11:42 +03:00
|
|
|
|
if self.unresolved_segments != 0 {
|
2016-06-03 23:15:00 +03:00
|
|
|
|
"associated item"
|
|
|
|
|
} else {
|
|
|
|
|
self.base_def.kind_name()
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-02-05 13:20:48 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-06-13 11:44:06 -05:00
|
|
|
|
/// Different kinds of symbols don't influence each other.
|
|
|
|
|
///
|
|
|
|
|
/// Therefore, they have a separate universe (namespace).
|
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
|
|
|
pub enum Namespace {
|
|
|
|
|
TypeNS,
|
|
|
|
|
ValueNS,
|
|
|
|
|
MacroNS,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Just a helper ‒ separate structure for each namespace.
|
|
|
|
|
#[derive(Copy, Clone, Default, Debug)]
|
|
|
|
|
pub struct PerNS<T> {
|
|
|
|
|
pub value_ns: T,
|
|
|
|
|
pub type_ns: T,
|
|
|
|
|
pub macro_ns: T,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<T> PerNS<T> {
|
|
|
|
|
pub fn map<U, F: FnMut(T) -> U>(self, mut f: F) -> PerNS<U> {
|
|
|
|
|
PerNS {
|
|
|
|
|
value_ns: f(self.value_ns),
|
|
|
|
|
type_ns: f(self.type_ns),
|
|
|
|
|
macro_ns: f(self.macro_ns),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<T> ::std::ops::Index<Namespace> for PerNS<T> {
|
|
|
|
|
type Output = T;
|
|
|
|
|
fn index(&self, ns: Namespace) -> &T {
|
|
|
|
|
match ns {
|
|
|
|
|
ValueNS => &self.value_ns,
|
|
|
|
|
TypeNS => &self.type_ns,
|
|
|
|
|
MacroNS => &self.macro_ns,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<T> ::std::ops::IndexMut<Namespace> for PerNS<T> {
|
|
|
|
|
fn index_mut(&mut self, ns: Namespace) -> &mut T {
|
|
|
|
|
match ns {
|
|
|
|
|
ValueNS => &mut self.value_ns,
|
|
|
|
|
TypeNS => &mut self.type_ns,
|
|
|
|
|
MacroNS => &mut self.macro_ns,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<T> PerNS<Option<T>> {
|
|
|
|
|
/// Returns whether all the items in this collection are `None`.
|
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
|
|
|
self.type_ns.is_none() && self.value_ns.is_none() && self.macro_ns.is_none()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns an iterator over the items which are `Some`.
|
|
|
|
|
pub fn present_items(self) -> impl Iterator<Item=T> {
|
|
|
|
|
use std::iter::once;
|
|
|
|
|
|
|
|
|
|
once(self.type_ns)
|
|
|
|
|
.chain(once(self.value_ns))
|
|
|
|
|
.chain(once(self.macro_ns))
|
|
|
|
|
.filter_map(|it| it)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// Definition mapping
|
2015-11-04 00:02:22 -06:00
|
|
|
|
pub type DefMap = NodeMap<PathResolution>;
|
2017-06-03 18:18:32 +02:00
|
|
|
|
|
|
|
|
|
/// This is the replacement export map. It maps a module to all of the exports
|
|
|
|
|
/// within.
|
2017-09-08 13:51:57 -07:00
|
|
|
|
pub type ExportMap = DefIdMap<Vec<Export>>;
|
2014-12-19 00:03:00 +02:00
|
|
|
|
|
2018-06-13 11:44:06 -05:00
|
|
|
|
/// Map used to track the `use` statements within a scope, matching it with all the items in every
|
|
|
|
|
/// namespace.
|
|
|
|
|
pub type ImportMap = NodeMap<PerNS<Option<PathResolution>>>;
|
|
|
|
|
|
2016-11-11 18:22:41 -05:00
|
|
|
|
#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
|
2014-12-19 00:03:00 +02:00
|
|
|
|
pub struct Export {
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// The name of the target.
|
|
|
|
|
pub ident: ast::Ident,
|
|
|
|
|
/// The definition of the target.
|
|
|
|
|
pub def: Def,
|
|
|
|
|
/// The span of the target definition.
|
|
|
|
|
pub span: Span,
|
2017-11-29 11:20:49 -08:00
|
|
|
|
/// The visibility of the export.
|
|
|
|
|
/// We include non-`pub` exports for hygienic macros that get used from extern crates.
|
|
|
|
|
pub vis: ty::Visibility,
|
2014-12-19 00:03:00 +02:00
|
|
|
|
}
|
2014-12-18 21:03:56 +02:00
|
|
|
|
|
2016-09-15 00:51:46 +03:00
|
|
|
|
impl CtorKind {
|
2016-09-15 00:51:46 +03:00
|
|
|
|
pub fn from_ast(vdata: &ast::VariantData) -> CtorKind {
|
2016-09-15 00:51:46 +03:00
|
|
|
|
match *vdata {
|
|
|
|
|
ast::VariantData::Tuple(..) => CtorKind::Fn,
|
|
|
|
|
ast::VariantData::Unit(..) => CtorKind::Const,
|
|
|
|
|
ast::VariantData::Struct(..) => CtorKind::Fictive,
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-09-15 00:51:46 +03:00
|
|
|
|
pub fn from_hir(vdata: &hir::VariantData) -> CtorKind {
|
|
|
|
|
match *vdata {
|
|
|
|
|
hir::VariantData::Tuple(..) => CtorKind::Fn,
|
|
|
|
|
hir::VariantData::Unit(..) => CtorKind::Const,
|
|
|
|
|
hir::VariantData::Struct(..) => CtorKind::Fictive,
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-09-15 00:51:46 +03:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-14 15:31:30 -04:00
|
|
|
|
impl Def {
|
2015-08-16 06:32:28 -04:00
|
|
|
|
pub fn def_id(&self) -> DefId {
|
2014-05-14 15:31:30 -04:00
|
|
|
|
match *self {
|
2016-09-08 19:05:50 +03:00
|
|
|
|
Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) |
|
2017-10-02 12:28:16 +00:00
|
|
|
|
Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) |
|
|
|
|
|
Def::TyAlias(id) | Def::TraitAlias(id) |
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
|
|
|
|
|
Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
|
2017-04-29 14:39:47 +03:00
|
|
|
|
Def::AssociatedConst(id) | Def::Macro(id, ..) |
|
2018-05-22 14:31:56 +02:00
|
|
|
|
Def::Existential(id) |
|
2017-09-03 19:53:58 +01:00
|
|
|
|
Def::GlobalAsm(id) | Def::TyForeign(id) => {
|
2014-05-14 15:31:30 -04:00
|
|
|
|
id
|
|
|
|
|
}
|
2015-09-02 16:11:32 -04:00
|
|
|
|
|
2017-04-29 14:39:47 +03:00
|
|
|
|
Def::Local(..) |
|
|
|
|
|
Def::Upvar(..) |
|
2016-01-20 22:31:10 +03:00
|
|
|
|
Def::Label(..) |
|
|
|
|
|
Def::PrimTy(..) |
|
|
|
|
|
Def::SelfTy(..) |
|
|
|
|
|
Def::Err => {
|
2016-03-26 19:59:04 +01:00
|
|
|
|
bug!("attempted .def_id() on invalid def: {:?}", self)
|
2015-09-07 14:27:13 -04:00
|
|
|
|
}
|
2014-05-14 15:31:30 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
2017-06-04 18:15:19 +02:00
|
|
|
|
|
2017-06-03 18:18:32 +02:00
|
|
|
|
/// A human readable kind name
|
2016-02-25 01:55:54 +00:00
|
|
|
|
pub fn kind_name(&self) -> &'static str {
|
|
|
|
|
match *self {
|
|
|
|
|
Def::Fn(..) => "function",
|
|
|
|
|
Def::Mod(..) => "module",
|
|
|
|
|
Def::Static(..) => "static",
|
|
|
|
|
Def::Variant(..) => "variant",
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Def::VariantCtor(.., CtorKind::Fn) => "tuple variant",
|
|
|
|
|
Def::VariantCtor(.., CtorKind::Const) => "unit variant",
|
|
|
|
|
Def::VariantCtor(.., CtorKind::Fictive) => "struct variant",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::Enum(..) => "enum",
|
2018-05-22 14:31:56 +02:00
|
|
|
|
Def::Existential(..) => "existential type",
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Def::TyAlias(..) => "type alias",
|
2017-10-02 12:28:16 +00:00
|
|
|
|
Def::TraitAlias(..) => "trait alias",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::AssociatedTy(..) => "associated type",
|
|
|
|
|
Def::Struct(..) => "struct",
|
2016-09-15 00:51:46 +03:00
|
|
|
|
Def::StructCtor(.., CtorKind::Fn) => "tuple struct",
|
|
|
|
|
Def::StructCtor(.., CtorKind::Const) => "unit struct",
|
|
|
|
|
Def::StructCtor(.., CtorKind::Fictive) => bug!("impossible struct constructor"),
|
2016-08-06 21:56:02 +03:00
|
|
|
|
Def::Union(..) => "union",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::Trait(..) => "trait",
|
2017-09-03 19:53:58 +01:00
|
|
|
|
Def::TyForeign(..) => "foreign type",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::Method(..) => "method",
|
2016-06-03 23:15:00 +03:00
|
|
|
|
Def::Const(..) => "constant",
|
|
|
|
|
Def::AssociatedConst(..) => "associated constant",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::TyParam(..) => "type parameter",
|
|
|
|
|
Def::PrimTy(..) => "builtin type",
|
|
|
|
|
Def::Local(..) => "local variable",
|
|
|
|
|
Def::Upvar(..) => "closure capture",
|
|
|
|
|
Def::Label(..) => "label",
|
|
|
|
|
Def::SelfTy(..) => "self type",
|
2018-05-28 22:13:59 +03:00
|
|
|
|
Def::Macro(.., macro_kind) => macro_kind.descr(),
|
2017-03-15 21:27:40 -05:00
|
|
|
|
Def::GlobalAsm(..) => "global asm",
|
2016-02-25 01:55:54 +00:00
|
|
|
|
Def::Err => "unresolved item",
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-05-14 15:31:30 -04:00
|
|
|
|
}
|