Merge pull request #1507 from andrew-johnson-4/gradually-port-macros-to-lsts

Gradually port macros to lsts

Author: andrew-johnson-4

BOOTSTRAP/cli.c

@@ -2,7 +2,7 @@ CC = cc
 CFLAGS = -O3 -march=native -mtune=native -ferror-limit=50
 
 dev: install-production
-	lm t.lsts
+	lm tests/unit/ast-macros.lsts
 	cc tmp.c
 	./a.out
 

Makefile

@@ -3,6 +3,35 @@ typed macro macro::let(lhs: lazy, rhs: lazy): lazy = (
    (fn(lhs) = ()) (rhs)
 );
 
+typed macro macro::set(lhs: lazy, rhs: lazy): lazy = (
+   mov(rhs, lhs)
+);
+
+#typed macro macro::set(base field: macro::lhs-field, rhs: lazy): lazy = (
+#   macro::concat(l"set.", field) (base, rhs)
+#);
+
+#typed macro macro::set(base index: macro::lhs-index, rhs: lazy): lazy = (
+#   $"set[]"( macro::lhs-as-rhs(base), index, rhs )
+#   macro::concat(l"set.", field) (base, rhs)
+#);
+
+#typed macro macro::lhs-as-rhs(v: macro::variable): lazy = (
+#   v
+#);
+
+#typed macro macro::lhs-as-rhs(_: macro::literal<"&">, v: lazy): lazy = (
+#   &v
+#);
+
+#typed macro macro::lhs-as-rhs(base field: macro::lhs-index): lazy = (
+#   macro::concat(l".", field)(base)
+#);
+
+#typed macro macro::lhs-index(base: lazy, field: lazy): lazy = (
+#   base; field
+#);
+
 typed macro macro::for(item: lazy, iter: List<?>, loop: lazy): lazy = (
    let uuid(iter-term) = iter;
    while uuid(iter-term).has-head { match uuid(iter-term) {
@@ -11,3 +40,18 @@ typed macro macro::for(item: lazy, iter: List<?>, loop: lazy): lazy = (
       );
    }}
 );
+
+typed macro macro::for(item: lazy, iter: Vector<?>, loop: lazy): lazy = (
+   let uuid(iter-term) = iter;
+   let uuid(iter-i) = 0_u64;
+   let uuid(iter-length) = uuid(iter-term).length;
+   while uuid(iter-i) < uuid(iter-length) { match uuid(iter-term)[uuid(iter-i)] {
+      item => (
+         loop; uuid(iter-i) = uuid(iter-i) + 1;
+      );
+   }}
+);
+
+typed macro macro::while(cond: lazy, body: lazy): lazy = (
+   $"primitive::while"( body as Nil, into-branch-conditional(cond) )
+);

PLATFORM/C/LIB/common-macros.lsts

@@ -1065,12 +1065,6 @@ let lsts-parse-small-expression(tokens: List<Token>): Tuple<AST,List<Token>> = (
             mk-var(with-location(mk-token("macro::let"),loc)),
             mk-cons(lhs-rest.first, rhs-rest.first)
          );
-         #base = mk-app(
-         #   mk-app(
-         #      mk-var(with-location(mk-token("let"),loc)),
-         #      lhs-rest.first
-         #   ), rhs-rest.first
-         #);
       );
       [Token{key:c"while"}.. rest] => (
          let loc = head(tokens).location; tokens = rest;
@@ -1081,13 +1075,13 @@ let lsts-parse-small-expression(tokens: List<Token>): Tuple<AST,List<Token>> = (
          tokens = rhs-rest.second;
          lsts-parse-expect(c"}", tokens); tokens = tail(tokens);
          base = mk-app(
-            mk-app(
-               Var{ c"while", with-location(mk-token("while"),loc) },
-               c-rest.first
-            ),
-            mk-app(
-               Var{ c"scope", with-location(mk-token("scope"),loc) },
-               rhs-rest.first
+            Var{ c"macro::while", with-location(mk-token("macro::while"),loc) },
+            mk-cons(
+               c-rest.first,
+               mk-app(
+                  Var{ c"scope", with-location(mk-token("scope"),loc) },
+                  rhs-rest.first
+               )
             )
          );         
       );
@@ -1220,11 +1214,8 @@ let lsts-parse-assign(tokens: List<Token>): Tuple<AST,List<Token>> = (
          let rhs-tmp-name = uuid();
          let rhs-tmp = Var{ rhs-tmp-name, with-location(mk-token(rhs-tmp-name),loc) };
          base = mk-app(
-            mk-app(
-               Var{ c"let", with-location(mk-token(c"let"),loc) },
-               rhs-tmp
-            ),
-            rhs-rest.first
+            Var{ c"macro::let", with-location(mk-token(c"macro::let"),loc) },
+            mk-cons( rhs-tmp, rhs-rest.first )
          );
 
          let i = 0_u64;
@@ -1251,11 +1242,8 @@ let lsts-parse-assign(tokens: List<Token>): Tuple<AST,List<Token>> = (
 
                ASTOrIdentId { id=id } => (
                   let x = mk-app(
-                     mk-app(
-                        Var{ c"let", with-location(mk-token("let"),loc) },
-                        id
-                     ),
-                     rexpr
+                     Var{ c"macro::let", with-location(mk-token("macro::let"),loc) },
+                     mk-cons( id, rexpr )
                   );
                   base = mk-cons(base, x);
                );

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -96,7 +96,7 @@ let std-infer-expr(tctx: Maybe<TContext>, term: AST, is-scoped: Bool, used: IsUs
       );
       Glb{key=key, val=val} => (
          let rough-tt = typeof(term);
-         if rough-tt.is-arrow && not(rough-tt.is-open) {
+         if rough-tt.is-arrow && not(rough-tt.is-open) && not(rough-tt.is-t(c"TypedMacro")) {
             (_, let new-val) = std-infer-expr(tctx, val, is-scoped, Used, TAny);
             if not(is(val,new-val)) then {
                let new-term = mk-glb(key,new-val);

SRC/std-infer-expr.lsts

@@ -11,13 +11,5 @@ typed macro ast-macros-test-add(x: I64, y: lazy): lazy = (
 assert( ast-macros-test-add(1_u64, 2_u64) == 3_u64 );
 assert( ast-macros-test-add(2_i64, 3_i64) == 5_i64 );
 
-typed macro macro::for(item: lazy, iter: List<?>, loop: lazy): lazy = (
-   let uuid(iter-term) = iter;
-   while uuid(iter-term).has-head { match uuid(iter-term) {
-      [item.. uuid(tl)] => (
-         loop; uuid(iter-term) = uuid(tl);
-      );
-   }}
-);
-
-$"macro::for"(x, [1, 2], print(x));
+#$"macro::for"(x, [1, 2], print(x));
+#$"macro::for"(x, mk-vector(type(U64)).push(3).push(4), print(x));