introduce an owned kind for data that contains no borrowed ptrs

Author: nikomatsakis

Diff for: src/libsyntax/ast.rs

@@ -62,6 +62,7 @@ enum ty_param_bound {
     bound_copy,
     bound_send,
     bound_const,
+    bound_owned,
     bound_trait(@ty),
 }
 

Diff for: src/libsyntax/fold.rs

@@ -135,7 +135,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
 
 fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
     alt tpb {
-      bound_copy | bound_send | bound_const { tpb }
+      bound_copy | bound_send | bound_const | bound_owned { tpb }
       bound_trait(ty) { bound_trait(fld.fold_ty(ty)) }
     }
 }

Diff for: src/libsyntax/parse/parser.rs

@@ -16,7 +16,8 @@ import dvec::{dvec, extensions};
 import vec::{push};
 import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
              bitand, bitor, bitxor, blk, blk_check_mode, bound_const,
-             bound_copy, bound_send, bound_trait, box, by_copy, by_move,
+             bound_copy, bound_send, bound_trait, bound_owned,
+             box, by_copy, by_move,
              by_mutbl_ref, by_ref, by_val, capture_clause, capture_item,
              carg_base, carg_ident, cdir_dir_mod, cdir_src_mod,
              cdir_view_item, checked_expr, claimed_expr, class_immutable,
@@ -1935,12 +1936,16 @@ class parser {
         let ident = self.parse_ident();
         if self.eat(token::COLON) {
             while self.token != token::COMMA && self.token != token::GT {
-                if self.eat_keyword(~"send") { push(bounds, bound_send); }
-                else if self.eat_keyword(~"copy") { push(bounds, bound_copy) }
+                if self.eat_keyword(~"send") {
+                    push(bounds, bound_send); }
+                else if self.eat_keyword(~"copy") {
+                    push(bounds, bound_copy) }
                 else if self.eat_keyword(~"const") {
-                    push(bounds, bound_const)
-                }
-                else { push(bounds, bound_trait(self.parse_ty(false))); }
+                    push(bounds, bound_const);
+                } else if self.eat_keyword(~"owned") {
+                    push(bounds, bound_owned);
+                } else {
+                    push(bounds, bound_trait(self.parse_ty(false))); }
             }
         }
         ret {ident: ident, id: self.get_id(), bounds: @bounds};

Diff for: src/libsyntax/parse/token.rs

@@ -313,7 +313,7 @@ fn restricted_keyword_table() -> hashmap<~str, ()> {
         ~"if", ~"iface", ~"impl", ~"import",
         ~"let", ~"log", ~"loop",
         ~"mod", ~"mut",
-        ~"new",
+        ~"new", ~"owned",
         ~"pure", ~"ret",
         ~"true", ~"trait", ~"type",
         ~"unchecked", ~"unsafe",

Diff for: src/libsyntax/print/pprust.rs

@@ -1377,6 +1377,7 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
               ast::bound_copy { word(s.s, ~"copy"); }
               ast::bound_send { word(s.s, ~"send"); }
               ast::bound_const { word(s.s, ~"const"); }
+              ast::bound_owned { word(s.s, ~"owned"); }
               ast::bound_trait(t) { print_type(s, t); }
             }
         }

Diff for: src/libsyntax/visit.rs

@@ -246,7 +246,7 @@ fn visit_ty_params<E>(tps: ~[ty_param], e: E, v: vt<E>) {
         for vec::each(*tp.bounds) |bound| {
             alt bound {
               bound_trait(t) { v.visit_ty(t, e, v); }
-              bound_copy | bound_send | bound_const { }
+              bound_copy | bound_send | bound_const | bound_owned { }
             }
         }
     }

Diff for: src/rustc/metadata/tydecode.rs

@@ -417,6 +417,7 @@ fn parse_bounds(st: @pstate, conv: conv_did) -> @~[ty::param_bound] {
           'S' { ty::bound_send }
           'C' { ty::bound_copy }
           'K' { ty::bound_const }
+          'O' { ty::bound_owned }
           'I' { ty::bound_trait(parse_ty(st, conv)) }
           '.' { break; }
         });

Diff for: src/rustc/metadata/tyencode.rs

