rustc compiles. still don't merge

Author: arielb1

src/librustc/middle/const_eval.rs

@@ -837,7 +837,7 @@ fn cast_const<'tcx>(tcx: &ty::ctxt<'tcx>, val: const_val, ty: Ty) -> CastResult
     macro_rules! convert_val {
         ($intermediate_ty:ty, $const_type:ident, $target_ty:ty) => {
             match val {
-                const_bool(b) => Ok($const_type(b as $intermediate_ty as $target_ty)),
+                const_bool(b) => Ok($const_type(b as u64 as $intermediate_ty as $target_ty)),
                 const_uint(u) => Ok($const_type(u as $intermediate_ty as $target_ty)),
                 const_int(i) => Ok($const_type(i as $intermediate_ty as $target_ty)),
                 const_float(f) => Ok($const_type(f as $intermediate_ty as $target_ty)),

src/librustc/middle/ty.rs

@@ -342,30 +342,6 @@ pub enum AutoAdjustment<'tcx> {
 /// }
 /// ```
 #[derive(Copy, Clone, Debug)]
-
-#[derive(Copy, PartialEq, Eq)]
-pub enum UnsizeKind {
-    Vtable,
-    Length
-}
-
-/// Returns the kind of unsize information of t, or None
-/// if t is sized or it is unknown.
-pub fn unsize_kind<'tcx>(cx: &ctxt<'tcx>,
-                         t: Ty<'tcx>)
-                         -> Option<UnsizeKind> {
-    match t.sty {
-        ty_vec(_, None) => Some(Length),
-        ty_trait(_) => Some(Vtable),
-        ty_struct(did, substs) => {
-            let last_field = struct_fields(cx, did, substs).pop();
-            last_field.map(|f| unsize_kind(f.mt.ty))
-        }
-        _ => None
-    }
-}
-
-#[derive(Clone, Debug)]
 pub struct AutoDerefRef<'tcx> {
     /// Step 1. Apply a number of dereferences, producing an lvalue.
     pub autoderefs: usize,

src/librustc_typeck/check/cast.rs

@@ -14,17 +14,27 @@
 //! * `e` has type `T` and `T` coerces to `U`; *coercion-cast*
 //! * `e` has type `*T`, `U` is `*U_0`, and either `U_0: Sized` or
 //!    unsize_kind(`T`) = unsize_kind(`U_0`); *ptr-ptr-cast*
-//! * `e` has type `*T` and `U` is `usize`, while `T: Sized`; *ptr-addr-cast*
+//! * `e` has type `*T` and `U` is a numeric type, while `T: Sized`; *ptr-addr-cast*
 //! * `e` has type `usize` and `U` is `*U_0`, while `U_0: Sized`; *addr-ptr-cast*
 //! * `e` has type `T` and `T` and `U` are any numeric types; *numeric-cast*
 //! * `e` is a C-like enum and `U` is an integer type or `bool`; *enum-cast*
 //! * `e` has type `bool` and `U` is an integer; *bool-cast*
 //! * `e` has type `u8` and `U` is `char`; *u8-char-cast*
 //! * `e` has type `&.[T; n]` and `U` is `*T`, and `e` is a mutable
 //!   reference if `U` is. *array-ptr-cast*
+//! * `e` is a function pointer type and `U` has type `*T`,
+//!   while `T: Sized`; *fptr-ptr-cast*
+//! * `e` is a function pointer type and `U` is an integer; *fptr-addr-cast*
+//!
+//! where `&.T` and `*T` are references of either mutability,
+//! and where unsize_kind(`T`) is the kind of the unsize info
+//! in `T` - a vtable or a length (or `()` if `T: Sized`).
+//!
+//! Casting is not transitive, that is, even if `e as U1 as U2` is a valid
+//! expression, `e as U2` is not necessarily so (in fact it will only be valid if
+//! `U1` coerces to `U2`).
 
 use super::coercion;
-use super::demand;
 use super::FnCtxt;
 use super::structurally_resolved_type;
 
@@ -33,12 +43,10 @@ use middle::infer;
 use middle::ty;
 use middle::ty::Ty;
 use syntax::ast;
-use syntax::ast::UintTy::{TyU8, TyUs};
+use syntax::ast::UintTy::{TyU8};
 use syntax::codemap::Span;
 use util::ppaux::Repr;
 
-use std::fmt;
-
 /// Reifies a cast check to be checked once we have full type information for
 /// a function context.
 pub struct CastCheck<'tcx> {
@@ -62,6 +70,7 @@ enum ETy<'tcx> {
     Float,
     Bool,
     Char,
+    FPtr,
     Ptr(&'tcx ty::mt<'tcx>),
     RPtr(&'tcx ty::mt<'tcx>),
 }
@@ -79,16 +88,41 @@ impl<'tcx> ETy<'tcx> {
                 fcx.tcx(), t) => Some(ETy::CEnum),
             ty::ty_ptr(ref mt) => Some(ETy::Ptr(mt)),
             ty::ty_rptr(_, ref mt) => Some(ETy::RPtr(mt)),
+            ty::ty_bare_fn(..) => Some(ETy::FPtr),
             _ => None,
         }
     }
 }
 
