passing typecheck

Author: andrew-johnson-4

PLATFORM/C/LIB/common-macros.lsts

@@ -7,9 +7,9 @@ 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 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 )

SRC/std-apply-macro-candidates.lsts

@@ -14,7 +14,6 @@ let std-apply-macro-candidates(tctx: TContext?, mname: CString, margs: AST, cand
          if mctx.is-some then t = with-location(substitute(mctx.get-or-panic, mrhs), margs.location);
       }
    };
-   if not(non-zero(t)) then fail("Macro Application failed match during destructuring: \{mname}\n");
    (tctx, t) = std-infer-expr(tctx, t, false, Used, TAny);
    (tctx, t)
 );
@@ -44,8 +43,10 @@ let std-try-destructure-macro(tctx: TContext?, margs: AST, mtype: Type, mcandida
                App{left:Lit{key:c":"}, right:App{mstruct=left, right:AType{tt=tt}}} => (
                   if non-zero(std-macro-helper-name(tt))
                   then {
-                     (tctx, let helped) = std-apply-macro(tctx, std-macro-helper-name(tt), margs);
-                     (tctx, std-direct-destructure-macro(helped, mstruct))
+                     (tctx, let helped) = std-apply-macro-weak(tctx, std-macro-helper-name(tt), margs);
+                     if non-zero(helped)
+                     then (tctx, std-direct-destructure-macro(helped, mstruct))
+                     else (tctx, no)
                   } else (tctx, std-direct-destructure-macro(margs, mstruct))
                );
                _ => (tctx, no);

SRC/std-apply-macro.lsts

@@ -7,7 +7,10 @@ let std-apply-macro(tctx: Maybe<TContext>, t: AST): (TContext?, AST) = (
    }
 );
 
-let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContext?, AST) = (
+let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContext?, AST) = std-apply-macro(tctx, mname, margs, true);
+let std-apply-macro-weak(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContext?, AST) = std-apply-macro(tctx, mname, margs, false);
+
+let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: Bool): (TContext?, AST) = (
    let row = index-macro-table.lookup(mname, [] :: List<(Type,Type,AST)>);
    let peep-holes = TAny;
    let peeped = TAny;
@@ -42,7 +45,9 @@ let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContex
          candidates = [(mtype,mterm)];
       }
    };
-   std-apply-macro-candidates(tctx, mname, margs, candidates);
+   (tctx, let result) = std-apply-macro-candidates(tctx, mname, margs, candidates);
+   if strong && not(non-zero(result)) then exit-error("Failed to Apply Macro: \{mname}", margs);
+   (tctx, result)
 );
 
 let std-infer-peeped-arguments(tctx: Maybe<TContext>, t: AST, peep: Type): (Type, AST) = (

SRC/std-direct-destructure-macro.lsts

@@ -3,10 +3,6 @@ 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{lrest=left,val=right}, second:App{rrest=left,right:Var{key=key}} } => (
-         let rest = std-direct-destructure-macro(lrest, rrest);
-         if rest.is-some then Some{cons((key,val), rest.get-or-panic)} else no;
-      );
-      _ => (fail("Unexpected Pattern std-direct-destructure-macro:\nargs: \{margs}\nlhs: \{mstruct}\n"); no);
+      _ => no;
    }
 );