Doctrine\ORM\Query\Parser::_processDeferredPathExpressions PHP Method

    private function _processDeferredPathExpressions($AST)
    {
        foreach ($this->_deferredPathExpressions as $deferredItem) {
            $pathExpression = $deferredItem['expression'];

            $qComp = $this->_queryComponents[$pathExpression->identificationVariable];
            $class = $qComp['metadata'];

            if (($field = $pathExpression->field) === null) {
                $field = $pathExpression->field = $class->identifier[0];
            }
            
            // Check if field or association exists
            if ( ! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
                $this->semanticalError(
                    'Class ' . $class->name . ' has no field or association named ' . $field,
                    $deferredItem['token']
                );
            }

            if (isset($class->fieldMappings[$field])) {
                $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
            } else {
                $assoc = $class->associationMappings[$field];
                $class = $this->_em->getClassMetadata($assoc['targetEntity']);

                if ($assoc['type'] & ClassMetadata::TO_ONE) {
                    $fieldType = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
                } else {
                    $fieldType = AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
                }
            }

            // Validate if PathExpression is one of the expected types
            $expectedType = $pathExpression->expectedType;

            if ( ! ($expectedType & $fieldType)) {
                // We need to recognize which was expected type(s)
                $expectedStringTypes = array();

                // Validate state field type
                if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
                    $expectedStringTypes[] = 'StateFieldPathExpression';
                }

                // Validate single valued association (*-to-one)
                if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
                    $expectedStringTypes[] = 'SingleValuedAssociationField';
                }

                // Validate single valued association (*-to-many)
                if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
                    $expectedStringTypes[] = 'CollectionValuedAssociationField';
                }

                // Build the error message
                $semanticalError = 'Invalid PathExpression. ';

                if (count($expectedStringTypes) == 1) {
                    $semanticalError .= 'Must be a ' . $expectedStringTypes[0] . '.';
                } else {
                    $semanticalError .= implode(' or ', $expectedStringTypes) . ' expected.';
                }

                $this->semanticalError($semanticalError, $deferredItem['token']);
            }
            
            // We need to force the type in PathExpression
            $pathExpression->type = $fieldType;
        }
    }