Support impls directly on primitive types.

Author: alexcrichton

src/librustc/metadata/common.rs

@@ -208,6 +208,11 @@ pub static tag_macro_registrar_fn: uint = 0x110;
 pub static tag_exported_macros: uint = 0x111;
 pub static tag_macro_def: uint = 0x112;
 
+pub static tag_prim_dids: uint = 0x113;
+pub static tag_prim_did: uint = 0x114;
+pub static tag_prim_did_ty: uint = 0x115;
+pub static tag_prim_did_did: uint = 0x116;
+
 #[deriving(Clone)]
 pub struct LinkMeta {
     crateid: CrateId,

src/librustc/metadata/csearch.rs

@@ -311,3 +311,10 @@ pub fn get_exported_macros(cstore: @cstore::CStore,
     let cdata = cstore.get_crate_data(crate_num);
     decoder::get_exported_macros(cdata)
 }
+
+pub fn prim_dids(cstore: @cstore::CStore,
+                 crate_num: ast::CrateNum,
+                 tcx: ty::ctxt) -> ~[(ty::t, ast::DefId)] {
+    let cdata = cstore.get_crate_data(crate_num);
+    decoder::prim_dids(cdata, tcx)
+}

src/librustc/metadata/decoder.rs

@@ -1292,3 +1292,19 @@ pub fn get_exported_macros(cdata: Cmd) -> ~[@ast::Item] {
     });
     result
 }
+
+pub fn prim_dids(cdata: Cmd, tcx: ty::ctxt) -> ~[(ty::t, ast::DefId)] {
+    let dids = reader::get_doc(reader::Doc(cdata.data()), tag_prim_dids);
+    let mut result = ~[];
+    reader::tagged_docs(dids, tag_prim_did, |did_doc| {
+        let ty_doc = reader::get_doc(did_doc, tag_prim_did_ty);
+        let id_doc = reader::get_doc(did_doc, tag_prim_did_did);
+        let did = ast::DefId {
+            node: reader::doc_as_u32(id_doc),
+            crate: cdata.cnum,
+        };
+        result.push((doc_type(ty_doc, tcx, cdata), did));
+        true
+    });
+    return result;
+}

src/librustc/metadata/encoder.rs

@@ -82,6 +82,7 @@ struct Stats {
     macro_registrar_fn_bytes: Cell<u64>,
     macro_defs_bytes: Cell<u64>,
     impl_bytes: Cell<u64>,
+    prim_did_bytes: Cell<u64>,
     misc_bytes: Cell<u64>,
     item_bytes: Cell<u64>,
     index_bytes: Cell<u64>,
@@ -1455,6 +1456,21 @@ fn encode_info_for_items(ecx: &EncodeContext,
         visit::walk_crate(&mut visitor, crate, ());
     }
 
+    for (_, did) in ty::prim_dids(ecx.tcx).move_iter() {
+        if !ast_util::is_local(did) { continue }
+        {
+            let mut index = index.borrow_mut();
+            index.get().push(entry {
+                val: did.node as i64,
+                pos: ebml_w.writer.tell(),
+            });
+        }
+        ebml_w.start_tag(tag_items_data_item);
+        encode_def_id(ebml_w, did);
+        encode_inherent_implementations(ecx, ebml_w, did);
+        ebml_w.end_tag();
+    }
+
     ebml_w.end_tag();
     return /*bad*/(*index).get();
 }
@@ -1818,6 +1834,23 @@ fn encode_misc_info(ecx: &EncodeContext,
     ebml_w.end_tag();
 }
 
+fn encode_prim_dids(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
+    ebml_w.start_tag(tag_prim_dids);
+    for (ty, did) in ty::prim_dids(ecx.tcx).move_iter() {
+        if !ast_util::is_local(did) { continue }
+        ebml_w.start_tag(tag_prim_did);
+
+        ebml_w.start_tag(tag_prim_did_ty);
+        encode_type(ecx, ebml_w, ty);
+        ebml_w.end_tag();
+
+        ebml_w.wr_tagged_u32(tag_prim_did_did, did.node);
+
+        ebml_w.end_tag();
+    }
+    ebml_w.end_tag();
+}
+
 fn encode_crate_dep(ecx: &EncodeContext,
                     ebml_w: &mut writer::Encoder,
                     dep: decoder::CrateDep) {
@@ -1865,6 +1898,7 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate)
         macro_registrar_fn_bytes: Cell::new(0),
         macro_defs_bytes: Cell::new(0),
         impl_bytes: Cell::new(0),
