PHPSA\Definition\ClassDefinition::mergeTrait PHP Method

    public function mergeTrait(TraitDefinition $definition, array $adaptations)
    {
        $methods = $definition->getMethods();
        if ($methods) {
            foreach ($adaptations as $adaptation) {
                // We don't support Trait name for now
                if (!$adaptation->trait) {
                    $methodNameFromTrait = $adaptation->method;
                    if (isset($methods[$methodNameFromTrait])) {
                        /** @var ClassMethod $method Method from Trait */
                        $method = $methods[$methodNameFromTrait];
                        if ($adaptation->newName || $adaptation->newModifier && $method->getModifier() != $adaptation->newModifier) {
                            // Don't modify original method from Trait
                            $method = clone $method;
                            $method->setName($adaptation->newName);
                            $method->setModifier($adaptation->newModifier);
                            $methods[$methodNameFromTrait] = $method;
                        }
                    }
                }
            }
            foreach ($methods as $method) {
                $this->addMethod($method, false);
            }
        }
    }

 /**
  * @param Node\Stmt|Node\Stmt[] $topStatement
  * @param AliasManager $aliasManager
  * @param string $filepath
  */
 protected function parseTopDefinitions($topStatement, AliasManager $aliasManager, $filepath)
 {
     foreach ($topStatement as $statement) {
         if ($statement instanceof Node\Stmt\Use_) {
             if (count($statement->uses) > 0) {
                 foreach ($statement->uses as $use) {
                     $aliasManager->add($use->name->parts);
                 }
             }
         } elseif ($statement instanceof Node\Stmt\GroupUse) {
             if (count($statement->uses) > 0) {
                 foreach ($statement->uses as $use) {
                     $aliasManager->add($statement->prefix . $use->name->parts);
                 }
             }
         } elseif ($statement instanceof Node\Stmt\Trait_) {
             $definition = new TraitDefinition($statement->name, $statement);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             $definition->precompile();
             $this->compiler->addTrait($definition);
         } elseif ($statement instanceof Node\Stmt\Class_) {
             $definition = new ClassDefinition($statement->name, $statement, $statement->type);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             if ($statement->extends) {
                 $definition->setExtendsClass($statement->extends->toString());
             }
             if ($statement->implements) {
                 foreach ($statement->implements as $interface) {
                     $definition->addInterface($interface->toString());
                 }
             }
             foreach ($statement->stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\ClassMethod) {
                     $definition->addMethod(new ClassMethod($stmt->name, $stmt, $stmt->type));
                 } elseif ($stmt instanceof Node\Stmt\Property) {
                     $definition->addProperty($stmt);
                 } elseif ($stmt instanceof Node\Stmt\TraitUse) {
                     foreach ($stmt->traits as $traitPart) {
                         $traitDefinition = $this->compiler->getTrait($traitPart->toString());
                         if ($traitDefinition) {
                             $definition->mergeTrait($traitDefinition, $stmt->adaptations);
                         }
                     }
                 } elseif ($stmt instanceof Node\Stmt\ClassConst) {
                     $definition->addConst($stmt);
                 }
             }
             $this->compiler->addClass($definition);
         } elseif ($statement instanceof Node\Stmt\Function_) {
             $definition = new FunctionDefinition($statement->name, $statement);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             $this->compiler->addFunction($definition);
         }
     }
 }