Tells if the specified method is final or not

@param string $className Name of the class containing the method
@param string $methodName Name of the method to analyze
@return boolean true if the method is final, otherwise false
@api
975935
public function isMethodFinal($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_FINAL]);
    }
185072
public function isMethodStatic($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_STATIC]);
    }
619224
public function isStaticClassMethod(ClassMethod $classMethod): bool
    {
        return (bool) $this->betterNodeFinder->findFirst((array) $classMethod->stmts, function (Node $node) {
            if (! $node instanceof Variable) {
                return false;
            }

            return $this->nameResolver->isName($node, 'this');
        });
    }
287277
private function isMethodCall(Node\Node $node, string $objectName, string $methodName): bool
    {
        if ($node instanceof Node\CallExpression) {
            $callee = $node->getCallee();

            if ($callee instanceof Node\MemberExpression) {
                $object = $callee->getObject();
                $property = $callee->getProperty();

                if ($object instanceof Node\Identifier && $property instanceof Node\Identifier) {
                    return $object->getName() === $objectName && $property->getName() === $methodName;
                }
            }
        }

        return false;
    }
969143
public function hasClass($className)
    {
        if ($this->hasAttribute('class')) {
            return in_array($className, preg_split('/\s+/', $this->getAttribute('class')));
        }

        return false;
    }
106846
public function hasDescendant(ClassName $className, Comparator $comparator = null)
    {
        if ($this->isAbsolute() !== $className->isAbsolute()) {
            return false;
        }

        if (null === $comparator) {
            $comparator = new Comparator;
        }

        while ($className->hasParent()) {
            $className = $className->parent();
            if ($comparator->equals($this, $className)) {
                return true;
            }
        }

        return false;
    }
1076365
public function hasMethod($methodName)
    {
        return \method_exists($this, $methodName) || \method_exists($this, $this->public_function_prefix . $methodName);
    }
311016
public function hasClass($className)
    {
        $ret = $this->doc()->hasClass($this, $className);
        if (!is_array($ret)) {
            return $ret;
        }

        if (count($this) < 2) {
            return reset($ret);
        }

        return max($ret);
    }
39276
private function isValidObjectClass($className)
    {
        //====================================================================//
        // Safety Check => Object Type is String
        if (!is_string($className)) {
            return "Object Type is Not a String";
        }
        //====================================================================//
        // Safety Check => Class Exists
        if (!class_exists($className)) {
            return "Object Class Not Found";
        }
        //====================================================================//
        // Safety Check => Class Extends
        if (!is_subclass_of($className, AbstractObject::class)) {
            return "Object Class MUST extends ".AbstractObject::class;
        }

        return true;
    }
924296
public function loadByPaymorrowName($methodName)
    {
        /** @var OxpsPaymorrowOxPayment|oxPayment $this */

        if (!array_key_exists($methodName, $this->paymorrowPaymentNameMap)) {
            return false;
        }

        $query = sprintf(
            "SELECT * FROM `%s` WHERE %s AND `OXPSPAYMORROWMAP` = %d ORDER BY `OXSORT` ASC, `OXTIMESTAMP` DESC LIMIT 1",
            $this->getViewName(),
            $this->getPaymorrowMethodWhereClause(),
            (int) $this->paymorrowPaymentNameMap[$methodName]
        );

        return $this->assignRecord($query);
    }
1163057
public function lastTokenIs($classNames)
    {
        $token = $this->getLastToken();
        foreach ($classNames as $className) {
            if ($token instanceof $className) {
                return true;
            }
        }

        return false;
    }
1271758
public static function parseClassMethod($fullClassName, $methodName)
    {
        $class      = self::parseClass($fullClassName);
        $classNodes = $class->stmts;

        foreach ($classNodes as $classLevelNode) {
            if ($classLevelNode instanceof ClassMethod && $classLevelNode->name->toString() == $methodName) {
                return $classLevelNode;
            }
        }

        throw new \InvalidArgumentException("Method $methodName was not found in the $fullClassName");
    }
198992
public function isClassAbstract($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_ABSTRACT]);
    }
372844
public function isMethodPublic($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return (isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY]) && $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY] === self::VISIBILITY_PUBLIC);
    }
985348
public function getLastErrorForMethod($methodName)
    {
        return array_key_exists($methodName, $this->lastError) ? $this->lastError[$methodName] : null;
    }
1264539
protected function getMethodReflection($className, $methodName)
    {
        $this->dataCacheNeedsUpdate = true;
        if (!isset($this->methodReflections[$className][$methodName])) {
            $this->methodReflections[$className][$methodName] = new MethodReflection($className, $methodName);
        }
        return $this->methodReflections[$className][$methodName];
    }
787478
private static function methodExists(string $method, string $className): bool
    {
        return method_exists($className, $method) || resolve($className)->hasMethod($method);
    }