Vérification de l'exhaustivité des instructions switch

Il est recommandé de veiller à ce que chaque instruction switch soit terminée de sorte que chaque exécution, pendant la phase d'exécution, trouve une branche appropriée. Il s'agit actuellement d'une tâche non élémentaire prenant en compte toutes les tâches suivantes :

De plus, le JLS mandate une analyse de flux pour les instructions switch d'énumération qui peut entraîner des erreurs de temps de compilation inattendues :

    enum Colors { RED, GREEN, BLUE }
    String colorString(Color c) {
        switch(c) {
            case RED: return "red";
            case GREEN: return "green";
            case BLUE: return "blue";
        }
    }

Le compilateur répondra :

"Cette méthode doit renvoyer un résultat de type 'String'. Notez qu'un problème concernant l'instruction 'default:' manquante sur l'instruction 'switch' a été supprimé, ce qui est sans doute lié à ce problème".

Ce message a été conçu pour alerter les utilisateurs des différentes notions de finalisation : l'analyse de flux mandatée par le JLS considère chaque instruction switch d'énumération sans cas default comme incomplète, même si elle liste toutes les constantes d'énumération (actuellement connues). Cela concerne les instructions de retour ainsi que l'affectation définitive des variables locales ou des zones finales vides. Cependant, si vous autorisez toutes les recommandation ci-dessous, le message d'erreur ci-dessus n'aura jamais lieu.

Consultez les préférences du compilateur concernant les options de configuration individuelles pour signaler les différents niveaux d'incomplétude. Par la suite, nous discuterons des différents objectifs et politiques de conception et de la façon dont ils peuvent être vérifiés à l'aide du compilateur Java d'Eclipse.

Sur l'utilisation de "default :"

De manière optimale, chaque instruction switch devrait avoir une branche par défaut significative, qui indique tous les cas qui ne sont pas listés explicitement à l'aide de la stratégie "toujours raisonnable". Bien évidemment, une telle stratégie est difficile voire même impossible à trouver dans de nombreux cas, mais si vous pouvez trouver une implémentation par défaut significative, il s'agirait certainement de la meilleure solution.

Recommandation : si vous laissez le compilateur vous avertir au sujet de chaque instruction switch pour laquelle il manque le cas default, le système vous rappelle de rechercher une bonne implémentation par défaut pour chaque instruction switch.

Si le compilateur vous avertit qu'il manque un cas default, mais que la chose raisonnable à faire par défaut est juste de ne rien faire, cela mérite également d'être noté.

Recommandation : si "ne rien faire" est une stratégie par défaut raisonnable, vous devriez ajouter une étiquette default: qui sert uniquement de commentaire expliquant que (et pourquoi) ne rien faire est CORRECT dans ce cas. Ainsi, vous pouvez également indiquer au compilateur que vous n'avez tout simplement pas oublié de cas default.

Si vraiment aucune implémentation par défaut ne peut être trouvée, vous pouvez en dernier recours vouloir éviter qu'une valeur inattendue ne soit la cause première de plusieurs autres erreurs en aval, par exemple, en faisant en sorte qu'elle échoue tôt au cours de l'exécution.

Recommandation : si une implémentation par défaut ne peut pas être trouvée ou si "ne rien faire" semble être une bonne stratégie, ajoutez un cas default: qui émet une exception et/ou consigne le problème.

Chaque instruction switch devrait être attribuée à l'une des trois catégories ci-dessus. Cela signifie que laisser le compilateur vous avertir de chaque cas default manquant est une stratégie universellement valide.

Traitement de toutes les constantes d'énumération

Lorsqu'on effectue une commutation vers une valeur d'énumération, il pourrait être souhaitable de traiter explicitement chaque constante d'énumération par une instruction case correspondante.

Recommandation : si vous voulez être averti des instructions switch d'énumération pour lesquelles il manque une instruction case pour n'importe quelle constante d'énumération, veuillez activer l'option Signaler même si le cas 'default' existe.

Si vous ne voulez pas que tous les commutateurs d'énumération mentionnent toutes les constantes d'énumération, mais que vous voulez être averti quand il manque les étiquettes case de certaines instructions 'switch' d'énumération, vous devrez sélectionner la stratégie pour chaque instruction 'switch' d'énumération individuelle.

Recommandation : si l'avertissement ci-dessus est souhaitable pour certaines instructions switch, pensez à activer globalement l'avertissement et à identifier les instructions switch pour lesquelles on peut omettre des cas pour certaines constantes d'énumération, car elles sont convenablement traitées par le cas default. Pour ces instructions switch, utilisez le commentaire de balise '//$CASES-OMITTED$' pour documenter votre décision :
    String colorString2(Color c) {
        switch(c) {
        case RED: return "red";
        case GREEN: return "green";
            //$CASES-OMITTED$
        default:
        	return "unknown color";
        }
    }

Suggestion : si le compilateur signale quelque chose comme "La constante d'énumération BLUE a besoin d'un libellé "case" correspondant dans cette instruction enum switch sur Color", un correctif rapide permettra d'insérer le commentaire de balise.

Récapitulatif

Les considérations ci-dessus ont montré que vous obteniez plus d'aide du compilateur en activant tous les avertissements facultatifs concernant les instructions switch incomplètes, et en utilisant des cas default qui ne sont pas documentés et des commentaires de balise //$CASES-OMITTED$ pour marquer que ces instructions incomplètes sont OK par conception. Si vous suivez ces recommandations, vous obtiendrez tous les avertissements appropriés (ou erreurs si vous le souhaitez) lors de l'omission accidentelle de branches, y compris la situation d'ajout tardif d'une ou plusieurs constantes d'énumération. Toutes les exceptions de cette finalisation maximale seront consignées dans le code et non plus marquées avec un avertissement.

Le compilateur ne pouvant toujours pas éviter l'utilisation de versions de classe incohérentes lors de l'exécution, une classe peut donc être compilée par rapport à une ancienne version d'un type d'énumération, mais dans l'application en cours d'exécution le type énumération peut avoir plusieurs constantes d'énumération. Dans le cas de situations similaires, des implémentations par défaut "catch-all" appropriées peuvent produire des exceptions d'exécution pour prévenir de cette incohérence et empêcher l'erreur de se propager plus loin dans l'application.

En tant que valeur ajoutée des paramètres de compilation stricts recommandés ci-dessus, le message d'erreur douteux à propos d'une instruction de retour manquante indiqué ci-dessus ou les messages similaires à propos des variables non initialisées ne s'afficheront plus.