retain / release divergence fixed, but not counting yet

Author: andrew4328

Makefile

@@ -8,13 +8,9 @@ LSTSFLAGS = MALLOC_CHECK_=3
 # recommendation: ulimit -s unlimited
 
 dev: install-production
-	#lm --v3 tests/promises/meta/generic-retain-release.lsts > out.txt
-	lm --v3 tests/promises/meta/fields-of.lsts
+	lm --v3 tests/promises/meta/generic-retain-release.lsts > out.txt
 	gcc tmp.c
-	./a.out
-	lm --v3 tests/promises/meta/cases-of.lsts
-	gcc tmp.c
-	./a.out
+	#./a.out
 
 build: compile-production
 	time env $(LSTSFLAGS) ./production --v3 -o deploy1.c SRC/index.lsts

PLUGINS/BACKEND/C/std-c-compile-expr.lsts

@@ -231,23 +231,6 @@ let std-c-compile-expr(ctx: FContext, t: AST, is-stmt: Bool): Fragment = (
       App{ is-cons=is-cons, left=left, right=right } => (
           if not(is-cons) and typeof-term(left).is-arrow {
              match left {
-                Var{fname1=key:c"<:"} => (
-                   match right {
-                      App{ lt=left, rt=right } => (
-                         let lt-tt = typeof-term(lt);
-                         let rt-tt = typeof-term(rt);
-                         if lt-tt.is-t(c"Type",1) and rt-tt.is-t(c"Type",1)
-                         then (
-                            let lt-val = denormalize(lt-tt.slot(c"Type",1).l1);
-                            let rt-val = denormalize(rt-tt.slot(c"Type",1).l1);
-                            if can-unify( rt-val, lt-val )
-                            then mk-expression(c"1")
-                            else mk-expression(c"0")
-                         ) else std-c-compile-call(ctx, fname1, right);
-                      );
-                      _ => std-c-compile-call(ctx, fname1, right);
-                   }
-                );
                 Var{fname2=key:c".into"} => (
                    match right {
                       App{ lt=left, rt=right } => (

SRC/typecheck-infer-expr.lsts

@@ -190,9 +190,11 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
       App{left:App{ left:App{ ifv=left:Var{key:c"if"}, cond=right }, t=right }, f=right} => (
          let short-circuit = ASTEOF;
          match cond {
-            App{ left:Var{key:c"<:"}, right:App{left:AType{lt=tt},right:AType{rt=tt}} } => (
-               lt = denormalize-strong(lt.slot(c"Type",1).l1);
-               rt = denormalize-strong(rt.slot(c"Type",1).l1);
+            App{ left:Var{key:c"<:"}, right:App{short-left=left, short-right=right} } => (
+               (tctx, short-left) = std-infer-expr(tctx, short-left, false, Used, ta);
+               (tctx, short-right) = std-infer-expr(tctx, short-right, false, Used, ta);
+               let lt = denormalize-strong(typeof-term(short-left).slot(c"Type",1).l1);
+               let rt = denormalize-strong(typeof-term(short-right).slot(c"Type",1).l1);
                if non-zero(lt) and non-zero(rt) {
                   if can-unify(rt, lt) {
                      (tctx, short-circuit) = std-infer-expr(tctx, t, false, Tail, ta);

lib/core/phi.lsts

@@ -60,4 +60,5 @@ let .release(x: xt): Nil = (
          };
       };
    };
+   mark-as-released(x);
 );