Parse iface items and interface references in impl items.

The (temporary) syntax is

    iface seq<T> {
        fn len() -> uint;
        fn iter(f: block(T));
    }

    // The 'blah<T>' can be left of to default the name of the
    // impl to seq<T>. The 'of seq<T>' can be left off when
    // not implementing a named interface.
    impl blah<T> of seq<T> for [T] {
        fn len() -> uint { vec::len(self) }
        fn iter(f: block(T)) { for x in self { f(x); } }
    }

Author: marijnh

src/comp/metadata/encoder.rs

@@ -64,6 +64,7 @@ fn encode_native_module_item_paths(ebml_w: ebml::writer, nmod: native_mod,
 
 fn encode_module_item_paths(ebml_w: ebml::writer, module: _mod, path: [str],
                             &index: [entry<str>]) {
+    // FIXME factor out add_to_index/start/encode_name/encode_def_id/end ops
     for it: @item in module.items {
         if !ast_util::is_exported(it.ident, module) { cont; }
         alt it.node {
@@ -137,7 +138,14 @@ fn encode_module_item_paths(ebml_w: ebml::writer, module: _mod, path: [str],
             encode_def_id(ebml_w, local_def(it.id));
             ebml::end_tag(ebml_w);
           }
-          item_impl(_, _, _) {}
+          item_iface(_, _) {
+            add_to_index(ebml_w, path, index, it.ident);
+            ebml::start_tag(ebml_w, tag_paths_data_item);
+            encode_name(ebml_w, it.ident);
+            encode_def_id(ebml_w, local_def(it.id));
+            ebml::end_tag(ebml_w);
+          }
+          item_impl(_, _, _, _) {}
         }
     }
 }
@@ -252,7 +260,7 @@ fn encode_info_for_mod(ebml_w: ebml::writer, md: _mod,
     encode_name(ebml_w, name);
     for i in md.items {
         alt i.node {
-          item_impl(_, _, _) {
+          item_impl(_, _, _, _) {
             if ast_util::is_exported(i.ident, md) {
                 ebml::start_tag(ebml_w, tag_mod_impl);
                 ebml_w.writer.write(str::bytes(def_to_str(local_def(i.id))));
@@ -363,7 +371,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
       }
-      item_impl(tps, _, methods) {
+      item_impl(tps, _, _, methods) {
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'i' as u8);
@@ -390,6 +398,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             ebml::end_tag(ebml_w);
         }
       }
+      item_iface(_, _) { /* FIXME[impl] */ }
     }
 }
 

src/comp/middle/ast_map.rs

@@ -71,7 +71,7 @@ fn map_item(cx: ctx, i: @item) {
             cx.map.insert(m.id, node_obj_method(m));
         }
       }
-      item_impl(_, _, ms) {
+      item_impl(_, _, _, ms) {
         for m in ms { cx.map.insert(m.id, node_method(m)); }
       }
       item_res(_, _, _, dtor_id, ctor_id) {

src/comp/middle/resolve.rs

@@ -401,8 +401,9 @@ fn resolve_names(e: @env, c: @ast::crate) {
 fn visit_item_with_scope(i: @ast::item, sc: scopes, v: vt<scopes>) {
     let sc = cons(scope_item(i), @sc);
     alt i.node {
-      ast::item_impl(tps, sty, methods) {
-        visit::visit_ty(sty, sc, v);
+      ast::item_impl(tps, ifce, sty, methods) {
+        alt ifce { some(ty) { v.visit_ty(ty, sc, v); } _ {} }
+        v.visit_ty(sty, sc, v);
         for m in methods {
             v.visit_fn_proto(m.decl, tps + m.tps, m.body, m.span,
                              some(m.ident), m.id, sc, v);
@@ -802,24 +803,22 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
               ast::item_obj(ob, ty_params, _) {
                 ret lookup_in_obj(name, ob, ty_params, ns, it.id);
               }
-              ast::item_impl(ty_params, _, _) {
+              ast::item_impl(ty_params, _, _, _) {
                 if (name == "self" && ns == ns_value) {
                     ret some(ast::def_self(local_def(it.id)));
                 }
                 if ns == ns_type { ret lookup_in_ty_params(name, ty_params); }
               }
-              ast::item_tag(_, ty_params) {
-                if ns == ns_type { ret lookup_in_ty_params(name, ty_params); }
+              ast::item_iface(tps, _) | ast::item_tag(_, tps) |
+              ast::item_ty(_, tps) {
+                if ns == ns_type { ret lookup_in_ty_params(name, tps); }
               }
               ast::item_mod(_) {
                 ret lookup_in_local_mod(e, it.id, sp, name, ns, inside);
               }
               ast::item_native_mod(m) {
                 ret lookup_in_local_native_mod(e, it.id, sp, name, ns);
               }
-              ast::item_ty(_, ty_params) {
-                if ns == ns_type { ret lookup_in_ty_params(name, ty_params); }
-              }
               _ { }
             }
           }
@@ -1064,7 +1063,7 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option::t<def> {
       ast::item_native_mod(_) {
         if ns == ns_module { ret some(ast::def_native_mod(local_def(i.id))); }
       }
-      ast::item_ty(_, _) {
+      ast::item_ty(_, _) | item_iface(_, _) | item_tag(_, _) {
         if ns == ns_type { ret some(ast::def_ty(local_def(i.id))); }
       }
       ast::item_res(_, _, _, _, ctor_id) {
@@ -1076,9 +1075,6 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option::t<def> {
           _ { }
         }
       }
-      ast::item_tag(_, _) {
-        if ns == ns_type { ret some(ast::def_ty(local_def(i.id))); }
-      }
       ast::item_obj(_, _, ctor_id) {
         alt ns {
           ns_value. {
@@ -1322,7 +1318,7 @@ fn index_mod(md: ast::_mod) -> mod_index {
           ast::item_const(_, _) | ast::item_fn(_, _, _) | ast::item_mod(_) |
           ast::item_native_mod(_) | ast::item_ty(_, _) |
           ast::item_res(_, _, _, _, _) | ast::item_obj(_, _, _) |
-          ast::item_impl(_, _, _) {
+          ast::item_impl(_, _, _, _) | ast::item_iface(_, _) {
             add_to_index(index, it.ident, mie_item(it));
           }
           ast::item_tag(variants, _) {
@@ -1570,7 +1566,9 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
                   ast::item_const(_, _) | ast::item_fn(_, _, _) {
                     add_name(values, it.span, it.ident);
                   }
-                  ast::item_ty(_, _) { add_name(types, it.span, it.ident); }
+                  ast::item_ty(_, _) | ast::item_iface(_, _) {
+                    add_name(types, it.span, it.ident);
+                  }
                   ast::item_res(_, _, _, _, _) | ast::item_obj(_, _, _) {
                     add_name(types, it.span, it.ident);
                     add_name(values, it.span, it.ident);
@@ -1768,7 +1766,7 @@ fn find_impls_in_item(i: @ast::item, &impls: [@_impl],
                       name: option::t<ident>,
                       ck_exports: option::t<ast::_mod>) {
     alt i.node {
-      ast::item_impl(_, _, mthds) {
+      ast::item_impl(_, _, _, mthds) {
         if alt name { some(n) { n == i.ident } _ { true } } &&
            alt ck_exports { some(m) { is_exported(i.ident, m) } _ { true } } {
             impls += [@{did: local_def(i.id),

src/comp/middle/trans.rs

@@ -5013,7 +5013,7 @@ fn trans_item(cx: @local_ctxt, item: ast::item) {
                  with *extend_path(cx, item.ident)};
         trans_obj(sub_cx, item.span, ob, ctor_id, tps);
       }
-      ast::item_impl(tps, _, ms) {
+      ast::item_impl(tps, _, _, ms) {
         trans_impl(cx, item.ident, ms, item.id, tps);
       }
       ast::item_res(decl, tps, body, dtor_id, ctor_id) {
@@ -5340,7 +5340,7 @@ fn collect_item_2(ccx: @crate_ctxt, i: @ast::item, &&pt: [str],
             ccx.obj_methods.insert(m.id, ());
         }
       }
-      ast::item_impl(tps, _, methods) {
+      ast::item_impl(tps, _, _, methods) {
         let name = ccx.names.next(i.ident);
         for m in methods {
             register_fn(ccx, i.span, pt + [name, m.ident],

src/comp/middle/tstate/pre_post_conditions.rs

@@ -64,8 +64,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) {
       }
       item_mod(m) { find_pre_post_mod(m); }
       item_native_mod(nm) { find_pre_post_native_mod(nm); }
-      item_ty(_, _) { ret; }
-      item_tag(_, _) { ret; }
+      item_ty(_, _) | item_tag(_, _) | item_iface(_, _) { ret; }
       item_res(_, _, body, dtor_id, _) {
         let fcx =
             {enclosing: ccx.fm.get(dtor_id),
@@ -75,7 +74,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) {
         find_pre_post_fn(fcx, body);
       }
       item_obj(o, _, _) {for m in o.methods { find_pre_post_method(ccx, m); }}
-      item_impl(_, _, ms) { for m in ms { find_pre_post_method(ccx, m); } }
+      item_impl(_, _, _, ms) { for m in ms { find_pre_post_method(ccx, m); } }
     }
 }
 

src/comp/middle/ty.rs

@@ -73,6 +73,7 @@ export mk_native;
 export mk_native_fn;
 export mk_nil;
 export mk_obj;
+export mk_iface;
 export mk_res;
 export mk_param;
 export mk_ptr;
@@ -123,6 +124,7 @@ export ty_vec;
 export ty_native;
 export ty_nil;
 export ty_obj;
+export ty_iface;
 export ty_res;
 export ty_param;
 export ty_ptr;
@@ -256,6 +258,7 @@ tag sty {
     ty_fn(fn_ty);
     ty_native_fn([arg], t);
     ty_obj([method]);
+    ty_iface(def_id, [t]);
     ty_res(def_id, t, [t]);
     ty_tup([t]);
     ty_var(int); // type variable
@@ -444,7 +447,7 @@ fn mk_raw_ty(cx: ctxt, st: sty) -> @raw_t {
       }
       ty_param(_, _) { has_params = true; }
       ty_var(_) { has_vars = true; }
-      ty_tag(_, tys) {
+      ty_tag(_, tys) | ty_iface(_, tys) {
         for tt: t in tys { derive_flags_t(cx, has_params, has_vars, tt); }
       }
       ty_box(m) { derive_flags_mt(cx, has_params, has_vars, m); }
@@ -584,6 +587,10 @@ fn mk_native_fn(cx: ctxt, args: [arg], ty: t) -> t {
 
 fn mk_obj(cx: ctxt, meths: [method]) -> t { ret gen_ty(cx, ty_obj(meths)); }
 
+fn mk_iface(cx: ctxt, did: ast::def_id, tys: [t]) -> t {
+    ret gen_ty(cx, ty_iface(did, tys));
+}
+
 fn mk_res(cx: ctxt, did: ast::def_id, inner: t, tps: [t]) -> t {
     ret gen_ty(cx, ty_res(did, inner, tps));
 }
@@ -634,7 +641,7 @@ fn walk_ty(cx: ctxt, walker: ty_walk, ty: t) {
         /* no-op */
       }
       ty_box(tm) | ty_vec(tm) | ty_ptr(tm) { walk_ty(cx, walker, tm.ty); }
-      ty_tag(tid, subtys) {
+      ty_tag(_, subtys) | ty_iface(_, subtys) {
         for subty: t in subtys { walk_ty(cx, walker, subty); }
       }
       ty_rec(fields) {
@@ -703,9 +710,10 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
         ty = mk_vec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
       ty_tag(tid, subtys) {
-        let new_subtys: [t] = [];
-        for subty: t in subtys { new_subtys += [fold_ty(cx, fld, subty)]; }
-        ty = mk_tag(cx, tid, new_subtys);
+        ty = mk_tag(cx, tid, vec::map(subtys, {|t| fold_ty(cx, fld, t) }));
+      }
+      ty_iface(did, subtys) {
+        ty = mk_iface(cx, did, vec::map(subtys, {|t| fold_ty(cx, fld, t) }));
       }
       ty_rec(fields) {
         let new_fields: [field] = [];
@@ -785,14 +793,10 @@ fn type_is_bool(cx: ctxt, ty: t) -> bool {
 
 fn type_is_structural(cx: ctxt, ty: t) -> bool {
     alt struct(cx, ty) {
-      ty_rec(_) { ret true; }
-      ty_tup(_) { ret true; }
-      ty_tag(_, _) { ret true; }
-      ty_fn(_) { ret true; }
-      ty_native_fn(_, _) { ret true; }
-      ty_obj(_) { ret true; }
-      ty_res(_, _, _) { ret true; }
-      _ { ret false; }
+      ty_rec(_) | ty_tup(_) | ty_tag(_, _) | ty_fn(_) |
+      ty_native_fn(_, _) | ty_obj(_) | ty_res(_, _, _) |
+      ty_iface(_, _) { true }
+      _ { false }
     }
 }
 
@@ -973,7 +977,7 @@ fn type_kind(cx: ctxt, ty: t) -> ast::kind {
       ty_opaque_closure. { kind_noncopyable }
       // Those with refcounts-to-inner raise pinned to shared,
       // lower unique to shared. Therefore just set result to shared.
-      ty_box(mt) { ast::kind_copyable }
+      ty_box(_) | ty_iface(_, _) { ast::kind_copyable }
       // Boxes and unique pointers raise pinned to shared.
       ty_vec(tm) | ty_uniq(tm) { type_kind(cx, tm.ty) }
       // Records lower to the lowest of their members.
@@ -1142,9 +1146,7 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
       ty_send_type. | ty_type. | ty_native(_) | ty_ptr(_) { result = true; }
       // Boxed types
       ty_str. | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) |
-      ty_native_fn(_, _) | ty_obj(_) {
-        result = false;
-      }
+      ty_native_fn(_, _) | ty_obj(_) | ty_iface(_, _) { result = false; }
       // Structural types
       ty_tag(did, tps) {
         let variants = tag_variants(cx, did);
@@ -1332,6 +1334,11 @@ fn hash_type_structure(st: sty) -> uint {
       ty_send_type. { ret 38u; }
       ty_opaque_closure. { ret 39u; }
       ty_named(t, name) { (str::hash(*name) << 5u) + hash_subty(40u, t) }
+      ty_iface(did, tys) {
+        let h = hash_def(41u, did);
+        for typ: t in tys { h += (h << 5u) + typ; }
+        ret h;
+      }
     }
 }
 
@@ -2024,6 +2031,20 @@ mod unify {
         }
     }
 
+    fn unify_tps(cx: @ctxt, expected_tps: [t], actual_tps: [t],
+                 variance: variance, finish: block([t]) -> result) -> result {
+        let result_tps = [], i = 0u;
+        for exp in expected_tps {
+            let act = actual_tps[i];
+            i += 1u;
+            let result = unify_step(cx, exp, act, variance);
+            alt result {
+              ures_ok(rty) { result_tps += [rty]; }
+              _ { ret result; }
+            }
+        }
+        finish(result_tps)
+    }
     fn unify_step(cx: @ctxt, expected: t, actual: t,
                   variance: variance) -> result {
         // FIXME: rewrite this using tuple pattern matching when available, to
@@ -2109,31 +2130,31 @@ mod unify {
           ty::ty_tag(expected_id, expected_tps) {
             alt struct(cx.tcx, actual) {
               ty::ty_tag(actual_id, actual_tps) {
-                if expected_id.crate != actual_id.crate ||
-                       expected_id.node != actual_id.node {
+                if expected_id != actual_id {
                     ret ures_err(terr_mismatch);
                 }
-                // TODO: factor this cruft out
-                let result_tps: [t] = [];
-                let i = 0u;
-                let expected_len = vec::len::<t>(expected_tps);
-                while i < expected_len {
-                    let expected_tp = expected_tps[i];
-                    let actual_tp = actual_tps[i];
-                    let result = unify_step(
-                        cx, expected_tp, actual_tp, variance);
-                    alt result {
-                      ures_ok(rty) { result_tps += [rty]; }
-                      _ { ret result; }
-                    }
-                    i += 1u;
-                }
-                ret ures_ok(mk_tag(cx.tcx, expected_id, result_tps));
+                ret unify_tps(cx, expected_tps, actual_tps, variance, {|tps|
+                    ures_ok(mk_tag(cx.tcx, expected_id, tps))
+                });
               }
               _ {/* fall through */ }
             }
             ret ures_err(terr_mismatch);
           }
+          ty_iface(expected_id, expected_tps) {
+            alt struct(cx.tcx, actual) {
+              ty::ty_iface(actual_id, actual_tps) {
+                if expected_id != actual_id {
+                    ret ures_err(terr_mismatch);
+                }
+                ret unify_tps(cx, expected_tps, actual_tps, variance, {|tps|
+                    ures_ok(mk_iface(cx.tcx, expected_id, tps))
+                });
+              }
+              _ {}
+            }
+            ret ures_err(terr_mismatch);
+          }
           ty::ty_box(expected_mt) {
             alt struct(cx.tcx, actual) {
               ty::ty_box(actual_mt) {