+        prim_did_bytes: Cell::new(0),
         misc_bytes: Cell::new(0),
         item_bytes: Cell::new(0),
         index_bytes: Cell::new(0),
@@ -1937,6 +1971,11 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate)
     encode_impls(&ecx, crate, &mut ebml_w);
     ecx.stats.impl_bytes.set(ebml_w.writer.tell() - i);
 
+    // Encode the def IDs of primitives (if we have any)
+    i = ebml_w.writer.tell();
+    encode_prim_dids(&ecx, &mut ebml_w);
+    ecx.stats.prim_did_bytes.set(ebml_w.writer.tell() - i);
+
     // Encode miscellaneous info.
     i = ebml_w.writer.tell();
     encode_misc_info(&ecx, crate, &mut ebml_w);
@@ -1969,6 +2008,7 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate)
         println!("            dep bytes: {}", ecx.stats.dep_bytes.get());
         println!("      lang item bytes: {}", ecx.stats.lang_item_bytes.get());
         println!("         native bytes: {}", ecx.stats.native_lib_bytes.get());
+        println!("       prim did bytes: {}", ecx.stats.prim_did_bytes.get());
         println!("macro registrar bytes: {}", ecx.stats.macro_registrar_fn_bytes.get());
         println!("      macro def bytes: {}", ecx.stats.macro_defs_bytes.get());
         println!("           impl bytes: {}", ecx.stats.impl_bytes.get());

src/librustc/middle/lang_items.rs

@@ -255,9 +255,25 @@ lets_do_this! {
 
     TypeIdLangItem,                  "type_id",                 type_id;
 
-    EhPersonalityLangItem,           "eh_personality",          eh_personality_fn;
-
     ManagedHeapLangItem,             "managed_heap",            managed_heap;
     ExchangeHeapLangItem,            "exchange_heap",           exchange_heap;
     GcLangItem,                      "gc",                      gc;
+
+    EhPersonalityLangItem,           "eh_personality",          eh_personality_fn;
+
+    CharImplLangItem,                "char_impl",               char_impl;
+    IntImplLangItem,                 "int_impl",                int_impl;
+    I8ImplLangItem,                  "i8_impl",                 i8_impl;
+    I16ImplLangItem,                 "i16_impl",                i16_impl;
+    I32ImplLangItem,                 "i32_impl",                i32_impl;
+    I64ImplLangItem,                 "i64_impl",                i64_impl;
+    UintImplLangItem,                "uint_impl",               uint_impl;
+    U8ImplLangItem,                  "u8_impl",                 u8_impl;
+    U16ImplLangItem,                 "u16_impl",                u16_impl;
+    U32ImplLangItem,                 "u32_impl",                u32_impl;
+    U64ImplLangItem,                 "u64_impl",                u64_impl;
+    BoolImplLangItem,                "bool_impl",               bool_impl;
+    NilImplLangItem,                 "nil_impl",                nil_impl;
+    F32ImplLangItem,                 "f32_impl",                f32_impl;
+    F64ImplLangItem,                 "f64_impl",                f64_impl;
 }

src/librustc/middle/ty.rs

@@ -361,6 +361,9 @@ struct ctxt_ {
     // is used for lazy resolution of traits.
     populated_external_traits: RefCell<HashSet<ast::DefId>>,
 
+    // TODO: dox
+    prim_dids: RefCell<HashMap<t, ast::DefId>>,
+
     // These two caches are used by const_eval when decoding external statics
     // and variants that are found.
     extern_const_statics: RefCell<HashMap<ast::DefId, Option<@ast::Expr>>>,
@@ -1003,6 +1006,7 @@ pub fn mk_ctxt(s: session::Session,
         impl_vtables: RefCell::new(HashMap::new()),
         populated_external_types: RefCell::new(HashSet::new()),
         populated_external_traits: RefCell::new(HashSet::new()),
+        prim_dids: RefCell::new(HashMap::new()),
 
         extern_const_statics: RefCell::new(HashMap::new()),
         extern_const_variants: RefCell::new(HashMap::new()),
@@ -5012,3 +5016,39 @@ impl substs {
         }
     }
 }
