public function __construct(InterfaceC $interface, Constant $constant, $declaringInterface = null) { $this->interface = $interface; $this->constant = $constant; $this->name = $constant->getName(); if ($interface->getName() === $declaringInterface) { $declaringInterface = null; } $this->declaringInterface = $declaringInterface; }
private function insertConstant(Constant $constant, $packageVersionId) { $this->constantStmt->bindValue(1, $constant->getName()); $this->constantStmt->bindValue(2, $this->phpType->convertToDatabaseValue($constant->getPhpType(), $this->platform)); $this->constantStmt->bindValue(3, $packageVersionId); $this->constantStmt->execute(); $constantId = $this->con->lastInsertId(); $this->constantIdRef->setValue($constant, $constantId); return $constantId; }
public function __construct(Clazz $class, Constant $constant, $declaringClass = null) { $this->class = $class; $this->constant = $constant; $this->name = $constant->getName(); if ($class->getName() === $declaringClass) { $declaringClass = null; } $this->declaringClass = $declaringClass; }
public function testPersistClazzWithConstant() { $this->packageVersion->addContainer($foo = new Clazz('Foo')); $foo->addConstant($constant = new Constant('BAR')); $constant->setPhpType($this->typeRegistry->getNativeType('string')); $this->persister->persist($this->packageVersion); $reloadedFoo = $this->em->createQuery('SELECT c FROM Scrutinizer\\PhpAnalyzer\\Model\\Clazz c WHERE c.name = :name')->setParameter('name', 'Foo')->getSingleResult(); assert($reloadedFoo instanceof Clazz); $this->assertTrue($reloadedFoo->hasConstant('BAR')); $this->assertEquals('string', (string) $reloadedFoo->getConstant('BAR')->getPhpType()); }
private function inferTypesForClassConstant(Constant $constant) { if (($type = $constant->getPhpType()) && !$type->isUnknownType()) { return; } if (null !== ($node = $constant->getAstNode())) { $type = $this->parser->getTypeFromVarAnnotation($node); } if (null === $type) { $type = $this->registry->getNativeType('unknown'); } $constant->setPhpType($type); if ($node) { $node->setAttribute('type', $type); } }
public function addConstant(Constant $constant, $declaringClass = null) { $classConstant = new InterfaceConstant($this, $constant, $declaringClass); $this->constants->set($constant->getName(), $classConstant); }
public function parse(\PHPParser_Node $node) { if ($node instanceof \PHPParser_Node_Stmt_Class) { $class = new Clazz(implode("\\", $node->namespacedName->parts)); // convert PHPParser modifier to our modifier $modifier = 0; if (\PHPParser_Node_Stmt_Class::MODIFIER_FINAL === ($node->type & \PHPParser_Node_Stmt_Class::MODIFIER_FINAL)) { $modifier |= Clazz::MODIFIER_FINAL; } if (\PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT === ($node->type & \PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT)) { $modifier |= Clazz::MODIFIER_ABSTRACT; } $class->setModifier($modifier); if (null !== $node->extends) { $class->setSuperClass(implode("\\", $node->extends->parts)); } foreach ($node->implements as $iface) { $class->addImplementedInterface(implode("\\", $iface->parts)); } } else { if ($node instanceof \PHPParser_Node_Stmt_Interface) { $class = new InterfaceC(implode("\\", $node->namespacedName->parts)); foreach ($node->extends as $interface) { $class->addExtendedInterface(implode("\\", $interface->parts)); } } else { if ($node instanceof \PHPParser_Node_Stmt_Trait) { $class = new TraitC(implode("\\", $node->namespacedName->parts)); } else { throw new \LogicException(sprintf('The other statements were exhaustive. The node "%s" is not supported.', get_class($node))); } } } $class->setImportedNamespaces($this->importedNamespaces); $class->setAstNode($node); // add methods, properties, and constants foreach ($node->stmts as $stmt) { if ($stmt instanceof \PHPParser_Node_Stmt_ClassMethod) { $this->scanMethod($stmt, $class); } else { if ($stmt instanceof \PHPParser_Node_Stmt_Property) { $visibility = \PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC === ($stmt->type & \PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC) ? Property::VISIBILITY_PUBLIC : (\PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED === ($stmt->type & \PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED) ? Property::VISIBILITY_PROTECTED : Property::VISIBILITY_PRIVATE); foreach ($stmt->props as $propNode) { assert($propNode instanceof \PHPParser_Node_Stmt_PropertyProperty); // This is a PHP error which we flag in a later pass. Here, we can just ignore the property definition. if ($class->isInterface()) { continue; } assert($class instanceof Clazz || $class instanceof TraitC); $property = new Property($propNode->name); $property->setAstNode($propNode); $property->setVisibility($visibility); $class->addProperty($property); } } else { if ($stmt instanceof \PHPParser_Node_Stmt_ClassConst) { foreach ($stmt->consts as $constNode) { assert($constNode instanceof \PHPParser_Node_Const); $constant = new Constant($constNode->name); $constant->setAstNode($constNode); if (null !== ($type = $constNode->value->getAttribute('type'))) { $constant->setPhpType($type); } $class->addConstant($constant); } } } } } // Add magic properties denoted by @property, @property-read, @property-write. if ($node instanceof \PHPParser_Node_Stmt_Class && preg_match_all('#@(?:property|property-read|property-write)\\s+[^\\s]+\\s+\\$?([^\\s]+)#', $node->getDocComment(), $matches)) { for ($i = 0, $c = count($matches[0]); $i < $c; $i++) { // If there is already an explicitly declared property of the same // name, it has precedence for us. if ($class->hasProperty($matches[1][$i])) { $this->logger->warning(sprintf('The property "%s" is already defined in code; ignoring @property tag.', $matches[1][$i])); continue; } $property = new Property($matches[1][$i]); $property->setAstNode($node); $class->addProperty($property); } } // Add magic methods denoted by @method. if ($node instanceof \PHPParser_Node_Stmt_Class && preg_match_all('#@method\\s+([^@]+)#s', $node->getDocComment(), $matches)) { foreach ($matches[1] as $methodDef) { if (null !== ($method = $this->parseCommentMethodDef($methodDef))) { // An explicitly defined method has precedence. if ($class->hasMethod($method->getName())) { $this->logger->warning(sprintf('The method "%s" is already defined in code; ignoring @method tag.', $method->getName())); continue; } $class->addMethod($method); } } } return $class; }