From 0cc2b4ea9d174cef60d0c3d461d5b3422a4f1e9c Mon Sep 17 00:00:00 2001 From: Adam Wick Date: Thu, 22 Feb 2024 14:23:41 -0800 Subject: [PATCH] wheee --- examples/basic/function0002.ngr | 10 ++++++++++ src/type_infer/solve.rs | 31 +++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 examples/basic/function0002.ngr diff --git a/examples/basic/function0002.ngr b/examples/basic/function0002.ngr new file mode 100644 index 0000000..9d8f014 --- /dev/null +++ b/examples/basic/function0002.ngr @@ -0,0 +1,10 @@ +x = 1; +function add_x(y) x + y +a = 3; +function add_x_twice(y) add_x(y) + x +print x; +result = add_x(a); +print x; +print result; +result = add_x_twice(a); +print result; \ No newline at end of file diff --git a/src/type_infer/solve.rs b/src/type_infer/solve.rs index fb668d2..44e8f90 100644 --- a/src/type_infer/solve.rs +++ b/src/type_infer/solve.rs @@ -328,6 +328,7 @@ pub fn solve_constraints( loc, from_type, to_type, )); } + println!("changed something because finished CanCastTo"); changed_something = true; } @@ -349,6 +350,7 @@ pub fn solve_constraints( TypeOrVar::Function(args2, ret2), )); } + println!("changed something because finished CanCastTo (2)"); changed_something = true; } @@ -358,6 +360,7 @@ pub fn solve_constraints( pt @ TypeOrVar::Primitive(_), ) => { errors.push(TypeInferenceError::CannotCastFromFunctionType(loc, pt)); + println!("changed something because finished CanCastTo (3)"); changed_something = true; } @@ -368,17 +371,20 @@ pub fn solve_constraints( ) => { errors.push(TypeInferenceError::CannotCastToFunctionType(loc, pt)); changed_something = true; + println!("changed something because finished CanCastTo (4)"); } // if we're testing if an actual primitive type is numeric, that's pretty easy Constraint::ConstantNumericType(_, TypeOrVar::Primitive(_)) => { changed_something = true; + println!("changed something because constant numeric type (1)"); } // if we're testing if a function type is numeric, then throw a useful warning Constraint::ConstantNumericType(loc, t @ TypeOrVar::Function(_, _)) => { errors.push(TypeInferenceError::CannotMakeNumberAFunction(loc, t, None)); changed_something = true; + println!("changed something because constant numeric type (2)"); } // if we're testing if a number can fit into a numeric type, we can just do that! @@ -393,6 +399,7 @@ pub fn solve_constraints( Some(_) => {} } changed_something = true; + println!("changed something because fits in numeric type (1)"); } // if we're testing if a function type can fit into a numeric type, that's a problem @@ -403,12 +410,14 @@ pub fn solve_constraints( Some(val), )); changed_something = true; + println!("changed something because fits in numeric type (2)"); } // if we want to know if a type is something, and it is something, then we're done Constraint::IsSomething(_, TypeOrVar::Function(_, _)) | Constraint::IsSomething(_, TypeOrVar::Primitive(_)) => { changed_something = true; + println!("changed something because 1"); } // if we want to know if something is signed, we can check its primitive type @@ -417,34 +426,40 @@ pub fn solve_constraints( errors.push(TypeInferenceError::IsNotSigned(loc, pt)); } changed_something = true; + println!("changed something because 2"); } // again with the functions and the numbers Constraint::IsSigned(loc, t @ TypeOrVar::Function(_, _)) => { errors.push(TypeInferenceError::CannotCastFromFunctionType(loc, t)); changed_something = true; + println!("changed something because 3"); } // if we're testing if an actual primitive type is numeric, that's pretty easy Constraint::NumericType(_, TypeOrVar::Primitive(_)) => { changed_something = true; + println!("changed something because 4"); } // if we're testing if a function type is numeric, then throw a useful warning Constraint::NumericType(loc, t @ TypeOrVar::Function(_, _)) => { errors.push(TypeInferenceError::CannotMakeNumberAFunction(loc, t, None)); changed_something = true; + println!("changed something because 5"); } // all of our primitive types are printable Constraint::Printable(_, TypeOrVar::Primitive(_)) => { changed_something = true; + println!("changed something because 6"); } // function types are definitely not printable Constraint::Printable(loc, TypeOrVar::Function(_, _)) => { errors.push(TypeInferenceError::FunctionsAreNotPrintable(loc)); changed_something = true; + println!("changed something because 7"); } Constraint::ProperPrimitiveArgs(loc, prim, mut args, ret) => match prim { @@ -463,6 +478,7 @@ pub fn solve_constraints( new_constraints.push(Constraint::Equivalent(loc.clone(), left, ret)); changed_something = true; all_constraints_solved = false; + println!("changed something because 8"); } Primitive::Minus if args.len() == 1 => { @@ -472,6 +488,7 @@ pub fn solve_constraints( new_constraints.push(Constraint::Equivalent(loc, value, ret)); changed_something = true; all_constraints_solved = false; + println!("changed something because 9"); } Primitive::Plus | Primitive::Times | Primitive::Divide => { @@ -483,6 +500,7 @@ pub fn solve_constraints( args.len(), )); changed_something = true; + println!("changed something because 10"); } Primitive::Minus => { @@ -494,6 +512,7 @@ pub fn solve_constraints( args.len(), )); changed_something = true; + println!("changed something because 11"); } }, @@ -511,6 +530,7 @@ pub fn solve_constraints( )); } changed_something = true; + println!("changed something because 12"); } Constraint::Equivalent( @@ -524,6 +544,11 @@ pub fn solve_constraints( pt @ TypeOrVar::Primitive(_), ) => { errors.push(TypeInferenceError::NotEquivalent(loc, pt, ft)); + changed_something = true; + println!("changed something because 13"); + } + + Constraint::Equivalent(_, TypeOrVar::Variable(_, name1), TypeOrVar::Variable(_, name2)) if name1 == name2 => { changed_something = true; } @@ -545,12 +570,16 @@ pub fn solve_constraints( } changed_something = true; + println!("changed something because 14"); } Constraint::Equivalent(_, TypeOrVar::Variable(_, ref name), ref rhs) => { changed_something |= replace_variable(&mut constraint_db, name, rhs); changed_something |= replace_variable(&mut new_constraints, name, rhs); all_constraints_solved &= rhs.is_resolved(); + if changed_something { + println!("changed something because 15, maybe (name is {})", name); + } new_constraints.push(constraint); } @@ -558,6 +587,7 @@ pub fn solve_constraints( new_constraints.push(Constraint::Equivalent(loc, rhs, lhs)); changed_something = true; all_constraints_solved = false; + println!("changed something because 16"); } Constraint::CanCastTo(_, TypeOrVar::Variable(_, _), _) @@ -602,6 +632,7 @@ pub fn solve_constraints( resty.clone(), )); warnings.push(TypeInferenceWarning::DefaultedTo(loc.clone(), resty)); + println!("Adding number equivalence"); false } else { true