rustc: move some functions in middle::ty working on Ty to methods.

Author: eddyb

src/librustc/middle/cast.rs

@@ -66,8 +66,8 @@ impl<'tcx> CastTy<'tcx> {
             ty::TyInt(_) => Some(CastTy::Int(IntTy::I)),
             ty::TyUint(u) => Some(CastTy::Int(IntTy::U(u))),
             ty::TyFloat(_) => Some(CastTy::Float),
-            ty::TyEnum(..) if ty::type_is_c_like_enum(
-                tcx, t) => Some(CastTy::Int(IntTy::CEnum)),
+            ty::TyEnum(..) if t.is_c_like_enum(tcx) =>
+                Some(CastTy::Int(IntTy::CEnum)),
             ty::TyRawPtr(ref mt) => Some(CastTy::Ptr(mt)),
             ty::TyRef(_, ref mt) => Some(CastTy::RPtr(mt)),
             ty::TyBareFn(..) => Some(CastTy::FnPtr),

src/librustc/middle/cfg/construct.rs

@@ -411,14 +411,14 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             func_or_rcvr: &ast::Expr,
             args: I) -> CFGIndex {
         let method_call = ty::MethodCall::expr(call_expr.id);
-        let return_ty = ty::ty_fn_ret(match self.tcx.method_map.borrow().get(&method_call) {
+        let fn_ty = match self.tcx.method_map.borrow().get(&method_call) {
             Some(method) => method.ty,
             None => ty::expr_ty_adjusted(self.tcx, func_or_rcvr)
-        });
+        };
 
         let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);
         let ret = self.straightline(call_expr, func_or_rcvr_exit, args);
