merge fix

Author: disconcision

src/haz3lcore/projectors/implementations/HTMLProj.re

@@ -251,7 +251,8 @@ module M: Projector = {
       Node.div(
         ~attrs=[
           Attr.classes(["html-proj-resize-handle"]),
-          Attr.on_pointerdown((evt: Js_of_ocaml.Js.t(Js_of_ocaml.Dom_html.pointerEvent)) => {
+          Attr.on_pointerdown(
+            (evt: Js_of_ocaml.Js.t(Js_of_ocaml.Dom_html.pointerEvent)) => {
             resize_cols := model.ui.cols;
             resize_rows := model.ui.rows;
             let target =
@@ -271,17 +272,24 @@ module M: Projector = {
           Attr.on_mousemove(evt => {
             switch (wrapper_ref^) {
             | Some(wrapper) =>
-              let container = Js_of_ocaml.Js.Unsafe.coerce(wrapper)##.parentNode;
+              let container =
+                Js_of_ocaml.Js.Unsafe.coerce(wrapper)##.parentNode;
               let rect = container##getBoundingClientRect();
               let left: float = rect##.left;
               let top: float = rect##.top;
               let e = Js_of_ocaml.Js.Unsafe.coerce(evt);
               let client_x: float = float_of_int(e##.clientX);
               let client_y: float = float_of_int(e##.clientY);
               let new_cols =
-                max(8, int_of_float(floor((client_x -. left) /. px_per_col^)));
+                max(
+                  8,
+                  int_of_float(floor((client_x -. left) /. px_per_col^)),
+                );
               let new_rows =
-                max(3, int_of_float(floor((client_y -. top) /. px_per_row^)));
+                max(
+                  3,
+                  int_of_float(floor((client_y -. top) /. px_per_row^)),
+                );
               if (new_cols != resize_cols^ || new_rows != resize_rows^) {
                 resize_cols := new_cols;
                 resize_rows := new_rows;
@@ -290,9 +298,10 @@ module M: Projector = {
                 Effect.Ignore;
               };
             | None => Effect.Ignore
-            };
+            }
           }),
-          Attr.on_pointerup((evt: Js_of_ocaml.Js.t(Js_of_ocaml.Dom_html.pointerEvent)) => {
+          Attr.on_pointerup(
+            (evt: Js_of_ocaml.Js.t(Js_of_ocaml.Dom_html.pointerEvent)) => {
             let target =
               evt##.currentTarget
               |> Js_of_ocaml.Js.Opt.get(_, _ => failwith("no target"));

src/language/dynamics/transition/Ascriptions.re

@@ -52,11 +52,10 @@ let rec transition = (~recursive=false, d: DHExp.t): option(DHExp.t) => {
        The ORIGINAL compact type `t` is preserved in newly created Asc nodes. */
     let t_resolved = Typ.weak_head_normalize(ctx, t);
     switch (DHExp.term_of(e), Typ.term_of(Typ.unroll(t_resolved))) {
-    | (Asc(e, t'), t)
+    | (Asc(e, t'), _)
         // This is only necessary because sometimes we add two ascriptions and aren't marking it as a non-value
-        when
-          Typ.is_consistent(ctx, Typ.unroll(t |> Typ.temp), Typ.unroll(t')) =>
-      switch (Typ.meet(ctx, Typ.unroll(t |> Typ.temp), Typ.unroll(t'))) {
+        when Typ.is_consistent(ctx, Typ.unroll(t), Typ.unroll(t')) =>
+      switch (Typ.meet(ctx, Typ.unroll(t), Typ.unroll(t'))) {
       | Some(t) => Some(recur(Asc(e, t) |> DHExp.fresh))
       | None => None //TODO  This is an impossible case since we checked consistency
       }
@@ -152,26 +151,26 @@ let rec transition = (~recursive=false, d: DHExp.t): option(DHExp.t) => {
           |> DHExp.fresh,
         ),
       );
-    | (If(cond, e1, e2), t) =>
+    | (If(cond, e1, e2), _) =>
       Some(
         IdTagged.fast_copy(
           DHExp.rep_id(e),
           If(
             recur(cond),
-            recur(Asc(e1, t |> Typ.temp) |> DHExp.fresh),
-            recur(Asc(e2, t |> Typ.temp) |> DHExp.fresh),
+            recur(Asc(e1, t) |> DHExp.fresh),
+            recur(Asc(e2, t) |> DHExp.fresh),
           )
           |> DHExp.fresh,
         ),
       )
-    | (Match(scrut, rules), t) =>
+    | (Match(scrut, rules), _) =>
       Some(
         IdTagged.fast_copy(
           DHExp.rep_id(e),
           Match(
             scrut,
             List.map(
-              ((p, body)) => (p, Asc(body, t |> Typ.temp) |> DHExp.fresh),
+              ((p, body)) => (p, Asc(body, t) |> DHExp.fresh),
               rules,
             ),
           )

test/evaluator/Test_Evaluator_Sum_Types.re

@@ -28,25 +28,47 @@ let tests = (
       )
     }),
     test_case(
-      "Constructors can pass through consistent ascriptions", `Quick, () => {
-      evaluation_test(
-        {|A : (+A +B) : (+A + ?)|},
-        constructor(
-          "A",
-          Some(
+      "Constructors can pass through consistent ascriptions",
+      `Quick,
+      () => {
+        evaluation_test(
+          {|A : (+A +B) : (+A + ?)|},
+          constructor(
+            "A",
             Some(
-              Typ.(
-                sum([
-                  Variant("A", ConstructorMap.empty_variant_ann, None),
-                  Variant("B", ConstructorMap.empty_variant_ann, None),
-                ])
+              Some(
+                Typ.(
+                  sum([
+                    Variant("A", ConstructorMap.empty_variant_ann, None),
+                    Variant("B", ConstructorMap.empty_variant_ann, None),
+                  ])
+                ),
               ),
             ),
           ),
-        ),
-        elaborate(parse_exp({|A : (+A +B) : (+A + ?)|})),
-      )
-    }),
+          elaborate(parse_exp({|A : (+A +B) : (+A + ?)|})),
+        );
+        evaluation_test(
+          "Ascriptions don't do unnecessary unrolling",
+          asc(
+            empty_hole(),
+            Typ.rec_(
+              TPat.var("X"),
+              Typ.sum([
+                Variant(
+                  "A",
+                  ConstructorMap.empty_variant_ann,
+                  Some(Typ.var("X")),
+                ),
+              ]),
+            ),
+          ),
+          elaborate(
+            parse_exp("(if true then ? else ?) : (rec X -> + A(X))"),
+          ),
+        );
+      },
+    ),
     test_case(
       "Constructors don't pass through inconsistent ascriptions", `Quick, () => {
       evaluation_test(