Enclosing class, what's available from the Universe?

adamw · October 10, 2017, 12:26pm

Hello,

I’ve been eagerly waiting for the new macros to see how migrating my two bigger open-source projects which use them: quicklens and macwire might go. While quicklens should be relatively easy (a blackbox macro manipulating the AST of the code passed as the argument), I’m not so sure of macwire.

I’m not sure if I understand the proposed capabilities of the new API correctly (I’m looking at the Universe from GitHub - scalacenter/macros: Archived - Scala Macros), but I think there’s no way currently to obtain information about the surrounding environment?

More specifically, what macwire relies on is the capability to browse the enclosing method/class/object & its parents for defined values of a specific type; once that’s available, then it’s a pretty straightforward black-box macro.

Is such functionality planned, or maybe on the opposite, deliberately not planned?

Thanks,
Adam

olafurpg · October 10, 2017, 1:07pm

It’s still to be decided what exact methods end up in Universe. In theory, we can expose the same capabilities as the existing macro API. The challenge is to strike a right balance genericity and portability. We want to avoid APIs that encourage coding against implementation details of individual compilers.

Can you share links to where you inspect the enclosing class members in macwire?

cb372 · October 10, 2017, 2:11pm

ScalaCache has a scala-reflect macro that depends on gathering knowledge about the surrounding environment in order to build up a cache key (see here for the source, which uses c.internal.enclosingOwner).

The other project off the top of my head that definitely requires knowledge of the macro’s surroundings is Enumeratum, which calls c.enclosingClass.

I know that Eugene was never that keen on letting macros gather this kind of information, for portability reasons I guess, but it’s really useful for certain use cases.

adamw · October 10, 2017, 3:07pm

Sure, here’s where enclosingClass is used:

github.com

adamw/macwire/blob/master/macros/src/main/scala/com/softwaremill/macwire/internals/EligibleValuesFinder.scala#L318




object ValDefOrEmptyDefDef {
  def unapply(t: Tree): Option[(TermName, Tree, Tree, Symbol)] = t match {
    case ValDef(_, name, tpt, rhs) => Some((name, tpt, rhs, t.symbol))
    case DefDef(_, name, _, Nil, tpt, rhs) => Some((name, tpt, rhs, t.symbol))
    case _ => None
  }
}


/** @return Nil if no body can be found */
private def enclosingClassBody: List[Tree] = c.enclosingClass match {
  case ClassDef(_, _, _, Template(_, _, body)) => body
  case ModuleDef(_, _, Template(_, _, body)) => body
  case e =>
    c.error(c.enclosingPosition, s"Unknown type of enclosing class: ${e.getClass}")
    Nil
}
}


object EligibleValuesFinder {
abstract class Scope private(val value: Int) extends Ordered[Scope] {

github.com

adamw/macwire/blob/master/macros/src/main/scala/com/softwaremill/macwire/internals/EligibleValuesFinder.scala#L128


  }


  log.withBlock("Building eligible values") {
    registerParentsMembers(
      doFind(enclosingClassBody.map(Scope.Class -> _), EligibleValues.empty))
  }
}


/** @return all the members of all the parents */
private def registerParentsMembers(values: EligibleValues): EligibleValues = {
  val parents = c.enclosingClass match {
    case ClassDef(_, _, _, Template(pp, self, _)) =>
      val selfTypes = self.tpt match {
        case ident : Ident => List(ident)
        case CompoundTypeTree(Template(selfParents,_,_)) => selfParents
        case x : Select if x.isType => List(x)
        case _ => Nil
      }
      pp ++ selfTypes


    case ModuleDef(_, _, Template(pp, _, _)) => pp

These are indeed deprecated since the last release I think, but nonetheless without them macwire wouldn’t be possible.

As an alternative to exposing the whole enclosing tree, the API could provide a way to obtain accessible values of a given type, together with information where they are coming from - their scope. Not sure, however, how that would work for other usages mentioned.

Adam

Andrei-Pozolotin · November 19, 2017, 3:41pm

@olafurpg please comment on @adamw examples? what is new pattern to replace enclosingClass?

olafurpg · November 20, 2017, 8:21am

@adamw @Andrei-Pozolotin I apologize for the slow response, I had a draft comment that never went out!

The API for the new macros hasn’t been decided yet, so it’s too early to say what the new pattern is. We’ve been exploring the past weeks hygiene, mixing of untyped/typed trees and owner chain corruptions that plague many scala-reflect macros.

Andrei-Pozolotin · November 20, 2017, 5:33pm

@adamw what do you think: https://github.com/scalacenter/macros/issues/35

adamw · November 20, 2017, 6:46pm

I’m not sure if that would be sufficient - how would we get the available symbols (eg in the enclosing class) in the first place?