public function getIsSubtypeTests()
 {
     $tests = array();
     try {
         $registry = new TypeRegistry();
         $foo = new Clazz('Foo');
         $foo->setSuperClass('Bar');
         $foo->setSuperClasses(array('Bar'));
         $foo->setImplementedInterfaces(array('Baz', 'FooBar'));
         $foo->setNormalized(true);
         $tests[] = array($foo, new InterfaceC('FooBar'), true);
         $tests[] = array($foo, new InterfaceC('Foo'), false);
         $tests[] = array($foo, $foo, true);
         $tests[] = array($foo, new Clazz('Bar'), true);
         $tests[] = array($foo, new Clazz('FooBar'), false);
         $tests[] = array($foo, NamedType::createResolved($registry, new InterfaceC('Baz')), true);
         $tests[] = array($foo, NamedType::createResolved($registry, new InterfaceC('Moo')), false);
         $tests[] = array($foo, NamedType::createResolved($registry, new Clazz('Foo')), true);
         $tests[] = array($foo, NamedType::createResolved($registry, new Clazz('FoooFooo')), false);
         $tests[] = array($foo, new UnknownType($registry, false), true);
         $tests[] = array($foo, new NoObjectType($registry), true);
         $tests[] = array($foo, new BooleanType($registry), false);
         $tests[] = array($foo, new IntegerType($registry), false);
         $tests[] = array($foo, new DoubleType($registry), false);
         $tests[] = array($foo, new StringType($registry), false);
         $tests[] = array($foo, $registry->createUnionType(array('string', new InterfaceC('Baz'))), true);
         $tests[] = array($foo, $registry->createUnionType(array('string', 'boolean')), false);
     } catch (\Exception $ex) {
         echo sprintf("Could not get tests for isSubtypeTests(): %s\n", $ex->getMessage() . ' on line ' . $ex->getLine() . ' in file ' . $ex->getFile());
     }
     return $tests;
 }
 private function setUpClass($class, array $extends)
 {
     $class = new Clazz($class);
     if (isset($extends[$class->getName()])) {
         $parentClass = $this->setUpClass($extends[$class->getName()], $extends);
         $class->setSuperClasses(array_merge(array($parentClass->getName()), $parentClass->getSuperClasses()));
         $class->setSuperClass($parentClass->getName());
     }
     $class->setNormalized(true);
     $this->registry->registerClass($class);
     return $class;
 }
 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;
 }