Como suprimir avisos Java para diretórios ou arquivos específicos, como código gerado

Estou usando um gerador de analisador que cria um código meio feio. Como resultado, meu projeto Eclipse tem várias dezenas de avisos provenientes de arquivos de origem gerados. Sei que posso usar a @SuppressWarninganotação para suprimir avisos específicos em elementos específicos, mas qualquer anotação que adicionar manualmente será perdida quando o gerador do analisador for executado novamente. Existe uma maneira de configurar o Eclipse para suprimir avisos para um arquivo ou diretório específico?

A partir da versão 3.8 M6, o Eclipse (para ser exato: o JDT) tem funcionalidade integrada para isso. É configurável por meio do caminho de construção de um projeto: Propriedades do projeto> Caminho de construção Java> Compilador> Código-fonte

Anunciado aqui: Eclipse 3.8 e 4.2 M6 - Novo e notável , chamado Ignorar erros / avisos seletivamente das pastas de origem . É também de onde vem a imagem. Este é o novo recurso desenvolvido no Bug 220928 anteriormente vinculado .

Há um tíquete para isso, Bug 220928 , que já foi concluído para o Eclipse 3.8. Por favor, veja esta resposta para detalhes.

Se você estiver preso ao Eclipse 3.7 ou inferior: O usuário "Marc" comentando sobre esse tíquete criou (ou pelo menos se vincula a) um plugin chamado 'warningcleaner' em comentário 35 . Estou usando isso com muito sucesso enquanto espero que esse recurso seja integrado ao Eclipse.

É realmente muito simples:

1. Instalar plugin.
2. Clique com o botão direito do mouse no projeto e selecione "Adicionar / remover natureza do código gerado".
3. Abra as configurações do projeto (clique com o botão direito e selecione "propriedades").
4. Abra a guia 'Warning Cleaner'.
5. Selecione as pastas de origem das quais deseja ignorar os avisos.

Eu resolvi isso usando o plugin maven regexp replace - ele não resolve a causa, mas cura a dor:

<plugin>
  <groupId>com.google.code.maven-replacer-plugin</groupId>
  <artifactId>maven-replacer-plugin</artifactId>
  <version>1.3.2</version>
  <executions>
<execution>
  <phase>prepare-package</phase>
  <goals>
    <goal>replace</goal>
  </goals>
</execution>
  </executions>
  <configuration>
<includes>
  <include>target/generated-sources/antlr/**/*.java</include>
</includes>

<regex>true</regex>
<regexFlags>
  <regexFlag>MULTILINE</regexFlag>
</regexFlags>

<replacements>
  <replacement>
    <token>^public class</token>
    <value>@SuppressWarnings("all") public class</value>
  </replacement>
</replacements>
  </configuration>
</plugin>

Observe que eu não consegui fazer a notação ** funcionar, então você pode ter que especificar o caminho exatamente.

Veja o comentário abaixo para uma melhoria em como não gerar @SupressWarnings duplicados

Acho que o melhor que você pode fazer é habilitar as configurações específicas do projeto para a exibição de avisos.

Janela -> Preferências -> Java -> Compilador -> Erros / Avisos

No topo do formulário está um link para definir as configurações específicas do projeto.

O usuário @Jorn sugeriu que o código Ant fizesse isso. Aqui está o que eu tenho

<echo>Adding @SuppressWarnings("all") to ANTLR generated parser/lexer *.java</echo>
<echo> in ${project.build.directory}/generated-sources/antlr/</echo>
<replace dir="${project.build.directory}/generated-sources/antlr/" 
         summary="true" 
         includes="**/*.java" 
         token="public class" 
         value='@SuppressWarnings("all") public class' />

Observe que o <replace> do Ant faz a substituição de texto, não a substituição de expressão regular, portanto, ele não pode usar o metacaractere ^ no token para corresponder ao início da linha como o plug-in maven regexp replace faz.

Estou fazendo isso ao mesmo tempo em que executo o Antlr do maven-antrun-plugin no meu pom Maven, porque o plugin ANTLR maven não funcionou bem com o plugin maven Cobertura.

(Eu percebo que esta não é uma resposta à pergunta original, mas não posso formatar o código Ant em um comentário / resposta a outra resposta, apenas em uma resposta)

Eu não acho que o Eclipse inerentemente fornece uma maneira de fazer isso no nível do diretório (mas não tenho certeza).

Você poderia fazer com que os arquivos gerados fossem para um projeto Java separado e controlar os avisos para esse projeto específico.

Eu geralmente prefiro colocar o código gerado automaticamente em um projeto separado de qualquer maneira.

