#(do #(values $...))

#(do #(values $1))

local function _1_()
  local function _2_(_2410)
    return _2410
  end
  return _2_
end
return _1_

(macro wont-output-body []
  ;; let also fails to output
  (local body [`(do (+ 1 1) (values 1))
               `(do (+ 2 2) (values 2))])
  `(fn []
     ,body
     (values :val)))

(macro will-output-body []
  (local body [`(do (+ 1 1) (values 1))
               `(do (+ 2 2) (values 2))])
  `(fn []
     nil ;; can be any expression
     ,body
     ;; (do ,body) also works
     (values :val)))

(comment the following WONT output body statements)
(wont-output-body)

(comment the following WILL output body statements)
(will-output-body)

(macro just-body []
  (local body [`(do (+ 1 1) (values 1))
               `(do (+ 2 2) (values 2))])
  body)

(comment otherwise this normally works)
(just-body)

--[[ the following WONT output body statements ]]
local function _1_()
  return "val"
end
--[[ the following WILL output body statements ]]
local function _2_()
  local _3_
  do
    do local _ = (1 + 1) end
    _3_ = 1
  end
  local function _4_()
    do local _ = (2 + 2) end
    return 2
  end
  do local _ = {_3_, _4_()} end
  return "val"
end
--[[ otherwise this normally works ]]
local _5_
do
  do local _ = (1 + 1) end
  _5_ = 1
end
local function _6_(...)
  do local _ = (2 + 2) end
  return 2
end
return {_5_, _6_(...)}

(local var 10)
(match x
  ^var true
  _ false)

(match [a b] &scoped ;; &nolocals?
  [1 2] 3)

(match &less [a b]
  [1 2] 3)

diff --git a/src/fennel/macros.fnl b/src/fennel/macros.fnl
index f2b7980..12d9c99 100644
--- a/src/fennel/macros.fnl
+++ b/src/fennel/macros.fnl
@@ -390,18 +390,18 @@ Example:
 
 ;;; Pattern matching
 
-(fn match-values [vals pattern unifications match-pattern]
+(fn match-values [vals pattern unifications match-pattern opts]
   (let [condition `(and)
         bindings []]
     (each [i pat (ipairs pattern)]
       (let [(subcondition subbindings) (match-pattern [(. vals i)] pat
-                                                      unifications)]
+                                                      unifications opts)]
         (table.insert condition subcondition)
         (each [_ b (ipairs subbindings)]
           (table.insert bindings b))))
     (values condition bindings)))
 
-(fn match-table [val pattern unifications match-pattern]
+(fn match-table [val pattern unifications match-pattern opts]
   (let [condition `(and (= (_G.type ,val) :table))
         bindings []]
     (each [k pat (pairs pattern)]
@@ -409,7 +409,7 @@ Example:
           (let [rest-pat (. pattern (+ k 1))
                 rest-val `(select ,k ((or table.unpack _G.unpack) ,val))
                 subcondition (match-table `(pick-values 1 ,rest-val)
-                                          rest-pat unifications match-pattern)]
+                                          rest-pat unifications match-pattern opts)]
             (if (not (sym? rest-pat))
                 (table.insert condition subcondition))
             (assert (= nil (. pattern (+ k 2)))
@@ -431,13 +431,13 @@ Example:
                                            (not= `& (. pattern (- k 1)))))
           (let [subval `(. ,val ,k)
                 (subcondition subbindings) (match-pattern [subval] pat
-                                                          unifications)]
+                                                          unifications opts)]
             (table.insert condition subcondition)
             (each [_ b (ipairs subbindings)]
               (table.insert bindings b)))))
     (values condition bindings)))
 
