macro application succeeds

Author: andrew-johnson-4

PLATFORM/C/LIB/common-macros.lsts

@@ -32,11 +32,15 @@ typed macro macro::lhs-field(base: lazy, field: lazy): lazy = (
 );
 
 typed macro macro::lhs-as-rhs(base field: macro::lhs-index): lazy = (
-   macro::concat(l".", field)(base)
+   $"macro::concat"(l".", field)(base)
 );
 
-typed macro macro::lhs-index(base: lazy, field: lazy): lazy = (
-   base; field
+typed macro macro::lhs-index(base: lazy, index: lazy): lazy = (
+   base; index
+);
+
+typed macro macro::lhs-index(base field: macro::lhs-field, index: lazy): lazy = (
+   $"macro::concat"($".", field); index
 );
 
 typed macro macro::for(item: lazy, iter: List<?>, loop: lazy): lazy = (

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -35,7 +35,7 @@ let lsts-parse-identifier(tokens: List<Token>): Tuple<CString, List<Token>> = (
    if lsts-parse-head(tokens)==c"." { name = c"."; tokens = tail(tokens); };
    lsts-parse-expect(c"Identifier", lsts-is-ident-head(lsts-parse-head(tokens)), tokens);
    name = name + lsts-unwrap-identifier(lsts-parse-head(tokens)); tokens = tail(tokens);
-   while lsts-parse-head(tokens)==c":" && lsts-parse-head(tail(tokens))==c":" {
+   while lsts-parse-head(tokens)==c":" && lsts-parse-head(tail(tokens))==c":" && lsts-is-ident-head(lsts-parse-head(tail(tail(tokens)))) {
       name = name + c"::"; tokens = tail(tokens); tokens = tail(tokens);
       lsts-parse-expect(c"Identifier", lsts-is-ident-head(lsts-parse-head(tokens)), tokens);
       name = name + lsts-unwrap-identifier(lsts-parse-head(tokens)); tokens = tail(tokens);
@@ -525,10 +525,14 @@ let lsts-make-maybe-var(tokens: List<Token>): Tuple<AST,List<Token>> = (
       lsts-parse-lit(tokens)
    } else {
       if not(non-zero(tokens)) { lsts-parse-expect(c"Identifier", tokens); };
-      let t = head(tokens);
-      let base = Var { lsts-unwrap-identifier(t.key), lsts-unwrap-identifier(t) };
-      if lsts-is-lit(t.key) { base = lsts-make-lit(t); };
-      tokens = tail(tokens);
+      let base = ASTEOF;
+      if lsts-is-lit(head(tokens).key) {
+         base = lsts-make-lit(head(tokens));
+         tokens = tail(tokens);
+      } else {
+         (let var-name, tokens) = lsts-parse-identifier(tokens);
+         base = mk-var(var-name);
+      };
       Tuple { base, tokens }
    }
 );

SRC/std-apply-macro.lsts

@@ -60,6 +60,7 @@ let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: B
    };
    if strong && not(non-zero(result)) then exit-error("Failed to Apply Macro: \{mname}\nArgs: \{margs}\n", margs);
    if strong then (tctx, result) = std-infer-expr(tctx, result, false, Used, TAny);
+   print("Applied \{mname} \{margs}\nResult \{result}\n");
    (tctx, result)
 );
 

SRC/std-direct-destructure-macro.lsts

@@ -3,10 +3,7 @@ let std-direct-destructure-macro(margs: AST, mstruct: AST): AContext? = (
    let no = None :: AContext?;
    match (margs, mstruct) {
       Tuple{ val=first, second:Var{key=key} } => Some{[(key,val)]};
-      Tuple{
-         first:App{is-cons:1_u8, lrest=left, val=right },
-         second:App{is-cons:1_u8, rrest=left, right:Var{key=key} }
-      } => (
+      Tuple{ first:App{lrest=left, val=right}, second:App{rrest=left, right:Var{key=key}} } => (
          let ctx = std-direct-destructure-macro(lrest, rrest);
          if ctx.is-some then Some{cons((key,val), ctx.get-or-panic)} else no;
       );