librustc: Refactor language items to have IDs. rs=refactor

Preparation for fixing the performance problems with language item collection.

Author: pcwalton

src/librustc/metadata/csearch.rs

@@ -48,6 +48,7 @@ export get_type;
 export get_impl_traits;
 export get_impl_method;
 export get_item_path;
+export get_lang_items;
 export maybe_get_item_ast, found_ast, found, found_parent, not_found;
 export ProvidedTraitMethodInfo;
 export StaticMethodInfo;

src/librustc/middle/lang_items.rs

@@ -33,104 +33,157 @@ use core::ptr;
 use std::map::HashMap;
 use str_eq = str::eq;
 
+pub enum LangItem {
+    ConstTraitLangItem,     // 0
+    CopyTraitLangItem,      // 1
+    OwnedTraitLangItem,     // 2
+    DurableTraitLangItem,   // 3
+
+    DropTraitLangItem,      // 4
+
+    AddTraitLangItem,       // 5
+    SubTraitLangItem,       // 6
+    MulTraitLangItem,       // 7
+    DivTraitLangItem,       // 8
+    ModuloTraitLangItem,    // 9
+    NegTraitLangItem,       // 10
+    BitXorTraitLangItem,    // 11
+    BitAndTraitLangItem,    // 12
+    BitOrTraitLangItem,     // 13
+    ShlTraitLangItem,       // 14
+    ShrTraitLangItem,       // 15
+    IndexTraitLangItem,     // 16
+
+    EqTraitLangItem,        // 17
+    OrdTraitLangItem,       // 18
+
+    StrEqFnLangItem,        // 19
+    UniqStrEqFnLangItem,    // 20
+    AnnihilateFnLangItem,   // 21
+    LogTypeFnLangItem,      // 22
+}
+
 struct LanguageItems {
-    mut const_trait: Option<def_id>,
-    mut copy_trait: Option<def_id>,
-    mut owned_trait: Option<def_id>,
-    mut durable_trait: Option<def_id>,
-
-    mut drop_trait: Option<def_id>,
-
-    mut add_trait: Option<def_id>,
-    mut sub_trait: Option<def_id>,
-    mut mul_trait: Option<def_id>,
-    mut div_trait: Option<def_id>,
-    mut modulo_trait: Option<def_id>,
-    mut neg_trait: Option<def_id>,
-    mut bitxor_trait: Option<def_id>,
-    mut bitand_trait: Option<def_id>,
-    mut bitor_trait: Option<def_id>,
-    mut shl_trait: Option<def_id>,
-    mut shr_trait: Option<def_id>,
-    mut index_trait: Option<def_id>,
-
-    mut eq_trait: Option<def_id>,
-    mut ord_trait: Option<def_id>,
-
-    mut str_eq_fn: Option<def_id>,
-    mut uniq_str_eq_fn: Option<def_id>,
-    mut annihilate_fn: Option<def_id>,
-    mut log_type_fn: Option<def_id>
+    items: [ Option<def_id> * 23 ]
 }
 
