Make chalk-ir not dependent on tracing

chalk-engine/src/forest.rs

@@ -4,9 +4,9 @@ use crate::table::AnswerIndex;
 use crate::tables::Tables;
 use crate::{TableIndex, TimeStamp};
 
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{Goal, InEnvironment, Substitution, UCanonical};
+use tracing::debug;
 
 pub struct Forest<I: Interner, C: Context<I>> {
     pub(crate) tables: Tables<I>,

chalk-engine/src/logic.rs

@@ -10,12 +10,12 @@ use crate::{
     TimeStamp,
 };
 
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     Canonical, ConstrainedSubst, DomainGoal, Floundered, Goal, GoalData, InEnvironment, NoSolution,
     Substitution, UCanonical, UniverseMap, WhereClause,
 };
+use tracing::{debug, info, instrument};
 
 type RootSearchResult<T> = Result<T, RootSearchFail>;
 

chalk-engine/src/simplify.rs

@@ -2,12 +2,12 @@ use crate::context::{Context, ContextOps, InferenceTable};
 use crate::forest::Forest;
 use crate::{ExClause, Literal, TimeStamp};
 
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     Constraint, DomainGoal, Environment, Fallible, Goal, GoalData, InEnvironment, LifetimeOutlives,
     QuantifierKind, Substitution, WhereClause,
 };
