rustc: Simplify crate loading constraints

The previous code passed around a {name,version} pair everywhere, but this is
better expressed as a CrateId. This patch changes these paths to store and pass
around crate ids instead of these pairs of name/version. This also prepares the
code to change the type of hash that is stored in crates.

Author: alexcrichton

src/librustc/metadata/common.rs

@@ -70,12 +70,12 @@ pub static tag_crate_deps: uint = 0x18;
 pub static tag_crate_dep: uint = 0x19;
 
 pub static tag_crate_hash: uint = 0x1a;
+pub static tag_crate_crateid: uint = 0x1b;
 
-pub static tag_parent_item: uint = 0x1b;
+pub static tag_parent_item: uint = 0x1c;
 
-pub static tag_crate_dep_name: uint = 0x1c;
-pub static tag_crate_dep_hash: uint = 0x1d;
-pub static tag_crate_dep_vers: uint = 0x1e;
+pub static tag_crate_dep_crateid: uint = 0x1d;
+pub static tag_crate_dep_hash: uint = 0x1e;
 
 pub static tag_mod_impl: uint = 0x1f;
 

src/librustc/metadata/creader.rs

@@ -79,7 +79,7 @@ struct cache_entry {
     cnum: ast::CrateNum,
     span: Span,
     hash: ~str,
-    crateid: CrateId,
+    crate_id: CrateId,
 }
 
 fn dump_crates(crate_cache: &[cache_entry]) {
@@ -95,10 +95,10 @@ fn warn_if_multiple_versions(e: &mut Env,
                              diag: @SpanHandler,
                              crate_cache: &[cache_entry]) {
     if crate_cache.len() != 0u {
-        let name = crate_cache[crate_cache.len() - 1].crateid.name.clone();
+        let name = crate_cache[crate_cache.len() - 1].crate_id.name.clone();
 
         let (matches, non_matches) = crate_cache.partitioned(|entry|
-            name == entry.crateid.name);
+            name == entry.crate_id.name);
 
         assert!(!matches.is_empty());
 
@@ -107,7 +107,7 @@ fn warn_if_multiple_versions(e: &mut Env,
                 format!("using multiple versions of crate `{}`", name));
             for match_ in matches.iter() {
                 diag.span_note(match_.span, "used here");
-                loader::note_crateid_attr(diag, &match_.crateid);
+                loader::note_crateid_attr(diag, &match_.crate_id);
             }
         }
 
@@ -146,14 +146,9 @@ fn visit_view_item(e: &mut Env, i: &ast::ViewItem) {
         return;
     }
 
-    match extract_crate_info(i) {
+    match extract_crate_info(e, i) {
         Some(info) => {
-            let cnum = resolve_crate(e,
-                                     None,
-                                     info.ident.clone(),
-                                     info.name.clone(),
-                                     info.version.clone(),
-                                     ~"",
+            let cnum = resolve_crate(e, None, info.ident, &info.crate_id, "",
                                      i.span);
             e.sess.cstore.add_extern_mod_stmt_cnum(info.id, cnum);
         }
@@ -163,38 +158,33 @@ fn visit_view_item(e: &mut Env, i: &ast::ViewItem) {
 
 struct CrateInfo {
     ident: ~str,
-    name: ~str,
-    version: ~str,
+    crate_id: CrateId,
     id: ast::NodeId,
 }
 
-fn extract_crate_info(i: &ast::ViewItem) -> Option<CrateInfo> {
+fn extract_crate_info(e: &Env, i: &ast::ViewItem) -> Option<CrateInfo> {
     match i.node {
         ast::ViewItemExternMod(ident, ref path_opt, id) => {
             let ident = token::get_ident(ident);
             debug!("resolving extern crate stmt. ident: {:?} path_opt: {:?}",
                    ident, path_opt);
-            let (name, version) = match *path_opt {
+            let crate_id = match *path_opt {
                 Some((ref path_str, _)) => {
                     let crateid: Option<CrateId> = from_str(path_str.get());
                     match crateid {
-                        None => (~"", ~""),
-                        Some(crateid) => {
-                            let version = match crateid.version {
-                                None => ~"",
-                                Some(ref ver) => ver.to_str(),
-                            };
-                            (crateid.name.to_str(), version)
+                        None => {
+                            e.sess.span_err(i.span, "malformed crate id");
+                            return None
                         }
+                        Some(id) => id
                     }
                 }
-                None => (ident.get().to_str(), ~""),
+                None => from_str(ident.get().to_str()).unwrap()
             };
             Some(CrateInfo {
-                  ident: ident.get().to_str(),
-                  name: name,
-                  version: version,
-                  id: id,
+                ident: ident.get().to_str(),
+                crate_id: crate_id,
+                id: id,
             })
         }
         _ => None
@@ -285,100 +275,93 @@ fn visit_item(e: &Env, i: &ast::Item) {
     }
 }
 
-fn existing_match(e: &Env, name: &str, version: &str, hash: &str) -> Option<ast::CrateNum> {
+fn existing_match(e: &Env, crate_id: &CrateId,
+                  hash: &str) -> Option<ast::CrateNum> {
     let crate_cache = e.crate_cache.borrow();
     for c in crate_cache.get().iter() {
-        let crateid_version = match c.crateid.version {
-            None => ~"0.0",
-            Some(ref ver) => ver.to_str(),
-        };
-        if (name.is_empty() || name == c.crateid.name) &&
-            (version.is_empty() || version == crateid_version) &&
-            (hash.is_empty() || hash == c.hash) {
-            return Some(c.cnum);
+        if crate_id.matches(&c.crate_id) &&
+           (hash.is_empty() || hash == c.hash.as_slice()) {
+            return Some(c.cnum)
         }
     }
     None
 }
 
 fn resolve_crate(e: &mut Env,
-                 root_ident: Option<~str>,
-                 ident: ~str,
-                 name: ~str,
-                 version: ~str,
-                 hash: ~str,
+                 root_ident: Option<&str>,
+                 ident: &str,
+                 crate_id: &CrateId,
+                 hash: &str,
                  span: Span)
               -> ast::CrateNum {
-    match existing_match(e, name, version, hash) {
-      None => {
-        let load_ctxt = loader::Context {
-            sess: e.sess,
-            span: span,
-            ident: ident,
-            name: name,
-            version: version,
-            hash: hash,
-            os: e.os,
-            intr: e.intr
-        };
-        let loader::Library {
-            dylib, rlib, metadata
-        } = load_ctxt.load_library_crate(root_ident.clone());
-
-        let attrs = decoder::get_crate_attributes(metadata.as_slice());
-        let crateid = attr::find_crateid(attrs).unwrap();
-        let hash = decoder::get_crate_hash(metadata.as_slice());
-
-        // Claim this crate number and cache it
-        let cnum = e.next_crate_num;
-        {
-            let mut crate_cache = e.crate_cache.borrow_mut();
-            crate_cache.get().push(cache_entry {
-                cnum: cnum,
+    match existing_match(e, crate_id, hash) {
+        None => {
+            let load_ctxt = loader::Context {
+                sess: e.sess,
                 span: span,
+                ident: ident,
+                crate_id: crate_id,
                 hash: hash,
-                crateid: crateid,
-            });
-        }
-        e.next_crate_num += 1;
-
-        // Maintain a reference to the top most crate.
-        let root_crate = match root_ident {
-            Some(c) => c,
-            None => load_ctxt.ident.clone()
-        };
+                os: e.os,
+                intr: e.intr
+            };
+            let loader::Library {
+                dylib, rlib, metadata
+            } = load_ctxt.load_library_crate(root_ident);
+
+            let crate_id = decoder::get_crate_id(metadata.as_slice());
+            let hash = decoder::get_crate_hash(metadata.as_slice());
+
+            // Claim this crate number and cache it
+            let cnum = e.next_crate_num;
+            {
+                let mut crate_cache = e.crate_cache.borrow_mut();
+                crate_cache.get().push(cache_entry {
+                    cnum: cnum,
+                    span: span,
+                    hash: hash,
+                    crate_id: crate_id,
+                });
+            }
+            e.next_crate_num += 1;
 
-        // Now resolve the crates referenced by this crate
-        let cnum_map = resolve_crate_deps(e,
-                                          Some(root_crate),
-                                          metadata.as_slice(),
-                                          span);
+            // Maintain a reference to the top most crate.
+            let root_crate = match root_ident {
+                Some(c) => c,
+                None => load_ctxt.ident.clone()
+            };
 
-        let cmeta = @cstore::crate_metadata {
-            name: load_ctxt.name,
-            data: metadata,
-            cnum_map: cnum_map,
-            cnum: cnum
-        };
+            // Now resolve the crates referenced by this crate
+            let cnum_map = resolve_crate_deps(e,
+            Some(root_crate),
+            metadata.as_slice(),
+            span);
+
+            let cmeta = @cstore::crate_metadata {
+                name: load_ctxt.crate_id.name.to_owned(),
+                data: metadata,
+                cnum_map: cnum_map,
+                cnum: cnum
+            };
 
-        let cstore = e.sess.cstore;
-        cstore.set_crate_data(cnum, cmeta);
-        cstore.add_used_crate_source(cstore::CrateSource {
-            dylib: dylib,
-            rlib: rlib,
-            cnum: cnum,
-        });
-        return cnum;
-      }
-      Some(cnum) => {
-        return cnum;
-      }
+            let cstore = e.sess.cstore;
+            cstore.set_crate_data(cnum, cmeta);
+            cstore.add_used_crate_source(cstore::CrateSource {
+                dylib: dylib,
+                rlib: rlib,
+                cnum: cnum,
+            });
+            return cnum;
+        }
+        Some(cnum) => {
+            return cnum;
+        }
     }
 }
 
 // Go through the crate metadata and load any crates that it references
 fn resolve_crate_deps(e: &mut Env,
-                      root_ident: Option<~str>,
+                      root_ident: Option<&str>,
                       cdata: &[u8], span : Span)
                    -> cstore::cnum_map {
     debug!("resolving deps of external crate");
@@ -388,31 +371,13 @@ fn resolve_crate_deps(e: &mut Env,
     let r = decoder::get_crate_deps(cdata);
     for dep in r.iter() {
         let extrn_cnum = dep.cnum;
-        let cname_str = token::get_ident(dep.name);
-        debug!("resolving dep crate {} ver: {} hash: {}",
-               cname_str, dep.vers, dep.hash);
-        match existing_match(e,
-                             cname_str.get(),
-                             dep.vers,
-                             dep.hash) {
-          Some(local_cnum) => {
-            debug!("already have it");
-            // We've already seen this crate
-            cnum_map.insert(extrn_cnum, local_cnum);
-          }
-          None => {
-            debug!("need to load it");
-            // This is a new one so we've got to load it
-            let local_cnum = resolve_crate(e,
-                                           root_ident.clone(),
-                                           cname_str.get().to_str(),
-                                           cname_str.get().to_str(),
-                                           dep.vers.clone(),
-                                           dep.hash.clone(),
-                                           span);
-            cnum_map.insert(extrn_cnum, local_cnum);
-          }
-        }
+        debug!("resolving dep crate {} hash: `{}`", dep.crate_id, dep.hash);
+        let local_cnum = resolve_crate(e, root_ident,
+                                       dep.crate_id.name.as_slice(),
+                                       &dep.crate_id,
+                                       dep.hash,
+                                       span);
+        cnum_map.insert(extrn_cnum, local_cnum);
     }
     return @RefCell::new(cnum_map);
 }
@@ -439,14 +404,9 @@ impl Loader {
 
 impl CrateLoader for Loader {
     fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate {
-        let info = extract_crate_info(krate).unwrap();
-        let cnum = resolve_crate(&mut self.env,
-                                 None,
-                                 info.ident.clone(),
-                                 info.name.clone(),
-                                 info.version.clone(),
-                                 ~"",
-                                 krate.span);
+        let info = extract_crate_info(&self.env, krate).unwrap();
+        let cnum = resolve_crate(&mut self.env, None, info.ident,
+                                 &info.crate_id, "", krate.span);
         let library = self.env.sess.cstore.get_used_crate_source(cnum).unwrap();
         MacroCrate {
             lib: library.dylib,