MacrosImpl

Possible configuration options that we can work with inside a macro. Parsed from pipez.PipeDerivationConfig

Possible errors that can happen during derivation

Helper which allows: use of for-comprehension, parallel error composition, logging

Stores information from what pieces Out is made

Final platform-independent result of matching inputs with outputs using resolved strategies

Translation strategy for a particular input subtype

Value generation strategy for a particular output parameter/setter

Type representing how we got the specific value from the in: In argument

Final platform-independent result of matching inputs with outputs using resolved strategies

Stores information how each attribute/getter could be extracted from In value

Stores information how Out value could be constructed from values of constructor parameters/passed to setters

Collection of config options obtained after parsing pipez.PipeDerivationConfig

Should create Out expression from the constructor arguments grouped in parameter lists

Platform-specific expression representation (c.universe.Expr[A] in 2, quotes.Expr[A] in 3

Platform-specific type representation (c.universe.Type in 2, scala.quoted.Type[A] in 3)

Provides Type instance for Pipe[I, O]

Check is A =:= B in a platform-independent code

Derives using Settings parsed from PipeDerivationConfig[Pipe, In, Out] expression

Derives using default Settings

Generate message to be displayed by macro on INFO level (if requested by config)

Generates error message to be returned from macro on ERROR level

Platform-specific way of parsing In data

Should:

• obtain a lift of subtypes OR enumeration values
• form it into EnumData[In]

Platform-specific way of parsing Out data

Should:

• obtain a lift of subtypes OR enumeration values
• form it into EnumData[In]

Platform-specific way of parsing In data

Should:

• obtain all methods which are Scala's getters (vals, nullary defs)
• obtain all methods which are Java Bean getters (starting with is- or get-)
• for each create an InField factory which takes In argument and returns InField expression
• form obtained collection into ProductInData

Platform-specific way of parsing Out data

Should:

• verify whether output is a case class, a case object or a Java Bean
• obtain respectively:
  • a constructor taking all arguments
  • expression containing case object value
  • a default constructor and collection of setters respectively
• form obtained data into ProductOutData

Platform-specific way of generating code from resolved information

For subtype input should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 in match {
   case inSubtype: In.Foo => pipeDerivation.unlift(fooPipe, inSubtype, updateContext(ctx, path))
   case inSubtype: In.Bar => pipeDerivation.unlift(barPipe, inSubtype, updateContext(ctx, path))
 }
}

Platform-specific way of generating code from resolved information

For case class output should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.mergeResult(
    ctx,
   pipeDerivation.mergeResult(
      ctx,
     pipeDerivation.pure(Array[Any](2)),
     pipeDerivation.unlift(fooPipe, in.foo, pipeDerivation.updateContext(ctx, Path.root.field("foo"))),
     { (left, right) =>
       left(0) = right
       left
      }
   ),
   pipeDerivation.unlift(barPipe, in.bar, pipeDerivation.updateContext(ctx, Path.root.field("bar"))),
   { (left, right) =>
     left(1) = right
     new Out(
       foo = left(0).asInstanceOf[Foo2],
       bar = left(1).asInstanceOf[Bar2],
     )
   }
 )
}

For case object output should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.pure(CaseObject)
}

For Java Bean should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.mergeResult(
   ctx,
   pipeDerivation.mergeResult(
     ctx,
     pipeDerivation.pure {
       val result = new Out()
       result
     },
     pipeDerivation.unlift(fooPipe, in.foo, pipeDerivation.updateContext(ctx, Path.root.field("foo"))),
     { (left, right) =>
       left.setFoo(right)
       left
     }
   ),
   pipeDerivation.unlift(barPipe, in.bar, pipeDerivation.updateContext(ctx, Path.root.field("bar"))),
   { (left, right) =>
     left.setBar(right)
     left
   }
 )
}

True iff A is sealed

True iff A is defined as case class, is NOT abstract and has a public constructor

True iff A is defined as case object, and is public

True iff A has a (public) default constructor and at least one (public) method starting with set

Check is A <:< B in a platform-independent code

True iff A is a tuple

Whether Out type could be constructed as "product case"

Whether both In and Out are ADTs/Java Enums

Should generate code pipeDerivation.lift { (in, ctx) => ... }

Should generate code pipeDerivation.mergeResults(ctx, ra, rb, (a, b) => ...)

Translates Path as seen in macro to runtime value we can pass to updateContext`

Allows displaying the generated code in platform-independent way

Prints type value

Should generate code pipeDerivation.pureResult(a)

Turns the code defining PipeDerivationConfig[Pipe, In, Out] into Settings.

Requires that config is created as one chain while passing the parameter.

Reads configs if passed, or fallback to defaults (empty Settings) otherwise

Should use platform-specific way of reporting information from macro on INFO level

Should use platform-specific way of reporting errors from macro

If we pass Single Abstract Method as argument, after expansion inference sometimes fails, compiler might need a hint

Allows summoning the type class in platform-independent way

Summons Type independently of the platform

Should generate code pipeDerivation.unlift(pipe)(in, ctx)

Should generate code pipeDerivation.updateContext(ctx, path)

Provides Type instance for In

Provides Type instance for Out

Value of PipeDerivation[Pipe], which was passed to macro as (most likely) implicit

Like previewCode(pipeDerivation) but allowing hiding some shenanigans we do

Takes Settings and passes them to generators, the first which decides it's their case, attempt generation