1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! This module contains the code to convert from the wacky tcx data
12 //! structures into the hair. The `builder` is generally ignorant of
13 //! the tcx etc, and instead goes through the `Cx` for most of its
19 use rustc_data_structures::indexed_vec::Idx;
20 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
21 use rustc::hir::map::blocks::FnLikeNode;
22 use rustc::middle::region;
23 use rustc::infer::InferCtxt;
24 use rustc::ty::subst::Subst;
25 use rustc::ty::{self, Ty, TyCtxt};
26 use rustc::ty::subst::{Kind, Substs};
27 use syntax::ast::{self, LitKind};
29 use syntax::symbol::Symbol;
31 use rustc_data_structures::sync::Lrc;
32 use hair::pattern::parse_float;
35 pub struct Cx<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
36 tcx: TyCtxt<'a, 'gcx, 'tcx>,
37 infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
39 pub root_lint_level: ast::NodeId,
40 pub param_env: ty::ParamEnv<'gcx>,
42 /// Identity `Substs` for use with const-evaluation.
43 pub identity_substs: &'gcx Substs<'gcx>,
45 pub region_scope_tree: Lrc<region::ScopeTree>,
46 pub tables: &'a ty::TypeckTables<'gcx>,
48 /// This is `Constness::Const` if we are compiling a `static`,
49 /// `const`, or the body of a `const fn`.
50 constness: hir::Constness,
52 /// What kind of body is being compiled.
53 pub body_owner_kind: hir::BodyOwnerKind,
55 /// True if this constant/function needs overflow checks.
59 impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
60 pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
61 src_id: ast::NodeId) -> Cx<'a, 'gcx, 'tcx> {
63 let src_def_id = tcx.hir.local_def_id(src_id);
64 let body_owner_kind = tcx.hir.body_owner_kind(src_id);
66 let constness = match body_owner_kind {
67 hir::BodyOwnerKind::Const |
68 hir::BodyOwnerKind::Static(_) => hir::Constness::Const,
69 hir::BodyOwnerKind::Fn => {
70 let fn_like = FnLikeNode::from_node(infcx.tcx.hir.get(src_id));
71 fn_like.map_or(hir::Constness::NotConst, |f| f.constness())
75 let attrs = tcx.hir.attrs(src_id);
77 // Some functions always have overflow checks enabled,
78 // however, they may not get codegen'd, depending on
79 // the settings for the crate they are codegened in.
80 let mut check_overflow = attr::contains_name(attrs, "rustc_inherit_overflow_checks");
82 // Respect -C overflow-checks.
83 check_overflow |= tcx.sess.overflow_checks();
85 // Constants and const fn's always need overflow checks.
86 check_overflow |= constness == hir::Constness::Const;
88 let lint_level = lint_level_for_hir_id(tcx, src_id);
92 root_lint_level: lint_level,
93 param_env: tcx.param_env(src_def_id),
94 identity_substs: Substs::identity_for_item(tcx.global_tcx(), src_def_id),
95 region_scope_tree: tcx.region_scope_tree(src_def_id),
96 tables: tcx.typeck_tables_of(src_def_id),
105 impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
106 /// Normalizes `ast` into the appropriate `mirror` type.
107 pub fn mirror<M: Mirror<'tcx>>(&mut self, ast: M) -> M::Output {
108 ast.make_mirror(self)
111 pub fn usize_ty(&mut self) -> Ty<'tcx> {
115 pub fn usize_literal(&mut self, value: u64) -> &'tcx ty::Const<'tcx> {
116 ty::Const::from_usize(self.tcx, value)
119 pub fn bool_ty(&mut self) -> Ty<'tcx> {
123 pub fn unit_ty(&mut self) -> Ty<'tcx> {
127 pub fn true_literal(&mut self) -> &'tcx ty::Const<'tcx> {
128 ty::Const::from_bool(self.tcx, true)
131 pub fn false_literal(&mut self) -> &'tcx ty::Const<'tcx> {
132 ty::Const::from_bool(self.tcx, false)
135 // FIXME: Combine with rustc_mir::hair::pattern::lit_to_const
136 pub fn const_eval_literal(
138 lit: &'tcx ast::LitKind,
142 ) -> &'tcx ty::Const<'tcx> {
143 trace!("const_eval_literal: {:#?}, {:?}, {:?}, {:?}", lit, ty, sp, neg);
145 let parse_float = |num, fty| -> ConstValue<'tcx> {
146 parse_float(num, fty, neg).unwrap_or_else(|_| {
147 // FIXME(#31407) this is only necessary because float parsing is buggy
148 self.tcx.sess.span_fatal(sp, "could not evaluate float literal (see issue #31407)");
153 let param_ty = self.param_env.and(self.tcx.lift_to_global(&ty).unwrap());
154 let bit_width = self.tcx.layout_of(param_ty).unwrap().size.bits();
155 trace!("trunc {} with size {} and shift {}", n, bit_width, 128 - bit_width);
156 let shift = 128 - bit_width;
157 let result = (n << shift) >> shift;
158 trace!("trunc result: {}", result);
159 ConstValue::Scalar(Scalar::Bits {
161 defined: bit_width as u8,
165 use rustc::mir::interpret::*;
166 let lit = match *lit {
167 LitKind::Str(ref s, _) => {
169 let id = self.tcx.allocate_bytes(s.as_bytes());
170 let value = Scalar::Ptr(id.into()).to_value_with_len(s.len() as u64, self.tcx);
171 ConstValue::from_byval_value(value)
173 LitKind::ByteStr(ref data) => {
174 let id = self.tcx.allocate_bytes(data);
175 ConstValue::Scalar(Scalar::Ptr(id.into()))
177 LitKind::Byte(n) => ConstValue::Scalar(Scalar::Bits {
181 LitKind::Int(n, _) if neg => {
183 let n = n.overflowing_neg().0;
186 LitKind::Int(n, _) => trunc(n),
187 LitKind::Float(n, fty) => {
190 LitKind::FloatUnsuffixed(n) => {
191 let fty = match ty.sty {
192 ty::TyFloat(fty) => fty,
197 LitKind::Bool(b) => ConstValue::Scalar(Scalar::Bits {
201 LitKind::Char(c) => ConstValue::Scalar(Scalar::Bits {
206 ty::Const::from_const_value(self.tcx, lit, ty)
209 pub fn pattern_from_hir(&mut self, p: &hir::Pat) -> Pattern<'tcx> {
210 let tcx = self.tcx.global_tcx();
211 let p = match tcx.hir.get(p.id) {
212 hir::map::NodePat(p) | hir::map::NodeBinding(p) => p,
213 node => bug!("pattern became {:?}", node)
215 Pattern::from_hir(tcx,
216 self.param_env.and(self.identity_substs),
221 pub fn trait_method(&mut self,
225 params: &[Kind<'tcx>])
226 -> (Ty<'tcx>, &'tcx ty::Const<'tcx>) {
227 let method_name = Symbol::intern(method_name);
228 let substs = self.tcx.mk_substs_trait(self_ty, params);
229 for item in self.tcx.associated_items(trait_def_id) {
230 if item.kind == ty::AssociatedKind::Method && item.ident.name == method_name {
231 let method_ty = self.tcx.type_of(item.def_id);
232 let method_ty = method_ty.subst(self.tcx, substs);
233 return (method_ty, ty::Const::zero_sized(self.tcx, method_ty));
237 bug!("found no method `{}` in `{:?}`", method_name, trait_def_id);
240 pub fn all_fields(&mut self, adt_def: &ty::AdtDef, variant_index: usize) -> Vec<Field> {
241 (0..adt_def.variants[variant_index].fields.len())
246 pub fn needs_drop(&mut self, ty: Ty<'tcx>) -> bool {
247 let (ty, param_env) = self.tcx.lift_to_global(&(ty, self.param_env)).unwrap_or_else(|| {
248 bug!("MIR: Cx::needs_drop({:?}, {:?}) got \
249 type with inference types/regions",
252 ty.needs_drop(self.tcx.global_tcx(), param_env)
255 fn lint_level_of(&self, node_id: ast::NodeId) -> LintLevel {
256 let hir_id = self.tcx.hir.definitions().node_to_hir_id(node_id);
257 let has_lint_level = self.tcx.dep_graph.with_ignore(|| {
258 self.tcx.lint_levels(LOCAL_CRATE).lint_level_set(hir_id).is_some()
262 LintLevel::Explicit(node_id)
268 pub fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {
272 pub fn tables(&self) -> &'a ty::TypeckTables<'gcx> {
276 pub fn check_overflow(&self) -> bool {
280 pub fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool {
281 self.infcx.type_moves_by_default(self.param_env, ty, span)
285 fn lint_level_for_hir_id(tcx: TyCtxt, mut id: ast::NodeId) -> ast::NodeId {
286 // Right now we insert a `with_ignore` node in the dep graph here to
287 // ignore the fact that `lint_levels` below depends on the entire crate.
288 // For now this'll prevent false positives of recompiling too much when
291 // Once red/green incremental compilation lands we should be able to
292 // remove this because while the crate changes often the lint level map
293 // will change rarely.
294 tcx.dep_graph.with_ignore(|| {
295 let sets = tcx.lint_levels(LOCAL_CRATE);
297 let hir_id = tcx.hir.definitions().node_to_hir_id(id);
298 if sets.lint_level_set(hir_id).is_some() {
301 let next = tcx.hir.get_parent_node(id);
303 bug!("lint traversal reached the root of the crate");