-(fn match-pattern [vals pattern unifications]
+(fn match-pattern [vals pattern unifications opts]
   "Take the AST of values and a single pattern and returns a condition
 to determine if it matches as well as a list of bindings to
 introduce for the duration of the body if it does match."
@@ -445,10 +445,11 @@ introduce for the duration of the body if it does match."
   ;; know we're either in a multi-valued clause (in which case we know the #
   ;; of vals) or we're not, in which case we only care about the first one.
   (let [[val] vals]
-    (if (or (and (sym? pattern) ; unification with outer locals (or nil)
-                 (not= "_" (tostring pattern)) ; never unify _
-                 (or (in-scope? pattern) (= :nil (tostring pattern))))
-            (and (multi-sym? pattern) (in-scope? (. (multi-sym? pattern) 1))))
+    (if (and (not (?. opts :matchless?))
+             (or (and (sym? pattern) ; unification with outer locals (or nil)
+                      (not= "_" (tostring pattern)) ; never unify _
+                      (or (in-scope? pattern) (= :nil (tostring pattern))))
+                 (and (multi-sym? pattern) (in-scope? (. (multi-sym? pattern) 1)))))
         (values `(= ,val ,pattern) [])
         ;; unify a local we've seen already
         (and (sym? pattern) (. unifications (tostring pattern)))
@@ -462,21 +463,21 @@ introduce for the duration of the body if it does match."
         ;; guard clause
         (and (list? pattern) (= (. pattern 2) `?))
         (let [(pcondition bindings) (match-pattern vals (. pattern 1)
-                                                   unifications)
+                                                   unifications opts)
               condition `(and ,(unpack pattern 3))]
           (values `(and ,pcondition
                         (let ,bindings
                           ,condition)) bindings))
         ;; multi-valued patterns (represented as lists)
         (list? pattern)
-        (match-values vals pattern unifications match-pattern)
+        (match-values vals pattern unifications match-pattern opts)
         ;; table patterns
         (= (type pattern) :table)
-        (match-table val pattern unifications match-pattern)
+        (match-table val pattern unifications match-pattern opts)
         ;; literal value
         (values `(= ,val ,pattern) []))))
 
-(fn match-condition [vals clauses]
+(fn match-condition [vals clauses opts]
   "Construct the actual `if` AST for the given match values and clauses."
   (if (not= 0 (% (length clauses) 2)) ; treat odd final clause as default
       (table.insert clauses (length clauses) (sym "_")))
@@ -484,7 +485,7 @@ introduce for the duration of the body if it does match."
     (for [i 1 (length clauses) 2]
       (let [pattern (. clauses i)
             body (. clauses (+ i 1))
-            (condition bindings) (match-pattern vals pattern {})]
+            (condition bindings) (match-pattern vals pattern {} opts)]
         (table.insert out condition)
         (table.insert out `(let ,bindings
                              ,body))))
@@ -513,6 +514,12 @@ introduce for the duration of the body if it does match."
     ;; many values as we ever match against in the clauses.
     (list `let [vals val] (match-condition vals clauses))))
 
+(fn matchless* [val ...]
+  ;; identical to match* but for match-condition options
+  (let [clauses [...]
+        vals (match-val-syms clauses)]
+    (list `let [vals val] (match-condition vals clauses {:matchless? true}))))
+
 ;; Construction of old match syntax from new syntax
 
 (fn partition-2 [seq]
@@ -636,4 +643,5 @@ returned as the value of the entire expression."
  :macrodebug macrodebug*
  :import-macros import-macros*
  :match match-where
+ :matchless matchless*
  :match-try match-try*}
diff --git a/test/macro.fnl b/test/macro.fnl
index 51c193c..7cb47e1 100644
--- a/test/macro.fnl
+++ b/test/macro.fnl
@@ -239,6 +239,20 @@
   (== (match nil _ :yes nil :no) "yes")
   (== (let [_ :bar] (match :foo _ :should-match :foo :no)) "should-match"))
 
