@param string $class    The fully qualified class name
@param string $property The name of the property to guess for
@param string $method   Guesser method

@return \Symfony\Component\Form\Guess\Guess|null
181271
private function guess($class, $property, $method)
    {
        if (!$this->translatableManager->isTranslatable($class)) {
            return null;
        }

        $firstGuess = $this->genericTypeGuesser->$method($class, $property);

        if (!$firstGuess instanceof Guess) {
            return null;
        }

        $secondGuess = $this->genericTypeGuesser->$method($this->translatableManager->getTranslationClass($class), $property);

        if (!$secondGuess instanceof Guess) {
            return null;
        }

        return $firstGuess->getConfidence() > $secondGuess->getConfidence() ? $firstGuess : $secondGuess;
    }
446114
private function extractFromConstructor(string $class, string $property): ?array
    {
        try {
            $reflectionClass = new \ReflectionClass($class);
        } catch (\ReflectionException $e) {
            return null;
        }

        $constructor = $reflectionClass->getConstructor();

        if (!$constructor) {
            return null;
        }

        foreach ($constructor->getParameters() as $parameter) {
            if ($property !== $parameter->name) {
                continue;
            }
            $reflectionType = $parameter->getType();

            return $reflectionType ? [$this->extractFromReflectionType($reflectionType, $constructor)] : null;
        }

        if ($parentClass = $reflectionClass->getParentClass()) {
            return $this->extractFromConstructor($parentClass->getName(), $property);
        }

        return null;
    }
33095
public static function fromProperty(
        string $class,
        string $property
    ): array
    {
        try {

            $property = new \ReflectionProperty($class, $property);
        }
        catch (\ReflectionException $e) {

            throw new Exception(
                "Property '{$class}::{$property}' not found.",
                Exception::PROPERTY_NOT_FOUND
            );
        }

        $docComment = $property->getDocComment();

        unset($property);

        if ($docComment === false) {

            return [];
        }

        return Parser::parseDocComment($docComment);
    }
1368352
protected function liberatorPropertyReflector($property)
    {
        $classReflector = $this->liberatorReflector();

        while ($classReflector) {
            if ($classReflector->hasProperty($property)) {
                $propertyReflector = $classReflector->getProperty($property);
                $propertyReflector->setAccessible(true);

                return $propertyReflector;
            }

            $classReflector = $classReflector->getParentClass();
        }

        return null;
    }
1314676
public Class<?> getClass(String property) {
    return getProperty(property, className -> {
      try {
        return Class.forName(className);
      } catch (ClassNotFoundException e) {
        throw new ConfigurationException("unknown class: " + className, e);
      }
    });
  }
1173847
private function getPropertyFor($attribute, $property) {
    return $this->propertyExists($attribute, $property)
         ? $this->__attributes[$attribute][$property]
         : null;
  }
349774
private function loadPropertyType(\ReflectionProperty $property)
    {
        if ($this->extractor === null) {
            return;
        }

        $types = $this->extractor->getTypes($property->class, $property->name);

        if (empty($types)) {
            return;
        }

        $extractedType = current($types);
        $type = $extractedType->getBuiltinType();

        if ($type === 'object') {
            $type = $extractedType->getClassName();
        }

        return $type;
    }
615691
protected function invokeProperty($obj, $property = null)
    {
        if (null === $property) {
            return null;
        }

        if (!settype($property, 'string')) {
            return null;
        }

        $property = trim($property);
        if (0 === mb_strlen($property)) {
            return null;
        }

        if (!is_object($obj)) {
            return null;
        }

        $methods = [
            $this->createMethodName('get', $property),
            $this->createMethodName('is', $property),
            $property
        ];

        $r = new \ReflectionObject($obj);
        foreach ($methods as $method) {
            if ($r->hasMethod($method)) {
                $result = $r->getMethod($method)->invoke($obj);

                return $result;
            }
        }

        if ($r->hasProperty($property)) {
            $rProperty = $r->getProperty($property);
            if ($rProperty->isPublic()) {
                $result = $rProperty->getValue($obj);

                return $result;
            }
        }

        return null;
    }
