Suggest using slice when encountering let x = ""[..];

src/librustc/hir/mod.rs

@@ -244,6 +244,23 @@ impl Path {
     pub fn is_global(&self) -> bool {
         !self.segments.is_empty() && self.segments[0].name == keywords::CrateRoot.name()
     }
+
+    /// Wether this path is any of `::std::ops::{Range, RangeTo, RangeFrom}`.
+    pub fn is_range(&self) -> bool {
+        let mut base = ["{{root}}", "std", "ops"].iter().map(|p| p.to_string()).collect::<Vec<_>>();
+        let range_paths = ["Range", "RangeTo", "RangeFrom"];
+        let segments = self.segments.iter()
+            .map(|segment| format!("{}", segment.name))
+            .collect::<Vec<String>>();
+        for path in &range_paths {
+            base.push(path.to_string());
+            if base == segments {
+                return true;
+            }
+            base.pop();
+        }
+        false
+    }
 }
 
 impl fmt::Debug for Path {

src/librustc/traits/error_reporting.rs

@@ -581,6 +581,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                                      trait_ref.self_ty()));
                         }
 
+                        self.suggest_borrow_on_unsized_slice(&obligation.cause.code, &mut err);
+
                         // Try to report a help message
                         if !trait_ref.has_infer_types() &&
                             self.predicate_can_apply(obligation.param_env, trait_ref) {
@@ -821,6 +823,33 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         err.emit();
     }
 
+    /// When encountering an assignment of an unsized trait, like `let x = ""[..];`, provide a
+    /// suggestion to borrow the initializer in order to use have a slice instead.
+    fn suggest_borrow_on_unsized_slice(&self,
+                                       code: &ObligationCauseCode<'tcx>,
+                                       err: &mut DiagnosticBuilder<'tcx>) {
+        if let &ObligationCauseCode::VariableType(node_id) = code {
+            let parent_node = self.tcx.hir.get_parent_node(node_id);
+            if let Some(hir::map::NodeLocal(ref local)) = self.tcx.hir.find(parent_node) {
+                if let Some(ref expr) = local.init {
+                    if let hir::ExprIndex(_, ref index) = expr.node {
+                        if let hir::ExprStruct(hir::QPath::Resolved(None, ref path),
+                                               ..) = index.node {
+                            if let (Ok(snippet), true) = (
+                                self.tcx.sess.codemap().span_to_snippet(expr.span),
+                                path.is_range()
+                            ) {
+                                err.span_suggestion(expr.span,
+                                                    "consider a slice instead",
+                                                    format!("&{}", snippet));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     fn report_arg_count_mismatch(
         &self,
         span: Span,