Você só pode suprimir avisos no nível do projeto. No entanto, você pode configurar a guia de problemas para suprimir avisos de arquivos ou pacotes. Vá para o menu Configurar Conteúdo e trabalhe com o escopo "No conjunto de trabalho:".

Este pequeno script python "corrige" os .classpatharquivos gerados por M2E e adiciona a tag XML necessária a todas as pastas de origem, começando com target/generated-sources. Você pode simplesmente executá-lo da pasta raiz do seu projeto. Obviamente, você precisa executá-lo novamente quando as informações do projeto Eclipse forem geradas novamente a partir do M2E. E tudo por sua própria conta e risco, obviamente ;-)

#!/usr/bin/env python
from xml.dom.minidom import parse
import glob
import os

print('Reading .classpath files...')
for root, dirs, files in os.walk('.'):
    for name in files:
        if (name == '.classpath'):
            classpathFile = os.path.join(root, name)
            print('Patching file:' + classpathFile)
            classpathDOM = parse(classpathFile)
            classPathEntries = classpathDOM.getElementsByTagName('classpathentry')
            for classPathEntry in classPathEntries:
                if classPathEntry.attributes["path"].value.startswith('target/generated-sources'):
                    # ensure that the <attributes> tag exists
                    attributesNode = None;
                    for attributes in classPathEntry.childNodes:
                            if (attributes.nodeName == 'attributes'):
                                attributesNode = attributes

                    if (attributesNode == None):
                        attributesNode = classpathDOM.createElement('attributes')
                        classPathEntry.appendChild(attributesNode)

                    # search if the 'ignore_optional_problems' entry exists
                    hasBeenSet = 0
                    for node in attributesNode.childNodes:
                        if (node.nodeName == 'attribute' and node.getAttribute('name') == 'ignore_optional_problems'):
                            # it exists, make sure its value is true
                            node.setAttribute('value','true')
                            #print(node.getAttribute('name'))
                            hasBeenSet = 1

                    if (not(hasBeenSet)):
                        # it does not exist, add it
                        x = classpathDOM.createElement("attribute")
                        x.setAttribute('name','ignore_optional_problems')
                        x.setAttribute('value','true')
                        attributesNode.appendChild(x)

            try:
                f = open(classpathFile, "w") 
                classpathDOM.writexml(f)
                print('Writing file:' + classpathFile)
            finally:
                f.close()
print('Done.')

Estou fazendo isso com algumas gramáticas ANTLR, que geram um analisador Java usando Ant. O script de construção Ant inclui o @SuppressWarnings("all")em um arquivo Java e @Overridealguns métodos em outro. Posso pesquisar como é feito exatamente, se você estiver interessado.

No caso do ANTLR 2, é possível suprimir avisos no código gerado por appenidng @SuppressWarningsantes da declaração da classe no arquivo de gramática, por exemplo

{@SuppressWarnings("all")} class MyBaseParser extends Parser;

Isso pode ser feito excluindo certos diretórios do caminho de construção (o exemplo a seguir é fornecido usando o Eclipse 3.5)

[1] Abra o caminho de construção Java

• Clique no projeto no Package Explorer
• Clique com o botão direito, propriedades
• Selecione o caminho de construção Java

[2] Adicionar diretórios para excluir

• A guia Fonte deve conter detalhes das pastas de fonte do projeto
• Expanda a pasta de origem e localize a propriedade 'Excluído:'
• Selecione 'Excluído:' e clique em Editar
• Adicione pastas aos padrões de exclusão usando as opções Adicionar / Adicionar vários
• Clique em Concluir e em ok para o Eclipse reconstruir.

Já faz um tempo desde que lancei o plugin de limpeza de avisos e agora que estou usando o Eclipse 3.8, não preciso mais dele. No entanto, para aqueles que ainda precisam desse plugin, eu o lancei no github com o site de atualização no bintray. Se você ainda estiver usando o Eclipse 3.7 ou antes, isso pode ser útil. Verifique este site para detalhes de instalação.

Se o projeto eclipse for gerado a partir do gradle usando o eclipse comando do plugin Eclipse, a Selectively ignore errors/warnings from source foldersopção pode ser definida adicionando-se isto no nível superior do seu build.gradlearquivo:

eclipse.classpath.file {
    whenMerged { classpath ->
        classpath.entries.each { entry -> 
            if (entry.path.contains('build/generated/parser')) {
                entry.entryAttributes['ignore_optional_problems'] = true
            }
        }
    }
}

Isso pressupõe que as fontes geradas estão na build/generated/parserpasta.