auto merge of #5709 : jbclements/rust/miscellaneous-cleanup, r=bstrie

There's no unifying theme here; I'm just trying to clear a bunch of small commits: removing dead code, adding comments, renaming to an upper-case type, fixing one test case.

Author: bors

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: ~[

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,

src/librustc/metadata/tydecode.rs

@@ -125,7 +125,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));
@@ -134,7 +134,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,

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) => {

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 {

src/librustc/middle/resolve.rs

@@ -47,7 +47,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};
@@ -4356,7 +4356,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)
@@ -4481,7 +4481,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 {
@@ -4495,7 +4495,7 @@ pub impl Resolver {
     }
 
     fn resolve_module_relative_path(@mut self,
-                                    path: @path,
+                                    path: @Path,
                                     +xray: XrayFlag,
                                     namespace: Namespace)
                                  -> Option<def> {
@@ -4541,7 +4541,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> {

src/librustc/middle/typeck/astconv.rs

@@ -133,7 +133,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)
+        path: @ast::Path)
      -> ty_param_substs_and_ty {
     let tcx = self.tcx();
     let ty::ty_param_bounds_and_ty {
@@ -189,7 +189,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
@@ -285,7 +285,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 {

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.
@@ -232,7 +232,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,
@@ -283,7 +283,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;
@@ -324,7 +324,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,

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

@@ -3197,7 +3197,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,

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],
@@ -300,10 +300,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),
@@ -566,7 +566,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>),
@@ -578,7 +578,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),
@@ -696,7 +696,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_>;
@@ -893,7 +893,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
@@ -1117,13 +1117,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]
@@ -1176,7 +1176,7 @@ pub struct attribute_ {
 #[auto_decode]
 #[deriving(Eq)]
 pub struct trait_ref {
-    path: @path,
+    path: @Path,
     ref_id: node_id,
 }