Remove old slicing hacks and make new slicing work

nrc · nikomatsakis · commit a7725420566f · 2015-01-05T13:23:55.000-05:00
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -441,28 +441,12 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
             }
 
             ast::ExprIndex(ref lhs, ref rhs) => {       // lhs[rhs]
-                match rhs.node {
-                    ast::ExprRange(ref start, ref end) => {
-                        // Hacked slicing syntax (KILLME).
-                        let args = match (start, end) {
-                            (&Some(ref e1), &Some(ref e2)) => vec![&**e1, &**e2],
-                            (&Some(ref e), &None) => vec![&**e],
-                            (&None, &Some(ref e)) => vec![&**e],
-                            (&None, &None) => Vec::new()
-                        };
-                        let overloaded =
-                            self.walk_overloaded_operator(expr, &**lhs, args, PassArgs::ByRef);
-                        assert!(overloaded);
-                    }
-                    _ => {
-                        if !self.walk_overloaded_operator(expr,
-                                                          &**lhs,
-                                                          vec![&**rhs],
-                                                          PassArgs::ByRef) {
-                            self.select_from_expr(&**lhs);
-                            self.consume_expr(&**rhs);
-                        }
-                    }
+                if !self.walk_overloaded_operator(expr,
+                                                  &**lhs,
+                                                  vec![&**rhs],
+                                                  PassArgs::ByRef) {
+                    self.select_from_expr(&**lhs);
+                    self.consume_expr(&**rhs);
                 }
             }
 
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
@@ -266,8 +266,6 @@ lets_do_this! {
     ShrTraitLangItem,                "shr",                     shr_trait;
     IndexTraitLangItem,              "index",                   index_trait;
     IndexMutTraitLangItem,           "index_mut",               index_mut_trait;
-    SliceTraitLangItem,              "slice",                   slice_trait;
-    SliceMutTraitLangItem,           "slice_mut",               slice_mut_trait;
     RangeStructLangItem,             "range",                   range_struct;
     RangeFromStructLangItem,         "range_from",              range_from_struct;
     RangeToStructLangItem,           "range_to",                range_to_struct;
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -490,28 +490,20 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             Ok(self.cat_tup_field(expr, base_cmt, idx.node, expr_ty))
           }
 
-          ast::ExprIndex(ref base, ref idx) => {
-            match idx.node {
-                ast::ExprRange(..) => {
-                    // Slicing syntax special case (KILLME).
-                    Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
+          ast::ExprIndex(ref base, _) => {
+            let method_call = ty::MethodCall::expr(expr.id());
+            match self.typer.node_method_ty(method_call) {
+                Some(method_ty) => {
+                    // If this is an index implemented by a method call, then it will
+                    // include an implicit deref of the result.
+                    let ret_ty = ty::ty_fn_ret(method_ty).unwrap();
+                    self.cat_deref(expr,
+                                   self.cat_rvalue_node(expr.id(),
+                                                        expr.span(),
+                                                        ret_ty), 1, true)
                 }
-                _ => {
-                    let method_call = ty::MethodCall::expr(expr.id());
-                    match self.typer.node_method_ty(method_call) {
-                        Some(method_ty) => {
-                            // If this is an index implemented by a method call, then it will
-                            // include an implicit deref of the result.
-                            let ret_ty = ty::ty_fn_ret(method_ty).unwrap();
-                            self.cat_deref(expr,
-                                           self.cat_rvalue_node(expr.id(),
-                                                                expr.span(),
-                                                                ret_ty), 1, true)
-                        }
-                        None => {
-                            self.cat_index(expr, try!(self.cat_expr(&**base)))
-                        }
-                    }
+                None => {
+                    self.cat_index(expr, self.cat_expr(&**base))
                 }
             }
           }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -1048,7 +1048,7 @@ pub struct ClosureTy<'tcx> {
     pub abi: abi::Abi,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Show)]
 pub enum FnOutput<'tcx> {
     FnConverging(Ty<'tcx>),
     FnDiverging
@@ -1701,8 +1701,7 @@ impl fmt::Show for RegionVid {
 
 impl<'tcx> fmt::Show for FnSig<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // grr, without tcx not much we can do.
-        write!(f, "(...)")
+        write!(f, "({}; variadic: {})->{}", self.inputs, self.variadic, self.output)
     }
 }
 
diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs
@@ -24,8 +24,7 @@ use trans::common;
 use trans::common::{Block, FunctionContext, ExprId, NodeInfo};
 use trans::debuginfo;
 use trans::glue;
-// Temporary due to slicing syntax hacks (KILLME)
-//use middle::region;
+use middle::region;
 use trans::type_::Type;
 use middle::ty::{self, Ty};
 use std::fmt;
@@ -129,16 +128,15 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
         // excluding id's that correspond to closure bodies only). For
         // now we just say that if there is already an AST scope on the stack,
         // this new AST scope had better be its immediate child.
-        // Temporarily removed due to slicing syntax hacks (KILLME).
-        /*let top_scope = self.top_ast_scope();
+        let top_scope = self.top_ast_scope();
         if top_scope.is_some() {
             assert_eq!(self.ccx
                            .tcx()
                            .region_maps
                            .opt_encl_scope(region::CodeExtent::from_node_id(debug_loc.id))
                            .map(|s|s.node_id()),
                        top_scope);
-        }*/
+        }
 
         self.push_scope(CleanupScope::new(AstScopeKind(debug_loc.id),
                                           Some(debug_loc)));
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
@@ -592,40 +592,7 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             trans_rec_tup_field(bcx, &**base, idx.node)
         }
         ast::ExprIndex(ref base, ref idx) => {
-            match idx.node {
-                ast::ExprRange(ref start, ref end) => {
-                    // Special case for slicing syntax (KILLME).
-                    let _icx = push_ctxt("trans_slice");
-                    let ccx = bcx.ccx();
-
-                    let method_call = MethodCall::expr(expr.id);
-                    let method_ty = ccx.tcx()
-                                       .method_map
-                                       .borrow()
-                                       .get(&method_call)
-                                       .map(|method| method.ty);
-                    let base_datum = unpack_datum!(bcx, trans(bcx, &**base));
-
-                    let mut args = vec![];
-                    start.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id)));
-                    end.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id)));
-
-                    let result_ty = ty::ty_fn_ret(monomorphize_type(bcx,
-                                                                    method_ty.unwrap())).unwrap();
-                    let scratch = rvalue_scratch_datum(bcx, result_ty, "trans_slice");
-
-                    unpack_result!(bcx,
-                                   trans_overloaded_op(bcx,
-                                                       expr,
-                                                       method_call,
-                                                       base_datum,
-                                                       args,
-                                                       Some(SaveIn(scratch.val)),
-                                                       true));
-                    DatumBlock::new(bcx, scratch.to_expr_datum())
-                }
-                _ => trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id))
-            }
+            trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id))
         }
         ast::ExprBox(_, ref contents) => {
             // Special case for `Box<T>`
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs

Original file line number	Diff line number	Diff line change
`@@ -1048,7 +1048,7 @@ pub struct ClosureTy<'tcx> {`
`1048`	`1048`	`pub abi: abi::Abi,`
`1049`	`1049`	`}`
`1050`	`1050`
`1051`		`-#[derive(Clone, Copy, PartialEq, Eq, Hash)]`
	`1051`	`+#[derive(Clone, Copy, PartialEq, Eq, Hash, Show)]`
`1052`	`1052`	`pub enum FnOutput<'tcx> {`
`1053`	`1053`	`FnConverging(Ty<'tcx>),`
`1054`	`1054`	`FnDiverging`
`@@ -1701,8 +1701,7 @@ impl fmt::Show for RegionVid {`
`1701`	`1701`
`1702`	`1702`	`impl<'tcx> fmt::Show for FnSig<'tcx> {`
`1703`	`1703`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`1704`		`- // grr, without tcx not much we can do.`
`1705`		`- write!(f, "(...)")`
	`1704`	`+ write!(f, "({}; variadic: {})->{}", self.inputs, self.variadic, self.output)`
`1706`	`1705`	`}`
`1707`	`1706`	`}`
`1708`	`1707`