What

This adds the ability to specify verbatim blocks in macros, so macro code isn't immediately execute.

Why

Take a look at how the macro def_clone is implemented:

  macro def_clone
    # Returns a copy of `self` with all instance variables cloned.
    def clone
      clone = \{{@type}}.allocate
      clone.initialize_copy(self)
      GC.add_finalizer(clone) if clone.responds_to?(:finalize)
      clone
    end

    protected def initialize_copy(other)
      \{% for ivar in @type.instance_vars %}
        @\{{ivar.id}} = other.@\{{ivar.id}}.clone
      \{% end %}
    end
  end

Note all the \{% and \{{ in there. It's needed because we don't want to execute @type right away: we want to defer it until the method is executed, so it works like a macro method. The \ is ugly, but it works.

With this PR, we can write it like this:

  macro def_clone
    {% verbatim do %}
      # Returns a copy of `self` with all instance variables cloned.
      def clone
        clone = {{@type}}.allocate
        clone.initialize_copy(self)
        GC.add_finalizer(clone) if clone.responds_to?(:finalize)
        clone
      end

      protected def initialize_copy(other)
        {% for ivar in @type.instance_vars %}
          @{{ivar.id}} = other.@{{ivar.id}}.clone
        {% end %}
      end
    {% end %}
  end

verbatim basically won't treat the block inside it as macro code, but instead as just a string that's being pasted. Then when the clone and initialize_copy methods are invoked, the pasted code that's actually macro is executed.

So this is just a better way to write and do what we can already do.

I also need this for a complete implementation of #6082 . The JSON::Serialize module must inject an initialize in the included type so that types referenced in attributes (like converter) work well. For example:

class Foo
  class MyConverter
  end

  @[JSON::Field(converter: MyConverter)]
  property x : Int32
end

If MyConverter is pasted in the included JSON::Serialize module, it will give an error because MyConverter can't be reached from that location (that's the reason why I had to remove all the private types in the specs in that PR). If initalize is injected with an included macro, MyConverter can be accessed.

But since that injected initialize method already uses @type in macros, I'll have to escape with \ all of that. But it's so much simpler to just surround everything with a verbatim block.