982681
protected function getMagicMethodProperty($method)
    {
        // Get the property name
        $property = lcfirst(substr($method, 3));

        $transform = function ($letters) {
            $letter = array_shift($letters);

            return '_' . strtolower($letter);
        };

        $property = preg_replace_callback('/([A-Z])/', $transform, $property);

        // Make sure the property exists
        if (! array_key_exists($property, $this->object)) {
            throw new InvalidArgumentException('Property, '.$property.', not found');
        }

        return $property;
    }
601201
public static function isPropertyClassArray($class, $propertyName)
    {
        // If the class doesn't exist, or the method doesn't exist, return null.
        if (!class_exists($class) || !method_exists($class, self::getter($class, $propertyName))) {
            return null;
        }

        if (($annotations = self::propertyAnnotations($class, $propertyName)) && isset($annotations['return'])) {
            $param = $annotations['return'];
        }

        if (isset($param)) {
            return substr($param, -strlen('[]')) === '[]';
        } else {
            throw new BlockCypherConfigurationException("Getter function for '$propertyName' in '$class' class should have a proper return type.");
        }
    }
609045
public static MethodInstance getGetterEL(Class clazz, String prop) {
	prop = "get" + StringUtil.ucFirst(prop);
	MethodInstance mi = getMethodInstanceEL(null, clazz, KeyImpl.getInstance(prop), ArrayUtil.OBJECT_EMPTY);
	if (mi == null) return null;
	if (mi.getMethod().getReturnType() == void.class) return null;
	return mi;
    }
14165
public static function ofMethod($class, $method, $key = null)
	{
		$reflector = is_object($class) ? new \ReflectionObject($class) : new \ReflectionClass($class);

		if(!static::cache()->hasMethod($reflector->getName(), $method)) {
			$annotations = static::parser()->parse($reflector->getMethod($method)->getDocComment());
			static::cache()->storeMethod($reflector->getName(), $method, $annotations);
		}
		else {
			$annotations = static::cache()->getMethod($reflector->getName(), $method);
		}

		if($key) {
			return isset($annotations[$key]) ? $annotations[$key] : null;
		}

		return $annotations;
	}
786246
public function staticProperty($class, $property, $args = array()) {
		if(!class_exists($class))
			return null;
		if(!property_exists($class, $property))
			return null;
		
		$vars = get_class_vars($class);
		return $vars[$property];
	}
745751
private function guessFieldType($field, $entityClass)
    {
        if (!$this->translatableManager->isTranslatable($entityClass)) {
            return null;
        }

        $guess = $this->formRegistry->getTypeGuesser()->guessType($entityClass, $field);

        return $guess->getConfidence() > 0
            ? $guess
            : $this->formRegistry->getTypeGuesser()->guessType($this->translatableManager->getTranslationClass($entityClass), $field);
    }
976570
private function getMutatorMethod(string $class, string $property): ?array
    {
        $ucProperty = ucfirst($property);
        $ucSingulars = (array) Inflector::singularize($ucProperty);

        foreach ($this->mutatorPrefixes as $prefix) {
            $names = [$ucProperty];
            if (\in_array($prefix, $this->arrayMutatorPrefixes)) {
                $names = array_merge($names, $ucSingulars);
            }

            foreach ($names as $name) {
                try {
                    $reflectionMethod = new \ReflectionMethod($class, $prefix.$name);
                    if ($reflectionMethod->isStatic()) {
                        continue;
                    }

                    // Parameter can be optional to allow things like: method(array $foo = null)
                    if ($reflectionMethod->getNumberOfParameters() >= 1) {
                        return [$reflectionMethod, $prefix];
                    }
                } catch (\ReflectionException $e) {
                    // Try the next prefix if the method doesn't exist
                }
            }
        }

        return null;
    }
743807
protected function getReflectionMethod($class, $method)
    {
        if (!isset($this->methodReflectors[$class])) {
            $this->methodReflectors[$class] = [];
        }
        if (!isset($this->methodReflectors[$class][$method])) {
            $this->methodReflectors[$class][$method] = new \ReflectionMethod($class, $method);
        }

        return $this->methodReflectors[$class][$method];
    }
581040
protected function getMethod($target, $property, $pre = 'get')
    {
        if(isset($this->$property)){
            $method = $pre . ucfirst($this->$property);
            if(method_exists($target, $method)){
                return $method;
            }
            throw new MethodNotFoundException($method, get_class($target));
        }
        throw new PropertyNotFoundException($property, get_class($target));
    }