Inheritance: extends ParentDefinition
Example #1
0
 /**
  * @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);
         }
     }
 }
Example #2
0
 /**
  * @param TraitDefinition $class
  */
 public function addTrait(TraitDefinition $class)
 {
     $this->traits[implode('\\', [$class->getNamespace(), $class->getName()])] = $class;
 }
Example #3
0
 /**
  * @param TraitDefinition $definition
  * @param Node\Stmt\TraitUseAdaptation\Alias[] $adaptations
  */
 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);
         }
     }
 }