BUG: module provide works strangely with macros

[IllustratedMan-code]

Macros appear to ignore the (provide) declaration in a module in the case of a syntax-rules macro, and creates an error in the case of the syntax-case macro.

Here is an example file (test_loading.scm):

(provide what)

(define what "what")

(define the "the")

(define-syntax hi!
  (syntax-rules ()
    ((_) (print "hello world"))))

(define-syntax subset!
  (lambda (stx)
    (syntax-case stx ()
      ((_ df)
       (error "Did you forget to add a subset expression?"))
      ((_ df string)
       (begin
	 (if
	  (string? (syntax->datum #'string))
	  #'(error string)
	  (symbol->string (syntax->datum #'(string))))
	  ))
      ((_ df cond ...)
       (symbol->string (syntax->datum #'(cond ...))))
      )))

When I require this module in the repl (require "test_loading.scm"), I have access to the variable what, and I don't have access to the variable the (as expected). However, I can call (hi!) and (subset!) just fine even though they aren't in the (provide) declaration. If I put the subset! macro in the provide delcaration, I get this error when I require the module:

error[E02]: FreeIdentifier
  ┌─ /home/david/Documents/Personal-Projects/piper/examples/test_loading.scm:2:3
  │
2 │      subset!)
  │      ^^^^^^^ Cannot reference an identifier before its definition: subset!

If I put hi! in the provide declaration, nothing seems to happen at all. I can call (hi!) fine.

Also, this might deserve its own issue, but errors thrown within the syntax-case macro are not reported correctly, for example, the above subset! macro will throw an error if it recieves a string as the second argument:

λ > (subset! metadata "hi")
Unable to locate source and span information for this error: Error: Generic:  hi

[mattwparas]

After brief investigation the modules leaking to the top level without provide is a small bug. I'll have that fixed shortly

Syntax-case has some shortcomings in the implementation, that might be a larger bug, both for the provide + the error message.

[mattwparas]

First issue with macros escaping to the top level should be fixed here #646

Will continue investigating the others

[IllustratedMan-code]

I think this change may have caused macros which call other macros to not be provided correctly.

For example, I have this macro process! which calls two other helper macros bindings-helper and hash-helper, when I provide the process! macro, it creates this error when I call it with no args:

λ > (process!)
error[E02]: FreeIdentifier
  ┌─ :1:2
  │
1 │ (process!)
  │  ^^^^^^^^ Cannot reference an identifier before its definition: hash-helper

If I provide both hash-helper and bindings-helper, then it works as normal.

Here are the macro definitions:

(define-syntax process!
  (syntax-rules ()
    [(_ (bindings) rest ...)
     (with-handler
      (lambda (err) (error err))
      (process
       (hash-helper rest ...)
       #:bindings (bindings-helper (bindings))))]
    [(_ rest ...)
     (with-handler (lambda (err) (error err))
		   (process (hash-helper rest ...)))]

  ))
	
(define-syntax bindings-helper
  (syntax-rules ()
    [(_ ())
     '()]
    [(_ (var ...))
     `((var ,var) ...)]))

(define-syntax hash-helper
  (syntax-rules (:)
    [(_ key : val)
     (hash 'key val)]
    [(_ key : val rest ...) (hash-union (hash-helper rest ...) (hash 'key val))]
    ))

(provide process!) ;; doesn't work
(provide process! bindings-helper hash-helper) ;; works

[mattwparas]

Taking a look, as a note this only happens at the repl. The expected behavior seems to happen if using this from within a module.

[IllustratedMan-code]

I noticed it first from a call to steel::steel_vm::engine::Engine::run if that matters.

[mattwparas]

same thing essentially - this was running at the top level vs from within a module. I think I have a fix though, just writing some tests.

[IllustratedMan-code]

I can confirm that the above is fixed, though syntax-case macros still appear to be leaking into the top-level and the error handling issue is still present.

However, I did find something interesting. The quasiquote does the correct error handling for some reason.

So for example in this macro:

(define-syntax subset!
  (lambda (stx)
    (syntax-case stx ()
      ((_ df)
       (error "Did you forget to add a subset expression?"))
      ((_ df string)
       (begin
	 (if
	  (string? (syntax->datum #'string))
	  #'(subset df string)
	  #`(subset df #,(symbol->string (syntax->datum #'string)))
	  )))
      ((_ df cond ...)
       #`(subset df #,(symbol->string (syntax->datum #'(cond ...)))))
      )))

If I call it like this (subset! df "a") I get this error:

Unable to locate source and span information for this error: Error: Generic: filter predicate must be of type `Boolean`, got `Int64`

Resolved plan until failure:

	---> FAILED HERE RESOLVING 'sink' <---
FILTER col("a")
FROM
  DF ["a", "b", "c", "d"]; PROJECT */4 COLUMNS

But if I use a backtick in this expression #`(subset df string), I get this:

error[E11]: Generic
   ┌─ derivation:71:7
   │
71 │       #`(subset df string)
   │          ^^^^^^ filter predicate must be of type `Boolean`, got `Int64`

Resolved plan until failure:

	---> FAILED HERE RESOLVING 'sink' <---
FILTER col("a")
FROM
  DF ["a", "b", "c", "d"]; PROJECT */4 COLUMNS

Which is what I would expect.