Merge pull request #1959 from andrew-johnson-4/lmcommon-typecheck-bounds-fdsuioo

Lmcommon typecheck bounds fdsuioo

Author: andrew4328

BOOTSTRAP/cli.c

@@ -10,9 +10,9 @@ let substitute(ctx: List<(CString,AST)>, v: Token): Token = (
 let substitute(ctx: List<(CString,AST)>, tt: Type): Type = (
    match tt {
       TVar{v=name} => match ctx.lookup(v, mk-eof()) {
-         Lit{tv=key} => t0(tv);
-         Var{tv=key} => t0(tv);
-         AType{tv=tt} => tv;
+         Lit{tv1=key} => t0(tv1);
+         Var{tv2=key} => t0(tv2);
+         AType{tv3=tt} => tv3;
          _ => tt;
       };
       TGround{tag=tag,parameters=parameters} => (

LM23COMMON/typecheck-acontext-substitute.lsts

@@ -1,17 +1,17 @@
 
 let infer-ctx(tctx: TypeContext?, lhs: AST): TypeContext? = (
    match lhs {
-      App{ left:Lit{key:c":"}, right:App{ v-t=left:Var{v=key,vtk=token}, right:AType{tt=tt} } } => (
+      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;
-         tctx = infer-tctx(tctx.bind(v, nt, dt, v-t), tt);
+         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{v=key,vtk=token}, right:AType{tt=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;
-         tctx = infer-tctx(infer-ctx(tctx.bind(v, nt, dt, v-t),ps), tt);
+         tctx = infer-tctx(infer-ctx(tctx.bind(v2, nt, dt, v-t),ps), tt);
       );
       ASTNil{} => ();
    }; tctx

LM23COMMON/typecheck-infer-ctx.lsts

@@ -190,11 +190,11 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             _ => def-i = def-i + 1;
          }};
       );
-      Glb{key=key, val=val} => (
+      Glb{key1=key, val=val} => (
          let rough-tt = typeof-term(term);
          if rough-tt.is-arrow and not(rough-tt.is-open) and not(rough-tt.is-t(c"TypedMacro",0)) {
             let tctx-tctx = tctx.get-or(mk-tctx());
-            tctx-tctx.function-name = key.key;
+            tctx-tctx.function-name = key1.key;
             tctx = Some(tctx-tctx);
             (let inner-tctx, let new-val) = std-infer-expr(tctx, val, is-scoped, Used(), ta);
             match new-val {
@@ -206,16 +206,16 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
                _ => ();
             };
             if not(is(val,new-val))  then {
-               let new-term = mk-glb(key,new-val);
+               let new-term = mk-glb(key1,new-val);
                mark-var-to-def(new-term, term);
                term = new-term;
             };
          };
       );
-      Var{key=key, token=token} => (
-         (tctx, let vt) = typeof-var(term, tctx, key, hint.is-t(c"MustNotFresh",0) or hint.is-t(c"TailPosition",0));
+      Var{key2=key, token=token} => (
+         (tctx, let vt) = typeof-var(term, tctx, key2, hint.is-t(c"MustNotFresh",0) or hint.is-t(c"TailPosition",0));
          vt = tctx.with-phi(vt, term);
-         mark-var-to-def-todo(tctx, key, ta, term);
+         mark-var-to-def-todo(tctx, key2, ta, term);
          # TailPosition LocalVariables don't need to be retained because +1/-1 retain/release cancels itself out
          if not(hint.is-t(c"TailPosition",0) and vt.is-t(c"LocalVariable",0))
          and not(hint.is-t(c"MustNotRetain",0))
@@ -226,13 +226,13 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             tctx = tctx.ascript(term, vt);
          };
       );
-      Lit{key=key, token=token} => (
+      Lit{key3=key, token=token} => (
          if hint.is-t(c"Literal",0) {
             tctx = tctx.ascript(term,hint);
          } else if not(non-zero(typeof-term(term))) {
-            if hint.is-t(c"HashtableEq",2) and hint.is-datatype and key==c"HashtableEqEOF"
+            if hint.is-t(c"HashtableEq",2) and hint.is-datatype and key3==c"HashtableEqEOF"
             then {
-               (tctx, let lit-tt) = tctx.apply-callable(key, t0(c"Nil"), term, hint);
+               (tctx, let lit-tt) = tctx.apply-callable(key3, t0(c"Nil"), term, hint);
                tctx = tctx.ascript(term, lit-tt);
             } else {
                tctx = tctx.ascript(term, t2(c"Arrow",t0(c"Any"),t0(c"Any")));

LM23COMMON/typecheck-infer-expr.lsts

@@ -29,7 +29,6 @@ let release-locals(tctx-before: TypeContext?, tctx-after: TypeContext?, term: AS
          tctx-after = tctx-after.ascript(def, binding-type);
       };
       for nd in needs-release {
-         let phi-id = nd.denormalized.slot(c"Phi::Id",1).l1.simple-tag;
          pid-seen = pid-seen.bind(nd.denormalized.slot(c"Phi::Id",1).l1.simple-tag,true);
          let do-release = mk-cons(
             mk-app(mk-var(c".release"),mk-var(nd.key-or-zero)),
@@ -46,7 +45,6 @@ let release-locals(tctx-before: TypeContext?, tctx-after: TypeContext?, term: AS
       term = mk-cons(term, return-term); tctx-after = tctx-after.ascript(term,return-type);
    };
    for nd in needs-mark-release {
-      let phi-id = nd.denormalized.slot(c"Phi::Id",1).l1.simple-tag;
       pid-seen = pid-seen.bind(nd.denormalized.slot(c"Phi::Id",1).l1.simple-tag,true);
       tctx-after = tctx-after.phi-move(tctx-after.with-phi(nd.denormalized, term), term);
    };

LM23COMMON/typecheck-release-locals.lsts

@@ -73,13 +73,13 @@ let std-try-destructure-macro(tctx: TypeContext?, margs: AST, mtype: Type, mcand
 
 let std-macro-helper-name(tt: Type): CString = (
    match tt {
-      TVar{name=name} => if name.has-prefix(c"macro::") then name else c"";
+      TVar{name1=name} => if name1.has-prefix(c"macro::") then name1 else c"";
       TAnd{conjugate=conjugate} => (
-         let name = c"";
+         let name2 = c"";
          for c in conjugate {
-            if not(non-zero(name)) then name = std-macro-helper-name(c);
+            if not(non-zero(name2)) then name2 = std-macro-helper-name(c);
          };
-         name
+         name2
       );
       _ => c"";
    };

LM23COMMON/typecheck-std-apply-macro-candidates.lsts

@@ -42,11 +42,11 @@ let std-release-after-call(tctx: TypeContext?, function-type: Type, param-types:
          #};
 
          (let tmp-release, tmp-return) = if param-types.is-t(c"MustNotRewrite",0) {
-            let tmp-id = uuid();
-            let tmp-def = mk-var(tmp-id); ascript-force(tmp-def, args-type);
-            let tmp-var2 = mk-var(tmp-id); ascript-force(tmp-var2, args-type);
-            tctx = tctx.bind(tmp-id, ta, args-type, tmp-def);
-            mark-var-to-def-todo(tctx, tmp-id, ta, tmp-var2);
+            let tmp-id1 = uuid();
+            let tmp-def = mk-var(tmp-id1); ascript-force(tmp-def, args-type);
+            let tmp-var2 = mk-var(tmp-id1); ascript-force(tmp-var2, args-type);
+            tctx = tctx.bind(tmp-id1, ta, args-type, tmp-def);
+            mark-var-to-def-todo(tctx, tmp-id1, ta, tmp-var2);
             let tmp-nil = mk-nil(); ascript-force(tmp-nil, t0(c"Nil"));
             let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, t0(c"Nil"));
             let bind = mk-app(declare, args); ascript-force(bind, t0(c"Nil"));
@@ -57,13 +57,13 @@ let std-release-after-call(tctx: TypeContext?, function-type: Type, param-types:
 
             (tmp-var2, args)
          } else {
-            let tmp-id = uuid();
-            let tmp-def = mk-var(tmp-id); ascript-force(tmp-def, args-type);
-            let tmp-var2 = mk-var(tmp-id); ascript-force(tmp-var2, args-type);
-            let tmp-direct = mk-var(tmp-id); ascript-force(tmp-direct, typeof-term(args));
-            tctx = tctx.bind(tmp-id, ta, args-type, tmp-def);
-            mark-var-to-def-todo(tctx, tmp-id, ta, tmp-var2);
-            mark-var-to-def-todo(tctx, tmp-id, ta, tmp-direct);
+            let tmp-id2 = uuid();
+            let tmp-def = mk-var(tmp-id2); ascript-force(tmp-def, args-type);
+            let tmp-var2 = mk-var(tmp-id2); ascript-force(tmp-var2, args-type);
+            let tmp-direct = mk-var(tmp-id2); ascript-force(tmp-direct, typeof-term(args));
+            tctx = tctx.bind(tmp-id2, ta, args-type, tmp-def);
+            mark-var-to-def-todo(tctx, tmp-id2, ta, tmp-var2);
+            mark-var-to-def-todo(tctx, tmp-id2, ta, tmp-direct);
             let tmp-nil = mk-nil(); ascript-force(tmp-nil, t0(c"Nil"));
             let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, t0(c"Nil"));
             let bind = mk-app(declare, args); ascript-force(bind, t0(c"Nil"));

LM23COMMON/typecheck-std-maybe-release-after-call.lsts

@@ -2,7 +2,7 @@ CC = clang
 CFLAGS = -w -O2 -march=native -mtune=native
 
 dev: install-production
-	lm tests/promises/list/comparison.lsts
+	lm tests/promises/lm-typecheck/direct-inference.lsts
 	gcc tmp.c
 	./a.out