green

Author: andrew-johnson-4

PLATFORM/C/LIB/common-macros.lsts

@@ -89,5 +89,5 @@ typed macro macro::match-pats(term: lazy, lhs rhs remainder: macro::match-case):
 );
 
 typed macro macro::match-arm(v: macro::variable, term: lazy): lazy = (
-   let v = term; true
+   (let v = term; true)
 );

PLUGINS/BACKEND/C/cc-blob.lm

@@ -4,7 +4,7 @@ cc-blob := λ(: caller-ctx FContext)(: function-name String)(: args AST)(: offse
    # caller context is provided but not propagated
    (let r (mk-fragment()))
 
-   (let f (find-global-callable( function-name (typeof args) )))
+   (let f (find-global-callable( function-name (typeof args) args )))
    (match f (
       ()
       ( (Glb( _ (Abs( lhs rhs tlt )) )) (
@@ -21,7 +21,7 @@ cc-blob := λ(: caller-ctx FContext)(: function-name String)(: args AST)(: offse
 
 cc-blob := λ(: callee-ctx FContext)(: function-name String)(: args-tt Type)(: offset I64)(: blame AST). (: (
    (let r (mk-fragment()))
-   (let f (find-global-callable( function-name args-tt )))
+   (let f (find-global-callable( function-name args-tt blame )))
    (match f (
       ()
       ( (Glb( _ (Abs( lhs rhs tlt )) )) (

PLUGINS/BACKEND/C/compile-expr.lm

@@ -4,7 +4,7 @@ compile-expr := λ(: ctx FContext)(: term AST)(: stack-offset I64)(: used IsUsed
    (match used (
       ()
       ( Return (
-         (let fterm (find-global-callable( 'cdecl::return_s (typeof term) )))
+         (let fterm (find-global-callable( 'cdecl::return_s (typeof term) term )))
          (set e (std-c-compile-call( ctx 'cdecl::return_s fterm term )))
       ))
       ( _ (

PLUGINS/BACKEND/C/std-c-compile-call.lsts

@@ -1,6 +1,6 @@
 
 let std-c-compile-call(ctx: FContext, fname: CString, fterm: AST, args: AST): Fragment = (
-   fterm = find-global-callable(fname, typeof(args));
+   fterm = find-global-callable(fname, typeof(args), args);
    if not(non-zero(fterm)) then fail("std-c-compile-call Function was null: \{fterm}\nArguments: \{typeof(args)}\n");
    if typeof(fterm).is-t(c"Blob") {
       let r = mk-fragment();
@@ -21,7 +21,7 @@ let std-c-compile-call(ctx: FContext, fname: CString, fterm: AST, args: AST): Fr
       let inner-ctx = mk-fctx().bind(c"ictx", t1(c"ImplicitContext"), ictx)
                                .bind(c"args", typeof(args), push-args);
       let r = mk-fragment();
-      match find-global-callable(c"primitive::call", t3(c"Cons",t1(c"ImplicitContext"),typeof(args))) {
+      match find-global-callable(c"primitive::call", t3(c"Cons",t1(c"ImplicitContext"),typeof(args)), args) {
          Glb{val:Abs{lhs=lhs, rhs=rhs}} => (
             r = blob-render(inner-ctx, rhs, r, 0);
             r.context = close(ctx);

PLUGINS/BACKEND/C/std-c-compile-expr.lsts

@@ -66,7 +66,7 @@ let std-c-compile-expr(ctx: FContext, t: AST, is-stmt: Bool): Fragment = (
                guid = uuid();
                compile-smart-string-index = compile-smart-string-index.bind(val,guid);
                let lit = mk-lit(val); ascript-normal(lit, t1(c"String"));
-               let intern-ss = std-c-compile-call(ctx, c"intern", find-global-callable(c"intern", t1(c"String")), lit);
+               let intern-ss = std-c-compile-call(ctx, c"intern", find-global-callable(c"intern", t1(c"String"), t), lit);
                assemble-header-section = assemble-header-section +
                mangle-c-type(typeof(t)) + SAtom{c" "} + SAtom{guid} + SAtom{c";\n"};
                assemble-string-initializer-section = assemble-string-initializer-section +

SRC/find-global-callable.lsts

@@ -1,5 +1,5 @@
 
-let find-global-callable(fname: CString, arg-types: Type): AST = (
+let find-global-callable(fname: CString, arg-types: Type, blame: AST): AST = (
    arg-types = denormalize-strong(arg-types);
    fname = find-alias(fname, arg-types);
    let match-set = mk-vector(type((Type,AST)), 16);
@@ -24,7 +24,7 @@ let find-global-callable(fname: CString, arg-types: Type): AST = (
       };
       exit(1);
    };
-   if not(non-zero(result)) then fail("Unable to find appropriate global callable: \{fname} \{arg-types}\n");
+   if not(non-zero(result)) then fail("Unable to find appropriate global callable: \{fname} \{arg-types}\nAt: \{blame.location}\n\{blame}\n");
    result
 );
 

SRC/std-apply-macro-candidates.lsts

@@ -46,15 +46,15 @@ let std-try-destructure-macro(tctx: TContext?, margs: AST, mtype: Type, mcandida
                      match margs {
                         App{left:Var{maybe-helper=key}, helper-args=right} => (
                            if macro-helper==maybe-helper {
-                              (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, helper-args);
+                              (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, helper-args, Used);
                               if non-zero(helped)
                               then (tctx, std-direct-destructure-macro(helped, mstruct))
                               else (tctx, no)
                            } else (tctx, no)
                         );
                         _ => (
                            if macro-helper==c"macro::variable" {
-                              (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, margs);
+                              (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, margs, Used);
                               if non-zero(helped)
                               then (tctx, std-direct-destructure-macro(helped, mstruct))
                               else (tctx, no)

SRC/std-apply-macro.lsts

@@ -1,14 +1,14 @@
 
-let std-apply-macro(tctx: Maybe<TContext>, t: AST): (TContext?, AST) = (
+let std-apply-macro(tctx: Maybe<TContext>, t: AST, used: IsUsed): (TContext?, AST) = (
    match t {
       App{left:Var{mname=key}, margs=right} => (
-         std-apply-macro(tctx, mname, margs);
+         std-apply-macro(tctx, mname, margs, used);
       );
    }
 );
 
-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, used: IsUsed): (TContext?, AST) = std-apply-macro(tctx, mname, margs, used, true);
+let std-apply-macro-weak(tctx: Maybe<TContext>, mname: CString, margs: AST, used: IsUsed): (TContext?, AST) = std-apply-macro(tctx, mname, margs, used, false);
 
 let std-apply-macro-concat(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContext?, AST) = (
    match margs {
@@ -28,7 +28,7 @@ let std-apply-macro-location(tctx: Maybe<TContext>, mname: CString, margs: AST):
    (tctx, mk-lit(to-smart-string(margs.location)).ascript(t1(c"SmartString")))
 );
 
-let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: Bool): (TContext?, AST) = (
+let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, used: IsUsed, strong: Bool): (TContext?, AST) = (
    let result = ASTEOF;
    if mname==c"macro::concat" then (tctx, result) = std-apply-macro-concat(tctx, mname, margs)
    else if mname==c"macro::location" then (tctx, result) = std-apply-macro-location(tctx, mname, margs)
@@ -71,7 +71,7 @@ let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: B
       (tctx, result) = std-apply-macro-candidates(tctx, mname, margs, candidates);
    };
    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);
+   if strong then (tctx, result) = std-infer-expr(tctx, result, false, used, TAny);
    (tctx, result)
 );
 

SRC/std-infer-expr.lsts

@@ -66,13 +66,13 @@ let std-infer-expr(tctx: Maybe<TContext>, term: AST, is-scoped: Bool, used: IsUs
       );
       App{left:App{ left:App{ ifv=left:Var{key:c"if"}, cond=right }, t=right }, f=right} => (
          if is-scoped {
-            (let tctx-inner, let new-cond) = std-infer-expr(tctx, cond, false, Used, TAny);
+            (let tctx-inner, let new-cond) = std-infer-expr(tctx, cond, false, Tail, TAny);
             (_, let new-t) = std-infer-expr(tctx-inner, t, false, Tail, TAny);
             (_, let new-f) = std-infer-expr(tctx, f, false, Tail, TAny);
             if not(is(cond,new-cond)) || not(is(t,new-t)) || not(is(f,new-f))
             then { cond = new-cond; t = new-t; f = new-f; term = mk-app(mk-app(mk-app(ifv,new-cond),new-t),new-f) };
          } else {
-            (tctx, let new-cond) = std-infer-expr(tctx, cond, false, Used, TAny);
+            (tctx, let new-cond) = std-infer-expr(tctx, cond, false, Tail, TAny);
             (let tctx-t, let new-t) = std-infer-expr(tctx, t, false, Tail, TAny);
             (_, let new-f) = std-infer-expr(tctx, f, false, Tail, TAny);
             tctx = tctx-t;
@@ -160,7 +160,7 @@ let std-infer-expr(tctx: Maybe<TContext>, term: AST, is-scoped: Bool, used: IsUs
             }};
 
             if index-macro-table.has(var-name-if-var(l)) {
-               (tctx, term) = std-apply-macro(tctx, term);
+               (tctx, term) = std-apply-macro(tctx, term, used);
                is-macro = true;
             } else {
                (tctx, let new-l) = std-infer-expr(tctx, l, false, used, TAny);

SRC/typeof-var-raw.lm

@@ -69,7 +69,7 @@ defof-var := λ(: sloc AST)(: tctx Maybe<TContext>)(: vname String)(: tt Type).
       (if (non-zero found) () (
          (if (.is-arrow kt) (
             (if (non-zero tt) (
-               (set found (find-global-callable( vname tt )))
+               (set found (find-global-callable( vname tt sloc )))
             ) (set found t))
          ) (
             (set found t)