private function isSubtype(PhpType $a, PhpType $b) { if ($a->isUnknownType()) { return false; } if (null === ($objType = $a->toMaybeObjectType())) { return false; } return $objType->isSubtypeOf($b); }
public function addAlternate(PhpType $alternate) { // build() returns the bottom type by default, so we can // just bail out early here. if ($alternate->isNoType()) { return $this; } $this->isAllType = $this->isAllType || $alternate->isAllType(); $isAlternateUnknown = $alternate instanceof UnknownType; // instanceof is desired here $this->isNativeUnknownType = $this->isNativeUnknownType || $isAlternateUnknown; if ($isAlternateUnknown) { $this->areAllUnknownsChecked = $this->areAllUnknownsChecked && $alternate->isChecked(); } if (!$this->isAllType && !$this->isNativeUnknownType) { if ($alternate->isUnionType()) { $union = $alternate->toMaybeUnionType(); foreach ($union->getAlternates() as $unionAlt) { $this->addAlternate($unionAlt); } } else { // Look through the alternates we've got so far, // and check if any of them are duplicates of // one another. foreach ($this->alternates as $index => $current) { // The Unknown type is special in that we cannot use our // subtype based check, but need to check for equality to // avoid duplicates, and not remove all other alternates. if ($alternate->isUnknownType()) { if ($alternate->equals($current)) { return $this; } continue; } // Check if we already have a more general type in the union. // Then, we do not add this alternate. if ($alternate->isSubTypeOf($current)) { return $this; } // Check if we have a subtype of the passed alternate. Then, // we remove that alternate in favor of the newly passed one. if ($current->isSubTypeOf($alternate)) { unset($this->alternates[$index]); } } $this->alternates[] = $alternate; } } return $this; }
private function restrictByCallable(PhpType $type = null, $outcome) { if (null === $type) { return $outcome ? $this->typeRegistry->getNativeType('callable') : null; } if ($outcome) { if ($type->isUnknownType() || $type->isAllType()) { return $this->typeRegistry->getNativeType('callable'); } if ($type->isUnionType()) { $types = array(); foreach ($type->getAlternates() as $altType) { if ($altType->canBeCalled()) { $types[] = $altType; } } return $this->typeRegistry->createUnionType($types); } return $type->canBeCalled() ? $type : $this->typeRegistry->getNativeType('none'); } if ($type->isCallableType()) { return $this->typeRegistry->getNativeType('none'); } if ($type->isUnionType()) { $types = array(); foreach ($type->getAlternates() as $altType) { if ($altType->isCallableType()) { continue; } $types[] = $altType; } return $this->typeRegistry->createUnionType($types); } return $type; }
/** * @param string $type * * @return null|PhpType */ private function tryGettingMoreSpecificType(PhpType $docType = null, PhpType $actualType, AbstractFunction $function, array $importedNamespaces, MethodContainer $container = null, $type) { if (!$docType) { if (!$actualType->isUnknownType() && !$actualType->isAllType()) { return null; } return $this->{'infer' . $type . 'TypeForFunction'}($function, $container); } // If the type defined by the comment is an object (and not the NoObjectType), // and a super type of the actual type, we keep it. if (null !== $docType->toMaybeObjectType() && $actualType->isSubtypeOf($docType)) { return $docType; } // If the type defined by the comment is a nullable object type (excluding the // NoObject type), we keep the comment that is currently in place. if ($this->isNullableObjectType($docType) && $actualType->isSubtypeOf($docType)) { return $docType; } if ($docType->getDocType($importedNamespaces) !== $actualType->getDocType($importedNamespaces)) { return $actualType; } if ($actualType === $this->registry->getNativeType('array')) { $inferredType = $this->{'infer' . $type . 'TypeForFunction'}($function, $container); if ($inferredType && $inferredType->isArrayType()) { return $inferredType; } } return null; }
/** * Returns whether the passed type is meaningfully different from this type. * * In contrast to ``equals()``, this method treats unknown types specially. * * If no unknown type is involved, then the result of this method is the opposite * boolean result of ``equals()``. * * If unknown types are involved, we regard the types as different if only one * of the involved types is an unknown type. * * TODO: Since the difference between known unknowns (aka checked unknowns), * and unknown unknowns has been removed. This method should be superfluous. * * @see http://www.youtube.com/watch?v=QaxqUDd4fiw&feature=related */ public function differsFrom(PhpType $that) { if (!$this->isUnknownType() && !$that->isUnknownType()) { return !$this->equals($that); } return (bool) ($this->isUnknownType() ^ $that->isUnknownType()); }
private function isMoreSpecificType(PhpType $actualType, PhpType $annotatedType) { if ($actualType->equals($annotatedType)) { return false; } if ($actualType->isUnknownType()) { return false; } return $actualType->isSubtypeOf($annotatedType); }