parser+source: improvements and cleanups

compiler/hash-ast-expand/Cargo.toml

@@ -8,8 +8,6 @@ edition = "2021"
 doctest = false
 
 [dependencies]
-derive_more = "0.99"
-
 hash-ast = { path = "../hash-ast" }
 hash-attrs = { path = "../hash-attrs" }
 hash-fmt = { path = "../hash-fmt" }

compiler/hash-ast-expand/src/diagnostics/error.rs

@@ -1,6 +1,5 @@
 //! Definitions of the various kinds of errors that can occur during the
 //! expansion phase of the compiler.
-use derive_more::Constructor;
 use hash_ast::ast::AstNodeId;
 use hash_attrs::{
     attr::{AttrArgIdx, AttrValueKind},
@@ -14,6 +13,7 @@ use hash_reporting::{
 };
 use hash_source::identifier::Identifier;
 use hash_tir::{tys::TyId, utils::params::ParamError};
+use hash_utils::derive_more::Constructor;
 
 #[derive(Constructor, Debug)]
 pub struct ExpansionError {

compiler/hash-ast-expand/src/diagnostics/warning.rs

@@ -1,9 +1,9 @@
 //! Compiler warnings that are emitted during AST expansion.
 
-use derive_more::{Constructor, From};
 use hash_ast::ast::AstNodeId;
 use hash_attrs::diagnostics::AttrWarning;
 use hash_reporting::reporter::{Reporter, Reports};
+use hash_utils::derive_more::{Constructor, From};
 
 #[derive(Constructor, Debug)]
 pub struct ExpansionWarning {

compiler/hash-attrs/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2021"
 doctest = false
 
 [dependencies]
-derive_more = "0.99"
 paste = "1.0.14"
 
 hash-ast = { path = "../hash-ast" }

compiler/hash-attrs/src/attr.rs

@@ -2,7 +2,6 @@
 
 use std::{fmt, sync::OnceLock};
 
-use derive_more::From;
 use hash_ast::{ast, ast::AstNodeId};
 use hash_source::{
     constant::{InternedFloat, InternedInt, InternedStr},
@@ -11,7 +10,7 @@ use hash_source::{
 use hash_storage::store::{DefaultPartialStore, PartialStore};
 use hash_target::{abi::Integer, data_layout::HasDataLayout, primitives::IntTy};
 use hash_tir::params::ParamIndex;
-use hash_utils::{fxhash::FxHashMap, lazy_static::lazy_static};
+use hash_utils::{derive_more::From, fxhash::FxHashMap, lazy_static::lazy_static};
 
 use crate::{
     diagnostics::{AttrError, AttrResult},

compiler/hash-codegen-llvm/src/translation/constants.rs

@@ -4,7 +4,7 @@ use hash_codegen::{
     traits::{constants::ConstValueBuilderMethods, layout::LayoutMethods, ty::TypeBuilderMethods},
 };
 use hash_ir::{ir::Const, ty::COMMON_IR_TYS};
-use hash_source::constant::{InternedStr, CONSTANT_MAP};
+use hash_source::constant::InternedStr;
 use inkwell::{module::Linkage, types::BasicTypeEnum, values::AnyValueEnum};
 
 use super::ty::ExtendedTyBuilderMethods;
@@ -143,8 +143,8 @@ impl<'b, 'm> ConstValueBuilderMethods<'b> for CodeGenCtx<'b, 'm> {
             Const::Zero(_) => unreachable!("`const_scalar_value` should not be called on a ZST"),
             Const::Bool(val) => self.const_bool(val),
             Const::Char(ch) => self.const_u32(ch as u32),
-            Const::Int(interned_int) => {
-                let const_int = CONSTANT_MAP.lookup_int(interned_int);
+            Const::Int(int) => {
+                let const_int = int.value();
 
                 // Convert the constant into a u128 and then emit the
                 // correct LLVM constant for it.
@@ -157,9 +157,7 @@ impl<'b, 'm> ConstValueBuilderMethods<'b> for CodeGenCtx<'b, 'm> {
                         unimplemented!()
                     })
             }
-            Const::Float(interned_float) => {
-                self.const_float(ty, CONSTANT_MAP.lookup_float(interned_float).as_f64())
-            }
+            Const::Float(interned_float) => self.const_float(ty, interned_float.value().as_f64()),
             Const::Str(str) => self.const_str(str).0,
         }
     }

compiler/hash-codegen/src/lower/terminator.rs

@@ -12,7 +12,6 @@
 use hash_abi::{ArgAbi, FnAbiId, PassMode};
 use hash_ir::{intrinsics::Intrinsic, ir, lang_items::LangItem, ty::COMMON_IR_TYS};
 use hash_pipeline::settings::{CodeGenBackend, OptimisationLevel};
-use hash_source::constant::CONSTANT_MAP;
 use hash_storage::store::{statics::StoreId, Store};
 use hash_target::abi::{AbiRepresentation, ValidScalarRange};
 
@@ -577,7 +576,7 @@ impl<'a, 'b, Builder: BlockBuilderMethods<'a, 'b>> FnBuilder<'a, 'b, Builder> {
         builder.switch_to_block(failure_block);
 
         // we need to convert the assert into a message.
-        let (bytes, len) = builder.const_str(CONSTANT_MAP.create_string(assert_kind.message()));
+        let (bytes, len) = builder.const_str(assert_kind.message().into());
         let args: [Builder::Value; 2] = (bytes, len).into();
 
         // Get the `panic` lang item.

compiler/hash-driver/src/driver.rs

@@ -318,7 +318,7 @@ impl<I: CompilerInterface> Driver<I> {
         }
 
         // Print compiler stage metrics if specified in the settings.
-        if self.compiler.settings().output_metrics && !self.bootstrapping {
+        if self.compiler.settings().show_timings && !self.bootstrapping {
             self.report_metrics();
         }
     }

compiler/hash-driver/src/lib.rs

@@ -60,7 +60,7 @@ impl CompilerBuilder {
         Self::build(
             interface,
             vec![
-                Box::new(Parser),
+                Box::<Parser>::default(),
                 Box::new(AstExpansionPass),
                 Box::new(AstDesugaringPass),
                 Box::new(UntypedSemanticAnalysis),

compiler/hash-exhaustiveness/src/constant.rs

@@ -2,7 +2,7 @@
 //! to represent literals, and convert them into a `ConstantValue` which is
 //! used within the exhaustiveness sub-system to represent these values within
 //! a single data type.
-use hash_source::constant::{InternedInt, CONSTANT_MAP};
+use hash_source::constant::InternedInt;
 use hash_tir::tys::TyId;
 
 #[derive(Debug, Clone, Copy)]
@@ -31,7 +31,7 @@ impl Constant {
     pub fn from_int(constant: InternedInt, ty: TyId) -> Self {
         // Get the associated bytes with the interned-int so we can convert
         // into a constant.
-        let data = CONSTANT_MAP.lookup_int(constant).value.as_u128().unwrap();
+        let data = constant.value().value.as_u128().unwrap();
         Constant { data, ty }
     }
 

compiler/hash-fmt/src/lib.rs

@@ -12,7 +12,7 @@ use hash_ast::{
     ast::{self, walk_mut_self, AstVisitorMutSelf, ParamOrigin},
     ast_visitor_mut_self_default_impl,
 };
-use hash_source::constant::{IntConstant, CONSTANT_MAP};
+use hash_source::constant::IntConstant;
 use hash_token::delimiter::Delimiter;
 use state::AstPrinterState;
 
@@ -701,7 +701,7 @@ where
         &mut self,
         node: ast::AstNodeRef<ast::IntLit>,
     ) -> Result<Self::IntLitRet, Self::Error> {
-        CONSTANT_MAP.map_int(node.body.value, |value| {
+        node.body.value.map(|value| {
             let IntConstant { value, suffix } = value;
 
             self.write(format!("{}", value))?;

compiler/hash-intrinsics/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2021"
 doctest = false
 
 [dependencies]
-derive_more = "0.99"
 num-bigint = "0.4"
 num_enum = "0.5"
 

compiler/hash-intrinsics/src/utils.rs

@@ -1,6 +1,7 @@
 use hash_ast::ast::{self};
 use hash_source::constant::{
-    FloatTy, IntConstant, IntConstantValue, IntTy, SIntTy, UIntTy, CONSTANT_MAP,
+    FloatConstant, FloatConstantValue, FloatTy, IntConstant, IntConstantValue, IntTy, InternedInt,
+    SIntTy, UIntTy,
 };
 use hash_storage::store::statics::{SequenceStoreValue, SingleStoreValue, StoreId};
 use hash_tir::{
@@ -227,11 +228,11 @@ pub trait PrimitiveUtils: AccessToEnv {
     }
 
     /// Get the given term as a float literal if possible.
-    fn create_term_from_float_lit<L: Into<f64>>(&self, lit: L) -> TermId {
+    fn create_term_from_float_lit<L: Into<FloatConstantValue>>(&self, lit: L) -> TermId {
         Term::create(Term::Lit(Lit::Float(FloatLit {
             underlying: ast::FloatLit {
                 kind: ast::FloatLitKind::Unsuffixed,
-                value: CONSTANT_MAP.create_f64_float(lit.into(), None),
+                value: FloatConstant::new(lit.into(), None).into(),
             },
         })))
     }
@@ -249,7 +250,7 @@ pub trait PrimitiveUtils: AccessToEnv {
         Term::create(Term::Lit(Lit::Int(IntLit {
             underlying: ast::IntLit {
                 kind: ast::IntLitKind::Unsuffixed,
-                value: CONSTANT_MAP.create_int(IntConstant::new(
+                value: InternedInt::create(IntConstant::new(
                     IntConstantValue::Big(Box::new(lit.into())),
                     None,
                 )),