+
+/// Register a primitive type as having it's lang-item implementation in this
+/// crate. This method will create a DefId if one doesn't already exist for it.
+pub fn add_local_prim_did(tcx: ctxt, t: t) -> ast::DefId {
+    let mut map = tcx.prim_dids.borrow_mut();
+    match map.get().find(&t) {
+        Some(&did) => return did,
+        None => {}
+    }
+    let id = tcx.next_id.get();
+    tcx.next_id.set(id + 1);
+    map.get().insert(t, ast_util::local_def(id as ast::NodeId));
+    return ast_util::local_def(id as ast::NodeId);
+}
+
+/// Fetch the DefId of the lang-item implementation of a primitive type. This
+/// may not succeed (as the local crate or linked crates may not provided an
+/// implementation).
+pub fn maybe_prim_did(tcx: ctxt, t: t) -> Option<ast::DefId> {
+    let map = tcx.prim_dids.borrow();
+    map.get().find(&t).map(|&x| x)
+}
+
+/// Adds the DefId of a lang-item implementation of a primitive from an external
+/// crate.
+pub fn add_extern_prim_did(tcx: ctxt, t: t, did: ast::DefId) {
+    let mut map = tcx.prim_dids.borrow_mut();
+    assert!(map.get().insert(t, did));
+}
+
+/// Fetch all primitive type implementations known to this crate. This includes
+/// local as well as external primitive types.
+pub fn prim_dids(tcx: ctxt) -> ~[(t, ast::DefId)] {
+    let map = tcx.prim_dids.borrow();
+    map.get().iter().map(|(&a, &b)| (a, b)).collect()
+}

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

@@ -295,6 +295,12 @@ impl<'a> LookupContext<'a> {
          */
 
         let mut self_ty = self_ty;
+        macro_rules! add( ($t:expr) => ({
+            match ty::maybe_prim_did(self.fcx.tcx(), $t) {
+                Some(did) => self.push_inherent_impl_candidates_for_type(did),
+                None => {}
+            }
+        }) )
         loop {
             match get(self_ty).sty {
                 ty_trait(did, ref substs, _, _, _) => {
@@ -306,6 +312,26 @@ impl<'a> LookupContext<'a> {
                         self.push_inherent_impl_candidates_for_type(did);
                     }
                 }
+                ty_nil | ty_bool | ty_char | ty_int(..) | ty_uint(..) |
+                ty_float(..) => {
+                    add!(self_ty);
+                }
+                ty_infer(FloatVar(..)) => {
+                    add!(ty::mk_f32());
+                    add!(ty::mk_f64());
+                }
+                ty_infer(IntVar(..)) => {
+                    add!(ty::mk_uint());
+                    add!(ty::mk_u8());
+                    add!(ty::mk_u16());
+                    add!(ty::mk_u32());
+                    add!(ty::mk_u64());
+                    add!(ty::mk_int());
+                    add!(ty::mk_i8());
+                    add!(ty::mk_i16());
+                    add!(ty::mk_i32());
+                    add!(ty::mk_i64());
+                }
                 _ => { /* No inherent methods in these types */ }
             }
 

src/librustc/middle/typeck/coherence.rs

@@ -35,7 +35,7 @@ use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::{new_infer_ctxt, resolve_ivar, resolve_type};
 use middle::typeck::infer;
 use util::ppaux::Repr;
-use syntax::ast::{Crate, DefId, DefStruct, DefTy};
+use syntax::ast::{Crate, DefId, DefStruct, DefTy, DefPrimTy};
 use syntax::ast::{Item, ItemEnum, ItemImpl, ItemMod, ItemStruct};
 use syntax::ast::{LOCAL_CRATE, TraitRef, TyPath};
 use syntax::ast;
@@ -81,9 +81,14 @@ pub fn get_base_type(inference_context: @InferCtxt,
             Some(resolved_type)
         }
 
-        ty_nil | ty_bot | ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) |
+        ty_nil | ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) => {
+            debug!("(getting base type) found primitive base type");
+            Some(resolved_type)
+        }
+
+        ty_bot |
         ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_closure(..) | ty_tup(..) |
