Infer variance of types with respect to the region parameter.

A similar approach could be used for type parameters.

Fixes #2282.

Author: nikomatsakis

src/libcore/task.rs

@@ -770,6 +770,7 @@ enum AncestorList = option<unsafe::Exclusive<AncestorNode>>;
 fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U {
     unsafe { x.with(blk) }
 }
+
 #[inline(always)]
 fn access_ancestors<U>(x: &unsafe::Exclusive<AncestorNode>,
                        blk: fn(x: &mut AncestorNode) -> U) -> U {

src/libsyntax/ast_map.rs

@@ -299,7 +299,20 @@ fn node_id_to_str(map: map, id: node_id, itr: ident_interner) -> ~str {
         fmt!{"unknown node (id=%d)", id}
       }
       some(node_item(item, path)) => {
-        fmt!{"item %s (id=%?)", path_ident_to_str(*path, item.ident, itr), id}
+        let path_str = path_ident_to_str(*path, item.ident, itr);
+        let item_str = match item.node {
+          item_const(*) => ~"const",
+          item_fn(*) => ~"fn",
+          item_mod(*) => ~"mod",
+          item_foreign_mod(*) => ~"foreign mod",
+          item_ty(*) => ~"ty",
+          item_enum(*) => ~"enum",
+          item_class(*) => ~"class",
+          item_trait(*) => ~"trait",
+          item_impl(*) => ~"impl",
+          item_mac(*) => ~"macro"
+        };
+        fmt!("%s %s (id=%?)", item_str, path_str, id)
       }
       some(node_foreign_item(item, abi, path)) => {
         fmt!{"foreign item %s with abi %? (id=%?)",

src/rustc/metadata/csearch.rs

@@ -127,7 +127,7 @@ fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
 }
 
 fn get_region_param(cstore: metadata::cstore::cstore,
-                    def: ast::def_id) -> bool {
+                    def: ast::def_id) -> option<ty::region_variance> {
     let cdata = cstore::get_crate_data(cstore, def.crate);
     return decoder::get_region_param(cdata, def.node);
 }
@@ -149,7 +149,9 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
                  class_id, def} );
     debug!{"got field data %?", the_field};
     let ty = decoder::item_type(def, the_field, tcx, cdata);
-    return {bounds: @~[], rp: false, ty: ty};
+    return {bounds: @~[],
+            region_param: none,
+            ty: ty};
 }
 
 // Given a def_id for an impl or class, return the traits it implements,

src/rustc/metadata/decoder.rs

@@ -237,11 +237,11 @@ fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
     @bounds
 }
 
-fn item_ty_region_param(item: ebml::doc) -> bool {
-    match ebml::maybe_get_doc(item, tag_region_param) {
-      some(_) => true,
-      none => false
-    }
+fn item_ty_region_param(item: ebml::doc) -> option<ty::region_variance> {
+    ebml::maybe_get_doc(item, tag_region_param).map(|doc| {
+        let d = ebml::ebml_deserializer(doc);
+        ty::deserialize_region_variance(d)
+    })
 }
 
 fn item_ty_param_count(item: ebml::doc) -> uint {
@@ -340,10 +340,14 @@ fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
         item_ty_param_bounds(item, tcx, cdata)
     } else { @~[] };
     let rp = item_ty_region_param(item);
-    return {bounds: tp_bounds, rp: rp, ty: t};
+    return {bounds: tp_bounds,
+            region_param: rp,
+            ty: t};
 }
 
-fn get_region_param(cdata: cmd, id: ast::node_id) -> bool {
+fn get_region_param(cdata: cmd, id: ast::node_id)
+    -> option<ty::region_variance> {
+
     let item = lookup_item(id, cdata.data);
     return item_ty_region_param(item);
 }

src/rustc/metadata/encoder.rs

@@ -81,8 +81,12 @@ fn encode_def_id(ebml_w: ebml::writer, id: def_id) {
 
 fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml::writer,
                        it: @ast::item) {
-    let rp = ecx.tcx.region_paramd_items.contains_key(it.id);
-    if rp { do ebml_w.wr_tag(tag_region_param) { } }
+    let opt_rp = ecx.tcx.region_paramd_items.find(it.id);
+    for opt_rp.each |rp| {
+        do ebml_w.wr_tag(tag_region_param) {
+            ty::serialize_region_variance(ebml_w, rp);
+        }
+    }
 }
 
 fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {

src/rustc/middle/astencode.rs

@@ -601,8 +601,10 @@ impl ebml::writer: ebml_writer_helpers {
                     self.emit_bounds(ecx, bs);
                 }
             }
-            do self.emit_rec_field(~"rp", 1u) {
-                self.emit_bool(tpbt.rp);
+            do self.emit_rec_field(~"region_param", 1u) {
+                ty::serialize_opt_region_variance(
+                    self,
+                    tpbt.region_param);
             }
             do self.emit_rec_field(~"ty", 2u) {
                 self.emit_ty(ecx, tpbt.ty);
@@ -817,8 +819,8 @@ impl ebml::ebml_deserializer: ebml_deserializer_decoder_helpers {
                 bounds: self.read_rec_field(~"bounds", 0u, || {
                     @self.read_to_vec(|| self.read_bounds(xcx) )
                 }),
-                rp: self.read_rec_field(~"rp", 1u, || {
-                    self.read_bool()
+                region_param: self.read_rec_field(~"region_param", 1u, || {
+                    ty::deserialize_opt_region_variance(self)
                 }),
                 ty: self.read_rec_field(~"ty", 2u, || {
                     self.read_ty(xcx)