Factory::fromClassReflection() refactoring

Author: dg

src/PhpGenerator/Factory.php

@@ -37,43 +37,65 @@ public function fromClassReflection(
 			throw new Nette\NotSupportedException('The $withBodies parameter cannot be used for anonymous or internal classes or interfaces.');
 		}
 
-		$enumIface = null;
-		if ($from->isEnum()) {
-			$class = new EnumType($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
+		$class = $this->createClassObject($from);
+		$this->setupInheritance($class, $from);
+		$this->populateMembers($class, $from, $withBodies);
+		return $class;
+	}
+
+
+	/** @param \ReflectionClass<object> $from */
+	private function createClassObject(\ReflectionClass &$from): ClassLike
+	{
+		if ($from->isAnonymous()) {
+			return new ClassType;
+		} elseif ($from->isEnum()) {
 			$from = new \ReflectionEnum($from->getName());
-			$enumIface = $from->isBacked() ? \BackedEnum::class : \UnitEnum::class;
-		} elseif ($from->isAnonymous()) {
-			$class = new ClassType;
+			$class = new EnumType($from->getName());
 		} elseif ($from->isInterface()) {
-			$class = new InterfaceType($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
+			$class = new InterfaceType($from->getName());
 		} elseif ($from->isTrait()) {
-			$class = new TraitType($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
+			$class = new TraitType($from->getName());
 		} else {
-			$class = new ClassType($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
+			$class = new ClassType($from->getShortName());
 			$class->setFinal($from->isFinal() && $class->isClass());
 			$class->setAbstract($from->isAbstract() && $class->isClass());
 			$class->setReadOnly(PHP_VERSION_ID >= 80200 && $from->isReadOnly());
 		}
 
+		$class->setNamespace(new PhpNamespace($from->getNamespaceName()));
+		return $class;
+	}
+
+
+	/** @param \ReflectionClass<object> $from */
+	private function setupInheritance(ClassLike $class, \ReflectionClass $from): void
+	{
 		$ifaces = $from->getInterfaceNames();
 		foreach ($ifaces as $iface) {
 			$ifaces = array_filter($ifaces, fn(string $item): bool => !is_subclass_of($iface, $item));
 		}
 
 		if ($from->isInterface()) {
-			$class->setExtends($ifaces);
+			$class->setExtends(array_values($ifaces));
 		} elseif ($ifaces) {
-			$ifaces = array_diff($ifaces, [$enumIface]);
-			$class->setImplements($ifaces);
+			$ifaces = array_diff($ifaces, [\BackedEnum::class, \UnitEnum::class]);
+			$class->setImplements(array_values($ifaces));
 		}
 
 		$class->setComment(Helpers::unformatDocComment((string) $from->getDocComment()));
 		$class->setAttributes($this->getAttributes($from));
 		if ($from->getParentClass()) {
 			$class->setExtends($from->getParentClass()->name);
-			$class->setImplements(array_diff($class->getImplements(), $from->getParentClass()->getInterfaceNames()));
+			$class->setImplements(array_values(array_diff($class->getImplements(), $from->getParentClass()->getInterfaceNames())));
 		}
+	}
+
 
+	/** @param \ReflectionClass<object> $from */
+	private function populateMembers(ClassLike $class, \ReflectionClass $from, bool $withBodies): void
+	{
+		// Properties
 		$props = [];
 		foreach ($from->getProperties() as $prop) {
 			$declaringClass = Reflection::getPropertyDeclaringClass($prop);
@@ -84,8 +106,8 @@ public function fromClassReflection(
 				&& !$class->isEnum()
 			) {
 				$props[] = $p = $this->fromPropertyReflection($prop);
-				if ($withBodies) {
-					$hookBodies ??= $this->getExtractor($declaringClass->getFileName())->extractPropertyHookBodies($declaringClass->name);
+				if ($withBodies && ($file = $declaringClass->getFileName())) {
+					$hookBodies ??= $this->getExtractor($file)->extractPropertyHookBodies($declaringClass->name);
 					foreach ($hookBodies[$prop->getName()] ?? [] as $hookType => [$body, $short]) {
 						$p->getHook($hookType)->setBody($body, short: $short);
 					}
@@ -97,19 +119,20 @@ public function fromClassReflection(
 			$class->setProperties($props);
 		}
 
+		// Methods and trait resolutions
 		$methods = $resolutions = [];
 		foreach ($from->getMethods() as $method) {
 			$declaringMethod = Reflection::getMethodDeclaringMethod($method);
 			$declaringClass = $declaringMethod->getDeclaringClass();
 
 			if (
 				$declaringClass->name === $from->name
-				&& (!$enumIface || !method_exists($enumIface, $method->name))
+				&& (!$from instanceof \ReflectionEnum || !method_exists($from->isBacked() ? \BackedEnum::class : \UnitEnum::class, $method->name))
 			) {
 				$methods[] = $m = $this->fromMethodReflection($method);
-				if ($withBodies) {
+				if ($withBodies && ($file = $declaringClass->getFileName())) {
 					$bodies = &$this->bodyCache[$declaringClass->name];
-					$bodies ??= $this->getExtractor($declaringClass->getFileName())->extractMethodBodies($declaringClass->name);
+					$bodies ??= $this->getExtractor($file)->extractMethodBodies($declaringClass->name);
 					if (isset($bodies[$declaringMethod->name])) {
 						$m->setBody($bodies[$declaringMethod->name]);
 					}
@@ -127,6 +150,7 @@ public function fromClassReflection(
 
 		$class->setMethods($methods);
 
+		// Traits
 		foreach ($from->getTraitNames() as $trait) {
 			$trait = $class->addTrait($trait);
 			foreach ($resolutions as $resolution) {
@@ -135,9 +159,10 @@ public function fromClassReflection(
 			$resolutions = [];
 		}
 
+		// Constants and enum cases
 		$consts = $cases = [];
 		foreach ($from->getReflectionConstants() as $const) {
-			if ($class->isEnum() && $from->hasCase($const->name)) {
+			if ($from instanceof \ReflectionEnum && $from->hasCase($const->name)) {
 				$cases[] = $this->fromCaseReflection($const);
 			} elseif ($const->getDeclaringClass()->name === $from->name) {
 				$consts[] = $this->fromConstantReflection($const);
@@ -150,8 +175,6 @@ public function fromClassReflection(
 		if ($cases) {
 			$class->setCases($cases);
 		}
-
-		return $class;
 	}
 
 
@@ -188,11 +211,11 @@ public function fromFunctionReflection(\ReflectionFunction $from, bool $withBody
 		$function->setReturnType((string) $from->getReturnType());
 
 		if ($withBody) {
-			if ($from->isClosure() || $from->isInternal()) {
+			if ($from->isClosure() || $from->isInternal() || !($file = $from->getFileName())) {
 				throw new Nette\NotSupportedException('The $withBody parameter cannot be used for closures or internal functions.');
 			}
 
-			$function->setBody($this->getExtractor($from->getFileName())->extractFunctionBody($from->name));
+			$function->setBody($this->getExtractor($file)->extractFunctionBody($from->name));
 		}
 
 		return $function;