-        if return_ty.diverges() {
+        if fn_ty.fn_ret().diverges() {
             self.add_unreachable_node()
         } else {
             ret

src/librustc/middle/check_match.rs

@@ -656,7 +656,9 @@ fn is_useful(cx: &MatchCheckCtxt,
         let left_ty = ty::pat_ty(cx.tcx, &*real_pat);
 
         match real_pat.node {
-            ast::PatIdent(ast::BindByRef(..), _, _) => ty::deref(left_ty, false).unwrap().ty,
+            ast::PatIdent(ast::BindByRef(..), _, _) => {
+                left_ty.builtin_deref(false).unwrap().ty
+            }
             _ => left_ty,
         }
     };

src/librustc/middle/expr_use_visitor.rs

@@ -821,7 +821,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
 
                     // the method call infrastructure should have
                     // replaced all late-bound regions with variables:
-                    let self_ty = ty::ty_fn_sig(method_ty).input(0);
+                    let self_ty = method_ty.fn_sig().input(0);
                     let self_ty = ty::no_late_bound_regions(self.tcx(), &self_ty).unwrap();
 
                     let (m, r) = match self_ty.sty {

src/librustc/middle/liveness.rs

@@ -1137,9 +1137,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
           }
 
           ast::ExprCall(ref f, ref args) => {
-            let diverges = !self.ir.tcx.is_method_call(expr.id) && {
-                ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f)).diverges()
-            };
+            let diverges = !self.ir.tcx.is_method_call(expr.id) &&
+                ty::expr_ty_adjusted(self.ir.tcx, &**f).fn_ret().diverges();
             let succ = if diverges {
                 self.s.exit_ln
             } else {
@@ -1152,8 +1151,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
           ast::ExprMethodCall(_, _, ref args) => {
             let method_call = ty::MethodCall::expr(expr.id);
             let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty;
-            let diverges = ty::ty_fn_ret(method_ty).diverges();
-            let succ = if diverges {
+            let succ = if method_ty.fn_ret().diverges() {
                 self.s.exit_ln
             } else {
                 succ
@@ -1500,8 +1498,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
         match fn_ty.sty {
             ty::TyClosure(closure_def_id, substs) =>
                 self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
-            _ =>
-                ty::ty_fn_ret(fn_ty),
+            _ => fn_ty.fn_ret()
         }
     }
 
@@ -1523,7 +1520,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             ty::FnConverging(t_ret)
                 if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
 
-                if ty::type_is_nil(t_ret) {
+                if t_ret.is_nil() {
                     // for nil return types, it is ok to not return a value expl.
                 } else {
                     let ends_with_stmt = match body.expr {

src/librustc/middle/mem_categorization.rs

@@ -426,7 +426,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                 // a bind-by-ref means that the base_ty will be the type of the ident itself,
                 // but what we want here is the type of the underlying value being borrowed.
                 // So peel off one-level, turning the &T into T.
-                match ty::deref(base_ty, false) {
+                match base_ty.builtin_deref(false) {
                     Some(t) => t.ty,
                     None => { return Err(()); }
                 }
@@ -928,13 +928,13 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             Some(method_ty) => {
                 let ref_ty =
                     ty::no_late_bound_regions(
-                        self.tcx(), &ty::ty_fn_ret(method_ty)).unwrap().unwrap();
+                        self.tcx(), &method_ty.fn_ret()).unwrap().unwrap();
                 self.cat_rvalue_node(node.id(), node.span(), ref_ty)
             }
             None => base_cmt
         };
         let base_cmt_ty = base_cmt.ty;
-        match ty::deref(base_cmt_ty, true) {
+        match base_cmt_ty.builtin_deref(true) {
             Some(mt) => {
                 let ret = self.cat_deref_common(node, base_cmt, deref_cnt,
                                               mt.ty,
@@ -1023,11 +1023,11 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                 base_cmt = self.cat_rvalue_node(elt.id(), elt.span(), ref_ty);
 
                 // FIXME(#20649) -- why are we using the `self_ty` as the element type...?
-                let self_ty = ty::ty_fn_sig(method_ty).input(0);
+                let self_ty = method_ty.fn_sig().input(0);
                 ty::no_late_bound_regions(self.tcx(), &self_ty).unwrap()
             }
             None => {
-                match ty::array_element_ty(self.tcx(), base_cmt.ty) {
+                match base_cmt.ty.builtin_index() {
                     Some(ty) => ty,
                     None => {
                         return Err(());
@@ -1081,7 +1081,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                     span:elt.span(),
                     cat:cat_deref(base_cmt.clone(), 0, ptr),
                     mutbl:m,
-                    ty: match ty::deref(base_cmt.ty, false) {
+                    ty: match base_cmt.ty.builtin_deref(false) {
                         Some(mt) => mt.ty,
                         None => self.tcx().sess.bug("Found non-derefable type")
                     },
@@ -1375,7 +1375,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
         // types are generated by method resolution and always have
         // all late-bound regions fully instantiated, so we just want
         // to skip past the binder.
-        ty::no_late_bound_regions(self.tcx(), &ty::ty_fn_ret(method_ty))
+        ty::no_late_bound_regions(self.tcx(), &method_ty.fn_ret())
            .unwrap()
            .unwrap() // overloaded ops do not diverge, either
     }

src/librustc/middle/traits/object_safety.rs

@@ -306,7 +306,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &ty::ctxt<'tcx>,
 
     let mut supertraits: Option<Vec<ty::PolyTraitRef<'tcx>>> = None;
     let mut error = false;
-    ty::maybe_walk_ty(ty, |ty| {
+    ty.maybe_walk(|ty| {
         match ty.sty {
             ty::TyParam(ref param_ty) => {
                 if param_ty.space == SelfSpace {

src/librustc/middle/traits/project.rs

@@ -773,7 +773,7 @@ fn confirm_fn_pointer_candidate<'cx,'tcx>(
     -> (Ty<'tcx>, Vec<PredicateObligation<'tcx>>)
 {
     let fn_type = selcx.infcx().shallow_resolve(fn_type);
-    let sig = ty::ty_fn_sig(fn_type);
+    let sig = fn_type.fn_sig();
     confirm_callable_candidate(selcx, obligation, sig, util::TupleArgumentsFlag::Yes)
 }
 

src/librustc/middle/traits/select.rs

@@ -540,7 +540,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // terms of `Fn` etc, but we could probably make this more
         // precise still.
         let input_types = stack.fresh_trait_ref.0.input_types();
-        let unbound_input_types = input_types.iter().any(|&t| ty::type_is_fresh(t));
+        let unbound_input_types = input_types.iter().any(|ty| ty.is_fresh());
         if
             unbound_input_types &&
              (self.intercrate ||
@@ -2334,7 +2334,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         // ok to skip binder; it is reintroduced below
         let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
-        let sig = ty::ty_fn_sig(self_ty);
+        let sig = self_ty.fn_sig();
         let trait_ref =
             util::closure_trait_ref_and_return_type(self.tcx(),
                                                     obligation.predicate.def_id(),
@@ -2536,15 +2536,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     return Err(Unimplemented);
                 };
                 let mut ty_params = vec![];
-                ty::walk_ty(field, |ty| {
+                for ty in field.walk() {
                     if let ty::TyParam(p) = ty.sty {
                         assert!(p.space == TypeSpace);
                         let idx = p.idx as usize;
                         if !ty_params.contains(&idx) {
                             ty_params.push(idx);
                         }
                     }
-                });
+                }
                 if ty_params.is_empty() {
                     return Err(Unimplemented);
                 }