[bibtex] Make hash type-strict, convert internals to indexmap (#1309)

Author: CraftSpider

Cargo.lock

@@ -21,6 +21,7 @@ edition = "2021"
 
 [dependencies]
 libc = "^0.2"
+indexmap = "2.0"
 tectonic_io_base = { path = "../io_base", version = '0.0.0-dev.0' }
 tectonic_bridge_core = { path = "../bridge_core", version = "0.0.0-dev.0" }
 tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }

crates/engine_bibtex/Cargo.toml

@@ -4,7 +4,8 @@ use crate::{
     char_info::LexClass,
     cite::CiteInfo,
     exec::print_bst_name,
-    hash::{HashData, HashExtra},
+    hash,
+    hash::{HashData, HashPointer},
     log::{
         aux_end1_err_print, aux_end2_err_print, aux_err_illegal_another_print,
         aux_err_no_right_brace_print, aux_err_print, aux_err_stuff_after_right_brace_print,
@@ -15,7 +16,7 @@ use crate::{
     peekable::PeekableInput,
     pool::{StrNumber, StringPool},
     scan::Scan,
-    Bibtex, BibtexError, File, GlobalItems, StrIlk,
+    Bibtex, BibtexError, File, GlobalItems,
 };
 use std::ffi::CString;
 use tectonic_bridge_core::FileFormat;
@@ -105,27 +106,27 @@ fn aux_bib_data_command(
 
         let file = &buffers.buffer(BufTy::Base)
             [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
-        let res = hash.lookup_str_insert(ctx, pool, file, HashExtra::BibFile)?;
+        let res = hash.lookup_str_insert::<hash::BibFile>(pool, file, ());
         if res.exists {
             ctx.write_logs("This database file appears more than once: ");
-            print_bib_name(ctx, pool, hash.text(res.loc))?;
+            print_bib_name(ctx, pool, hash.get(res.loc).text())?;
             aux_err_print(ctx, buffers, aux, pool)?;
             return Ok(());
         }
 
-        let name = pool.get_str(hash.text(res.loc));
+        let name = pool.get_str(hash.get(res.loc).text());
         let fname = CString::new(name).unwrap();
         let bib_in = PeekableInput::open(ctx, &fname, FileFormat::Bib);
         match bib_in {
             Err(_) => {
                 ctx.write_logs("I couldn't open database file ");
-                print_bib_name(ctx, pool, hash.text(res.loc))?;
+                print_bib_name(ctx, pool, hash.get(res.loc).text())?;
                 aux_err_print(ctx, buffers, aux, pool)?;
                 return Ok(());
             }
             Ok(file) => {
                 bibs.push_file(File {
-                    name: hash.text(res.loc),
+                    name: hash.get(res.loc).text(),
                     file,
                     line: 0,
                 });
@@ -176,27 +177,27 @@ fn aux_bib_style_command(
 
     let file = &buffers.buffer(BufTy::Base)
         [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
-    let res = hash.lookup_str_insert(ctx, pool, file, HashExtra::BstFile)?;
+    let res = hash.lookup_str_insert::<hash::BstFile>(pool, file, ());
     if res.exists {
         ctx.write_logs("Already encountered style file");
         print_confusion(ctx);
         return Err(BibtexError::Fatal);
     }
 
-    let name = pool.get_str(hash.text(res.loc));
+    let name = pool.get_str(hash.get(res.loc).text());
     let fname = CString::new(name).unwrap();
     let bst_file = PeekableInput::open(ctx, &fname, FileFormat::Bst);
     match bst_file {
         Err(_) => {
             ctx.write_logs("I couldn't open style file ");
-            print_bst_name(ctx, pool, hash.text(res.loc))?;
+            print_bst_name(ctx, pool, hash.get(res.loc).text())?;
             ctx.bst = None;
             aux_err_print(ctx, buffers, aux, pool)?;
             return Ok(());
         }
         Ok(file) => {
             ctx.bst = Some(File {
-                name: hash.text(res.loc),
+                name: hash.get(res.loc).text(),
                 file,
                 line: 0,
             });
@@ -276,20 +277,15 @@ fn aux_citation_command(
         let lc_cite = &mut buffers.buffer_mut(BufTy::Ex)[range];
         lc_cite.make_ascii_lowercase();
 
-        let lc_res = hash.lookup_str_insert(ctx, pool, lc_cite, HashExtra::LcCite(0))?;
+        let lc_res = hash.lookup_str_insert::<hash::LcCite>(pool, lc_cite, HashPointer::default());
         if lc_res.exists {
-            let HashExtra::LcCite(cite_loc) = hash.node(lc_res.loc).extra else {
-                panic!("LcCite lookup didn't have LcCite extra");
-            };
+            let &cite_loc = hash.get(lc_res.loc).extra();
 
             let cite = &buffers.buffer(BufTy::Base)
                 [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
-            let uc_res = hash.lookup_str(pool, cite, StrIlk::Cite);
-            if !uc_res.exists {
-                let HashExtra::Cite(cite) = hash.node(cite_loc).extra else {
-                    panic!("LcCite location didn't have a Cite extra");
-                };
-
+            let uc_res = hash.lookup_str::<hash::Cite>(pool, cite);
+            if uc_res.is_none() {
+                let &cite = hash.get(cite_loc).extra();
                 ctx.write_logs("Case mismatch error between cite keys ");
                 print_a_token(ctx, buffers);
                 ctx.write_logs(" and ");
@@ -301,7 +297,7 @@ fn aux_citation_command(
         } else {
             let cite = &buffers.buffer(BufTy::Base)
                 [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
-            let uc_res = hash.lookup_str_insert(ctx, pool, cite, HashExtra::Cite(0))?;
+            let uc_res = hash.lookup_str_insert::<hash::Cite>(pool, cite, 0);
             if uc_res.exists {
                 hash_cite_confusion(ctx);
                 return Err(BibtexError::Fatal);
@@ -311,9 +307,9 @@ fn aux_citation_command(
                 cites.grow();
             }
 
-            cites.set_cite(cites.ptr(), hash.text(uc_res.loc));
-            hash.node_mut(uc_res.loc).extra = HashExtra::Cite(cites.ptr());
-            hash.node_mut(lc_res.loc).extra = HashExtra::LcCite(uc_res.loc);
+            cites.set_cite(cites.ptr(), hash.get(uc_res.loc).text());
+            hash.set_extra(uc_res.loc, cites.ptr());
+            hash.set_extra(lc_res.loc, uc_res.loc);
             cites.set_ptr(cites.ptr() + 1);
         }
     }
@@ -375,27 +371,27 @@ fn aux_input_command(
 
     let file = &buffers.buffer(BufTy::Base)
         [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
-    let res = hash.lookup_str_insert(ctx, pool, file, HashExtra::AuxFile)?;
+    let res = hash.lookup_str_insert::<hash::AuxFile>(pool, file, ());
     if res.exists {
         ctx.write_logs("Already encountered file ");
-        print_aux_name(ctx, pool, hash.text(res.loc))?;
+        print_aux_name(ctx, pool, hash.get(res.loc).text())?;
         aux_err_print(ctx, buffers, aux, pool)?;
         return Ok(());
     }
 
-    let name = pool.get_str(hash.text(res.loc));
+    let name = pool.get_str(hash.get(res.loc).text());
     let fname = CString::new(name).unwrap();
     let file = PeekableInput::open(ctx, &fname, FileFormat::Tex);
     match file {
         Err(_) => {
             ctx.write_logs("I couldn't open auxiliary file ");
-            print_aux_name(ctx, pool, hash.text(res.loc))?;
+            print_aux_name(ctx, pool, hash.get(res.loc).text())?;
             aux_err_print(ctx, buffers, aux, pool)?;
             return Ok(());
         }
         Ok(file) => {
             aux.push_file(File {
-                name: hash.text(res.loc),
+                name: hash.get(res.loc).text(),
                 file,
                 line: 0,
             });
@@ -420,14 +416,10 @@ pub(crate) fn get_aux_command_and_process(
 
     let line = &globals.buffers.buffer(BufTy::Base)
         [globals.buffers.offset(BufTy::Base, 1)..globals.buffers.offset(BufTy::Base, 2)];
-    let res = globals
-        .hash
-        .lookup_str(globals.pool, line, StrIlk::AuxCommand);
+    let res = globals.hash.lookup_str::<AuxCommand>(globals.pool, line);
 
-    if res.exists {
-        let HashExtra::AuxCommand(cmd) = globals.hash.node(res.loc).extra else {
-            panic!("AuxCommand lookup didn't have AuxCommand extra");
-        };
+    if let Some(loc) = res {
+        let &cmd = globals.hash.get(loc).extra();
 
         match cmd {
             AuxCommand::Data => aux_bib_data_command(