@@ -350,6 +350,7 @@ fn enc_bounds(w: io::writer, cx: @ctxt, bs: @~[ty::param_bound]) {
           ty::bound_send { w.write_char('S'); }
           ty::bound_copy { w.write_char('C'); }
           ty::bound_const { w.write_char('K'); }
+          ty::bound_owned { w.write_char('O'); }
           ty::bound_trait(tp) {
             w.write_char('I');
             enc_ty(w, cx, tp);

Diff for: src/rustc/middle/kind.rs

@@ -1,8 +1,7 @@
 import syntax::{visit, ast_util};
 import syntax::ast::*;
 import syntax::codemap::span;
-import ty::{kind, kind_sendable, kind_copyable, kind_noncopyable, kind_const,
-           operators};
+import ty::{kind, kind_copyable, kind_noncopyable, kind_const, operators};
 import driver::session::session;
 import std::map::hashmap;
 import util::ppaux::{ty_to_str, tys_to_str};
@@ -21,6 +20,7 @@ import lint::{non_implicitly_copyable_typarams,implicit_copies};
 //  copy: Things that can be copied.
 //  const: Things thare are deeply immutable. They are guaranteed never to
 //    change, and can be safely shared without copying between tasks.
+//  owned: Things that do not contain borrowed pointers.
 //
 // Send includes scalar types as well as classes and unique types containing
 // only sendable types.
@@ -41,15 +41,21 @@ import lint::{non_implicitly_copyable_typarams,implicit_copies};
 
 fn kind_to_str(k: kind) -> ~str {
     let mut kinds = ~[];
+
     if ty::kind_lteq(kind_const(), k) {
         vec::push(kinds, ~"const");
     }
+
     if ty::kind_can_be_copied(k) {
         vec::push(kinds, ~"copy");
     }
+
     if ty::kind_can_be_sent(k) {
         vec::push(kinds, ~"send");
+    } else if ty::kind_is_owned(k) {
+        vec::push(kinds, ~"owned");
     }
+
     str::connect(kinds, ~" ")
 }
 
@@ -93,8 +99,8 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) {
     fn check_for_uniq(cx: ctx, id: node_id, fv: option<@freevar_entry>,
                       is_move: bool, var_t: ty::t, sp: span) {
         // all captured data must be sendable, regardless of whether it is
-        // moved in or copied in
-        check_send(cx, var_t, sp);
+        // moved in or copied in.  Note that send implies owned.
+        if !check_send(cx, var_t, sp) { ret; }
 
         // copied in data must be copyable, but moved in data can be anything
         let is_implicit = fv.is_some();
@@ -108,6 +114,9 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) {
 
     fn check_for_box(cx: ctx, id: node_id, fv: option<@freevar_entry>,
                      is_move: bool, var_t: ty::t, sp: span) {
+        // all captured data must be owned
+        if !check_owned(cx, var_t, sp) { ret; }
+
         // copied in data must be copyable, but moved in data can be anything
         let is_implicit = fv.is_some();
         if !is_move { check_copy(cx, id, var_t, sp, is_implicit); }
@@ -422,9 +431,21 @@ fn check_copy(cx: ctx, id: node_id, ty: ty::t, sp: span,
     }
 }
 
-fn check_send(cx: ctx, ty: ty::t, sp: span) {
+fn check_send(cx: ctx, ty: ty::t, sp: span) -> bool {
     if !ty::kind_can_be_sent(ty::type_kind(cx.tcx, ty)) {
         cx.tcx.sess.span_err(sp, ~"not a sendable value");
+        false
+    } else {
+        true
+    }
+}
+
+fn check_owned(cx: ctx, ty: ty::t, sp: span) -> bool {
+    if !ty::kind_is_owned(ty::type_kind(cx.tcx, ty)) {
+        cx.tcx.sess.span_err(sp, ~"not an owned value");
+        false
+    } else {
+        true
     }
 }
 

Diff for: src/rustc/middle/resolve3.rs

@@ -4,6 +4,7 @@ import metadata::cstore::find_use_stmt_cnum;
 import metadata::decoder::{def_like, dl_def, dl_field, dl_impl};
 import middle::lint::{error, ignore, level, unused_imports, warn};
 import syntax::ast::{_mod, arm, blk, bound_const, bound_copy, bound_trait};
+import syntax::ast::{bound_owned};
 import syntax::ast::{bound_send, capture_clause, class_ctor, class_dtor};
 import syntax::ast::{class_member, class_method, crate, crate_num, decl_item};
 import syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn};
@@ -3181,7 +3182,7 @@ class Resolver {
         for type_parameters.each |type_parameter| {
             for (*type_parameter.bounds).each |bound| {
                 alt bound {
-                    bound_copy | bound_send | bound_const {
+                    bound_copy | bound_send | bound_const | bound_owned {
                         // Nothing to do.
                     }
                     bound_trait(interface_type) {