+use tracing::debug;
 
 impl<I: Interner, C: Context<I>> Forest<I, C> {
     /// Simplifies a goal into a series of positive domain goals

chalk-engine/src/table.rs

@@ -6,9 +6,9 @@ use std::collections::hash_map::Entry;
 use std::collections::VecDeque;
 use std::mem;
 
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{AnswerSubst, Canonical, Goal, InEnvironment, UCanonical};
+use tracing::{debug, info, instrument};
 
 pub(crate) struct Table<I: Interner> {
     /// The goal this table is trying to solve (also the key to look

chalk-integration/src/lowering.rs

@@ -1,6 +1,5 @@
 use crate::interner::{ChalkFnAbi, ChalkIr};
 use chalk_ir::cast::{Cast, Caster};
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::{
     self, AdtId, AssocTypeId, BoundVar, ClausePriority, DebruijnIndex, FnDefId, ImplId, OpaqueTyId,
@@ -13,6 +12,7 @@ use chalk_solve::rust_ir::{
 use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 use string_cache::DefaultAtom as Atom;
+use tracing::{debug, instrument};
 
 use crate::error::RustIrError;
 use crate::program::Program as LoweredProgram;

chalk-ir/Cargo.toml

@@ -11,5 +11,4 @@ edition = "2018"
 
 [dependencies]
 lazy_static = "1.4.0"
-tracing = "0.1"
 chalk-derive = { version = "0.14.0-dev.0", path = "../chalk-derive" }

chalk-ir/src/lib.rs

@@ -52,7 +52,6 @@ pub mod fold;
 pub mod visit;
 
 pub mod debug_macros {
-    pub use tracing::{debug, info, instrument};
     #[macro_export]
     macro_rules! debug_span {
         ($($t: tt)*) => {

chalk-solve/src/clauses.rs

@@ -5,10 +5,10 @@ use crate::split::Split;
 use crate::RustIrDatabase;
 use chalk_ir::cast::Cast;
 use chalk_ir::could_match::CouldMatch;
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use rustc_hash::FxHashSet;
+use tracing::{debug, instrument};
 
 pub mod builder;
 mod builtin_traits;

chalk-solve/src/clauses/builder.rs

@@ -3,10 +3,10 @@ use std::marker::PhantomData;
 
 use crate::cast::{Cast, CastTo};
 use crate::RustIrDatabase;
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::{Fold, Shift};
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
+use tracing::{debug, instrument};
 
 /// The "clause builder" is a useful tool for building up sets of
 /// program clauses. It takes ownership of the output vector while it

chalk-solve/src/clauses/env_elaborator.rs

@@ -7,11 +7,11 @@ use crate::ProgramClause;
 use crate::RustIrDatabase;
 use crate::Ty;
 use crate::TyData;
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::visit::{Visit, Visitor};
 use chalk_ir::DebruijnIndex;
 use rustc_hash::FxHashSet;
+use tracing::debug;
 
 /// When proving a `FromEnv` goal, we elaborate all `FromEnv` goals
 /// found in the environment.

chalk-solve/src/clauses/program_clauses.rs

@@ -2,10 +2,10 @@ use crate::clauses::builder::ClauseBuilder;
 use crate::rust_ir::*;
 use crate::split::Split;
 use chalk_ir::cast::{Cast, CastTo, Caster};
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use std::iter;
+use tracing::instrument;
 
 /// Trait for lowering a given piece of rust-ir source (e.g., an impl
 /// or struct definition) into its associated "program clauses" --

chalk-solve/src/coherence/orphan.rs

@@ -3,9 +3,9 @@ use crate::ext::GoalExt;
 use crate::solve::SolverChoice;
 use crate::RustIrDatabase;
 use chalk_ir::cast::*;
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
+use tracing::{debug, instrument};
 
 // Test if a local impl violates the orphan rules.
 //

chalk-solve/src/coherence/solve.rs

@@ -3,11 +3,11 @@ use crate::ext::*;
 use crate::rust_ir::*;
 use crate::{goal_builder::GoalBuilder, Solution};
 use chalk_ir::cast::*;
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::shift::Shift;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use itertools::Itertools;
+use tracing::{debug, instrument};
 
 impl<I: Interner> CoherenceSolver<'_, I> {
     pub(super) fn visit_specializations_of_trait(

chalk-solve/src/infer.rs

@@ -1,7 +1,7 @@
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
 use chalk_ir::{cast::Cast, fold::Fold};
+use tracing::{debug, instrument};
 
 pub(crate) mod canonicalize;
 pub(crate) mod instantiate;

chalk-solve/src/infer/canonicalize.rs

@@ -1,9 +1,9 @@
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::shift::Shift;
 use chalk_ir::fold::{Fold, Folder};
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
 use std::cmp::max;
+use tracing::{debug, instrument};
 
 use super::{InferenceTable, ParameterEnaVariable};
 

chalk-solve/src/infer/ucanonicalize.rs

@@ -1,8 +1,8 @@
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::{Fold, Folder};
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::visit::{Visit, Visitor};
 use chalk_ir::*;
+use tracing::debug;
 
 use super::InferenceTable;
 

chalk-solve/src/recursive.rs

@@ -10,10 +10,10 @@ use self::search_graph::{DepthFirstNumber, SearchGraph};
 use self::solve::{SolveDatabase, SolveIteration};
 use self::stack::{Stack, StackDepth};
 use crate::{coinductive_goal::IsCoinductive, RustIrDatabase};
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, ConstrainedSubst, Fallible};
 use rustc_hash::FxHashMap;
+use tracing::{debug, info, instrument};
 
 pub(crate) struct RecursiveContext<I: Interner> {
     stack: Stack,

chalk-solve/src/recursive/combine.rs

@@ -1,5 +1,5 @@
 use super::lib::Solution;
-use chalk_ir::debug_macros::*;
+use tracing::debug;
 
 use chalk_ir::interner::Interner;
 use chalk_ir::{ClausePriority, DomainGoal, Fallible, GenericArg, Goal, GoalData};

chalk-solve/src/recursive/fulfill.rs

@@ -1,7 +1,6 @@
 use super::lib::{Guidance, Minimums, Solution};
 use super::solve::SolveDatabase;
 use chalk_ir::cast::Cast;
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::visit::Visit;
@@ -13,6 +12,7 @@ use chalk_ir::{
 };
 use rustc_hash::FxHashSet;
 use std::fmt::Debug;
+use tracing::debug;
 
 enum Outcome {
     Complete,

chalk-solve/src/recursive/lib.rs

@@ -1,8 +1,8 @@
 use super::search_graph::DepthFirstNumber;
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, ConstrainedSubst, Goal, InEnvironment, Substitution, UCanonical};
 use std::fmt;
+use tracing::debug;
 
 pub type UCanonicalGoal<I> = UCanonical<InEnvironment<Goal<I>>>;
 

chalk-solve/src/recursive/search_graph.rs

@@ -5,9 +5,9 @@ use std::usize;
 
 use super::lib::{Minimums, Solution, UCanonicalGoal};
 use super::stack::StackDepth;
-use chalk_ir::debug_macros::*;
 use chalk_ir::{interner::Interner, ClausePriority, Fallible, NoSolution};
 use rustc_hash::FxHashMap;
+use tracing::debug;
 
 /// The "search graph" stores in-progress goals that are still
 /// being solved.

chalk-solve/src/recursive/solve.rs

@@ -4,7 +4,6 @@ use super::lib::{Guidance, Minimums, Solution, UCanonicalGoal};
 use crate::clauses::program_clauses_for_goal;
 use crate::infer::{InferenceTable, ParameterEnaVariableExt};
 use crate::{solve::truncate, RustIrDatabase};
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::visit::Visit;
@@ -15,6 +14,7 @@ use chalk_ir::{
     ProgramClauseImplication, Substitution, UCanonical, UniverseMap,
 };
 use std::fmt::Debug;
+use tracing::{debug, instrument};
 
 pub(super) trait SolveDatabase<I: Interner>: Sized {
     fn solve_goal(

chalk-solve/src/solve/slg/resolvent.rs

@@ -1,11 +1,11 @@
 use crate::infer::InferenceTable;
 use crate::solve::slg::{self, SlgContext, TruncatingInferenceTable};
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::shift::Shift;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::zip::{Zip, Zipper};
 use chalk_ir::*;
+use tracing::{debug, instrument};
 
 use chalk_engine::context;
 use chalk_engine::{ExClause, Literal, TimeStamp};

chalk-solve/src/split.rs

@@ -1,9 +1,9 @@
 use crate::rust_ir::*;
 use crate::RustIrDatabase;
-use chalk_ir::debug_macros::*;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use std::sync::Arc;
+use tracing::{debug, instrument};
 
 /// Methods for splitting up the projections for associated types from
 /// the surrounding context.

chalk-solve/src/wf.rs

@@ -7,11 +7,11 @@ use crate::solve::SolverChoice;
 use crate::split::Split;
 use crate::RustIrDatabase;
 use chalk_ir::cast::*;
-use chalk_ir::debug_macros::*;
 use chalk_ir::fold::shift::Shift;
 use chalk_ir::interner::Interner;
 use chalk_ir::visit::{Visit, Visitor};
 use chalk_ir::*;
+use tracing::debug;
 
 #[derive(Debug)]
 pub enum WfError<I: Interner> {