src/librustc/middle/ty/adjustment.rs

   1 // Copyright 2012-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.
   4 //
   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.
  10
  11 pub use self::AutoAdjustment::*;
  12 pub use self::AutoRef::*;
  13
  14 use middle::ty::{self, Ty, TypeAndMut};
  15 use middle::ty::HasTypeFlags;
  16 use middle::ty::LvaluePreference::{NoPreference};
  17
  18 use syntax::ast;
  19 use syntax::codemap::Span;
  20
  21 use rustc_front::hir;
  22
  23 #[derive(Copy, Clone)]
  24 pub enum AutoAdjustment<'tcx> {
  25     AdjustReifyFnPointer,   // go from a fn-item type to a fn-pointer type
  26     AdjustUnsafeFnPointer,  // go from a safe fn pointer to an unsafe fn pointer
  27     AdjustDerefRef(AutoDerefRef<'tcx>),
  28 }
  29
  30 /// Represents coercing a pointer to a different kind of pointer - where 'kind'
  31 /// here means either or both of raw vs borrowed vs unique and fat vs thin.
  32 ///
  33 /// We transform pointers by following the following steps in order:
  34 /// 1. Deref the pointer `self.autoderefs` times (may be 0).
  35 /// 2. If `autoref` is `Some(_)`, then take the address and produce either a
  36 ///    `&` or `*` pointer.
  37 /// 3. If `unsize` is `Some(_)`, then apply the unsize transformation,
  38 ///    which will do things like convert thin pointers to fat
  39 ///    pointers, or convert structs containing thin pointers to
  40 ///    structs containing fat pointers, or convert between fat
  41 ///    pointers.  We don't store the details of how the transform is
  42 ///    done (in fact, we don't know that, because it might depend on
  43 ///    the precise type parameters). We just store the target
  44 ///    type. Trans figures out what has to be done at monomorphization
  45 ///    time based on the precise source/target type at hand.
  46 ///
  47 /// To make that more concrete, here are some common scenarios:
  48 ///
  49 /// 1. The simplest cases are where the pointer is not adjusted fat vs thin.
  50 /// Here the pointer will be dereferenced N times (where a dereference can
  51 /// happen to to raw or borrowed pointers or any smart pointer which implements
  52 /// Deref, including Box<_>). The number of dereferences is given by
  53 /// `autoderefs`.  It can then be auto-referenced zero or one times, indicated
  54 /// by `autoref`, to either a raw or borrowed pointer. In these cases unsize is
  55 /// None.
  56 ///
  57 /// 2. A thin-to-fat coercon involves unsizing the underlying data. We start
  58 /// with a thin pointer, deref a number of times, unsize the underlying data,
  59 /// then autoref. The 'unsize' phase may change a fixed length array to a
  60 /// dynamically sized one, a concrete object to a trait object, or statically
  61 /// sized struct to a dyncamically sized one. E.g., &[i32; 4] -> &[i32] is
  62 /// represented by:
  63 ///
  64 /// ```
  65 /// AutoDerefRef {
  66 ///     autoderefs: 1,          // &[i32; 4] -> [i32; 4]
  67 ///     autoref: Some(AutoPtr), // [i32] -> &[i32]
  68 ///     unsize: Some([i32]),    // [i32; 4] -> [i32]
  69 /// }
  70 /// ```
  71 ///
  72 /// Note that for a struct, the 'deep' unsizing of the struct is not recorded.
  73 /// E.g., `struct Foo<T> { x: T }` we can coerce &Foo<[i32; 4]> to &Foo<[i32]>
  74 /// The autoderef and -ref are the same as in the above example, but the type
  75 /// stored in `unsize` is `Foo<[i32]>`, we don't store any further detail about
  76 /// the underlying conversions from `[i32; 4]` to `[i32]`.
  77 ///
  78 /// 3. Coercing a `Box<T>` to `Box<Trait>` is an interesting special case.  In
  79 /// that case, we have the pointer we need coming in, so there are no
  80 /// autoderefs, and no autoref. Instead we just do the `Unsize` transformation.
  81 /// At some point, of course, `Box` should move out of the compiler, in which
  82 /// case this is analogous to transformating a struct. E.g., Box<[i32; 4]> ->
  83 /// Box<[i32]> is represented by:
  84 ///
  85 /// ```
  86 /// AutoDerefRef {
  87 ///     autoderefs: 0,
  88 ///     autoref: None,
  89 ///     unsize: Some(Box<[i32]>),
  90 /// }
  91 /// ```
  92 #[derive(Copy, Clone)]
  93 pub struct AutoDerefRef<'tcx> {
  94     /// Step 1. Apply a number of dereferences, producing an lvalue.
  95     pub autoderefs: usize,
  96
  97     /// Step 2. Optionally produce a pointer/reference from the value.
  98     pub autoref: Option<AutoRef<'tcx>>,
  99
 100     /// Step 3. Unsize a pointer/reference value, e.g. `&[T; n]` to
 101     /// `&[T]`. The stored type is the target pointer type. Note that
 102     /// the source could be a thin or fat pointer.
 103     pub unsize: Option<Ty<'tcx>>,
 104 }
 105
 106 impl<'tcx> AutoAdjustment<'tcx> {
 107     pub fn is_identity(&self) -> bool {
 108         match *self {
 109             AdjustReifyFnPointer |
 110             AdjustUnsafeFnPointer => false,
 111             AdjustDerefRef(ref r) => r.is_identity(),
 112         }
 113     }
 114 }
 115 impl<'tcx> AutoDerefRef<'tcx> {
 116     pub fn is_identity(&self) -> bool {
 117         self.autoderefs == 0 && self.unsize.is_none() && self.autoref.is_none()
 118     }
 119 }
 120
 121
 122 #[derive(Copy, Clone, PartialEq, Debug)]
 123 pub enum AutoRef<'tcx> {
 124     /// Convert from T to &T.
 125     AutoPtr(&'tcx ty::Region, hir::Mutability),
 126
 127     /// Convert from T to *T.
 128     /// Value to thin pointer.
 129     AutoUnsafe(hir::Mutability),
 130 }
 131
 132 #[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)]
 133 pub enum CustomCoerceUnsized {
 134     /// Records the index of the field being coerced.
 135     Struct(usize)
 136 }
 137
 138 impl<'tcx> ty::TyS<'tcx> {
 139     /// See `expr_ty_adjusted`
 140     pub fn adjust<F>(&'tcx self, cx: &ty::ctxt<'tcx>,
 141                      span: Span,
 142                      expr_id: ast::NodeId,
 143                      adjustment: Option<&AutoAdjustment<'tcx>>,
 144                      mut method_type: F)
 145                      -> Ty<'tcx> where
 146         F: FnMut(ty::MethodCall) -> Option<Ty<'tcx>>,
 147     {
 148         if let ty::TyError = self.sty {
 149             return self;
 150         }
 151
 152         return match adjustment {
 153             Some(adjustment) => {
 154                 match *adjustment {
 155                    AdjustReifyFnPointer => {
 156                         match self.sty {
 157                             ty::TyBareFn(Some(_), b) => {
 158                                 cx.mk_fn(None, b)
 159                             }
 160                             _ => {
 161                                 cx.sess.bug(
 162                                     &format!("AdjustReifyFnPointer adjustment on non-fn-item: \
 163                                               {:?}", self));
 164                             }
 165                         }
 166                     }
 167
 168                    AdjustUnsafeFnPointer => {
 169                         match self.sty {
 170                             ty::TyBareFn(None, b) => cx.safe_to_unsafe_fn_ty(b),
 171                             ref b => {
 172                                 cx.sess.bug(
 173                                     &format!("AdjustReifyFnPointer adjustment on non-fn-item: \
 174                                              {:?}",
 175                                             b));
 176                             }
 177                         }
 178                    }
 179
 180                     AdjustDerefRef(ref adj) => {
 181                         let mut adjusted_ty = self;
 182
 183                         if !adjusted_ty.references_error() {
 184                             for i in 0..adj.autoderefs {
 185                                 adjusted_ty =
 186                                     adjusted_ty.adjust_for_autoderef(cx,
 187                                                                      expr_id,
 188                                                                      span,
 189                                                                      i as u32,
 190                                                                      &mut method_type);
 191                             }
 192                         }
 193
 194                         if let Some(target) = adj.unsize {
 195                             target
 196                         } else {
 197                             adjusted_ty.adjust_for_autoref(cx, adj.autoref)
 198                         }
 199                     }
 200                 }
 201             }
 202             None => self
 203         };
 204     }
 205
 206     pub fn adjust_for_autoderef<F>(&'tcx self,
 207                                    cx: &ty::ctxt<'tcx>,
 208                                    expr_id: ast::NodeId,
 209                                    expr_span: Span,
 210                                    autoderef: u32, // how many autoderefs so far?
 211                                    mut method_type: F)
 212                                    -> Ty<'tcx> where
 213         F: FnMut(ty::MethodCall) -> Option<Ty<'tcx>>,
 214     {
 215         let method_call = ty::MethodCall::autoderef(expr_id, autoderef);
 216         let mut adjusted_ty = self;
 217         if let Some(method_ty) = method_type(method_call) {
 218             // Method calls always have all late-bound regions
 219             // fully instantiated.
 220             let fn_ret = cx.no_late_bound_regions(&method_ty.fn_ret()).unwrap();
 221             adjusted_ty = fn_ret.unwrap();
 222         }
 223         match adjusted_ty.builtin_deref(true, NoPreference) {
 224             Some(mt) => mt.ty,
 225             None => {
 226                 cx.sess.span_bug(
 227                     expr_span,
 228                     &format!("the {}th autoderef failed: {}",
 229                              autoderef,
 230                              adjusted_ty)
 231                         );
 232             }
 233         }
 234     }
 235
 236     pub fn adjust_for_autoref(&'tcx self, cx: &ty::ctxt<'tcx>,
 237                               autoref: Option<AutoRef<'tcx>>)
 238                               -> Ty<'tcx> {
 239         match autoref {
 240             None => self,
 241             Some(AutoPtr(r, m)) => {
 242                 cx.mk_ref(r, TypeAndMut { ty: self, mutbl: m })
 243             }
 244             Some(AutoUnsafe(m)) => {
 245                 cx.mk_ptr(TypeAndMut { ty: self, mutbl: m })
 246             }
 247         }
 248     }
 249 }