---

yaml
---
r: 56026
b: refs/heads/auto
c: 3c08be9
h: refs/heads/master
v: v3

Author: bleibig

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 2c649830be732bc0af585ba4ef54b2c6555b7c1c
+refs/heads/auto: 3c08be9b48f5a4413a35728a0c392df3b0bed785
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/front/core_inject.rs

@@ -77,7 +77,7 @@ fn inject_libcore_ref(sess: Session,
         fold_mod: |module, fld| {
             let n2 = sess.next_node_id();
 
-            let prelude_path = @ast::Path {
+            let prelude_path = @ast::path {
                 span: dummy_sp(),
                 global: false,
                 idents: ~[

branches/auto/src/librustc/front/test.rs

@@ -336,16 +336,16 @@ fn nospan<T:Copy>(t: T) -> codemap::spanned<T> {
     codemap::spanned { node: t, span: dummy_sp() }
 }
 
-fn path_node(+ids: ~[ast::ident]) -> @ast::Path {
-    @ast::Path { span: dummy_sp(),
+fn path_node(+ids: ~[ast::ident]) -> @ast::path {
+    @ast::path { span: dummy_sp(),
                 global: false,
                 idents: ids,
                 rp: None,
                 types: ~[] }
 }
 
-fn path_node_global(+ids: ~[ast::ident]) -> @ast::Path {
-    @ast::Path { span: dummy_sp(),
+fn path_node_global(+ids: ~[ast::ident]) -> @ast::path {
+    @ast::path { span: dummy_sp(),
                  global: true,
                  idents: ids,
                  rp: None,

branches/auto/src/librustc/metadata/tydecode.rs

@@ -137,7 +137,7 @@ pub fn parse_arg_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
     parse_arg(st, conv)
 }
 
-fn parse_path(st: @mut PState) -> @ast::Path {
+fn parse_path(st: @mut PState) -> @ast::path {
     let mut idents: ~[ast::ident] = ~[];
     fn is_last(c: char) -> bool { return c == '(' || c == ':'; }
     idents.push(parse_ident_(st, is_last));
@@ -146,7 +146,7 @@ fn parse_path(st: @mut PState) -> @ast::Path {
           ':' => { next(st); next(st); }
           c => {
             if c == '(' {
-                return @ast::Path { span: dummy_sp(),
+                return @ast::path { span: dummy_sp(),
                                     global: false,
                                     idents: idents,
                                     rp: None,

branches/auto/src/librustc/middle/pat_util.rs

@@ -72,7 +72,7 @@ pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @pat) -> bool {
 }
 
 pub fn pat_bindings(dm: resolve::DefMap, pat: @pat,
-                it: &fn(binding_mode, node_id, span, @Path)) {
+                it: &fn(binding_mode, node_id, span, @path)) {
     do walk_pat(pat) |p| {
         match p.node {
           pat_ident(binding_mode, pth, _) if pat_is_binding(dm, p) => {

branches/auto/src/librustc/middle/privacy.rs

@@ -26,7 +26,7 @@ use syntax::ast::{decl_item, def, def_fn, def_id, def_static_method};
 use syntax::ast::{def_variant, expr_field, expr_method_call, expr_path};
 use syntax::ast::{expr_struct, expr_unary, ident, inherited, item_enum};
 use syntax::ast::{item_foreign_mod, item_fn, item_impl, item_struct};
-use syntax::ast::{item_trait, local_crate, node_id, pat_struct, Path};
+use syntax::ast::{item_trait, local_crate, node_id, pat_struct, path};
 use syntax::ast::{private, provided, public, required, stmt_decl, visibility};
 use syntax::ast;
 use syntax::ast_map::{node_foreign_item, node_item, node_method};
@@ -276,7 +276,7 @@ pub fn check_crate(tcx: ty::ctxt,
     };
 
     // Checks that a private path is in scope.
-    let check_path: @fn(span: span, def: def, path: @Path) =
+    let check_path: @fn(span: span, def: def, path: @path) =
             |span, def, path| {
         debug!("checking path");
         match def {

branches/auto/src/librustc/middle/resolve.rs

@@ -48,7 +48,7 @@ use syntax::ast::{item_const, item_enum, item_fn, item_foreign_mod};
 use syntax::ast::{item_impl, item_mac, item_mod, item_trait, item_ty, le};
 use syntax::ast::{local, local_crate, lt, method, mode, mul};
 use syntax::ast::{named_field, ne, neg, node_id, pat, pat_enum, pat_ident};
-use syntax::ast::{Path, pat_lit, pat_range, pat_struct};
+use syntax::ast::{path, pat_lit, pat_range, pat_struct};
 use syntax::ast::{prim_ty, private, provided};
 use syntax::ast::{public, required, rem, self_ty_, shl, shr, stmt_decl};
 use syntax::ast::{struct_dtor, struct_field, struct_variant_kind};
@@ -4368,7 +4368,7 @@ pub impl Resolver {
     /// If `check_ribs` is true, checks the local definitions first; i.e.
     /// doesn't skip straight to the containing module.
     fn resolve_path(@mut self,
-                    path: @Path,
+                    path: @path,
                     namespace: Namespace,
                     check_ribs: bool,
                     visitor: ResolveVisitor)
@@ -4493,7 +4493,7 @@ pub impl Resolver {
         return NoNameDefinition;
     }
 
-    fn intern_module_part_of_path(@mut self, path: @Path) -> ~[ident] {
+    fn intern_module_part_of_path(@mut self, path: @path) -> ~[ident] {
         let mut module_path_idents = ~[];
         for path.idents.eachi |index, ident| {
             if index == path.idents.len() - 1 {
@@ -4507,7 +4507,7 @@ pub impl Resolver {
     }
 
     fn resolve_module_relative_path(@mut self,
-                                    path: @Path,
+                                    path: @path,
                                     +xray: XrayFlag,
                                     namespace: Namespace)
                                  -> Option<def> {
@@ -4553,7 +4553,7 @@ pub impl Resolver {
     /// Invariant: This must be called only during main resolution, not during
     /// import resolution.
     fn resolve_crate_relative_path(@mut self,
-                                   path: @Path,
+                                   path: @path,
                                    +xray: XrayFlag,
                                    namespace: Namespace)
                                 -> Option<def> {

branches/auto/src/librustc/middle/trans/debuginfo.rs

@@ -542,13 +542,23 @@ fn create_tuple(cx: @CrateContext, t: ty::t, elements: &[ty::t], span: span)
     return mdval;
 }
 
-fn create_boxed_type(cx: @CrateContext, outer: ty::t, _inner: ty::t,
+// returns (void* type as a ValueRef, size in bytes, align in bytes)
+fn voidptr() -> (ValueRef, int, int) {
+    let null = ptr::null();
+    let size = sys::size_of::<ValueRef>() as int;
+    let align = sys::min_align_of::<ValueRef>() as int;
+    let vp = create_derived_type(PointerTypeTag, null, ~"", 0,
+                                 size, align, 0, null);
+    return (vp, size, align);
+}
+
+fn create_boxed_type(cx: @CrateContext, contents: ty::t,
                      span: span, boxed: @Metadata<TyDescMetadata>)
     -> @Metadata<TyDescMetadata> {
     //let tg = StructureTypeTag;
     /*let cache = cx.llmetadata;
     match cached_metadata::<@Metadata<TyDescMetadata>>(
-        cache, tg, {|md| ty::hash_ty(outer) == ty::hash_ty(md.data.hash)}) {
+        cache, tg, {|md| ty::hash_ty(contents) == ty::hash_ty(md.data.hash)}) {
       option::Some(md) { return md; }
       option::None {}
     }*/
@@ -557,18 +567,23 @@ fn create_boxed_type(cx: @CrateContext, outer: ty::t, _inner: ty::t,
     //let cu_node = create_compile_unit_metadata(cx, fname);
     let uint_t = ty::mk_uint(cx.tcx);
     let refcount_type = create_basic_type(cx, uint_t, span);
-    let scx = create_structure(file_node,
-                               @/*bad*/ copy ty_to_str(cx.tcx, outer), 0);
+    let name = ty_to_str(cx.tcx, contents);
+    let scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
     add_member(scx, ~"refcnt", 0, sys::size_of::<uint>() as int,
                sys::min_align_of::<uint>() as int, refcount_type.node);
-    add_member(scx, ~"boxed", 0, 8, //XXX member_size_and_align(??)
-               8, //XXX just a guess
-               boxed.node);
+    // the tydesc and other pointers should be irrelevant to the
+    // debugger, so treat them as void* types
+    let (vp, vpsize, vpalign) = voidptr();
+    add_member(scx, ~"tydesc", 0, vpsize, vpalign, vp);
+    add_member(scx, ~"prev", 0, vpsize, vpalign, vp);
+    add_member(scx, ~"next", 0, vpsize, vpalign, vp);
+    let (size, align) = size_and_align_of(cx, contents);
+    add_member(scx, ~"boxed", 0, size, align, boxed.node);
     let llnode = finish_structure(scx);
     let mdval = @Metadata {
         node: llnode,
         data: TyDescMetadata {
-            hash: ty::type_id(outer)
+            hash: ty::type_id(contents)
         }
     };
     //update_cache(cache, tg, tydesc_metadata(mdval));
@@ -655,11 +670,10 @@ fn create_ty(cx: @CrateContext, t: ty::t, span: span)
         ty::ty_enum(_did, ref _substs) => {
             cx.sess.span_bug(span, ~"debuginfo for enum NYI")
         }
-        ty::ty_box(ref _mt) => {
-            cx.sess.span_bug(span, ~"debuginfo for box NYI")
-        },
-        ty::ty_uniq(ref _mt) => {
-            cx.sess.span_bug(span, ~"debuginfo for uniq NYI")
+        ty::ty_box(ref mt) | ty::ty_uniq(ref mt) => {
+            let boxed = create_ty(cx, mt.ty, span);
+            let box_md = create_boxed_type(cx, mt.ty, span, boxed);
+            create_pointer_type(cx, t, span, box_md)
         },
         ty::ty_evec(ref _mt, ref _vstore) => {
             cx.sess.span_bug(span, ~"debuginfo for evec NYI")

branches/auto/src/librustc/middle/typeck/astconv.rs

@@ -136,7 +136,7 @@ fn ast_path_substs<AC:AstConv,RS:region_scope + Copy + Durable>(
     def_id: ast::def_id,
     decl_generics: &ty::Generics,
     self_ty: Option<ty::t>,
-    path: @ast::Path) -> ty::substs
+    path: @ast::path) -> ty::substs
 {
     /*!
      *
@@ -188,7 +188,7 @@ pub fn ast_path_to_substs_and_ty<AC:AstConv,RS:region_scope + Copy + Durable>(
     self: &AC,
     rscope: &RS,
     did: ast::def_id,
-    path: @ast::Path) -> ty_param_substs_and_ty
+    path: @ast::path) -> ty_param_substs_and_ty
 {
     let tcx = self.tcx();
     let ty::ty_param_bounds_and_ty {
@@ -206,7 +206,7 @@ pub fn ast_path_to_trait_ref<AC:AstConv,RS:region_scope + Copy + Durable>(
     rscope: &RS,
     trait_def_id: ast::def_id,
     self_ty: Option<ty::t>,
-    path: @ast::Path) -> @ty::TraitRef
+    path: @ast::path) -> @ty::TraitRef
 {
     let trait_def =
         self.get_trait_def(trait_def_id);
@@ -229,7 +229,7 @@ pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>(
         self: &AC,
         rscope: &RS,
         did: ast::def_id,
-        path: @ast::Path)
+        path: @ast::path)
      -> ty_param_substs_and_ty
 {
     // Look up the polytype of the item and then substitute the provided types
@@ -318,7 +318,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
     }
 
     fn check_path_args(tcx: ty::ctxt,
-                       path: @ast::Path,
+                       path: @ast::path,
                        flags: uint) {
         if (flags & NO_TPS) != 0u {
             if path.types.len() > 0u {

branches/auto/src/librustc/middle/typeck/check/_match.rs

@@ -99,7 +99,7 @@ pub struct pat_ctxt {
     block_region: ty::Region, // Region for the block of the arm
 }
 
-pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::Path,
+pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
                          subpats: &Option<~[@ast::pat]>, expected: ty::t) {
 
     // Typecheck the path.
@@ -234,7 +234,7 @@ pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::Path,
 /// `etc` is true if the pattern said '...' and false otherwise.
 pub fn check_struct_pat_fields(pcx: pat_ctxt,
                                span: span,
-                               path: @ast::Path,
+                               path: @ast::path,
                                fields: &[ast::field_pat],
                                class_fields: ~[ty::field_ty],
                                class_id: ast::def_id,
@@ -285,7 +285,7 @@ pub fn check_struct_pat_fields(pcx: pat_ctxt,
 }
 
 pub fn check_struct_pat(pcx: pat_ctxt, pat_id: ast::node_id, span: span,
-                        expected: ty::t, path: @ast::Path,
+                        expected: ty::t, path: @ast::path,
                         fields: &[ast::field_pat], etc: bool,
                         class_id: ast::def_id, substitutions: &ty::substs) {
     let fcx = pcx.fcx;
@@ -326,7 +326,7 @@ pub fn check_struct_like_enum_variant_pat(pcx: pat_ctxt,
                                           pat_id: ast::node_id,
                                           span: span,
                                           expected: ty::t,
-                                          path: @ast::Path,
+                                          path: @ast::path,
                                           fields: &[ast::field_pat],
                                           etc: bool,
                                           enum_id: ast::def_id,

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -3211,7 +3211,7 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt,
 // Instantiates the given path, which must refer to an item with the given
 // number of type parameters and type.
 pub fn instantiate_path(fcx: @mut FnCtxt,
-                        pth: @ast::Path,
+                        pth: @ast::path,
                         tpt: ty_param_bounds_and_ty,
                         span: span,
                         node_id: ast::node_id,

branches/auto/src/libsyntax/ast.rs

@@ -113,7 +113,7 @@ pub struct Lifetime {
 #[auto_encode]
 #[auto_decode]
 #[deriving(Eq)]
-pub struct Path {
+pub struct path {
     span: span,
     global: bool,
     idents: ~[ident],
@@ -301,10 +301,10 @@ pub enum pat_ {
     // which it is. The resolver determines this, and
     // records this pattern's node_id in an auxiliary
     // set (of "pat_idents that refer to nullary enums")
-    pat_ident(binding_mode, @Path, Option<@pat>),
-    pat_enum(@Path, Option<~[@pat]>), /* "none" means a * pattern where
+    pat_ident(binding_mode, @path, Option<@pat>),
+    pat_enum(@path, Option<~[@pat]>), /* "none" means a * pattern where
                                        * we don't bind the fields to names */
-    pat_struct(@Path, ~[field_pat], bool),
+    pat_struct(@path, ~[field_pat], bool),
     pat_tup(~[@pat]),
     pat_box(@pat),
     pat_uniq(@pat),
@@ -567,7 +567,7 @@ pub enum expr_ {
     expr_assign_op(binop, @expr, @expr),
     expr_field(@expr, ident, ~[@Ty]),
     expr_index(@expr, @expr),
-    expr_path(@Path),
+    expr_path(@path),
     expr_addr_of(mutability, @expr),
     expr_break(Option<ident>),
     expr_again(Option<ident>),
@@ -579,7 +579,7 @@ pub enum expr_ {
     expr_mac(mac),
 
     // A struct literal expression.
-    expr_struct(@Path, ~[field], Option<@expr>),
+    expr_struct(@path, ~[field], Option<@expr>),
 
     // A vector literal constructed from one repeated element.
     expr_repeat(@expr /* element */, @expr /* count */, mutability),
@@ -697,7 +697,7 @@ pub type mac = spanned<mac_>;
 #[auto_decode]
 #[deriving(Eq)]
 pub enum mac_ {
-    mac_invoc_tt(@Path,~[token_tree]),   // new macro-invocation
+    mac_invoc_tt(@path,~[token_tree]),   // new macro-invocation
 }
 
 pub type lit = spanned<lit_>;
@@ -894,7 +894,7 @@ pub enum ty_ {
     ty_closure(@TyClosure),
     ty_bare_fn(@TyBareFn),
     ty_tup(~[@Ty]),
-    ty_path(@Path, node_id),
+    ty_path(@path, node_id),
     ty_mac(mac),
     // ty_infer means the type should be inferred instead of it having been
     // specified. This should only appear at the "top level" of a type and not
@@ -1118,13 +1118,13 @@ pub enum view_path_ {
     // or just
     //
     // foo::bar::baz  (with 'baz =' implicitly on the left)
-    view_path_simple(ident, @Path, namespace, node_id),
+    view_path_simple(ident, @path, namespace, node_id),
 
     // foo::bar::*
-    view_path_glob(@Path, node_id),
+    view_path_glob(@path, node_id),
 
     // foo::bar::{a,b,c}
-    view_path_list(@Path, ~[path_list_ident], node_id)
+    view_path_list(@path, ~[path_list_ident], node_id)
 }
 
 #[auto_encode]
@@ -1177,7 +1177,7 @@ pub struct attribute_ {
 #[auto_decode]
 #[deriving(Eq)]
 pub struct trait_ref {
-    path: @Path,
+    path: @path,
     ref_id: node_id,
 }
 

branches/auto/src/libsyntax/ast_util.rs

@@ -30,7 +30,7 @@ pub fn path_name_i(idents: &[ident], intr: @token::ident_interner) -> ~str {
 }
 
 
-pub fn path_to_ident(p: @Path) -> ident { copy *p.idents.last() }
+pub fn path_to_ident(p: @path) -> ident { copy *p.idents.last() }
 
 pub fn local_def(id: node_id) -> def_id {
     ast::def_id { crate: local_crate, node: id }
@@ -223,8 +223,8 @@ pub fn default_block(
     }
 }
 
-pub fn ident_to_path(s: span, +i: ident) -> @Path {
-    @ast::Path { span: s,
+pub fn ident_to_path(s: span, +i: ident) -> @path {
+    @ast::path { span: s,
                  global: false,
                  idents: ~[i],
                  rp: None,