Properly implement the method withChildren for PAdtConstructor

-As for PDomainFunction we have to make some adaptions to the method withChildren such that it can properly be used. (e.g needed if we use some StrategyBuilder)
-Basically we have to make sure that 'adtName' is handled correctly
-Currently, the only way it works, is with the Reflection approach. A simplified implementation is desired and provided in a later step

src/main/scala/viper/silver/plugin/standard/adt/AdtPASTExtension.scala

@@ -7,9 +7,11 @@
 package viper.silver.plugin.standard.adt
 
 import viper.silver.ast.{Member, NoInfo, NoPosition, Position, TypeVar}
+import viper.silver.parser.Transformer.ParseTreeDuplicationError
 import viper.silver.parser.{NameAnalyser, PAnyFormalArgDecl, PExtender, PGenericType, PGlobalDeclaration, PIdentifier, PIdnDef, PIdnUse, PMember, PNode, PType, PTypeSubstitution, PTypeVarDecl, Translator, TypeChecker}
 import viper.silver.plugin.standard.adt.PAdtConstructor.findAdtConstructor
 
+import scala.reflect.runtime.{universe => reflection}
 
 case class PAdt(idndef: PIdnDef, typVars: Seq[PTypeVarDecl], constructors: Seq[PAdtConstructor])(val pos: (Position, Position)) extends PExtender with PMember with PGlobalDeclaration {
 
@@ -61,6 +63,50 @@ case class PAdtConstructor(idndef: PIdnDef, formalArgs: Seq[PAnyFormalArgDecl])(
   override def translateMember(t: Translator): Member = {
     findAdtConstructor(idndef, t)
   }
+
+  override def withChildren(children: Seq[Any], pos: Option[(Position, Position)] = None, forceRewrite: Boolean = false): this.type = {
+    if (!forceRewrite && this.children == children && pos.isEmpty)
+      this
+    else {
+
+      // TODO: Why can we not simplify with following code? => results in an Exception, is reflection really the only way?
+      /*
+      val first = children.head.asInstanceOf[PIdnDef]
+      val others = children.tail.asInstanceOf[Seq[PAnyFormalArgDecl]]
+
+
+      PAdtConstructor(first, others)(this.adtName)(pos.getOrElse(this.pos)).asInstanceOf[this.type]
+      */
+
+      // Infer constructor from type
+      val mirror = reflection.runtimeMirror(reflection.getClass.getClassLoader)
+      val instanceMirror = mirror.reflect(this)
+      val classSymbol = instanceMirror.symbol
+      val classMirror = mirror.reflectClass(classSymbol)
+      val constructorSymbol = instanceMirror.symbol.primaryConstructor.asMethod
+      val constructorMirror = classMirror.reflectConstructor(constructorSymbol)
+
+      // Add additional arguments to constructor call, besides children
+      val firstArgList = children
+      var secondArgList = Seq.empty[Any]
+
+      this match {
+        case pd: PAdtConstructor => secondArgList = Seq(pd.adtName) ++ Seq(pos.getOrElse(pd.pos))
+        case _ =>
+      }
+
+      // Call constructor
+      val newNode = try {
+        constructorMirror(firstArgList ++ secondArgList: _*)
+      }
+      catch {
+        case _: Exception if this.isInstanceOf[PNode] =>
+          throw ParseTreeDuplicationError(this.asInstanceOf[PNode], children)
+      }
+
+      newNode.asInstanceOf[this.type]
+    }
+  }
 }
 
 object PAdtConstructor {