Q:

include, require dentro de funções métodos

Usar include (ou require) dentro de uma função ou método pode ocasionar algum conflito ou problema com versões mais antigas do PHP (como a 5.3)?
Notei que a maioria dos frameworks que trabalha com MVC usa require dentro de um método, por exemplo o arquivo ./CodeIgniter/system/core/Loader.php do CodeIgniter3:
public function model($model, $name = '', $db_conn = FALSE)
{
    ...

    foreach ($this->_ci_model_paths as $mod_path)
    {
        if ( ! file_exists($mod_path.'models/'.$path.$model.'.php'))
        {
            continue;
        }

        require_once($mod_path.'models/'.$path.$model.'.php');

        $this->_ci_models[] = $name;
        $CI->$name = new $model();
        return $this;
    }

    show_error('Unable to locate the model you have specified: '.$model);
}

Acredito que todos FrameWorks PHP baseados em rotas (e mvc) trabalhem assim, por isto talvez seja algo que não ocasione problemas na versões mais recentes do PHP, mas gostaria de saber referentes a versão 5.3 se pode ocorrer algum problema (não vou usar a versão 5.3 é apenas curiosidade).
Minha preocupação é devido ao require geralmente incluir uma classe (vinda do Model ou Controller geralmente) no momento da execução e no comportamento da API (PHP).

A:

Não existe problema em fazer includes dentro de funções, o que muda é apenas o escopo. Se você faz o include dentro da função, o escopo do include fica apenas dentro dessa função, ou seja, seria como se aquele código incluído fosse digitado dentro da função.
Essa resposta pode ser encontrada no site do PHP na documentação da instrução include: http://php.net/manual/pt_BR/function.include.php.

Se a inclusão ocorrer dentro de uma função todo o código contido no arquivo incluído irá se comportar como se tivesse sido definido dentro da função. Portanto ele seguirá o escopo de variáveis da função. Uma exceção para essa regra são as constantes mágicas que são interpretadas antes da inclusão ocorrer.

// Object.php
<?php
return new Object();
?>

// Classe.php
<?php
class Classe {
    public static function createObject(){
         include_once 'Object.php';
    }
}

// file.php
<?php
$object = Classe::createObject();
var_dump($object instanceof Object); //true

A:

Não ocasiona problemas. Pelo menos conheço do PHP 5.0 para cima e nunca tive problemas com isso.
include/require dentro de funções podem ser feitos normalmente. A diferença é que ela vai ficar "presa" dentro do escopo daquela função.
Perigos
Uma coisa que talvez você quisesse evitar é que um arquivo que é incluído dentro de uma função ter acesso a funções como func_get_args e os próprios argumentos da função.
Examine o seguinte exemplo:
  function add_user($user, $id)
  {
       include 'alguma_coisa.php';
  }

No arquivo alguma_coisa.php
$user = null

Imagina o que vai acontecer quando ao comportamento da função add_user?
Outra problema de dar include dentro de um método de uma classe (não confundir com função), é que você tem acesso direto ao $this, self e static, podendo também acessar propriedades privadas e protegidas.
Veja essa pergunta que fiz aqui, onde dou também uma solução para o problema:
Include dentro da classe e acesso ao $this, self ou static
Casos úteis
É claro que não se pode generalizar. Por exemplo, funções de autoload em PHP geralmente utilizam include internamente. E isso é amplamente utilizado em framework como Laravel e Codeigniter. Até mesmo o próprio composer faz uso disso.
Então veja o exemplo de uma implementação com autoload:
spl_autoload_register(function ($class)
{
      return include DIRETORIO_CLASSE . $class . '.php';
});

Classes de View (a do padrão MVC mesmo) costuma utilizar um include para "renderizar" determinado layout feito em PHP.
public function render(array $data)
{

    ob_start();
    extract($data);

    include $this->file

    return ob_get_clean();
}

#FicaADica