-mod language_items {
-    #[legacy_exports];
-    fn make() -> LanguageItems {
+impl LanguageItems {
+    static pub fn new() -> LanguageItems {
         LanguageItems {
-            const_trait: None,
-            copy_trait: None,
-            owned_trait: None,
-            durable_trait: None,
-
-            drop_trait: None,
-
-            add_trait: None,
-            sub_trait: None,
-            mul_trait: None,
-            div_trait: None,
-            modulo_trait: None,
-            neg_trait: None,
-            bitxor_trait: None,
-            bitand_trait: None,
-            bitor_trait: None,
-            shl_trait: None,
-            shr_trait: None,
-            index_trait: None,
-
-            eq_trait: None,
-            ord_trait: None,
-
-            str_eq_fn: None,
-            uniq_str_eq_fn: None,
-            annihilate_fn: None,
-            log_type_fn: None
+            items: [ None, ..23 ]
         }
     }
-}
 
-fn LanguageItemCollector(crate: @crate, session: Session,
-                         items: &r/LanguageItems)
-    -> LanguageItemCollector/&r {
+    // XXX: Method macros sure would be nice here.
+
+    pub fn const_trait(&const self) -> def_id {
+        self.items[ConstTraitLangItem as uint].get()
+    }
+    pub fn copy_trait(&const self) -> def_id {
+        self.items[CopyTraitLangItem as uint].get()
+    }
+    pub fn owned_trait(&const self) -> def_id {
+        self.items[OwnedTraitLangItem as uint].get()
+    }
+    pub fn durable_trait(&const self) -> def_id {
+        self.items[DurableTraitLangItem as uint].get()
+    }
+
+    pub fn drop_trait(&const self) -> def_id {
+        self.items[DropTraitLangItem as uint].get()
+    }
+
+    pub fn add_trait(&const self) -> def_id {
+        self.items[AddTraitLangItem as uint].get()
+    }
+    pub fn sub_trait(&const self) -> def_id {
+        self.items[SubTraitLangItem as uint].get()
+    }
+    pub fn mul_trait(&const self) -> def_id {
+        self.items[MulTraitLangItem as uint].get()
+    }
+    pub fn div_trait(&const self) -> def_id {
+        self.items[DivTraitLangItem as uint].get()
+    }
+    pub fn modulo_trait(&const self) -> def_id {
+        self.items[ModuloTraitLangItem as uint].get()
+    }
+    pub fn neg_trait(&const self) -> def_id {
+        self.items[NegTraitLangItem as uint].get()
+    }
+    pub fn bitxor_trait(&const self) -> def_id {
+        self.items[BitXorTraitLangItem as uint].get()
+    }
+    pub fn bitand_trait(&const self) -> def_id {
+        self.items[BitAndTraitLangItem as uint].get()
+    }
+    pub fn bitor_trait(&const self) -> def_id {
+        self.items[BitOrTraitLangItem as uint].get()
+    }
+    pub fn shl_trait(&const self) -> def_id {
+        self.items[ShlTraitLangItem as uint].get()
+    }
+    pub fn shr_trait(&const self) -> def_id {
+        self.items[ShrTraitLangItem as uint].get()
+    }
+    pub fn index_trait(&const self) -> def_id {
+        self.items[IndexTraitLangItem as uint].get()
+    }
+
+    pub fn eq_trait(&const self) -> def_id {
+        self.items[EqTraitLangItem as uint].get()
+    }
+    pub fn ord_trait(&const self) -> def_id {
+        self.items[OrdTraitLangItem as uint].get()
+    }
 
+    pub fn str_eq_fn(&const self) -> def_id {
+        self.items[StrEqFnLangItem as uint].get()
+    }
+    pub fn uniq_str_eq_fn(&const self) -> def_id {
+        self.items[UniqStrEqFnLangItem as uint].get()
+    }
+    pub fn annihilate_fn(&const self) -> def_id {
+        self.items[AnnihilateFnLangItem as uint].get()
+    }
+    pub fn log_type_fn(&const self) -> def_id {
+        self.items[LogTypeFnLangItem as uint].get()
+    }
+}
+
+fn LanguageItemCollector(crate: @crate,
+                         session: Session,
+                         items: &r/mut LanguageItems)
+                      -> LanguageItemCollector/&r {
     let item_refs = HashMap();
 
-    item_refs.insert(~"const", &mut items.const_trait);
-    item_refs.insert(~"copy", &mut items.copy_trait);
-    item_refs.insert(~"owned", &mut items.owned_trait);
-    item_refs.insert(~"durable", &mut items.durable_trait);
-
-    item_refs.insert(~"drop", &mut items.drop_trait);
-
-    item_refs.insert(~"add", &mut items.add_trait);
-    item_refs.insert(~"sub", &mut items.sub_trait);
-    item_refs.insert(~"mul", &mut items.mul_trait);
-    item_refs.insert(~"div", &mut items.div_trait);
-    item_refs.insert(~"modulo", &mut items.modulo_trait);
-    item_refs.insert(~"neg", &mut items.neg_trait);
-    item_refs.insert(~"bitxor", &mut items.bitxor_trait);
-    item_refs.insert(~"bitand", &mut items.bitand_trait);
-    item_refs.insert(~"bitor", &mut items.bitor_trait);
-    item_refs.insert(~"shl", &mut items.shl_trait);
-    item_refs.insert(~"shr", &mut items.shr_trait);
-    item_refs.insert(~"index", &mut items.index_trait);
-
-    item_refs.insert(~"eq", &mut items.eq_trait);
-    item_refs.insert(~"ord", &mut items.ord_trait);
-
-    item_refs.insert(~"str_eq", &mut items.str_eq_fn);
-    item_refs.insert(~"uniq_str_eq", &mut items.uniq_str_eq_fn);
-    item_refs.insert(~"annihilate", &mut items.annihilate_fn);
-    item_refs.insert(~"log_type", &mut items.log_type_fn);
+    item_refs.insert(~"const", ConstTraitLangItem as uint);
+    item_refs.insert(~"copy", CopyTraitLangItem as uint);
+    item_refs.insert(~"owned", OwnedTraitLangItem as uint);
+    item_refs.insert(~"durable", DurableTraitLangItem as uint);
+
+    item_refs.insert(~"drop", DropTraitLangItem as uint);
+
+    item_refs.insert(~"add", AddTraitLangItem as uint);
+    item_refs.insert(~"sub", SubTraitLangItem as uint);
+    item_refs.insert(~"mul", MulTraitLangItem as uint);
+    item_refs.insert(~"div", DivTraitLangItem as uint);
+    item_refs.insert(~"modulo", ModuloTraitLangItem as uint);
+    item_refs.insert(~"neg", NegTraitLangItem as uint);
+    item_refs.insert(~"bitxor", BitXorTraitLangItem as uint);
+    item_refs.insert(~"bitand", BitAndTraitLangItem as uint);
+    item_refs.insert(~"bitor", BitOrTraitLangItem as uint);
+    item_refs.insert(~"shl", ShlTraitLangItem as uint);
+    item_refs.insert(~"shr", ShrTraitLangItem as uint);
+    item_refs.insert(~"index", IndexTraitLangItem as uint);
+
+    item_refs.insert(~"eq", EqTraitLangItem as uint);
+    item_refs.insert(~"ord", OrdTraitLangItem as uint);
+
+    item_refs.insert(~"str_eq", StrEqFnLangItem as uint);
+    item_refs.insert(~"uniq_str_eq", UniqStrEqFnLangItem as uint);
+    item_refs.insert(~"annihilate", AnnihilateFnLangItem as uint);
+    item_refs.insert(~"log_type", LogTypeFnLangItem as uint);
 
     LanguageItemCollector {
         crate: crate,
@@ -141,16 +194,15 @@ fn LanguageItemCollector(crate: @crate, session: Session,
 }
 
 struct LanguageItemCollector {
-    items: &LanguageItems,
+    items: &mut LanguageItems,
 
     crate: @crate,
     session: Session,
 
-    item_refs: HashMap<~str,&mut Option<def_id>>,
+    item_refs: HashMap<~str,uint>,
 }
 
 impl LanguageItemCollector {
-
     fn match_and_collect_meta_item(item_def_id: def_id,
                                    meta_item: meta_item) {
         match meta_item.node {
@@ -177,12 +229,11 @@ impl LanguageItemCollector {
             None => {
                 // Didn't match.
             }
-            Some(item_ref) => {
+            Some(item_index) => {
                 // Check for duplicates.
-                match copy *item_ref {
+                match self.items.items[item_index] {
                     Some(original_def_id)
                             if original_def_id != item_def_id => {
-
                         self.session.err(fmt!("duplicate entry for `%s`",
                                               value));
                     }
@@ -192,7 +243,7 @@ impl LanguageItemCollector {
                 }
 
                 // Matched.
-                *item_ref = Some(item_def_id);
+                self.items.items[item_index] = Some(item_def_id);
             }
         }
     }
@@ -240,7 +291,7 @@ impl LanguageItemCollector {
 
     fn check_completeness() {
         for self.item_refs.each |key, item_ref| {
-            match *item_ref {
+            match self.items.items[item_ref] {
                 None => {
                     self.session.err(fmt!("no item found for `%s`", key));
                 }
@@ -259,8 +310,8 @@ impl LanguageItemCollector {
 }
 
 fn collect_language_items(crate: @crate, session: Session) -> LanguageItems {
-    let items = language_items::make();
-    let collector = LanguageItemCollector(crate, session, &items);
+    let mut items = LanguageItems::new();
+    let collector = LanguageItemCollector(crate, session, &mut items);
     collector.collect();
     copy items
 }