Def macros: ways macros could be defined and invoked

Listing the interesting cases related to def macros. A tick means that this case is tested and works properly.

Macro defined in

[x] object in root package
[x] class in root package
[x] object in non-root package
[x] class in non-root package
[x] object inside an object
[x] class inside an object
[x] package object
[x] object inside a package object
[x] class inside a package object
[x] object inside a class
[x] class inside a class
[ ] anonymous class
[x] trait
[x] implicit class
[x] implicit def
[x] curried def i.e. def m(a:Any,b:Any)(c:Any) :-1: partial application not avaiable
[x] def with type arguments
[ ] class with @specialized()
[ ] def with @specialized()
[ ] :-1: def without arguments i.e. def a = Does not currently work. Workaround use def a() = instead.
[ ] def with implicit arguments
[x] def with default arguments
[x] polymorphic method, i.e. multiple defs with the same name, but different arguments
[x] def with varargs

Macro applied to prefix of

[x] no prefix. (prefix = null inside the meta block). This happens for implicit defs and when the prefix is imported.
[x] a variable/value
[x] newly instance created. I.e. new MyClass()
[x] method invocation
[ ] anonymous class
[ ] anonymous function
[x] code block
[ ] output from another def macro

Macro arguments are

Other:

[x] Macro invoked implicitly (implicit class)
[x] Macro invoked as a implicit conversion (implicit def)
[ ] A macro defined in the supertype is invoked in a subtype
[ ] map flatMap and withFilter macros invoked by for comprehensions
[ ] Multiple calls of a macro use shared state, for example, generating global unique identifiers
[ ] A macro returns a tree that invokes another macro

liufengyun / gestalt