Merge pull request #29 from Chia-Network/20220524-fix-fe-opt

20220524 fix fe opt

Author: prozacchiwawa

src/compiler/codegen.rs

@@ -987,7 +987,8 @@ fn start_codegen(
                 let updated_opts = opts
                     .set_compiler(use_compiler.clone())
                     .set_in_defun(false)
-                    .set_stdenv(false);
+                    .set_stdenv(false)
+                    .set_frontend_opt(false);
 
                 updated_opts
                     .compile_program(

src/compiler/compiler.rs

@@ -16,7 +16,7 @@ use crate::compiler::codegen::codegen;
 use crate::compiler::comptypes::{
     BodyForm, CompileErr, CompileForm, CompilerOpts, HelperForm, PrimaryCodegen,
 };
-use crate::compiler::evaluate::Evaluator;
+use crate::compiler::evaluate::{build_reflex_captures, Evaluator};
 use crate::compiler::frontend::frontend;
 use crate::compiler::prims;
 use crate::compiler::runtypes::RunFailure;
@@ -124,13 +124,10 @@ fn fe_opt(
     for h in compiler_helpers.iter() {
         match h {
             HelperForm::Defun(loc, name, inline, args, body) => {
-                let body_rc = evaluator.shrink_bodyform(
-                    allocator,
-                    Rc::new(SExp::Nil(compileform.args.loc())),
-                    &HashMap::new(),
-                    body.clone(),
-                    true,
-                )?;
+                let mut env = HashMap::new();
+                build_reflex_captures(&mut env, args.clone());
+                let body_rc =
+                    evaluator.shrink_bodyform(allocator, args.clone(), &env, body.clone(), true)?;
                 let new_helper = HelperForm::Defun(
                     loc.clone(),
                     name.clone(),

src/compiler/evaluate.rs

@@ -313,6 +313,13 @@ fn synthesize_args(
     }
 }
 
+fn reflex_capture(name: &Vec<u8>, capture: Rc<BodyForm>) -> bool {
+    match capture.borrow() {
+        BodyForm::Value(SExp::Atom(_, n)) => n == name,
+        _ => false,
+    }
+}
+
 impl Evaluator {
     pub fn new(
         opts: Rc<dyn CompilerOpts>,
@@ -350,6 +357,7 @@ impl Evaluator {
             self.expand_macro(allocator, l.clone(), program.clone(), macro_args)?;
 
         let input_sexp = dequote(call_loc.clone(), macro_expansion)?;
+
         let frontend_macro_input = Rc::new(SExp::Cons(
             l.clone(),
             Rc::new(SExp::atom_from_string(l.clone(), &"mod".to_string())),
@@ -620,13 +628,17 @@ impl Evaluator {
                 } else {
                     env.get(name)
                         .map(|x| {
-                            self.shrink_bodyform(
-                                allocator,
-                                prog_args.clone(),
-                                env,
-                                x.clone(),
-                                only_inline,
-                            )
+                            if reflex_capture(name, x.clone()) {
+                                Ok(x.clone())
+                            } else {
+                                self.shrink_bodyform(
+                                    allocator,
+                                    prog_args.clone(),
+                                    env,
+                                    x.clone(),
+                                    only_inline,
+                                )
+                            }
                         })
                         .unwrap_or_else(|| {
                             self.get_constant(name)
@@ -774,7 +786,11 @@ impl Evaluator {
         // Com takes place in the current environment.
         // We can only reduce com if all bindings are
         // primitive.
-        let updated_opts = self.opts.set_stdenv(!in_defun).set_in_defun(in_defun);
+        let updated_opts = self
+            .opts
+            .set_stdenv(!in_defun)
+            .set_in_defun(in_defun)
+            .set_frontend_opt(false);
 
         let com_result = updated_opts.compile_program(
             allocator,

src/tests/compiler/compiler.rs

@@ -173,7 +173,7 @@ fn run_test_3() {
 
 #[test]
 fn run_test_3_opt() {
-    // run_test_3_maybe_opt(true);
+    run_test_3_maybe_opt(true);
 }
 
 fn run_test_4_maybe_opt(opt: bool) {
@@ -193,7 +193,7 @@ fn run_test_4() {
 
 #[test]
 fn run_test_4_opt() {
-    // run_test_4_maybe_opt(true);
+    run_test_4_maybe_opt(true);
 }
 
 fn run_test_5_maybe_opt(opt: bool) {
@@ -209,7 +209,7 @@ fn run_test_5() {
 
 #[test]
 fn run_test_5_opt() {
-    // run_test_5_maybe_opt(true);
+    run_test_5_maybe_opt(true);
 }
 
 fn run_test_6_maybe_opt(opt: bool) {
@@ -229,7 +229,7 @@ fn run_test_6() {
 
 #[test]
 fn run_test_6_opt() {
-    // run_test_6_maybe_opt(true);
+    run_test_6_maybe_opt(true);
 }
 
 fn run_test_7_maybe_opt(opt: bool) {
@@ -252,7 +252,7 @@ fn run_test_7() {
 
 #[test]
 fn run_test_7_opt() {
-    // run_test_7_maybe_opt(true);
+    run_test_7_maybe_opt(true);
 }
 
 fn run_test_8_maybe_opt(opt: bool) {
@@ -597,3 +597,39 @@ fn cant_redefine_defun_with_defun() {
         assert!(result.is_err());
     }
 }
+
+fn test_collatz_maybe_opt(opt: bool) {
+    let result = run_string_maybe_opt(
+        &indoc! {"
+            (mod (A)
+             (include *standard-cl-22*)
+             (defun-inline odd (X) (logand X 1))
+             (defun collatz (N X)
+              (if (= X 1)
+               N
+               (let ((incN (+ N 1)))
+                (if (odd X)
+                 (collatz incN (+ 1 (* 3 X)))
+                 (collatz incN (/ X 2))
+                )
+               )
+              )
+             )
+             (collatz 0 A)
+            )
+        "}
+        .to_string(),
+        &"(4)".to_string(),
+        opt,
+    )
+    .unwrap();
+    assert_eq!(result.to_string(), "(q . 2)");
+}
+
+fn test_collatz() {
+    test_collatz_maybe_opt(false);
+}
+
+fn test_collatz_opt() {
+    test_collatz_maybe_opt(true);
+}

src/tests/compiler/repl.rs

@@ -139,3 +139,27 @@ fn test_last_of_pwcoin_2() {
         "(q (51 3735928559 1))"
     );
 }
+
+#[test]
+fn test_collatz() {
+    assert_eq!(
+        test_repl_outcome(vec![
+            "(defun-inline odd (X) (logand X 1))",
+            "(defun collatz (N X)",
+            "  (if (= X 1)",
+            "    N",
+            "    (let ((incN (+ N 1)))",
+            "      (if (odd X)",
+            "        (collatz incN (+ 1 (* 3 X)))",
+            "        (collatz incN (/ X 2))",
+            "        )",
+            "      )",
+            "    )",
+            "  )",
+            "(collatz 0 3)"
+        ])
+        .unwrap()
+        .unwrap(),
+        "(q . 7)"
+    );
+}