fix:minor optimization fixes

Unique only comparison for equals led to strange results
Fixed by interning in a different spot

crates/aiken-lang/src/uplc.rs

@@ -13,6 +13,7 @@ use uplc::{
     },
     builtins::DefaultFunction,
     machine::cost_model::ExBudget,
+    optimize::aiken_optimize_and_intern,
     parser::interner::Interner,
 };
 
@@ -112,9 +113,11 @@ impl<'a> CodeGenerator<'a> {
             term,
         };
 
-        let mut interner = Interner::new();
+        println!("{}", program.to_pretty());
 
-        interner.program(&mut program);
+        program = aiken_optimize_and_intern(program);
+
+        println!("{}", program.to_pretty());
 
         program
     }

crates/uplc/src/optimize.rs

@@ -1,7 +1,16 @@
-use crate::ast::{Name, Program};
+use crate::{
+    ast::{Name, Program},
+    parser::interner::Interner,
+};
 
 pub mod shrinker;
 
-pub fn aiken_optimize(term: Program<Name>) -> Program<Name> {
+pub fn aiken_optimize_and_intern(program: Program<Name>) -> Program<Name> {
-    term.builtin_force_reduce().lambda_reduce().inline_reduce()
+    let mut program = program.builtin_force_reduce();
+
+    let mut interner = Interner::new();
+
+    interner.program(&mut program);
+
+    program.lambda_reduce().inline_reduce()
 }

crates/uplc/src/optimize/shrinker.rs

@@ -89,7 +89,7 @@ fn builtin_force_reduce(term: &mut Term<Name>, builtin_map: &mut IndexMap<u8, ()
                     builtin_map.insert(*func as u8, ());
                     *term = Term::Var(
                         Name {
-                            text: format!("__{}", func.aiken_name()),
+                            text: format!("__{}_wrapped", func.aiken_name()),
                             unique: 0.into(),
                         }
                         .into(),
@@ -160,7 +160,7 @@ fn inline_reduce(term: &mut Term<Name>) {
 fn var_occurrences(term: &Term<Name>, search_for: Rc<Name>, occurrences: &mut usize) {
     match term {
         Term::Var(name) => {
-            if name.clone() == search_for {
+            if name.as_ref() == search_for.as_ref() {
                 *occurrences += 1;
             }
         }
@@ -202,8 +202,7 @@ fn lambda_reduce(term: &mut Term<Name>) {
             {
                 if let replace_term @ (Term::Var(_) | Term::Constant(_)) = argument.as_ref() {
                     let body = Rc::make_mut(body);
-                    lambda_reduce(body);
+                    *term = substitute_term(body, parameter_name.clone(), replace_term);
-                    *body = substitute_term(body, parameter_name.clone(), replace_term);
                 }
             }
         }
@@ -226,7 +225,7 @@ fn lambda_reduce(term: &mut Term<Name>) {
 fn substitute_term(term: &Term<Name>, original: Rc<Name>, replace_with: &Term<Name>) -> Term<Name> {
     match term {
         Term::Var(name) => {
-            if name.clone() == original {
+            if name.as_ref() == original.as_ref() {
                 replace_with.clone()
             } else {
                 Term::Var(name.clone())
@@ -239,7 +238,7 @@ fn substitute_term(term: &Term<Name>, original: Rc<Name>, replace_with: &Term<Na
             parameter_name,
             body,
         } => {
-            if parameter_name.clone() != original {
+            if parameter_name.as_ref() != original.as_ref() {
                 Term::Lambda {
                     parameter_name: parameter_name.clone(),
                     body: Rc::new(substitute_term(body.as_ref(), original, replace_with)),