Accept prefix notation for writing the types of str/~ and friends.

Author: msullivan

doc/tutorial.md

@@ -1347,7 +1347,7 @@ imply ownership. Pointers may be borrowed from any type, in which case
 the pointer is guaranteed not to outlive the value it points to.
 
 ~~~~
-# fn work_with_foo_by_pointer(f: &str) { }
+# fn work_with_foo_by_pointer(f: &str/~) { }
 let foo = "foo";
 work_with_foo_by_pointer(&foo);
 ~~~~

src/fuzzer/fuzzer.rs

@@ -418,7 +418,7 @@ fn check_compiling(filename: str) -> happiness {
 }
 
 
-fn parse_and_print(code: @str) -> str {
+fn parse_and_print(code: @str/~) -> str {
     let filename = "tmp.rs";
     let sess = parse::new_parse_sess(option::none);
     write_file(filename, *code);
@@ -501,7 +501,7 @@ fn file_might_not_converge(filename: str) -> bool {
     ret false;
 }
 
-fn check_roundtrip_convergence(code: @str, maxIters: uint) {
+fn check_roundtrip_convergence(code: @str/~, maxIters: uint) {
 
     let mut i = 0u;
     let mut newv = code;

src/libcore/task.rs

@@ -1300,7 +1300,7 @@ fn test_unkillable_nested() {
 
 #[test]
 fn test_tls_multitask() unsafe {
-    fn my_key(+_x: @str) { }
+    fn my_key(+_x: @str/~) { }
     local_data_set(my_key, @"parent data");
     do task::spawn {
         assert local_data_get(my_key) == none; // TLS shouldn't carry over.
@@ -1316,15 +1316,15 @@ fn test_tls_multitask() unsafe {
 
 #[test]
 fn test_tls_overwrite() unsafe {
-    fn my_key(+_x: @str) { }
+    fn my_key(+_x: @str/~) { }
     local_data_set(my_key, @"first data");
     local_data_set(my_key, @"next data"); // Shouldn't leak.
     assert *(local_data_get(my_key).get()) == "next data";
 }
 
 #[test]
 fn test_tls_pop() unsafe {
-    fn my_key(+_x: @str) { }
+    fn my_key(+_x: @str/~) { }
     local_data_set(my_key, @"weasel");
     assert *(local_data_pop(my_key).get()) == "weasel";
     // Pop must remove the data from the map.
@@ -1333,7 +1333,7 @@ fn test_tls_pop() unsafe {
 
 #[test]
 fn test_tls_modify() unsafe {
-    fn my_key(+_x: @str) { }
+    fn my_key(+_x: @str/~) { }
     local_data_modify(my_key, |data| {
         alt data {
             some(@val) { fail "unwelcome value: " + val }
@@ -1357,15 +1357,15 @@ fn test_tls_crust_automorestack_memorial_bug() unsafe {
     // jump over to the rust stack, which causes next_c_sp to get recorded as
     // something within a rust stack segment. Then a subsequent upcall (esp.
     // for logging, think vsnprintf) would run on a stack smaller than 1 MB.
-    fn my_key(+_x: @str) { }
+    fn my_key(+_x: @str/~) { }
     do task::spawn {
         unsafe { local_data_set(my_key, @"hax"); }
     }
 }
 
 #[test]
 fn test_tls_multiple_types() unsafe {
-    fn str_key(+_x: @str) { }
+    fn str_key(+_x: @str/~) { }
     fn box_key(+_x: @@()) { }
     fn int_key(+_x: @int) { }
     do task::spawn {
@@ -1377,7 +1377,7 @@ fn test_tls_multiple_types() unsafe {
 
 #[test]
 fn test_tls_overwrite_multiple_types() unsafe {
-    fn str_key(+_x: @str) { }
+    fn str_key(+_x: @str/~) { }
     fn box_key(+_x: @@()) { }
     fn int_key(+_x: @int) { }
     do task::spawn {
@@ -1393,7 +1393,7 @@ fn test_tls_overwrite_multiple_types() unsafe {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_tls_cleanup_on_failure() unsafe {
-    fn str_key(+_x: @str) { }
+    fn str_key(+_x: @str/~) { }
     fn box_key(+_x: @@()) { }
     fn int_key(+_x: @int) { }
     local_data_set(str_key, @"parent data");

src/libcore/to_bytes.rs

@@ -14,6 +14,6 @@ impl of to_bytes for str {
     fn to_bytes() -> ~[u8] { str::bytes(self) }
 }
 
-impl of to_bytes for @str {
+impl of to_bytes for @(str/~) {
     fn to_bytes() -> ~[u8] { str::bytes(*self) }
 }

src/libcore/unsafe.rs

@@ -61,8 +61,8 @@ mod tests {
             let box = @"box box box";       // refcount 1
             bump_box_refcount(box);         // refcount 2
             let ptr: *int = transmute(box); // refcount 2
-            let _box1: @str = reinterpret_cast(ptr);
-            let _box2: @str = reinterpret_cast(ptr);
+            let _box1: @str/~ = reinterpret_cast(ptr);
+            let _box2: @str/~ = reinterpret_cast(ptr);
             assert *_box1 == "box box box";
             assert *_box2 == "box box box";
             // Will destroy _box1 and _box2. Without the bump, this would

src/libstd/json.rs

@@ -29,7 +29,7 @@ export null;
 /// Represents a json value
 enum json {
     num(float),
-    string(@str),
+    string(@str/~),
     boolean(bool),
     list(@~[json]),
     dict(map::hashmap<str, json>),
@@ -39,7 +39,7 @@ enum json {
 type error = {
     line: uint,
     col: uint,
-    msg: @str,
+    msg: @str/~,
 };
 
 /// Serializes a json value into a io::writer
@@ -324,7 +324,7 @@ impl parser for parser {
         ok(res)
     }
 
-    fn parse_str() -> result<@str, error> {
+    fn parse_str() -> result<@str/~, error> {
         let mut escape = false;
         let mut res = "";
 
@@ -579,7 +579,7 @@ impl of to_json for str {
     fn to_json() -> json { string(@copy self) }
 }
 
-impl of to_json for @str {
+impl of to_json for @str/~ {
     fn to_json() -> json { string(self) }
 }
 

src/libstd/map.rs

@@ -310,8 +310,8 @@ fn str_hash<V: copy>() -> hashmap<str, V> {
 }
 
 /// Construct a hashmap for boxed string keys
-fn box_str_hash<V: copy>() -> hashmap<@str, V> {
-    ret hashmap(|x: @str| str::hash(*x), |x,y| str::eq(*x,*y));
+fn box_str_hash<V: copy>() -> hashmap<@str/~, V> {
+    ret hashmap(|x: @str/~| str::hash(*x), |x,y| str::eq(*x,*y));
 }
 
 /// Construct a hashmap for byte string keys

src/libstd/rope.rs

@@ -53,7 +53,7 @@ fn empty() -> rope {
  * * this operation does not copy the string;
  * * the function runs in linear time.
  */
-fn of_str(str: @str) -> rope {
+fn of_str(str: @str/~) -> rope {
     ret of_substr(str, 0u, str::len(*str));
 }
 
@@ -79,7 +79,7 @@ fn of_str(str: @str) -> rope {
  * * this function does _not_ check the validity of the substring;
  * * this function fails if `byte_offset` or `byte_len` do not match `str`.
  */
-fn of_substr(str: @str, byte_offset: uint, byte_len: uint) -> rope {
+fn of_substr(str: @str/~, byte_offset: uint, byte_len: uint) -> rope {
     if byte_len == 0u { ret node::empty; }
     if byte_offset + byte_len  > str::len(*str) { fail; }
     ret node::content(node::of_substr(str, byte_offset, byte_len));
@@ -107,7 +107,7 @@ fn append_char(rope: rope, char: char) -> rope {
  *
  * * this function executes in near-linear time
  */
-fn append_str(rope: rope, str: @str) -> rope {
+fn append_str(rope: rope, str: @str/~) -> rope {
     ret append_rope(rope, of_str(str))
 }
 
@@ -127,7 +127,7 @@ fn prepend_char(rope: rope, char: char) -> rope {
  * # Performance note
  * * this function executes in near-linear time
  */
-fn prepend_str(rope: rope, str: @str) -> rope {
+fn prepend_str(rope: rope, str: @str/~) -> rope {
     ret append_rope(of_str(str), rope)
 }
 
@@ -567,7 +567,7 @@ mod node {
         byte_offset: uint,
         byte_len:    uint,
         char_len:   uint,
-        content:    @str
+        content:    @str/~
     };
 
     /**
@@ -627,7 +627,7 @@ mod node {
      * Performance note: The complexity of this function is linear in
      * the length of `str`.
      */
-    fn of_str(str: @str) -> @node {
+    fn of_str(str: @str/~) -> @node {
         ret of_substr(str, 0u, str::len(*str));
     }
 
@@ -648,7 +648,7 @@ mod node {
      * Behavior is undefined if `byte_start` or `byte_len` do not represent
      * valid positions in `str`
      */
-    fn of_substr(str: @str, byte_start: uint, byte_len: uint) -> @node {
+    fn of_substr(str: @str/~, byte_start: uint, byte_len: uint) -> @node {
         ret of_substr_unsafer(str, byte_start, byte_len,
                               str::count_chars(*str, byte_start, byte_len));
     }
@@ -674,7 +674,7 @@ mod node {
      * * Behavior is undefined if `char_len` does not accurately represent the
      *   number of chars between byte_start and byte_start+byte_len
      */
-    fn of_substr_unsafer(str: @str, byte_start: uint, byte_len: uint,
+    fn of_substr_unsafer(str: @str/~, byte_start: uint, byte_len: uint,
                           char_len: uint) -> @node {
         assert(byte_start + byte_len <= str::len(*str));
         let candidate = @leaf({

src/libsyntax/ast.rs

@@ -32,7 +32,7 @@ fn deserialize_span<D>(_d: D) -> span {
 type spanned<T> = {node: T, span: span};
 
 #[auto_serialize]
-type ident = @str;
+type ident = @str/~;
 
 // Functions may or may not have names.
 #[auto_serialize]
@@ -427,11 +427,11 @@ type lit = spanned<lit_>;
 
 #[auto_serialize]
 enum lit_ {
-    lit_str(@str),
+    lit_str(@str/~),
     lit_int(i64, int_ty),
     lit_uint(u64, uint_ty),
     lit_int_unsuffixed(i64),
-    lit_float(@str, float_ty),
+    lit_float(@str/~, float_ty),
     lit_nil,
     lit_bool(bool),
 }

src/libsyntax/attr.rs

@@ -124,7 +124,7 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
  * Gets the string value if the meta_item is a meta_name_value variant
  * containing a string, otherwise none
  */
-fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@str> {
+fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@str/~> {
     alt meta.node {
       ast::meta_name_value(_, v) {
         alt v.node {
@@ -154,7 +154,7 @@ fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
  */
 fn get_name_value_str_pair(
     item: @ast::meta_item
-) -> option<(ast::ident, @str)> {
+) -> option<(ast::ident, @str/~)> {
     alt attr::get_meta_item_value_str(item) {
       some(value) {
         let name = attr::get_meta_item_name(item);
@@ -239,7 +239,7 @@ fn attrs_contains_name(attrs: ~[ast::attribute], +name: str) -> bool {
 }
 
 fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: str)
-    -> option<@str> {
+    -> option<@str/~> {
     let mattrs = find_attrs_by_name(attrs, name);
     if vec::len(mattrs) > 0u {
         ret get_meta_item_value_str(attr_meta(mattrs[0]));
@@ -258,7 +258,7 @@ fn last_meta_item_by_name(
 fn last_meta_item_value_str_by_name(
     items: ~[@ast::meta_item],
     +name: str
-) -> option<@str> {
+) -> option<@str/~> {
     alt last_meta_item_by_name(items, name) {
       some(item) {
         alt attr::get_meta_item_value_str(item) {

src/libsyntax/codemap.rs

@@ -45,7 +45,7 @@ enum file_substr {
 }
 
 type filemap =
-    @{name: filename, substr: file_substr, src: @str,
+    @{name: filename, substr: file_substr, src: @str/~,
       start_pos: file_pos, mut lines: ~[file_pos]};
 
 type codemap = @{files: dvec<filemap>};
@@ -55,15 +55,15 @@ type loc = {file: filemap, line: uint, col: uint};
 fn new_codemap() -> codemap { @{files: dvec()} }
 
 fn new_filemap_w_substr(+filename: filename, +substr: file_substr,
-                        src: @str,
+                        src: @str/~,
                         start_pos_ch: uint, start_pos_byte: uint)
    -> filemap {
     ret @{name: filename, substr: substr, src: src,
           start_pos: {ch: start_pos_ch, byte: start_pos_byte},
           mut lines: ~[{ch: start_pos_ch, byte: start_pos_byte}]};
 }
 
-fn new_filemap(+filename: filename, src: @str,
+fn new_filemap(+filename: filename, src: @str/~,
                start_pos_ch: uint, start_pos_byte: uint)
     -> filemap {
     ret new_filemap_w_substr(filename, fss_none, src,

src/libsyntax/ext/auto_serialize.rs

@@ -218,7 +218,7 @@ impl helpers for ext_ctxt {
                 ast::expr_alt(v, arms, ast::alt_exhaustive)))
     }
 
-    fn lit_str(span: span, s: @str) -> @ast::expr {
+    fn lit_str(span: span, s: @str/~) -> @ast::expr {
         self.expr(
             span,
             ast::expr_lit(
@@ -343,8 +343,19 @@ fn ser_lambda(cx: ext_ctxt, tps: ser_tps_map, ty: @ast::ty,
     cx.lambda(cx.blk(ty.span, ser_ty(cx, tps, ty, s, v)))
 }
 
+fn is_vec_or_str(ty: @ast::ty) -> bool {
+    alt ty.node {
+      ast::ty_vec(_) { true }
+      // This may be wrong if the user has shadowed (!) str
+      ast::ty_path(@{span: _, global: _, idents: ids,
+                             rp: none, types: _}, _)
+      if ids == ~[@"str"] { true }
+      _ { false }
+    }
+}
+
 fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
-                ty: @ast::ty, -s: @ast::expr, -v: @ast::expr)
+          ty: @ast::ty, -s: @ast::expr, -v: @ast::expr)
     -> ~[@ast::stmt] {
 
     let ext_cx = cx; // required for #ast{}
@@ -365,6 +376,11 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
         ~[#ast(stmt){$(s).emit_box($(l));}]
       }
 
+      // For unique evecs/estrs, just pass through to underlying vec or str
+      ast::ty_uniq(mt) if is_vec_or_str(mt.ty) {
+        ser_ty(cx, tps, mt.ty, s, v)
+      }
+
       ast::ty_uniq(mt) {
         let l = ser_lambda(cx, tps, mt.ty, cx.clone(s), #ast{ *$(v) });
         ~[#ast(stmt){$(s).emit_uniq($(l));}]
@@ -612,6 +628,11 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
         #ast{ @$(d).read_box($(l)) }
       }
 
+      // For unique evecs/estrs, just pass through to underlying vec or str
+      ast::ty_uniq(mt) if is_vec_or_str(mt.ty) {
+        deser_ty(cx, tps, mt.ty, d)
+      }
+
       ast::ty_uniq(mt) {
         let l = deser_lambda(cx, tps, mt.ty, cx.clone(d));
         #ast{ ~$(d).read_uniq($(l)) }

src/libsyntax/ext/simplext.rs

@@ -679,7 +679,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
                      _body: ast::mac_body) -> base::macro_def {
     let args = get_mac_args_no_max(cx, sp, arg, 0u, "macro");
 
-    let mut macro_name: option<@str> = none;
+    let mut macro_name: option<@str/~> = none;
     let mut clauses: ~[@clause] = ~[];
     for args.each |arg| {
         alt arg.node {