+(fn test-matchless []
+  (== (let [a 10
+            b 20]
+        (matchless [1 2]
+          [x y] [x y a b]))
+      [1 2 10 20]
+      nil "matchless without a shadow")
+  (== (let [a 10
+            b 20]
+        (matchless [1 2]
+          [a x] [a x b]))
+      [1 2 20]
+      nil "matchless with a shadow"))
+
 (fn test-match-try []
   (== (match-try [1 2 1]
         [1 a b] [b a]
@@ -330,4 +344,5 @@
  : test-disabled-sandbox-searcher
  : test-expand
  : test-match-try
+ : test-matchless
  : test-literal}

diff --git a/src/fennel/specials.fnl b/src/fennel/specials.fnl
index 5d9fc7f..58301a7 100644
--- a/src/fennel/specials.fnl
+++ b/src/fennel/specials.fnl
@@ -1099,6 +1099,7 @@ table.insert(package.loaders or package.searchers, fennel.searcher)"
 
 (fn fennel-macro-searcher [module-name]
   (let [opts (doto (utils.copy utils.root.options)
+               (tset :module-name module-name)
                (tset :env :_COMPILER)
                (tset :requireAsInclude false)
                (tset :allowedGlobals nil))]
@@ -1148,12 +1149,19 @@ modules in the compiler environment."
                      "expected each macro to be function" ast)
     (tset scope.macros k v)))
 
-(fn resolve-module-name [{: filename 2 second} _scope _parent opts]
+(fn resolve-module-name [ast _scope _parent opts]
   ;; Compile module path to resolve real module name.  Allows using
   ;; (.. ... :.foo.bar) expressions and self-contained
   ;; statement-expressions in `require`, `include`, `require-macros`,
   ;; and `import-macros`.
-  (let [filename (or filename (and (utils.table? second) second.filename))
+  ;; The first statement in the AST will be `import-macros` which is not
+  ;; appropriate to give as the filename to the compiler.
+  ;; We instead check the user-suppied form (right after `import-macros`) and
+  ;; use that value. If the user only gave a literal string, the filename will
+  ;; be nil, but in the context of compiling that literal to code, that wont
+  ;; really matter
+  (let [{2 second} ast
+        {: filename} second
         module-name utils.root.options.module-name
         modexpr (compiler.compile second opts)
         modname-chunk (load-code modexpr)]

(fn resolve-module-name [ast  _scope _parent opts]
      ;; Compile module path to resolve real module name.  Allows using
      ;; (.. ... :.foo.bar) expressions and self-contained
      ;; statement-expressions in `require`, `include`, `require-macros`,
      ;; and `import-macros`.

++    ;; filename here will be `src/fennel/macros.fnl` as it's pulled from
++    ;; `import-macros`. this is probably largely useless in this context.
++    (local {: filename 2 second} ast)
++    (let [;; filename (or filename (and (utils.table? second) second.filename))
++          ;; extract filename from actual form from user, not the filename for
++          ;; import-macros which is, not so useful.
++          ;; when given only a string, the filename will be nil, which is probably
++          ;; fine as the string just has to exist for half a moment.
++          ;; this always seems to be false, even though it is a table.
            ; _ (print (utils.table? second))
++          {: filename} second
            ;; module-name is always nil from utils.root.options
            ;; module-name utils.root.options.module-name
++          module-name (-> (or filename "") ;; or "" for seconds as literal strings with no filenames
++                          (string.gsub "%.fnl$" "")
++                          (string.gsub "%.lua$" "") ;; needed?
++                          (string.gsub "^%./" "") ;; not x-compat
++                          (string.gsub "/" ".")) ;; not x-compat
            ; _ (print :filename filename :module-name module-name)
            ; _ (print second (fennel.view opts))
            ;; _ (require "pl")
            ; _ (print (pretty (. ast 2)))
            modexpr (compiler.compile second opts)
            modname-chunk (load-code modexpr nil filename)]
        ; (print :resovle-module-name (fennel.view module-name))
        (modname-chunk module-name filename)))