Advertências

Advertências não são uma parte definida da Linguagem de Programação D. Elas existem à arbítrio do vendedor do compilador, e provavelmente variará de vendedor para vendedor. Todas as construções que uma implementação pode gerar uma mensagem de advertência são código D legal.

Estas são as advertyências geradas pelo compilador D da Digital Mars quando a interruptor -w é lançado. A maioria tem gerado o mesmo debate animado sobre se deveria ser uma advertência, um erro, e qual seria o jeito correto de escrever código D nessas situações. Já que nenhum consenso emergiu, elas aparecem como advertências opcionais, com alternativas de como escrever código correto.

warning - implicit conversion of expression expr of type type to type can cause loss of data

byte a, b, c;
...
a = b + c;

Se é um bug ou não em um programa depende se os valores para b e c podem possivelmente causar um tranbordamento, e se esse transbordamento importa ou não para o algorítmo. A advertência pode ser resolvida por:

1. Inserir um molde:

   a = cast(byte)(b + c);
   

   Isso elimina a advertência, mas já que moldar é um instrumento obtuso que evita checagem de tipo, isso pode mascarar outro bug que poderia ser introduzido se os tipos de a, b ou c mudarem no futuro, ou se seus tipos são ajustados por uma instanciação de gabarito. (Em código genérico, o cast(byte) provavelmente seria cast(typeof(a))).
2. Mudar o tipo de a para int. Isso é geralmente uma solução melhor, mas claro que pode não trabalhar se isso deve ser de um tipo menor, que nos leva a:
3. Fazer uma checagem por transbordamento em tempo de execução:

   byte a, b, c;
   int tmp;
   ...
   tmp = b + c;
   assert(cast(byte)tmp == tmp);
   a = cast(byte)tmp;
   

   Isso assegura que nenhum bit significante será perdido.

1. Ter o compilador automaticamente inserindo o euquivalente da opção 3 checagem em tempo de execução.
2. Adicionar uma nova construção, implicit_cast(tipo)expressão que é uma forma restrita do molde geral, e somente trabalhará onde moldes implicitos normalmente seriam permitidos.
3. Implementar o implicit_cast como um gabarito.

warning - array 'length' hides other 'length' name in outer scope

Se length foi declarado como um nome de variável em um escopo exterior, aquela versão pode ter sido planejada para uso entre o [ ]. Por exemplo:

char[10] a;
int length = 4;
...
return a[length - 1]; // retorna a[9], não a[3]

1. Renomear o length exterior para outro nome.
2. Substituir o uso de length dentro do [ ] com a.length.
3. Se length estão em ecopo global ou de clase, e isso era o que a pessoa pretendia para ser usado, use .length ou this.length para desambiguação.

1. Faça length um símbolo especial ou uma pavavra reservada ao invés de uma variável declarada implicitamente.

warning - no return at end of function

int foo(int k, Collection c)
{
  foreach (int x; c)
  {
    if (x == k)
    return x + 1;
  }
}

O comportamento de D nisso, porém, não é comum para outras linguagens, e alguns programadores serã intensamente incomodados com confiar nisso, ou eles desejam ver o erro em tempo de compilação ao invés de em tempo de execução. Eles desejam ver algo explicito espressado no código fonte que o foreach não pode cair. Conseqüentemente a advertência.

A advertência pode ser resolvida por:

1. Colocando uma instruão de retorno no fechamento da função, retornando algum valor arbitrário (depois de tudo, ele nunca será executado):

   int foo(int k, Collection c)
   {
     foreach (int x; c)
     {
     if(x == k)
       return x + 1;
     }
     return 0; // suprime advertência sobre nenhuma instrução de retorno
   }
   

   Enquanto fazer isso é surpreendentemente comum, e acontece quando o programador é inexperiente ou está com pressa, é um solução espetacularmente ruim. O problema acontece quando o foreach cai devido a um bug, então ao invés de o bug ser detectado, a função retorna um valor inexperado, que pode causar outros problemas ou seguir não detectado. Há outra questão com o programador de manutenção que vê isso, e ao analisar o comportamento do código, deseja saber por que há uma instrução de retorno que nunca será executada. (Isso pode ser resolvido com comentários, mas comentários são sempre perdidos, desatualizados, ou simplesmente errados.) Código morto é sempre um problema confuso para programação de manutenção, então inserir isso deliberadamente é uma má idéia.
2. Uma solução melhor é tornar explícito o que a linguagem D faz implicitamente - por um assert lá:

   int foo(int k, Collection c)
   {
     foreach (int x; c)
     {
       if (x == k)
         return x + 1;
     }
     assert(0);
   }
   

   Agora, se o foreach cair, o erro será detectado. Além disso, ele é auto-documentado.
3. Outra alternativa é fazer um throw com uma classe de erro customizada e uma mensagem mais amiável:

   int foo(int k, Collection c)
   {
     foreach (int x; c)
     {
       if (x == k)
         return x + 1;
     }
     throw new MyErrorClass("caiu do fim de foo()");
   }
   

warning - switch statement has no default

switch (i)
{
  case 1: dothis(); break;
  case 2: dothat(); break;
}

switch (i)
{
  case 1: dothis(); break;
  case 2: dothat(); break;
  default: throw new SwitchError();
}

switch (i)
{
  case 1: dothis(); break;
  case 2: dothat(); break;
  default: break;
}

A advertência pode ser resolvida por:

1. Inserir um default explícito na forma:

   switch (i)
   {
     case 1: dothis(); break;
     case 2: dothat(); break;
     default: assert(0);
   }
   

2. Como no retorno perdido, um default com um throw de uma classe de erro customizada pode ser usado.

warning - statement is not reachable

int foo(int i)
{
  return i;
  return i + 1;
}

1. Comente o código morto com comentários /+ ... +/:

   int foo(int i)
   {
     return i;
     /+
       retorna i + 1;
     +/
   }
   

2. Ponha o código morto dentro de um version(none) condicional:

   int foo(int i)
   {
     return i;
     version (none)
     {
       return i + 1;
     }
   }
   

3. Somente compile com advertências ligadas quando fazendo construções de lançamento.