diff --git a/src/type_infer/solve.rs b/src/type_infer/solve.rs index 2301d1d..73d85b5 100644 --- a/src/type_infer/solve.rs +++ b/src/type_infer/solve.rs @@ -330,7 +330,7 @@ pub fn solve_constraints( loc, from_type, to_type, )); } - tracing::trace!(form = %from_type, to = %to_type, "changed something because we can determine if we can do the cast"); + tracing::trace!(form = %from_type, to = %to_type, "we can determine if we can do the cast"); changed_something = true; } @@ -352,7 +352,7 @@ pub fn solve_constraints( TypeOrVar::Function(args2, ret2), )); } - tracing::trace!("changed something because we transferred CanCastTo to equivalence checks for function types"); + tracing::trace!("we transferred CanCastTo to equivalence checks for function types"); changed_something = true; } @@ -361,7 +361,7 @@ pub fn solve_constraints( ft @ TypeOrVar::Function(_, _), pt @ TypeOrVar::Primitive(_), ) => { - tracing::trace!(function_type = %ft, primitive_type = %pt, "changed something because we can't cast a function type to a primitive type"); + tracing::trace!(function_type = %ft, primitive_type = %pt, "we can't cast a function type to a primitive type"); errors.push(TypeInferenceError::CannotCastFromFunctionType(loc, pt)); changed_something = true; } @@ -371,14 +371,14 @@ pub fn solve_constraints( pt @ TypeOrVar::Primitive(_), ft @ TypeOrVar::Function(_, _), ) => { - tracing::trace!(function_type = %ft, primitive_type = %pt, "changed something because we can't cast a primitive type to a function type"); + tracing::trace!(function_type = %ft, primitive_type = %pt, "we can't cast a primitive type to a function type"); errors.push(TypeInferenceError::CannotCastToFunctionType(loc, pt)); changed_something = true; } // if we're testing if an actual primitive type is numeric, that's pretty easy Constraint::ConstantNumericType(loc, TypeOrVar::Primitive(pt)) => { - tracing::trace!(primitive_type = %pt, "changed something because its easy to tell if a constant number can be a primitive type"); + tracing::trace!(primitive_type = %pt, "its easy to tell if a constant number can be a primitive type"); if pt.max_value().is_none() { errors.push(TypeInferenceError::NotANumber(loc, pt)) } @@ -387,7 +387,7 @@ pub fn solve_constraints( // if we're testing if a function type is numeric, then throw a useful warning Constraint::ConstantNumericType(loc, t @ TypeOrVar::Function(_, _)) => { - tracing::trace!(function_type = %t, "changed something because functions can't be constant numbers"); + tracing::trace!(function_type = %t, "functions can't be constant numbers"); errors.push(TypeInferenceError::CannotMakeNumberAFunction(loc, t, None)); changed_something = true; } @@ -404,12 +404,12 @@ pub fn solve_constraints( Some(_) => {} } changed_something = true; - tracing::trace!(primitive_type = %ctype, value = val, "changed something because we can test for a value fitting in a primitive type"); + tracing::trace!(primitive_type = %ctype, value = val, "we can test for a value fitting in a primitive type"); } // if we're testing if a function type can fit into a numeric type, that's a problem Constraint::FitsInNumType(loc, t @ TypeOrVar::Function(_, _), val) => { - tracing::trace!(function_type = %t, "changed something because values don't fit in function types"); + tracing::trace!(function_type = %t, "values don't fit in function types"); errors.push(TypeInferenceError::CannotMakeNumberAFunction( loc, t, @@ -421,13 +421,13 @@ pub fn solve_constraints( // if we want to know if a type is something, and it is something, then we're done Constraint::IsSomething(_, t @ TypeOrVar::Function(_, _)) | Constraint::IsSomething(_, t @ TypeOrVar::Primitive(_)) => { - tracing::trace!(tested_type = %t, "changed something because type is definitely something"); + tracing::trace!(tested_type = %t, "type is definitely something"); changed_something = true; } // if we want to know if something is signed, we can check its primitive type Constraint::IsSigned(loc, TypeOrVar::Primitive(pt)) => { - tracing::trace!(primitive_type = %pt, "changed something because we can check if a primitive is signed"); + tracing::trace!(primitive_type = %pt, "we can check if a primitive is signed"); if !pt.valid_operators().contains(&("-", 1)) { errors.push(TypeInferenceError::IsNotSigned(loc, pt)); } @@ -436,14 +436,14 @@ pub fn solve_constraints( // again with the functions and the numbers Constraint::IsSigned(loc, t @ TypeOrVar::Function(_, _)) => { - tracing::trace!(function_type = %t, "changed something because functions are not signed"); + tracing::trace!(function_type = %t, "functions are not signed"); errors.push(TypeInferenceError::CannotCastFromFunctionType(loc, t)); changed_something = true; } // if we're testing if an actual primitive type is numeric, that's pretty easy Constraint::NumericType(loc, TypeOrVar::Primitive(pt)) => { - tracing::trace!(primitive_type = %pt, "changed something because its easy to tell if a primitive type is numeric"); + tracing::trace!(primitive_type = %pt, "its easy to tell if a primitive type is numeric"); if pt.max_value().is_none() { errors.push(TypeInferenceError::NotANumber(loc, pt)) } @@ -452,20 +452,20 @@ pub fn solve_constraints( // if we're testing if a function type is numeric, then throw a useful warning Constraint::NumericType(loc, t @ TypeOrVar::Function(_, _)) => { - tracing::trace!(function_type = %t, "changed something because function types aren't numeric"); + tracing::trace!(function_type = %t, "function types aren't numeric"); errors.push(TypeInferenceError::CannotMakeNumberAFunction(loc, t, None)); changed_something = true; } // all of our primitive types are printable Constraint::Printable(_, TypeOrVar::Primitive(pt)) => { - tracing::trace!(primitive_type = %pt, "changed something because primitive types are printable"); + tracing::trace!(primitive_type = %pt, "primitive types are printable"); changed_something = true; } // function types are definitely not printable Constraint::Printable(loc, ft @ TypeOrVar::Function(_, _)) => { - tracing::trace!(function_type = %ft, "changed something because function types are not printable"); + tracing::trace!(function_type = %ft, "function types are not printable"); errors.push(TypeInferenceError::FunctionsAreNotPrintable(loc)); changed_something = true; } @@ -486,7 +486,7 @@ pub fn solve_constraints( new_constraints.push(Constraint::Equivalent(loc.clone(), left, ret)); changed_something = true; all_constraints_solved = false; - tracing::trace!(primitive = %prim, "changed something because we expanded out a binary primitive operation"); + tracing::trace!(primitive = %prim, "we expanded out a binary primitive operation"); } Primitive::Minus if args.len() == 1 => { @@ -496,7 +496,7 @@ pub fn solve_constraints( new_constraints.push(Constraint::Equivalent(loc, value, ret)); changed_something = true; all_constraints_solved = false; - tracing::trace!(primitive = %prim, "changed something because we expanded out a unary primitive operation"); + tracing::trace!(primitive = %prim, "we expanded out a unary primitive operation"); } Primitive::Plus | Primitive::Times | Primitive::Divide => { @@ -508,7 +508,7 @@ pub fn solve_constraints( args.len(), )); changed_something = true; - tracing::trace!(primitive = %prim, provided_arity = args.len(), "changed something because binary primitive operation arity is wrong"); + tracing::trace!(primitive = %prim, provided_arity = args.len(), "binary primitive operation arity is wrong"); } Primitive::Minus => { @@ -520,7 +520,7 @@ pub fn solve_constraints( args.len(), )); changed_something = true; - tracing::trace!(primitive = %prim, provided_arity = args.len(), "changed something because unary primitive operation arity is wrong"); + tracing::trace!(primitive = %prim, provided_arity = args.len(), "unary primitive operation arity is wrong"); } }, @@ -538,7 +538,7 @@ pub fn solve_constraints( )); } changed_something = true; - tracing::trace!(primitive_type1 = %pt1, primitive_type2 = %pt2, "changed something because we checked for primitive type equivalence"); + tracing::trace!(primitive_type1 = %pt1, primitive_type2 = %pt2, "we checked for primitive type equivalence"); } Constraint::Equivalent( @@ -551,7 +551,7 @@ pub fn solve_constraints( ft @ TypeOrVar::Function(_, _), pt @ TypeOrVar::Primitive(_), ) => { - tracing::trace!(primitive_type = %pt, function_type = %ft, "changed something because function and primitive types cannot be equivalent"); + tracing::trace!(primitive_type = %pt, function_type = %ft, "function and primitive types cannot be equivalent"); errors.push(TypeInferenceError::NotEquivalent(loc, pt, ft)); changed_something = true; } @@ -561,7 +561,7 @@ pub fn solve_constraints( TypeOrVar::Variable(_, name1), TypeOrVar::Variable(_, name2), ) if name1 == name2 => { - tracing::trace!(name = %name1, "changed something because variable is equivalent to itself"); + tracing::trace!(name = %name1, "variable is equivalent to itself"); changed_something = true; } @@ -583,7 +583,7 @@ pub fn solve_constraints( } changed_something = true; - tracing::trace!("changed something because we checked/rewrote if function types are equivalent"); + tracing::trace!("we checked/rewrote if function types are equivalent"); } Constraint::Equivalent(_, TypeOrVar::Variable(_, ref name), ref rhs) => { @@ -591,13 +591,13 @@ pub fn solve_constraints( changed_something |= replace_variable(&mut new_constraints, name, rhs); all_constraints_solved &= rhs.is_resolved(); if changed_something { - tracing::trace!(%name, new_type = %rhs, "changed something because we were able to rewrite name somewhere"); + tracing::trace!(%name, new_type = %rhs, "we were able to rewrite name somewhere"); } new_constraints.push(constraint); } Constraint::Equivalent(loc, lhs, rhs @ TypeOrVar::Variable(_, _)) => { - tracing::trace!(new_left = %rhs, new_right = %lhs, "changed something because we flipped the order on an equivalence"); + tracing::trace!(new_left = %rhs, new_right = %lhs, "we flipped the order on an equivalence"); new_constraints.push(Constraint::Equivalent(loc, rhs, lhs)); changed_something = true; all_constraints_solved = false;