Prevent unsized types being stored in variables

src/librustc/middle/kind.rs

@@ -20,7 +20,7 @@ use syntax::ast::*;
 use syntax::attr;
 use syntax::codemap::Span;
 use syntax::owned_slice::OwnedSlice;
-use syntax::print::pprust::expr_to_str;
+use syntax::print::pprust::{expr_to_str,path_to_str};
 use syntax::{visit,ast_util};
 use syntax::visit::Visitor;
 
@@ -63,9 +63,14 @@ impl<'a> Visitor<()> for Context<'a> {
     fn visit_ty(&mut self, t: &Ty, _: ()) {
         check_ty(self, t);
     }
+
     fn visit_item(&mut self, i: &Item, _: ()) {
         check_item(self, i);
     }
+
+    fn visit_pat(&mut self, p: &Pat, _: ()) {
+        check_pat(self, p);
+    }
 }
 
 pub fn check_crate(tcx: &ty::ctxt,
@@ -551,3 +556,38 @@ pub fn check_cast_for_escaping_regions(
         }
     }
 }
+
+// Ensure that `ty` has a statically known size (i.e., it has the `Sized` bound).
+fn check_sized(tcx: &ty::ctxt, ty: ty::t, name: ~str, sp: Span) {
+    if !ty::type_is_sized(tcx, ty) {
+        tcx.sess.span_err(sp, format!("variable `{}` has dynamically sized type `{}`",
+                                      name, ty_to_str(tcx, ty)));
+    }
+}
+
+// Check that any variables in a pattern have types with statically known size.
+fn check_pat(cx: &mut Context, pat: &Pat) {
+    let var_name = match pat.node {
+        PatWild => Some("_".to_owned()),
+        PatIdent(_, ref path, _) => Some(path_to_str(path)),
+        _ => None
+    };
+
+    match var_name {
+        Some(name) => {
+            let types = cx.tcx.node_types.borrow();
+            let ty = types.find(&(pat.id as uint));
+            match ty {
+                Some(ty) => {
+                    debug!("kind: checking sized-ness of variable {}: {}",
+                           name, ty_to_str(cx.tcx, *ty));
+                    check_sized(cx.tcx, *ty, name, pat.span);
+                }
+                None => {} // extern fn args
+            }
+        }
+        None => {}
+    }
+
+    visit::walk_pat(cx, pat, ());
+}

src/test/compile-fail/unsized5.rs

@@ -9,18 +9,7 @@
 // except according to those terms.
 #![feature(struct_variant)]
 
-// Test `type` types not allowed in fields or local variables.
-
-/*trait T for type {}
-
-fn f5<type X>(x: &X) {
-    let _: X; // ERROR local variable with dynamically sized type X
-    let _: (int, (X, int)); // ERROR local variable with dynamically sized type (int,(X,int))
-}
-fn f6<type X: T>(x: &X) {
-    let _: X; // ERROR local variable with dynamically sized type X
-    let _: (int, (X, int)); // ERROR local variable with dynamically sized type (int,(X,int))
-}*/
+// Test `type` types not allowed in fields.
 
 struct S1<type X> {
     f1: X, //~ ERROR type `f1` is dynamically sized. dynamically sized types may only appear as the

src/test/compile-fail/unsized6.rs

@@ -0,0 +1,43 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test `type` local variables.
+
+trait T for type {}
+
+fn f1<type X>(x: &X) {
+    let _: X; //~ERROR variable `_` has dynamically sized type `X`
+    let _: (int, (X, int)); //~ERROR variable `_` has dynamically sized type `(int,(X,int))`
+    let y: X; //~ERROR variable `y` has dynamically sized type `X`
+    let y: (int, (X, int)); //~ERROR variable `y` has dynamically sized type `(int,(X,int))`
+}
+fn f2<type X: T>(x: &X) {
+    let _: X; //~ERROR variable `_` has dynamically sized type `X`
+    let _: (int, (X, int)); //~ERROR variable `_` has dynamically sized type `(int,(X,int))`
+    let y: X; //~ERROR variable `y` has dynamically sized type `X`
+    let y: (int, (X, int)); //~ERROR variable `y` has dynamically sized type `(int,(X,int))`
+}
+
+fn f3<type X>(x1: ~X, x2: ~X, x3: ~X) {
+    let y: X = *x1; //~ERROR variable `y` has dynamically sized type `X`
+    let y = *x2; //~ERROR variable `y` has dynamically sized type `X`
+    let (y, z) = (*x3, 4); //~ERROR variable `y` has dynamically sized type `X`
+}
+fn f4<type X: T>(x1: ~X, x2: ~X, x3: ~X) {
+    let y: X = *x1;         //~ERROR variable `y` has dynamically sized type `X`
+    let y = *x2;            //~ERROR variable `y` has dynamically sized type `X`
+    let (y, z) = (*x3, 4); //~ERROR variable `y` has dynamically sized type `X`
+}
+
+fn g1<type X>(x: X) {} //~ERROR variable `x` has dynamically sized type `X`
+fn g2<type X: T>(x: X) {} //~ERROR variable `x` has dynamically sized type `X`
+
+pub fn main() {
+}