---

yaml
---
r: 4794
b: refs/heads/master
c: cd440d3
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 2885c67d473b4522441f118149945b516d5ca658
+refs/heads/master: cd440d338efa935713c92a56dc8eec67a703e521

trunk/src/comp/back/link.rs

@@ -313,7 +313,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
     }
 
     // This calculates CMH as defined above
-    fn crate_meta_extras_hash(sha: sha1, crate: &ast::crate,
+    fn crate_meta_extras_hash(sha: sha1, _crate: &ast::crate,
                               metas: &provided_metas) -> str {
         fn len_and_str(s: &str) -> str {
             ret #fmt("%u_%s", str::byte_len(s), s);
@@ -349,7 +349,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
                        name, default));
     }
 
-    fn crate_meta_name(sess: &session::session, crate: &ast::crate,
+    fn crate_meta_name(sess: &session::session, _crate: &ast::crate,
                        output: &str, metas: &provided_metas) -> str {
         ret alt metas.name {
               some(v) { v }
@@ -368,7 +368,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
             };
     }
 
-    fn crate_meta_vers(sess: &session::session, crate: &ast::crate,
+    fn crate_meta_vers(sess: &session::session, _crate: &ast::crate,
                        metas: &provided_metas) -> str {
         ret alt metas.vers {
               some(v) { v }
@@ -435,7 +435,7 @@ fn mangle(ss: &[str]) -> str {
     ret n;
 }
 
-fn exported_name(path: &[str], hash: &str, vers: &str) -> str {
+fn exported_name(path: &[str], hash: &str, _vers: &str) -> str {
     // FIXME: versioning isn't working yet
 
     ret mangle(path + ~[hash]); //  + "@" + vers;
@@ -459,7 +459,7 @@ fn mangle_internal_name_by_path_and_seq(ccx: &@crate_ctxt, path: &[str],
     ret mangle(path + ~[ccx.names.next(flav)]);
 }
 
-fn mangle_internal_name_by_path(ccx: &@crate_ctxt, path: &[str]) -> str {
+fn mangle_internal_name_by_path(_ccx: &@crate_ctxt, path: &[str]) -> str {
     ret mangle(path);
 }
 

trunk/src/comp/back/upcall.rs

@@ -50,23 +50,23 @@ type upcalls =
      dynastack_alloc: ValueRef,
      dynastack_free: ValueRef};
 
-fn declare_upcalls(tn: type_names, tydesc_type: TypeRef,
+fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef,
                    taskptr_type: TypeRef, llmod: ModuleRef) -> @upcalls {
-    fn decl(tn: type_names, llmod: ModuleRef, name: str, tys: [TypeRef],
+    fn decl(llmod: ModuleRef, name: str, tys: [TypeRef],
           rv: TypeRef) -> ValueRef {
         let arg_tys: [TypeRef] = ~[];
         for t: TypeRef in tys { arg_tys += ~[t]; }
         let fn_ty = T_fn(arg_tys, rv);
         ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
     }
-    fn decl_with_taskptr(taskptr_type: TypeRef, tn: type_names,
+    fn decl_with_taskptr(taskptr_type: TypeRef,
                          llmod: ModuleRef, name: str, tys: [TypeRef],
                          rv: TypeRef) -> ValueRef {
-        ret decl(tn, llmod, name, ~[taskptr_type] + tys, rv);
+        ret decl(llmod, name, ~[taskptr_type] + tys, rv);
     }
-    let dv = bind decl_with_taskptr(taskptr_type, tn, llmod, _, _, T_void());
-    let d = bind decl_with_taskptr(taskptr_type, tn, llmod, _, _, _);
-    let dr = bind decl(tn, llmod, _, _, _);
+    let dv = bind decl_with_taskptr(taskptr_type, llmod, _, _, T_void());
+    let d = bind decl_with_taskptr(taskptr_type, llmod, _, _, _);
+    let dr = bind decl(llmod, _, _, _);
 
     let empty_vec: [TypeRef] = ~[];
     ret @{grow_task: dv("grow_task", ~[T_size_t()]),

trunk/src/comp/front/test.rs

@@ -51,7 +51,8 @@ fn modify_for_testing(crate: @ast::crate) -> @ast::crate {
     ret res;
 }
 
-fn fold_mod(cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold) -> ast::_mod {
+fn fold_mod(_cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold)
+    -> ast::_mod {
 
     // Remove any defined main function from the AST so it doesn't clash with
     // the one we're going to add.  FIXME: This is sloppy. Instead we should

trunk/src/comp/lib/llvm.rs

@@ -1264,7 +1264,7 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
         ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, str::buf(""));
     }
 
-    fn Cast(Op: Opcode, Val: ValueRef, DestTy: TypeRef, Name: sbuf) ->
+    fn Cast(Op: Opcode, Val: ValueRef, DestTy: TypeRef, _Name: sbuf) ->
        ValueRef {
         assert (!*terminated);
         ret llvm::LLVMBuildCast(B, Op, Val, DestTy, str::buf(""));

trunk/src/comp/metadata/decoder.rs

@@ -224,7 +224,7 @@ fn get_symbol(data: @[u8], id: ast::node_id) -> str {
     ret item_symbol(lookup_item(id, data));
 }
 
-fn get_tag_variants(data: &@[u8], def: ast::def_id, tcx: &ty::ctxt,
+fn get_tag_variants(_data: &@[u8], def: ast::def_id, tcx: &ty::ctxt,
                     extres: &external_resolver) -> [ty::variant_info] {
     let external_crate_id = def.crate;
     let data =

trunk/src/comp/metadata/tydecode.rs

@@ -39,7 +39,7 @@ fn parse_ident(st: @pstate, sd: str_def, last: char) -> ast::ident {
     ret parse_ident_(st, sd, bind is_last(last, _));
 }
 
-fn parse_ident_(st: @pstate, sd: str_def, is_last: fn(char) -> bool ) ->
+fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn(char) -> bool ) ->
    ast::ident {
     let rslt = "";
     while !is_last(peek(st) as char) {
@@ -117,7 +117,7 @@ fn parse_path(st: @pstate, sd: str_def) -> ast::path {
 
 type arg_parser<T> = fn(@pstate, str_def) -> ast::constr_arg_general_<T> ;
 
-fn parse_constr_arg(st: @pstate, sd: str_def) -> ast::fn_constr_arg {
+fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg {
     alt peek(st) as char {
       '*' { st.pos += 1u; ret ast::carg_base; }
       c {

trunk/src/comp/middle/alias.rs

@@ -51,8 +51,8 @@ fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
     tcx.sess.abort_if_errors();
 }
 
-fn visit_fn(cx: &@ctx, f: &ast::_fn, tp: &[ast::ty_param], sp: &span,
-            name: &fn_ident, id: ast::node_id, sc: &scope, v: &vt<scope>) {
+fn visit_fn(cx: &@ctx, f: &ast::_fn, _tp: &[ast::ty_param], _sp: &span,
+            _name: &fn_ident, id: ast::node_id, sc: &scope, v: &vt<scope>) {
     visit::visit_fn_decl(f.decl, sc, v);
     for arg_: ast::arg in f.decl.inputs {
         cx.local_map.insert(arg_.id, arg(arg_.mode));

trunk/src/comp/middle/ast_map.rs

@@ -87,7 +87,7 @@ fn new_smallintmap_adapter<@K,
             ret smallintmap::find(map, key_idx(key));
         }
 
-        fn remove(key: &K) -> option::t<V> { fail }
+        fn remove(_key: &K) -> option::t<V> { fail }
 
         fn rehash() { fail }
 

trunk/src/comp/middle/freevars.rs

@@ -44,8 +44,8 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
     for decl: ast::node_id in initial_decls { set_add(decls, decl); }
     let refs = @mutable ~[];
 
-    let walk_fn = lambda(f: &ast::_fn, tps: &[ast::ty_param], sp: &span,
-                         i: &ast::fn_ident, nid: ast::node_id) {
+    let walk_fn = lambda(f: &ast::_fn, _tps: &[ast::ty_param], _sp: &span,
+                         _i: &ast::fn_ident, _nid: ast::node_id) {
         for a: ast::arg in f.decl.inputs { set_add(decls, a.id); }
     };
     let walk_expr = lambda(expr: &@ast::expr) {

trunk/src/comp/middle/resolve.rs

@@ -169,7 +169,7 @@ fn map_crate(e: &@env, c: &@ast::crate) {
                        index: index_mod(c.node.module),
                        mutable glob_imports: ~[],
                        glob_imported_names: new_str_hash::<import_state>()});
-    fn index_vi(e: @env, i: &@ast::view_item, sc: &scopes, v: &vt<scopes>) {
+    fn index_vi(e: @env, i: &@ast::view_item, sc: &scopes, _v: &vt<scopes>) {
         alt i.node {
           ast::view_item_import(name, ids, id) {
             e.imports.insert(id, todo(id, name, ids, i.span, sc));
@@ -215,7 +215,8 @@ fn map_crate(e: &@env, c: &@ast::crate) {
              with *visit::default_visitor::<scopes>()};
     visit::visit_crate(*c, cons(scope_crate, @nil),
                        visit::mk_vt(v_link_glob));
-    fn link_glob(e: @env, vi: &@ast::view_item, sc: &scopes, v: &vt<scopes>) {
+    fn link_glob(e: @env, vi: &@ast::view_item, sc: &scopes,
+                 _v: &vt<scopes>) {
         fn find_mod(e: @env, sc: scopes) -> @indexed_mod {
             alt sc {
               cons(scope_item(i), tl) {
@@ -267,7 +268,7 @@ fn resolve_names(e: &@env, c: &@ast::crate) {
           visit_item: visit_item_with_scope,
           visit_block: visit_block_with_scope,
           visit_decl: visit_decl_with_scope,
-          visit_arm: bind walk_arm(e, _, _, _),
+          visit_arm: walk_arm,
           visit_pat: bind walk_pat(e, _, _, _),
           visit_expr: bind walk_expr(e, _, _, _),
           visit_ty: bind walk_ty(e, _, _, _),
@@ -299,10 +300,10 @@ fn resolve_names(e: &@env, c: &@ast::crate) {
         }
     }
     fn walk_constr(e: @env, p: &ast::path, sp: &span, id: node_id,
-                   sc: &scopes, v: &vt<scopes>) {
+                   sc: &scopes, _v: &vt<scopes>) {
         maybe_insert(e, id, lookup_path_strict(*e, sc, sp, p.node, ns_value));
     }
-    fn walk_arm(e: @env, a: &ast::arm, sc: &scopes, v: &vt<scopes>) {
+    fn walk_arm(a: &ast::arm, sc: &scopes, v: &vt<scopes>) {
         visit_arm_with_scope(a, sc, v);
     }
     fn walk_pat(e: &@env, pat: &@ast::pat, sc: &scopes, v: &vt<scopes>) {
@@ -359,7 +360,7 @@ fn visit_fn_with_scope(e: &@env, f: &ast::_fn, tp: &[ast::ty_param],
     // for f's constrs in the table.
 
     for c: @ast::constr in f.decl.constraints {
-        resolve_constr(e, id, c, sc, v);
+        resolve_constr(e, c, sc, v);
     }
     visit::visit_fn(f, tp, sp, name, id,
                     cons(scope_fn(f.decl, f.proto, tp), @sc), v);
@@ -436,8 +437,7 @@ fn follow_import(e: &env, sc: &scopes, path: &[ident], sp: &span) ->
     } else { ret none; }
 }
 
-fn resolve_constr(e: @env, id: node_id, c: &@ast::constr, sc: &scopes,
-                  v: &vt<scopes>) {
+fn resolve_constr(e: @env, c: &@ast::constr, sc: &scopes, _v: &vt<scopes>) {
     let new_def =
         lookup_path_strict(*e, sc, c.span, c.node.path.node, ns_value);
     if option::is_some(new_def) {
@@ -921,7 +921,7 @@ fn lookup_in_mod(e: &env, m: &def, sp: &span, name: &ident, ns: namespace,
     }
 }
 
-fn found_view_item(e: &env, vi: @ast::view_item, ns: namespace) ->
+fn found_view_item(e: &env, vi: @ast::view_item) ->
    option::t<def> {
     alt vi.node {
       ast::view_item_use(_, _, id) {
@@ -1040,7 +1040,9 @@ fn lookup_glob_in_mod(e: &env, info: @indexed_mod, sp: &span, id: &ident,
 fn lookup_in_mie(e: &env, mie: &mod_index_entry, ns: namespace) ->
    option::t<def> {
     alt mie {
-      mie_view_item(view_item) { ret found_view_item(e, view_item, ns); }
+      mie_view_item(view_item) {
+        if ns == ns_module { ret found_view_item(e, view_item); }
+      }
       mie_import_ident(id, _) { ret lookup_import(e, local_def(id), ns); }
       mie_item(item) { ret found_def_item(item, ns); }
       mie_tag_variant(item, variant_idx) {

trunk/src/comp/middle/shape.rs

@@ -231,15 +231,15 @@ fn tag_kind(ccx : &@crate_ctxt, did : &ast::def_id) -> tag_kind {
 
 
 // Returns the code corresponding to the pointer size on this architecture.
-fn s_int(tcx : &ty_ctxt) -> u8 {
+fn s_int(_tcx : &ty_ctxt) -> u8 {
     ret shape_i32;      // TODO: x86-64
 }
 
-fn s_uint(tcx : &ty_ctxt) -> u8 {
+fn s_uint(_tcx : &ty_ctxt) -> u8 {
     ret shape_u32;      // TODO: x86-64
 }
 
-fn s_float(tcx : &ty_ctxt) -> u8 {
+fn s_float(_tcx : &ty_ctxt) -> u8 {
     ret shape_f64;      // TODO: x86-64
 }