Regras de resolução de nomes

Nomes são resolvidos seguindo estas regras de resolução:

Todos nomes qualificados são traduzidos durante a compilação de acordo com a atual regra do import. Por exemplo, se o namespace A\B\C é importado, uma chamada para C\D\e() é traduzida para A\B\C\D\e().
Nomes não qualificados de classes são traduzidos durante compilação de acordo com a atual regra de import (nome completo substituído pelo pequeno nome importado). Por exemplo, se o namespace A\B\C é importado, new C() é traduzido para new A\B\C().
Dentro do namespace, chamadas para nomes não qualificados de funções que são definidos no atual namespace (e é conhecido na hora que a chamada é analisada) são interpretados como chamadas para estas funções do namespace, em tempo de compilação.
Dentro do namespace (digo A\B), chamadas para funções não qualificadas que não são definidas no atual namespace são resolvidos em tempo de execução. Veja como uma chamada para uma função foo() é resolvida:
1. Ele procura por uma função do atual namespace: A\B\foo().
2. Ele procura e tenta chamar a função interna foo().
Para chamar a função definida do usuário no namespace global, \foo() tem que ser usado.
Dentro do namespace (digo A\B), chamadas para não qualificados nomes de classes são resolvidos em tempo de execução. Veja como uma chamada para new C() é resolvida:
1. Ele verifica por uma classe do namespace atual: A\B\C.
2. Ele tenta buscar e chamar a classe interna C.
3. Ele tenta fazer autoload A\B\C.
Para referenciar a classe definida pelo usuário no namespace global, new \C() tem que ser usado.
Chamadas para qualificadas funções são resolvidas em tempo de execução. Veja como a chamada para A\B\foo() é resolvida:
1. Ele verifica por uma função foo() no namespace A\B.
2. Ele verifica por uma classe A\B e chama o método estático foo(). Irá fazer autoload da class se necessário.
Qualificados nomes de classes são resolvidos em tempo de compilação como classes correspondentes do namespace. Por exemplo, new A\B\C() refere-se a classe C do namespace A\B.

Exemplo #1 Ilustrando resolução de nomes


<?php
namespace A;

// function calls

foo();      // first tries to call "foo" defined in namespace "A"
            // then calls internal function "foo"

\foo();    // calls function "foo" defined in global scope

// class references

new B();    // first tries to create object of class "B" defined in namespace "A"
            // then creates object of internal class "B"

new \B();  // creates object of class "B" defined in global scope

// static methods/namespace functions from another namespace

B\foo();   // first tries to call function "foo" from namespace "A\B"
            // then calls method "foo" of internal class "B"

\B\foo(); // first tries to call function "foo" from namespace "B"
            // then calls method "foo" of class "B" from global scope

// static methods/namespace functions of current namespace

A\foo();   // first tries to call function "foo" from namespace "A\A"
            // then tries to call method "foo" of class "A" from namespace "A"
            // then tries to call function "foo" from namespace "A"
            // then calls method "foo" of internal class "A" 

\A\foo(); // first tries to call function "foo" from namespace "A"
            // then calls method "foo" of class "A" from global scope
?>