Move collector to rustc_trans_utils
This commit is contained in:
bjorn3
parent
b7960878ba
commit
906523efea
13 changed files with 565 additions and 460 deletions
|
|
@ -98,7 +98,7 @@
|
|||
//! DefPaths which are much more robust in the face of changes to the code base.
|
||||
|
||||
use monomorphize::Instance;
|
||||
use trans_item::{TransItemExt, InstantiationMode};
|
||||
use trans_item::{BaseTransItemExt, InstantiationMode};
|
||||
|
||||
use rustc::middle::weak_lang_items;
|
||||
use rustc::middle::trans::TransItem;
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ use monomorphize::{self, Instance};
|
|||
use partitioning::{self, PartitioningStrategy, CodegenUnit, CodegenUnitExt};
|
||||
use symbol_names_test;
|
||||
use time_graph;
|
||||
use trans_item::{TransItem, TransItemExt, DefPathBasedNames};
|
||||
use trans_item::{TransItem, BaseTransItemExt, TransItemExt, DefPathBasedNames};
|
||||
use type_::Type;
|
||||
use type_of;
|
||||
use value::Value;
|
||||
|
|
@ -93,6 +93,7 @@ use syntax::ast;
|
|||
use mir::lvalue::Alignment;
|
||||
|
||||
pub use rustc_trans_utils::{find_exported_symbols, check_for_rustc_errors_attr};
|
||||
pub use rustc_trans_utils::trans_item::linkage_by_name;
|
||||
|
||||
pub struct StatRecorder<'a, 'tcx: 'a> {
|
||||
ccx: &'a CrateContext<'a, 'tcx>,
|
||||
|
|
@ -618,33 +619,6 @@ pub fn trans_instance<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, instance: Instance
|
|||
mir::trans_mir(ccx, lldecl, &mir, instance, sig);
|
||||
}
|
||||
|
||||
pub fn linkage_by_name(name: &str) -> Option<Linkage> {
|
||||
use rustc::middle::trans::Linkage::*;
|
||||
|
||||
// Use the names from src/llvm/docs/LangRef.rst here. Most types are only
|
||||
// applicable to variable declarations and may not really make sense for
|
||||
// Rust code in the first place but whitelist them anyway and trust that
|
||||
// the user knows what s/he's doing. Who knows, unanticipated use cases
|
||||
// may pop up in the future.
|
||||
//
|
||||
// ghost, dllimport, dllexport and linkonce_odr_autohide are not supported
|
||||
// and don't have to be, LLVM treats them as no-ops.
|
||||
match name {
|
||||
"appending" => Some(Appending),
|
||||
"available_externally" => Some(AvailableExternally),
|
||||
"common" => Some(Common),
|
||||
"extern_weak" => Some(ExternalWeak),
|
||||
"external" => Some(External),
|
||||
"internal" => Some(Internal),
|
||||
"linkonce" => Some(LinkOnceAny),
|
||||
"linkonce_odr" => Some(LinkOnceODR),
|
||||
"private" => Some(Private),
|
||||
"weak" => Some(WeakAny),
|
||||
"weak_odr" => Some(WeakODR),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_link_section(ccx: &CrateContext,
|
||||
llval: ValueRef,
|
||||
attrs: &[ast::Attribute]) {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -36,7 +36,6 @@ use libc::{c_uint, c_char};
|
|||
use std::iter;
|
||||
|
||||
use syntax::abi::Abi;
|
||||
use syntax::attr;
|
||||
use syntax::symbol::InternedString;
|
||||
use syntax_pos::{Span, DUMMY_SP};
|
||||
|
||||
|
|
@ -552,22 +551,6 @@ pub fn ty_fn_sig<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
|
|||
}
|
||||
}
|
||||
|
||||
pub fn requests_inline<'a, 'tcx>(
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
instance: &ty::Instance<'tcx>
|
||||
) -> bool {
|
||||
if is_inline_instance(tcx, instance) {
|
||||
return true
|
||||
}
|
||||
if let ty::InstanceDef::DropGlue(..) = instance.def {
|
||||
// Drop glue wants to be instantiated at every translation
|
||||
// unit, but without an #[inline] hint. We should make this
|
||||
// available to normal end-users.
|
||||
return true
|
||||
}
|
||||
attr::requests_inline(&instance.def.attrs(tcx)[..])
|
||||
}
|
||||
|
||||
pub fn is_inline_instance<'a, 'tcx>(
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
instance: &ty::Instance<'tcx>
|
||||
|
|
|
|||
|
|
@ -83,6 +83,9 @@ use rustc::ty::maps::Providers;
|
|||
use rustc::ty::{self, TyCtxt};
|
||||
use rustc::util::nodemap::{FxHashSet, FxHashMap};
|
||||
|
||||
use rustc_trans_utils::collector;
|
||||
use rustc_trans_utils::monomorphize;
|
||||
|
||||
mod diagnostics;
|
||||
|
||||
pub mod back {
|
||||
|
|
@ -124,7 +127,6 @@ mod cabi_x86;
|
|||
mod cabi_x86_64;
|
||||
mod cabi_x86_win64;
|
||||
mod callee;
|
||||
mod collector;
|
||||
mod common;
|
||||
mod consts;
|
||||
mod context;
|
||||
|
|
@ -137,7 +139,6 @@ mod machine;
|
|||
mod metadata;
|
||||
mod meth;
|
||||
mod mir;
|
||||
mod monomorphize;
|
||||
mod partitioning;
|
||||
mod symbol_names_test;
|
||||
mod time_graph;
|
||||
|
|
|
|||
|
|
@ -1,136 +0,0 @@
|
|||
// Copyright 2012-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.
|
||||
|
||||
use rustc::hir::def_id::DefId;
|
||||
use rustc::middle::lang_items::DropInPlaceFnLangItem;
|
||||
use rustc::traits;
|
||||
use rustc::ty::adjustment::CustomCoerceUnsized;
|
||||
use rustc::ty::subst::{Kind, Subst, Substs};
|
||||
use rustc::ty::{self, Ty, TyCtxt};
|
||||
|
||||
pub use rustc::ty::Instance;
|
||||
|
||||
fn fn_once_adapter_instance<'a, 'tcx>(
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
closure_did: DefId,
|
||||
substs: ty::ClosureSubsts<'tcx>,
|
||||
) -> Instance<'tcx> {
|
||||
debug!("fn_once_adapter_shim({:?}, {:?})",
|
||||
closure_did,
|
||||
substs);
|
||||
let fn_once = tcx.lang_items().fn_once_trait().unwrap();
|
||||
let call_once = tcx.associated_items(fn_once)
|
||||
.find(|it| it.kind == ty::AssociatedKind::Method)
|
||||
.unwrap().def_id;
|
||||
let def = ty::InstanceDef::ClosureOnceShim { call_once };
|
||||
|
||||
let self_ty = tcx.mk_closure_from_closure_substs(
|
||||
closure_did, substs);
|
||||
|
||||
let sig = tcx.fn_sig(closure_did).subst(tcx, substs.substs);
|
||||
let sig = tcx.erase_late_bound_regions_and_normalize(&sig);
|
||||
assert_eq!(sig.inputs().len(), 1);
|
||||
let substs = tcx.mk_substs([
|
||||
Kind::from(self_ty),
|
||||
Kind::from(sig.inputs()[0]),
|
||||
].iter().cloned());
|
||||
|
||||
debug!("fn_once_adapter_shim: self_ty={:?} sig={:?}", self_ty, sig);
|
||||
Instance { def, substs }
|
||||
}
|
||||
|
||||
fn needs_fn_once_adapter_shim(actual_closure_kind: ty::ClosureKind,
|
||||
trait_closure_kind: ty::ClosureKind)
|
||||
-> Result<bool, ()>
|
||||
{
|
||||
match (actual_closure_kind, trait_closure_kind) {
|
||||
(ty::ClosureKind::Fn, ty::ClosureKind::Fn) |
|
||||
(ty::ClosureKind::FnMut, ty::ClosureKind::FnMut) |
|
||||
(ty::ClosureKind::FnOnce, ty::ClosureKind::FnOnce) => {
|
||||
// No adapter needed.
|
||||
Ok(false)
|
||||
}
|
||||
(ty::ClosureKind::Fn, ty::ClosureKind::FnMut) => {
|
||||
// The closure fn `llfn` is a `fn(&self, ...)`. We want a
|
||||
// `fn(&mut self, ...)`. In fact, at trans time, these are
|
||||
// basically the same thing, so we can just return llfn.
|
||||
Ok(false)
|
||||
}
|
||||
(ty::ClosureKind::Fn, ty::ClosureKind::FnOnce) |
|
||||
(ty::ClosureKind::FnMut, ty::ClosureKind::FnOnce) => {
|
||||
// The closure fn `llfn` is a `fn(&self, ...)` or `fn(&mut
|
||||
// self, ...)`. We want a `fn(self, ...)`. We can produce
|
||||
// this by doing something like:
|
||||
//
|
||||
// fn call_once(self, ...) { call_mut(&self, ...) }
|
||||
// fn call_once(mut self, ...) { call_mut(&mut self, ...) }
|
||||
//
|
||||
// These are both the same at trans time.
|
||||
Ok(true)
|
||||
}
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn resolve_closure<'a, 'tcx> (
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
def_id: DefId,
|
||||
substs: ty::ClosureSubsts<'tcx>,
|
||||
requested_kind: ty::ClosureKind)
|
||||
-> Instance<'tcx>
|
||||
{
|
||||
let actual_kind = tcx.closure_kind(def_id);
|
||||
|
||||
match needs_fn_once_adapter_shim(actual_kind, requested_kind) {
|
||||
Ok(true) => fn_once_adapter_instance(tcx, def_id, substs),
|
||||
_ => Instance::new(def_id, substs.substs)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn resolve_drop_in_place<'a, 'tcx>(
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
ty: Ty<'tcx>)
|
||||
-> ty::Instance<'tcx>
|
||||
{
|
||||
let def_id = tcx.require_lang_item(DropInPlaceFnLangItem);
|
||||
let substs = tcx.intern_substs(&[Kind::from(ty)]);
|
||||
Instance::resolve(tcx, ty::ParamEnv::empty(traits::Reveal::All), def_id, substs).unwrap()
|
||||
}
|
||||
|
||||
pub fn custom_coerce_unsize_info<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
source_ty: Ty<'tcx>,
|
||||
target_ty: Ty<'tcx>)
|
||||
-> CustomCoerceUnsized {
|
||||
let def_id = tcx.lang_items().coerce_unsized_trait().unwrap();
|
||||
|
||||
let trait_ref = ty::Binder(ty::TraitRef {
|
||||
def_id: def_id,
|
||||
substs: tcx.mk_substs_trait(source_ty, &[target_ty])
|
||||
});
|
||||
|
||||
match tcx.trans_fulfill_obligation( (ty::ParamEnv::empty(traits::Reveal::All), trait_ref)) {
|
||||
traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => {
|
||||
tcx.coerce_unsized_info(impl_def_id).custom_kind.unwrap()
|
||||
}
|
||||
vtable => {
|
||||
bug!("invalid CoerceUnsized vtable: {:?}", vtable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the normalized type of a struct field
|
||||
pub fn field_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
param_substs: &Substs<'tcx>,
|
||||
f: &'tcx ty::FieldDef)
|
||||
-> Ty<'tcx>
|
||||
{
|
||||
tcx.normalize_associated_type(&f.ty(tcx, param_substs))
|
||||
}
|
||||
|
||||
|
|
@ -114,7 +114,7 @@ use rustc::util::nodemap::{FxHashMap, FxHashSet};
|
|||
use std::collections::hash_map::Entry;
|
||||
use syntax::ast::NodeId;
|
||||
use syntax::symbol::{Symbol, InternedString};
|
||||
use trans_item::{TransItem, TransItemExt, InstantiationMode};
|
||||
use trans_item::{TransItem, BaseTransItemExt, TransItemExt, InstantiationMode};
|
||||
|
||||
pub use rustc::middle::trans::CodegenUnit;
|
||||
|
||||
|
|
|
|||
|
|
@ -24,50 +24,21 @@ use declare;
|
|||
use llvm;
|
||||
use monomorphize::Instance;
|
||||
use rustc::hir;
|
||||
use rustc::hir::def_id::DefId;
|
||||
use rustc::middle::trans::{Linkage, Visibility};
|
||||
use rustc::session::config::OptLevel;
|
||||
use rustc::traits;
|
||||
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
|
||||
use rustc::ty::subst::{Subst, Substs};
|
||||
use rustc::ty::{self, TyCtxt, TypeFoldable};
|
||||
use syntax::ast;
|
||||
use syntax::attr::{self, InlineAttr};
|
||||
use syntax::attr;
|
||||
use syntax_pos::Span;
|
||||
use syntax_pos::symbol::Symbol;
|
||||
use type_of;
|
||||
use std::fmt::{self, Write};
|
||||
use std::iter;
|
||||
use std::fmt;
|
||||
|
||||
pub use rustc::middle::trans::TransItem;
|
||||
|
||||
/// Describes how a translation item will be instantiated in object files.
|
||||
#[derive(PartialEq, Eq, Clone, Copy, Debug, Hash)]
|
||||
pub enum InstantiationMode {
|
||||
/// There will be exactly one instance of the given TransItem. It will have
|
||||
/// external linkage so that it can be linked to from other codegen units.
|
||||
GloballyShared {
|
||||
/// In some compilation scenarios we may decide to take functions that
|
||||
/// are typically `LocalCopy` and instead move them to `GloballyShared`
|
||||
/// to avoid translating them a bunch of times. In this situation,
|
||||
/// however, our local copy may conflict with other crates also
|
||||
/// inlining the same function.
|
||||
///
|
||||
/// This flag indicates that this situation is occuring, and informs
|
||||
/// symbol name calculation that some extra mangling is needed to
|
||||
/// avoid conflicts. Note that this may eventually go away entirely if
|
||||
/// ThinLTO enables us to *always* have a globally shared instance of a
|
||||
/// function within one crate's compilation.
|
||||
may_conflict: bool,
|
||||
},
|
||||
|
||||
/// Each codegen unit containing a reference to the given TransItem will
|
||||
/// have its own private copy of the function (with internal linkage).
|
||||
LocalCopy,
|
||||
}
|
||||
|
||||
pub trait TransItemExt<'a, 'tcx>: fmt::Debug {
|
||||
fn as_trans_item(&self) -> &TransItem<'tcx>;
|
||||
pub use rustc_trans_utils::trans_item::*;
|
||||
pub use rustc_trans_utils::trans_item::TransItemExt as BaseTransItemExt;
|
||||
|
||||
pub trait TransItemExt<'a, 'tcx>: fmt::Debug + BaseTransItemExt<'a, 'tcx> {
|
||||
fn define(&self, ccx: &CrateContext<'a, 'tcx>) {
|
||||
debug!("BEGIN IMPLEMENTING '{} ({})' in cgu {}",
|
||||
self.to_string(ccx.tcx()),
|
||||
|
|
@ -165,53 +136,6 @@ pub trait TransItemExt<'a, 'tcx>: fmt::Debug {
|
|||
}.map(|node_id| tcx.hir.span(node_id))
|
||||
}
|
||||
|
||||
fn instantiation_mode(&self,
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>)
|
||||
-> InstantiationMode {
|
||||
let inline_in_all_cgus =
|
||||
tcx.sess.opts.debugging_opts.inline_in_all_cgus.unwrap_or_else(|| {
|
||||
tcx.sess.opts.optimize != OptLevel::No
|
||||
});
|
||||
|
||||
match *self.as_trans_item() {
|
||||
TransItem::Fn(ref instance) => {
|
||||
// If this function isn't inlined or otherwise has explicit
|
||||
// linkage, then we'll be creating a globally shared version.
|
||||
if self.explicit_linkage(tcx).is_some() ||
|
||||
!common::requests_inline(tcx, instance)
|
||||
{
|
||||
return InstantiationMode::GloballyShared { may_conflict: false }
|
||||
}
|
||||
|
||||
// At this point we don't have explicit linkage and we're an
|
||||
// inlined function. If we're inlining into all CGUs then we'll
|
||||
// be creating a local copy per CGU
|
||||
if inline_in_all_cgus {
|
||||
return InstantiationMode::LocalCopy
|
||||
}
|
||||
|
||||
// Finally, if this is `#[inline(always)]` we're sure to respect
|
||||
// that with an inline copy per CGU, but otherwise we'll be
|
||||
// creating one copy of this `#[inline]` function which may
|
||||
// conflict with upstream crates as it could be an exported
|
||||
// symbol.
|
||||
let attrs = instance.def.attrs(tcx);
|
||||
match attr::find_inline_attr(Some(tcx.sess.diagnostic()), &attrs) {
|
||||
InlineAttr::Always => InstantiationMode::LocalCopy,
|
||||
_ => {
|
||||
InstantiationMode::GloballyShared { may_conflict: true }
|
||||
}
|
||||
}
|
||||
}
|
||||
TransItem::Static(..) => {
|
||||
InstantiationMode::GloballyShared { may_conflict: false }
|
||||
}
|
||||
TransItem::GlobalAsm(..) => {
|
||||
InstantiationMode::GloballyShared { may_conflict: false }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_generic_fn(&self) -> bool {
|
||||
match *self.as_trans_item() {
|
||||
TransItem::Fn(ref instance) => {
|
||||
|
|
@ -222,97 +146,6 @@ pub trait TransItemExt<'a, 'tcx>: fmt::Debug {
|
|||
}
|
||||
}
|
||||
|
||||
fn explicit_linkage(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option<Linkage> {
|
||||
let def_id = match *self.as_trans_item() {
|
||||
TransItem::Fn(ref instance) => instance.def_id(),
|
||||
TransItem::Static(node_id) => tcx.hir.local_def_id(node_id),
|
||||
TransItem::GlobalAsm(..) => return None,
|
||||
};
|
||||
|
||||
let attributes = tcx.get_attrs(def_id);
|
||||
if let Some(name) = attr::first_attr_value_str_by_name(&attributes, "linkage") {
|
||||
if let Some(linkage) = base::linkage_by_name(&name.as_str()) {
|
||||
Some(linkage)
|
||||
} else {
|
||||
let span = tcx.hir.span_if_local(def_id);
|
||||
if let Some(span) = span {
|
||||
tcx.sess.span_fatal(span, "invalid linkage specified")
|
||||
} else {
|
||||
tcx.sess.fatal(&format!("invalid linkage specified: {}", name))
|
||||
}
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether this instance is instantiable - whether it has no unsatisfied
|
||||
/// predicates.
|
||||
///
|
||||
/// In order to translate an item, all of its predicates must hold, because
|
||||
/// otherwise the item does not make sense. Type-checking ensures that
|
||||
/// the predicates of every item that is *used by* a valid item *do*
|
||||
/// hold, so we can rely on that.
|
||||
///
|
||||
/// However, we translate collector roots (reachable items) and functions
|
||||
/// in vtables when they are seen, even if they are not used, and so they
|
||||
/// might not be instantiable. For example, a programmer can define this
|
||||
/// public function:
|
||||
///
|
||||
/// pub fn foo<'a>(s: &'a mut ()) where &'a mut (): Clone {
|
||||
/// <&mut () as Clone>::clone(&s);
|
||||
/// }
|
||||
///
|
||||
/// That function can't be translated, because the method `<&mut () as Clone>::clone`
|
||||
/// does not exist. Luckily for us, that function can't ever be used,
|
||||
/// because that would require for `&'a mut (): Clone` to hold, so we
|
||||
/// can just not emit any code, or even a linker reference for it.
|
||||
///
|
||||
/// Similarly, if a vtable method has such a signature, and therefore can't
|
||||
/// be used, we can just not emit it and have a placeholder (a null pointer,
|
||||
/// which will never be accessed) in its place.
|
||||
fn is_instantiable(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> bool {
|
||||
debug!("is_instantiable({:?})", self);
|
||||
let (def_id, substs) = match *self.as_trans_item() {
|
||||
TransItem::Fn(ref instance) => (instance.def_id(), instance.substs),
|
||||
TransItem::Static(node_id) => (tcx.hir.local_def_id(node_id), Substs::empty()),
|
||||
// global asm never has predicates
|
||||
TransItem::GlobalAsm(..) => return true
|
||||
};
|
||||
|
||||
let predicates = tcx.predicates_of(def_id).predicates.subst(tcx, substs);
|
||||
traits::normalize_and_test_predicates(tcx, predicates)
|
||||
}
|
||||
|
||||
fn to_string(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> String {
|
||||
let hir_map = &tcx.hir;
|
||||
|
||||
return match *self.as_trans_item() {
|
||||
TransItem::Fn(instance) => {
|
||||
to_string_internal(tcx, "fn ", instance)
|
||||
},
|
||||
TransItem::Static(node_id) => {
|
||||
let def_id = hir_map.local_def_id(node_id);
|
||||
let instance = Instance::new(def_id, tcx.intern_substs(&[]));
|
||||
to_string_internal(tcx, "static ", instance)
|
||||
},
|
||||
TransItem::GlobalAsm(..) => {
|
||||
"global_asm".to_string()
|
||||
}
|
||||
};
|
||||
|
||||
fn to_string_internal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
prefix: &str,
|
||||
instance: Instance<'tcx>)
|
||||
-> String {
|
||||
let mut result = String::with_capacity(32);
|
||||
result.push_str(prefix);
|
||||
let printer = DefPathBasedNames::new(tcx, false, false);
|
||||
printer.push_instance_as_string(instance, &mut result);
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn to_raw_string(&self) -> String {
|
||||
match *self.as_trans_item() {
|
||||
TransItem::Fn(instance) => {
|
||||
|
|
@ -330,11 +163,7 @@ pub trait TransItemExt<'a, 'tcx>: fmt::Debug {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> TransItemExt<'a, 'tcx> for TransItem<'tcx> {
|
||||
fn as_trans_item(&self) -> &TransItem<'tcx> {
|
||||
self
|
||||
}
|
||||
}
|
||||
impl<'a, 'tcx> TransItemExt<'a, 'tcx> for TransItem<'tcx> {}
|
||||
|
||||
fn predefine_static<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
|
||||
node_id: ast::NodeId,
|
||||
|
|
@ -402,235 +231,3 @@ fn predefine_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
|
|||
ccx.instances().borrow_mut().insert(instance, lldecl);
|
||||
}
|
||||
|
||||
//=-----------------------------------------------------------------------------
|
||||
// TransItem String Keys
|
||||
//=-----------------------------------------------------------------------------
|
||||
|
||||
// The code below allows for producing a unique string key for a trans item.
|
||||
// These keys are used by the handwritten auto-tests, so they need to be
|
||||
// predictable and human-readable.
|
||||
//
|
||||
// Note: A lot of this could looks very similar to what's already in the
|
||||
// ppaux module. It would be good to refactor things so we only have one
|
||||
// parameterizable implementation for printing types.
|
||||
|
||||
/// Same as `unique_type_name()` but with the result pushed onto the given
|
||||
/// `output` parameter.
|
||||
pub struct DefPathBasedNames<'a, 'tcx: 'a> {
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
omit_disambiguators: bool,
|
||||
omit_local_crate_name: bool,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> DefPathBasedNames<'a, 'tcx> {
|
||||
pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
omit_disambiguators: bool,
|
||||
omit_local_crate_name: bool)
|
||||
-> Self {
|
||||
DefPathBasedNames {
|
||||
tcx,
|
||||
omit_disambiguators,
|
||||
omit_local_crate_name,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn push_type_name(&self, t: Ty<'tcx>, output: &mut String) {
|
||||
match t.sty {
|
||||
ty::TyBool => output.push_str("bool"),
|
||||
ty::TyChar => output.push_str("char"),
|
||||
ty::TyStr => output.push_str("str"),
|
||||
ty::TyNever => output.push_str("!"),
|
||||
ty::TyInt(ast::IntTy::Is) => output.push_str("isize"),
|
||||
ty::TyInt(ast::IntTy::I8) => output.push_str("i8"),
|
||||
ty::TyInt(ast::IntTy::I16) => output.push_str("i16"),
|
||||
ty::TyInt(ast::IntTy::I32) => output.push_str("i32"),
|
||||
ty::TyInt(ast::IntTy::I64) => output.push_str("i64"),
|
||||
ty::TyInt(ast::IntTy::I128) => output.push_str("i128"),
|
||||
ty::TyUint(ast::UintTy::Us) => output.push_str("usize"),
|
||||
ty::TyUint(ast::UintTy::U8) => output.push_str("u8"),
|
||||
ty::TyUint(ast::UintTy::U16) => output.push_str("u16"),
|
||||
ty::TyUint(ast::UintTy::U32) => output.push_str("u32"),
|
||||
ty::TyUint(ast::UintTy::U64) => output.push_str("u64"),
|
||||
ty::TyUint(ast::UintTy::U128) => output.push_str("u128"),
|
||||
ty::TyFloat(ast::FloatTy::F32) => output.push_str("f32"),
|
||||
ty::TyFloat(ast::FloatTy::F64) => output.push_str("f64"),
|
||||
ty::TyAdt(adt_def, substs) => {
|
||||
self.push_def_path(adt_def.did, output);
|
||||
self.push_type_params(substs, iter::empty(), output);
|
||||
},
|
||||
ty::TyTuple(component_types, _) => {
|
||||
output.push('(');
|
||||
for &component_type in component_types {
|
||||
self.push_type_name(component_type, output);
|
||||
output.push_str(", ");
|
||||
}
|
||||
if !component_types.is_empty() {
|
||||
output.pop();
|
||||
output.pop();
|
||||
}
|
||||
output.push(')');
|
||||
},
|
||||
ty::TyRawPtr(ty::TypeAndMut { ty: inner_type, mutbl } ) => {
|
||||
output.push('*');
|
||||
match mutbl {
|
||||
hir::MutImmutable => output.push_str("const "),
|
||||
hir::MutMutable => output.push_str("mut "),
|
||||
}
|
||||
|
||||
self.push_type_name(inner_type, output);
|
||||
},
|
||||
ty::TyRef(_, ty::TypeAndMut { ty: inner_type, mutbl }) => {
|
||||
output.push('&');
|
||||
if mutbl == hir::MutMutable {
|
||||
output.push_str("mut ");
|
||||
}
|
||||
|
||||
self.push_type_name(inner_type, output);
|
||||
},
|
||||
ty::TyArray(inner_type, len) => {
|
||||
output.push('[');
|
||||
self.push_type_name(inner_type, output);
|
||||
write!(output, "; {}",
|
||||
len.val.to_const_int().unwrap().to_u64().unwrap()).unwrap();
|
||||
output.push(']');
|
||||
},
|
||||
ty::TySlice(inner_type) => {
|
||||
output.push('[');
|
||||
self.push_type_name(inner_type, output);
|
||||
output.push(']');
|
||||
},
|
||||
ty::TyDynamic(ref trait_data, ..) => {
|
||||
if let Some(principal) = trait_data.principal() {
|
||||
self.push_def_path(principal.def_id(), output);
|
||||
self.push_type_params(principal.skip_binder().substs,
|
||||
trait_data.projection_bounds(),
|
||||
output);
|
||||
}
|
||||
},
|
||||
ty::TyFnDef(..) |
|
||||
ty::TyFnPtr(_) => {
|
||||
let sig = t.fn_sig(self.tcx);
|
||||
if sig.unsafety() == hir::Unsafety::Unsafe {
|
||||
output.push_str("unsafe ");
|
||||
}
|
||||
|
||||
let abi = sig.abi();
|
||||
if abi != ::abi::Abi::Rust {
|
||||
output.push_str("extern \"");
|
||||
output.push_str(abi.name());
|
||||
output.push_str("\" ");
|
||||
}
|
||||
|
||||
output.push_str("fn(");
|
||||
|
||||
let sig = self.tcx.erase_late_bound_regions_and_normalize(&sig);
|
||||
|
||||
if !sig.inputs().is_empty() {
|
||||
for ¶meter_type in sig.inputs() {
|
||||
self.push_type_name(parameter_type, output);
|
||||
output.push_str(", ");
|
||||
}
|
||||
output.pop();
|
||||
output.pop();
|
||||
}
|
||||
|
||||
if sig.variadic {
|
||||
if !sig.inputs().is_empty() {
|
||||
output.push_str(", ...");
|
||||
} else {
|
||||
output.push_str("...");
|
||||
}
|
||||
}
|
||||
|
||||
output.push(')');
|
||||
|
||||
if !sig.output().is_nil() {
|
||||
output.push_str(" -> ");
|
||||
self.push_type_name(sig.output(), output);
|
||||
}
|
||||
},
|
||||
ty::TyGenerator(def_id, ref closure_substs, _) |
|
||||
ty::TyClosure(def_id, ref closure_substs) => {
|
||||
self.push_def_path(def_id, output);
|
||||
let generics = self.tcx.generics_of(self.tcx.closure_base_def_id(def_id));
|
||||
let substs = closure_substs.substs.truncate_to(self.tcx, generics);
|
||||
self.push_type_params(substs, iter::empty(), output);
|
||||
}
|
||||
ty::TyError |
|
||||
ty::TyInfer(_) |
|
||||
ty::TyProjection(..) |
|
||||
ty::TyParam(_) |
|
||||
ty::TyAnon(..) => {
|
||||
bug!("DefPathBasedNames: Trying to create type name for \
|
||||
unexpected type: {:?}", t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn push_def_path(&self,
|
||||
def_id: DefId,
|
||||
output: &mut String) {
|
||||
let def_path = self.tcx.def_path(def_id);
|
||||
|
||||
// some_crate::
|
||||
if !(self.omit_local_crate_name && def_id.is_local()) {
|
||||
output.push_str(&self.tcx.crate_name(def_path.krate).as_str());
|
||||
output.push_str("::");
|
||||
}
|
||||
|
||||
// foo::bar::ItemName::
|
||||
for part in self.tcx.def_path(def_id).data {
|
||||
if self.omit_disambiguators {
|
||||
write!(output, "{}::", part.data.as_interned_str()).unwrap();
|
||||
} else {
|
||||
write!(output, "{}[{}]::",
|
||||
part.data.as_interned_str(),
|
||||
part.disambiguator).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// remove final "::"
|
||||
output.pop();
|
||||
output.pop();
|
||||
}
|
||||
|
||||
fn push_type_params<I>(&self,
|
||||
substs: &Substs<'tcx>,
|
||||
projections: I,
|
||||
output: &mut String)
|
||||
where I: Iterator<Item=ty::PolyExistentialProjection<'tcx>>
|
||||
{
|
||||
let mut projections = projections.peekable();
|
||||
if substs.types().next().is_none() && projections.peek().is_none() {
|
||||
return;
|
||||
}
|
||||
|
||||
output.push('<');
|
||||
|
||||
for type_parameter in substs.types() {
|
||||
self.push_type_name(type_parameter, output);
|
||||
output.push_str(", ");
|
||||
}
|
||||
|
||||
for projection in projections {
|
||||
let projection = projection.skip_binder();
|
||||
let name = &self.tcx.associated_item(projection.item_def_id).name.as_str();
|
||||
output.push_str(name);
|
||||
output.push_str("=");
|
||||
self.push_type_name(projection.ty, output);
|
||||
output.push_str(", ");
|
||||
}
|
||||
|
||||
output.pop();
|
||||
output.pop();
|
||||
|
||||
output.push('>');
|
||||
}
|
||||
|
||||
pub fn push_instance_as_string(&self,
|
||||
instance: Instance<'tcx>,
|
||||
output: &mut String) {
|
||||
self.push_def_path(instance.def_id(), output);
|
||||
self.push_type_params(instance.substs, iter::empty(), output);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue