Come aggiungere una nuova classe in un plugin per compilatore Scala?

Question

In un plugin per compilatore Scala, sto provando a creare una nuova classe che implementa un tratto preesistente. Finora il mio codice assomiglia a questo:

def trait2Impl(original: ClassDef, newName: String): ClassDef = { 
    val impl = original.impl 
    // Seems OK to have same self, but does not make sense to me ... 
    val self = impl.self 
    // TODO: implement methods ... 
    val body = impl.body 
    // We implement original 
    val parents = original :: impl.parents 
    val newImpl = treeCopy.Template(impl, parents, self, body) 
    val name = newTypeName(newName) 
    // We are a syntheic class, not a user-defined trait 
    val mods = (original.mods | SYNTHETIC) &~ TRAIT 
    val tp = original.tparams 
    val result = treeCopy.ClassDef(original, mods, name, tp, newImpl) 
    // Same Package? 
    val owner = original.symbol.owner 
    // New symbol. What's a Position good for? 
    val symbol = new TypeSymbol(owner, NoPosition, name) 
    result.setSymbol(symbol) 
    symbol.setFlag(SYNTHETIC) 
    symbol.setFlag(ABSTRACT) 
    symbol.resetFlag(INTERFACE) 
    symbol.resetFlag(TRAIT) 
    owner.info.decls.enter(symbol) 
    result 
} 

Ma non sembra essere aggiunto al pacchetto. Sospetto che sia perché effettivamente il pacchetto è "attraversato" prima del tratto che causa la generazione, e/o perché il metodo "override def transform (tree: Tree): Tree" di TypingTransformer può restituire solo un albero ogni albero che riceve, quindi non può effettivamente produrre un nuovo albero, ma modificarne solo uno.

Quindi, come si aggiunge una nuova classe a un pacchetto esistente? Forse funzionerebbe se trasformassi il pacchetto quando "transform (Tree)" lo ottiene, ma io quel punto non conosco ancora il contenuto del pacchetto, quindi non posso generare la nuova classe così presto (o potrei?) . O forse è legato al parametro "Posizione" del Simbolo?

Finora ho trovato diversi esempi in cui gli alberi vengono modificati, ma nessuno in cui una classe completamente nuova viene creata in un plug-in compilatore.

Answer 1

Il codice sorgente completo è qui: https://gist.github.com/1794246

Il trucco è quello di memorizzare le appena creati ClassDef s e li usa quando si crea una nuova PackageDef. Si noti che è necessario gestire sia i simboli che gli alberi: un simbolo del pacchetto è solo un handle. Per generare codice, è necessario generare un AST (proprio come per una classe, in cui il simbolo contiene il nome e il tipo della classe, ma il codice si trova negli alberi ClassDef).

Come si è notato, le definizioni dei pacchetti sono più in alto dell'albero rispetto alle classi, quindi è necessario prima recurse (supponendo che si generi la nuova classe da una classe esistente). Quindi, una volta attraversati i sottoalberi, è possibile preparare un nuovo PackageDef (ogni unità di compilazione ha una definizione di pacchetto, che per impostazione predefinita è il pacchetto vuoto) con le nuove classi.

Nel esempio, supponendo che il codice sorgente è

class Foo { 
    def foo { 
    "spring" 
    } 
} 

il compilatore avvolge in

package <empty> { 
    class Foo { 
    def foo { 
     "spring" 
    } 
    } 
} 

e il plugin trasforma in

package <empty> { 
    class Foo { 
    def foo { 
     "spring" 
    } 
    } 
    package mypackage { 
    class MyClass extends AnyRef 
    } 
}