-        ty_infer(..) | ty_param(..) | ty_self(..) | ty_type |
+        ty_infer(..) | ty_param(..) | ty_self(..) | ty_type | ty_opaque_box |
         ty_opaque_closure_ptr(..) | ty_unboxed_vec(..) | ty_err | ty_box(_) |
         ty_uniq(_) | ty_ptr(_) | ty_rptr(_, _) => {
             debug!("(getting base type) no base type; found {:?}",
@@ -121,6 +126,7 @@ pub fn type_is_defined_in_local_crate(original_type: t) -> bool {
 
 // Returns the def ID of the base type, if there is one.
 pub fn get_base_type_def_id(inference_context: @InferCtxt,
+                            id: ast::NodeId,
                             span: Span,
                             original_type: t)
                          -> Option<DefId> {
@@ -129,17 +135,61 @@ pub fn get_base_type_def_id(inference_context: @InferCtxt,
             return None;
         }
         Some(base_type) => {
+            let did = local_def(id);
+            let li = inference_context.tcx.lang_items;
             match get(base_type).sty {
                 ty_enum(def_id, _) |
                 ty_struct(def_id, _) |
                 ty_trait(def_id, _, _, _, _) => {
                     return Some(def_id);
                 }
+
+                ty_char => { if li.char_impl() != Some(did) { return None } }
+                ty_nil => { if li.nil_impl() != Some(did) { return None } }
+                ty_bool => { if li.bool_impl() != Some(did) { return None } }
+                ty_float(ast::ty_f32) => {
+                    if li.f32_impl() != Some(did) { return None }
+                }
+                ty_float(ast::ty_f64) => {
+                    if li.f64_impl() != Some(did) { return None }
+                }
+                ty_uint(ast::ty_u) => {
+                    if li.uint_impl() != Some(did) { return None }
+                }
+                ty_int(ast::ty_i) => {
+                    if li.int_impl() != Some(did) { return None }
+                }
+                ty_int(ast::ty_i8) => {
+                    if li.i8_impl() != Some(did) { return None }
+                }
+                ty_int(ast::ty_i16) => {
+                    if li.i16_impl() != Some(did) { return None }
+                }
+                ty_int(ast::ty_i32) => {
+                    if li.i32_impl() != Some(did) { return None }
+                }
+                ty_int(ast::ty_i64) => {
+                    if li.i64_impl() != Some(did) { return None }
+                }
+                ty_uint(ast::ty_u8) => {
+                    if li.u8_impl() != Some(did) { return None }
+                }
+                ty_uint(ast::ty_u16) => {
+                    if li.u16_impl() != Some(did) { return None }
+                }
+                ty_uint(ast::ty_u32) => {
+                    if li.u32_impl() != Some(did) { return None }
+                }
+                ty_uint(ast::ty_u64) => {
+                    if li.u64_impl() != Some(did) { return None }
+                }
+
                 _ => {
                     fail!("get_base_type() returned a type that wasn't an \
-                           enum, struct, or trait");
+                           enum, struct, trait, or known primitive");
                 }
             }
+            return Some(ty::add_local_prim_did(inference_context.tcx, base_type));
         }
     }
 }
@@ -273,7 +323,7 @@ impl CoherenceChecker {
                    self.crate_context.tcx.sess.str_of(item.ident));
 
             match get_base_type_def_id(self.inference_context,
-                                       item.span,
+                                       item.id, item.span,
                                        self_type.ty) {
                 None => {
                     let session = self.crate_context.tcx.sess;
@@ -303,7 +353,7 @@ impl CoherenceChecker {
         // type def ID, if there is a base type for this implementation and
         // the implementation does not have any associated traits.
         match get_base_type_def_id(self.inference_context,
-                                   item.span,
+                                   item.id, item.span,
                                    self_type.ty) {
             None => {
                 // Nothing to do.
@@ -585,9 +635,12 @@ impl CoherenceChecker {
                             Some(_) => false,
                         }
                     }
+                    DefPrimTy(ast::ty_str) => false,
+                    DefPrimTy(..) => true,
                     _ => false
                 }
             }
+            ast::ty_nil => true,
             _ => false
         }
     }
@@ -688,7 +741,12 @@ impl CoherenceChecker {
             each_impl(crate_store, crate_number, |def_id| {
                 assert_eq!(crate_number, def_id.crate);
                 self.add_external_impl(&mut impls_seen, def_id)
-            })
+            });
+            let prims = csearch::prim_dids(crate_store, crate_number,
+                                           self.crate_context.tcx);
+            for (t, did) in prims.move_iter() {
+                ty::add_extern_prim_did(self.crate_context.tcx, t, did);
+            }
         })
     }