+#[derive(Copy, PartialEq, Eq)]
+enum UnsizeKind {
+    Vtable,
+    Length
+}
+
+/// Returns the kind of unsize information of t, or None
+/// if t is sized or it is unknown.
+fn unsize_kind<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+                        t: Ty<'tcx>)
+                        -> Option<UnsizeKind> {
+    match t.sty {
+        ty::ty_vec(_, None) => Some(UnsizeKind::Length),
+        ty::ty_trait(_) => Some(UnsizeKind::Vtable),
+        ty::ty_struct(did, substs) => {
+            match ty::struct_fields(fcx.tcx(), did, substs).pop() {
+                None => None,
+                Some(f) => unsize_kind(fcx, f.mt.ty)
+            }
+        }
+        _ => None
+    }
+}
 
 #[derive(Copy)]
 enum CastError {
     CastToBool,
     CastToChar,
+    DifferingKinds,
     IllegalCast,
     NeedViaPtr,
     NeedViaInt,
@@ -149,6 +183,13 @@ impl<'tcx> CastCheck<'tcx> {
                             fcx.infcx().ty_to_string(self.cast_ty))
                 }, self.expr_ty, None);
             }
+            CastError::DifferingKinds => {
+                fcx.type_error_message(self.span, |actual| {
+                    format!("illegal cast: `{}` as `{}`; vtable kinds may not match",
+                            actual,
+                            fcx.infcx().ty_to_string(self.cast_ty))
+                }, self.expr_ty, None);
+            }
             CastError::RefToMutPtr => {
                 span_err!(fcx.tcx().sess, self.span, E0188,
                           "cannot cast an immutable reference to a \
@@ -186,7 +227,7 @@ impl<'tcx> CastCheck<'tcx> {
         self.expr_ty = structurally_resolved_type(fcx, self.span, self.expr_ty);
         self.cast_ty = structurally_resolved_type(fcx, self.span, self.cast_ty);
 
-        println!("cast: {} -> {}", self.expr_ty.repr(fcx.tcx()),
+        debug!("check_cast({} -> {})", self.expr_ty.repr(fcx.tcx()),
                self.cast_ty.repr(fcx.tcx()));
 
         if ty::type_is_error(self.expr_ty) || ty::type_is_error(self.cast_ty) {
@@ -217,17 +258,17 @@ impl<'tcx> CastCheck<'tcx> {
 
         match (t_e, t_1) {
             // All non-coercion casts create a true scalar
-            (_, RPtr(_)) | (_, CEnum) => Err(CastError::NonScalar),
+            (_, RPtr(_)) | (_, CEnum) | (_, FPtr) => Err(CastError::NonScalar),
 
             (Ptr(m1), Ptr(m2)) => self.check_ptr_ptr_cast(fcx, m1, m2), // ptr-ptr-cast
-
-            (Ptr(mt), Int(U(ast::TyUs))) =>
-                self.check_ptr_addr_cast(fcx, mt), // ptr-addr-cast
-            (Ptr(_), Int(_)) | (Ptr(_), Float) => Err(CastError::NeedViaUsize),
+            (Ptr(mt), Int(_)) => self.check_ptr_addr_cast(fcx, mt), // ptr-addr-cast
+            (Ptr(_), Float) | (FPtr, Float) => Err(CastError::NeedViaUsize),
+            (FPtr, Int(_)) => Ok(()), // fptr-addr-cast
             (RPtr(_), Int(_)) | (RPtr(_), Float) => Err(CastError::NeedViaPtr),
-            (Int(U(ast::TyUs)), Ptr(mt)) =>
-                self.check_addr_ptr_cast(fcx, mt), // addr-ptr-cast
-            (Int(_), Ptr(_)) | (Float, Ptr(_)) => Err(CastError::NeedViaUsize),
+
+            (Int(_), Ptr(mt)) => self.check_addr_ptr_cast(fcx, mt), // addr-ptr-cast
+            (FPtr, Ptr(mt)) => self.check_fptr_ptr_cast(fcx, mt),
+            (Float, Ptr(_)) => Err(CastError::NeedViaUsize),
 
             (CEnum, Bool) | (CEnum, Int(_)) => Ok(()), // enum-cast
             (_, Bool) => Err(CastError::CastToBool),
@@ -247,20 +288,42 @@ impl<'tcx> CastCheck<'tcx> {
             (Bool, Ptr(_)) | (CEnum, Ptr(_)) | (Char, Ptr(_))
                 => Err(CastError::NeedViaUsize),
 
-
             (RPtr(rmt), Ptr(mt)) => self.check_ref_cast(fcx, rmt, mt), // array-ptr-cast
         }
     }
 
     fn check_ptr_ptr_cast<'a>(&self,
-                              _fcx: &FnCtxt<'a, 'tcx>,
-                              _m_e: &'tcx ty::mt<'tcx>,
-                              _m_1: &'tcx ty::mt<'tcx>)
+                              fcx: &FnCtxt<'a, 'tcx>,
+                              m_e: &'tcx ty::mt<'tcx>,
+                              m_1: &'tcx ty::mt<'tcx>)
                               -> Result<(), CastError>
     {
         // ptr-ptr cast. vtables must match.
-        // TODO: implement
-        Ok(())
+
+        // Cast to sized is OK
+        if fcx.type_is_known_to_be_sized(m_1.ty, self.span) {
+            return Ok(());
+        }
+
+        // vtable kinds must match
+        match (unsize_kind(fcx, m_1.ty), unsize_kind(fcx, m_e.ty)) {
+            (Some(a), Some(b)) if a == b => Ok(()),
+            _ => Err(CastError::DifferingKinds)
+        }
+    }
+
+    fn check_fptr_ptr_cast<'a>(&self,
+                               fcx: &FnCtxt<'a, 'tcx>,
+                               m_1: &'tcx ty::mt<'tcx>)
+                               -> Result<(), CastError>
+    {
+        // fptr-ptr cast. must be to sized ptr
+
+        if fcx.type_is_known_to_be_sized(m_1.ty, self.span) {
+            Ok(())
+        } else {
+            Err(CastError::IllegalCast)
+        }
     }
 
     fn check_ref_cast<'a>(&self,
@@ -294,7 +357,7 @@ impl<'tcx> CastCheck<'tcx> {
         Err(CastError::IllegalCast)
     }
 
-    fn check_ptr_addr_cast<'a>(&self,
+    fn check_addr_ptr_cast<'a>(&self,
                                fcx: &FnCtxt<'a, 'tcx>,
                                m_1: &'tcx ty::mt<'tcx>)
                                -> Result<(), CastError>
@@ -307,7 +370,7 @@ impl<'tcx> CastCheck<'tcx> {
         }
     }
 
-    fn check_addr_ptr_cast<'a>(&self,
+    fn check_ptr_addr_cast<'a>(&self,
                                fcx: &FnCtxt<'a, 'tcx>,
                                m_e: &'tcx ty::mt<'tcx>)
                                -> Result<(), CastError>

src/librustc_typeck/check/mod.rs

@@ -1509,13 +1509,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                                  span)
     }
 
-    pub fn type_is_fat_ptr(&self, ty: Ty<'tcx>, span: Span) -> bool {
-        if let Some(mt) = ty::deref(ty, true) {
-            return !self.type_is_known_to_be_sized(mt.ty, span);
-        }
-        false
-    }
-
     pub fn register_builtin_bound(&self,
                                   ty: Ty<'tcx>,
                                   builtin_bound: ty::BuiltinBound,