that test passes now, lets see what happens for the big test

Author: andrew4328

LM23COMMON/typecheck-infer-ctx.lsts

@@ -2,15 +2,15 @@
 let infer-ctx(tctx: TypeContext?, lhs: AST): TypeContext? = (
    match lhs {
       App{ left:Lit{key:c":"}, right:App{ v-t=left:Var{v1=key,vtk=token}, right:AType{tt=tt} } } => (
-         (tctx, tt) = tctx.phi-initialize(tt, lhs);
-         let dt = denormalize(tt) && t0(c"LocalVariable");
-         let nt = tt.normalize;
+         let dt = denormalize(tt.rewrite-type-alias.expand-implied-phi) && t0(c"LocalVariable");
+         (tctx, dt) = tctx.phi-initialize(dt, lhs);
+         let nt = dt.normalize;
          tctx = infer-tctx(tctx.bind(v1, nt, dt, v-t), tt);
       );
       App{ ps=left, right:App{ left:Lit{key:c":"}, right:App{ v-t=left:Var{v2=key,vtk=token}, right:AType{tt=tt} } } } => (
-         (tctx, tt) = tctx.phi-initialize(tt, lhs);
-         let dt = denormalize(tt) && t0(c"LocalVariable");
-         let nt = tt.normalize;
+         let dt = denormalize(tt.rewrite-type-alias.expand-implied-phi) && t0(c"LocalVariable");
+         (tctx, dt) = tctx.phi-initialize(dt, lhs);
+         let nt = dt.normalize;
          tctx = infer-tctx(infer-ctx(tctx.bind(v2, nt, dt, v-t),ps), tt);
       );
       ASTNil{} => ();

LM23COMMON/typecheck-infer-expr.lsts

@@ -102,7 +102,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
       );
       App{asc=left:Var{key:c"as"}, right:App{t=left,right:AType{tt=tt}}} => (
          let original-tt = tt;
-         tt = tt.rewrite-type-alias;
+         tt = tt.rewrite-type-alias.expand-implied-phi;
          add-concrete-type-instance(tt, term);
          (tctx, let new-t) = std-infer-expr(tctx, t, false, used, tt && hint);
          if not(is(t,new-t)) then { t = new-t; term = mk-app(asc, mk-app(t, mk-atype(tt))); };
@@ -246,6 +246,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
          let before-tctx = tctx; # make sure to capture locals as "local" scope
          tctx = infer-ctx(tctx, lhs);
          if not(inner-rhs.is-nil) {
+            return-type = return-type.rewrite-type-alias.expand-implied-phi;
             (tctx, let new-inner-rhs) = std-infer-expr(tctx, inner-rhs, false, Tail(), return-type && t0(c"TailPosition"));
             if not(direct-tctx.is-blob) {
                let return-type-after-alias = return-type.rewrite-type-alias;

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -609,7 +609,7 @@ let lsts-parse-ascript(tokens: List<Token>): Tuple<AST,List<Token>> = (
       tokens = tail(tokens);
       (let tt, tokens) = lsts-parse-type(tokens);
       if tt.is-t(c"L",0) then tt = tt && t0(c"Literal");
-      tt = phi-as-state(tt).expand-implied-phi;
+      tt = phi-as-state(tt);
       match term {
          App{ constructor=left:Lit{}, right:ASTNil{} } => (
             term = mk-app(constructor.ascript(tt), mk-nil());
@@ -1003,7 +1003,7 @@ let lsts-parse-function-signature(fname: CString, tokens: List<Token>, loc: Sour
          had-type = true;
          lsts-parse-expect(c":", tokens); tokens = tail(tokens);
          (arg-type, tokens) = lsts-parse-type(tokens);
-         if fname!=c"phi" then arg-type = phi-as-state(arg-type).expand-implied-phi;
+         if fname!=c"phi" then arg-type = phi-as-state(arg-type);
       };
       if lsts-parse-head(tokens)==c"," { tokens = tail(tokens); } else { lsts-parse-expect(c")", tokens); };
       let arg-binding = if had-type then mk-cons(
@@ -1024,7 +1024,7 @@ let lsts-parse-function-signature(fname: CString, tokens: List<Token>, loc: Sour
        lsts-parse-expect(c":", tokens); tokens = tail(tokens);
        let rtype-rest = lsts-parse-type(tokens);
        out.return-type = rtype-rest.first;
-       if fname!=c"phi" then out.return-type = phi-as-state(out.return-type).expand-implied-phi;
+       if fname!=c"phi" then out.return-type = phi-as-state(out.return-type);
        tokens = rtype-rest.second;
    } else if non-zero(out.args-type) {
        out.return-type = t0(c"Nil");
@@ -2049,7 +2049,7 @@ let lsts-parse-atom-tail(base: AST, tokens: List<Token>): Tuple<AST,List<Token>>
             tokens = type-rest.second;
             base = mk-app(
                Var( c"as", with-location(mk-token("as"),loc) ),
-               mk-cons(base, mk-atype(phi-as-state(type-rest.first).expand-implied-phi))
+               mk-cons(base, mk-atype(phi-as-state(type-rest.first)))
             );
          );
          [Token{key:"["}.. rest] => (

tests/promises/typechecking/phi-on-alias.lsts

@@ -9,3 +9,10 @@ let f(ctx: AContext): Nil = (
 
 # just referencing the aliased List leads to a GC bug
 # because no phi state is inferred for the AContext
+
+# can also be a problem on return values
+
+let g(ctx: AContext): AContext = ctx;
+let h(ctx: AContext): Nil = (
+   h(ctx); ()
+);