Instruction de retour manquante dans une méthode non void compile

J'ai rencontré une situation dans laquelle une méthode non void manque une déclaration de retour et le code se compile toujours. Je sais que les instructions après la boucle while sont inaccessibles (code mort) et ne seraient jamais exécutées. Mais pourquoi le compilateur ne prévient-il même pas de retourner quelque chose? Ou pourquoi un langage nous permettrait-il d'avoir une méthode non vide ayant une boucle infinie et ne renvoyant rien?

public int doNotReturnAnything() {
    while(true) {
        //do something
    }
    //no return statement
}

Si j'ajoute une instruction break (même conditionnelle) dans la boucle while, le compilateur se plaint des erreurs infâmes: Method does not return a valuedans Eclipse et Not all code paths return a valuedans Visual Studio.

public int doNotReturnAnything() {
    while(true) {
        if(mustReturn) break;
        //do something
    }
    //no return statement
}

Cela est vrai à la fois pour Java et C #.

Pourquoi un langage nous permettrait-il d'avoir une méthode non vide ayant une boucle infinie et ne renvoyant rien?

La règle pour les méthodes non-void est que chaque chemin de code qui retourne doit renvoyer une valeur , et cette règle est satisfaite dans votre programme: zéro chemin de code sur zéro qui retourne renvoient une valeur. La règle n'est pas "chaque méthode non-void doit avoir un chemin de code qui retourne".

Cela vous permet d'écrire des méthodes de stub comme:

IEnumerator IEnumerable.GetEnumerator() 
{ 
    throw new NotImplementedException(); 
}

C'est une méthode non nulle. Il doit s'agir d'une méthode non vide pour satisfaire l'interface. Mais il semble ridicule de rendre cette implémentation illégale car elle ne renvoie rien.

Que votre méthode ait un point final inaccessible à cause d'un goto(rappelez-vous, a while(true)est juste une manière plus agréable d'écrire goto) au lieu d'un throw(qui est une autre forme de goto) n'est pas pertinent.

Pourquoi le compilateur ne prévient-il même pas de retourner quelque chose?

Parce que le compilateur n'a aucune bonne preuve que le code est incorrect. Quelqu'un a écrit while(true)et il semble probable que la personne qui a fait cela savait ce qu'elle faisait.

Où puis-je en savoir plus sur l'analyse d'accessibilité en C #?

Voir mes articles sur le sujet, ici:

ATBG: accessibilité de facto et de jure

Et vous pouvez également envisager de lire la spécification C #.

Le compilateur Java est suffisamment intelligent pour trouver le code inaccessible (le code après whileboucle)

et comme il est inaccessible , il ne sert à rien d'y ajouter une returndéclaration (après la whilefin)

il en va de même avec le conditionnel if

public int get() {
   if(someBoolean) {   
     return 10;
   }
   else {
     return 5;
   }
   // there is no need of say, return 11 here;
}

étant donné que la condition booléenne ne someBooleanpeut être évaluée qu'à l'un trueou l' autre false, il n'est pas nécessaire de fournir un après return explicitementif-else , car ce code est inaccessible et Java ne s'en plaint pas.

Le compilateur sait que la whileboucle n'arrêtera jamais de s'exécuter, donc la méthode ne se terminera jamais, donc une returninstruction n'est pas nécessaire.

Étant donné que votre boucle s'exécute sur une constante - le compilateur sait que c'est une boucle infinie - ce qui signifie que la méthode ne pourra jamais revenir, de toute façon.

Si vous utilisez une variable, le compilateur appliquera la règle:

Cela ne compilera pas:

// Define other methods and classes here
public int doNotReturnAnything() {
    var x = true;

    while(x == true) {
        //do something
    }
    //no return statement - won't compile
}

La spécification Java définit un concept appelé Unreachable statements. Vous n'êtes pas autorisé à avoir une instruction inaccessible dans votre code (c'est une erreur de compilation). Vous n'êtes même pas autorisé à avoir une déclaration de retour après le while (true); déclaration en Java. Une while(true);instruction rend les instructions suivantes inaccessibles par définition, vous n'avez donc pas besoin d'une returninstruction.

Notez que bien que le problème d'arrêt soit indécidable dans le cas générique, la définition de l'instruction inaccessible est plus stricte que simplement l'arrêt. C'est décider des cas très spécifiques où un programme ne s'arrête définitivement pas. Le compilateur n'est théoriquement pas capable de détecter toutes les boucles infinies et les instructions inaccessibles mais il doit détecter les cas spécifiques définis dans la spécification (par exemple, le while(true)cas)

Le compilateur est suffisamment intelligent pour découvrir que votre whileboucle est infinie.

Le compilateur ne peut donc pas penser à votre place. Il ne peut pas deviner pourquoi vous avez écrit ce code. Même chose pour les valeurs de retour des méthodes. Java ne se plaindra pas si vous ne faites rien avec les valeurs de retour de la méthode.

Donc, pour répondre à votre question:

Le compilateur analyse votre code et après avoir découvert qu'aucun chemin d'exécution ne conduit à tomber la fin de la fonction, il se termine par OK.

Il peut y avoir des raisons légitimes à une boucle infinie. Par exemple, de nombreuses applications utilisent une boucle principale infinie. Un autre exemple est un serveur Web qui peut attendre indéfiniment des demandes.

Dans la théorie des types, il y a quelque chose appelé le type inférieur qui est une sous-classe de tous les autres types (!) Et est utilisé pour indiquer la non-terminaison entre autres. (Les exceptions peuvent compter comme un type de non-résiliation - vous ne vous arrêtez pas via le chemin normal.)

Donc, d'un point de vue théorique, ces instructions qui ne se terminent pas peuvent être considérées comme retournant quelque chose de type Bottom, qui est un sous-type de int, donc vous obtenez (en quelque sorte) votre valeur de retour après tout du point de vue du type. Et c'est parfaitement normal que cela n'a aucun sens qu'un type puisse être une sous-classe de tout le reste, y compris int, car vous n'en retournez jamais un.

Dans tous les cas, via la théorie des types explicites ou non, les compilateurs (rédacteurs de compilateurs) reconnaissent que demander une valeur de retour après une instruction sans fin est idiot: il n'y a aucun cas possible dans lequel vous pourriez avoir besoin de cette valeur. (Cela peut être bien que votre compilateur vous avertisse quand il sait que quelque chose ne se terminera pas mais il semble que vous vouliez qu'il renvoie quelque chose. Mais c'est mieux de laisser les vérificateurs de style à la lint, car vous avez peut-être besoin de la signature de type qui pour une autre raison (par exemple, sous-classification) mais vous voulez vraiment la non-terminaison.)

Il n'y a pas de situation dans laquelle la fonction peut atteindre sa fin sans renvoyer une valeur appropriée. Par conséquent, le compilateur n'a rien à redire.

Visual studio a le moteur intelligent pour détecter si vous avez tapé un type de retour, alors il devrait avoir une instruction return avec dans la fonction / méthode.

Comme en PHP Votre type de retour est vrai si vous n'avez rien retourné. le compilateur obtient 1 si rien n'est retourné.

À partir de ce

public int doNotReturnAnything() {
    while(true) {
        //do something
    }
    //no return statement
}

Le compilateur sait que l'instruction while elle-même a une nature infinie afin de ne pas la considérer. et le compilateur php deviendra automatiquement vrai si vous écrivez une condition dans l'expression de while.

Mais pas dans le cas de VS il vous renverra une erreur dans la pile.

Votre boucle while fonctionnera pour toujours et par conséquent ne sortira pas pendant; il continuera à s'exécuter. Par conséquent, la partie extérieure de while {} est inaccessible et il n'y a pas de raison d'écrire return ou non. Le compilateur est suffisamment intelligent pour déterminer quelle partie est accessible et quelle partie ne l'est pas.

Exemple:

public int xyz(){
    boolean x=true;

    while(x==true){
        // do something  
    }

    // no return statement
}

Le code ci-dessus ne se compilera pas, car il peut y avoir un cas où la valeur de la variable x est modifiée dans le corps de la boucle while. Cela rend donc la partie extérieure de la boucle while accessible! Et par conséquent, le compilateur lancera une erreur «aucune instruction de retour trouvée».

Le compilateur n'est pas assez intelligent (ou plutôt paresseux;)) pour déterminer si la valeur de x sera modifiée ou non. J'espère que cela efface tout.

"Pourquoi le compilateur ne prévient-il même pas de renvoyer quelque chose? Ou pourquoi un langage nous permettrait-il d'avoir une méthode non vide ayant une boucle infinie et ne renvoyant rien?".

Ce code est également valable dans toutes les autres langues (probablement sauf Haskell!). Parce que la première hypothèse est que nous écrivons «intentionnellement» du code.

Et il y a des situations où ce code peut être totalement valide comme si vous allez l'utiliser comme thread; ou s'il retournait a Task<int>, vous pourriez effectuer une vérification d'erreur basée sur la valeur int retournée - qui ne devrait pas être retournée.

Je me trompe peut-être mais certains débogueurs permettent la modification des variables. Ici, alors que x n'est pas modifié par le code et qu'il sera optimisé par JIT, on pourrait modifier x en false et la méthode devrait retourner quelque chose (si une telle chose est autorisée par le débogueur C #).

Les spécificités du cas Java pour cela (qui sont probablement très similaires au cas C #) sont liées à la façon dont le compilateur Java détermine si une méthode est capable de retourner.

Plus précisément, les règles sont qu'une méthode avec un type de retour ne doit pas pouvoir se terminer normalement et doit à la place toujours se terminer brusquement (brusquement ici indiquant via une instruction de retour ou une exception) selon JLS 8.4.7 .

Si une méthode est déclarée avoir un type de retour, une erreur de compilation se produit si le corps de la méthode peut se terminer normalement. En d'autres termes, une méthode avec un type de retour doit renvoyer uniquement en utilisant une instruction return qui fournit un retour de valeur; il n'est pas autorisé à «déposer le bout de son corps» .

Le compilateur cherche à voir si une terminaison normale est possible sur la base des règles définies dans JLS 14.21 Instructions inaccessibles car il définit également les règles pour la complétion normale.

Notamment, les règles pour les instructions inaccessibles font un cas spécial uniquement pour les boucles qui ont une trueexpression constante définie :

Une instruction while peut se terminer normalement si au moins l'une des conditions suivantes est vraie:

• L'instruction while est accessible et l'expression de condition n'est pas une expression constante (§15.28) avec la valeur true.

• Il existe une instruction break accessible qui quitte l'instruction while.

Donc, si l' whileinstruction peut se terminer normalement , une instruction return ci-dessous est nécessaire car le code est considéré comme accessible, et toute whileboucle sans instruction break ou constante accessibletrue expression est considérée comme capable de se terminer normalement.

Ces règles signifient que votre whileinstruction avec une expression vraie constante et sans a breakn'est jamais considérée comme terminée normalement , et donc tout code en dessous n'est jamais considéré comme accessible . La fin de la méthode est en dessous de la boucle, et comme tout ce qui se trouve en dessous de la boucle est inaccessible, la fin de la méthode l'est aussi, et donc la méthode ne peut pas se terminer normalement (ce que recherche le complicateur).

if les instructions, en revanche, ne bénéficient pas de l'exemption spéciale concernant les expressions constantes accordées aux boucles.

Comparer:

// I have a compiler error!
public boolean testReturn()
{
    final boolean condition = true;

    if (condition) return true;
}

Avec:

// I compile just fine!
public boolean testReturn()
{
    final boolean condition = true;

    while (condition)
    {
        return true;
    }
}

La raison de la distinction est assez intéressante, et est due au désir de permettre des indicateurs de compilation conditionnelle qui ne provoquent pas d'erreurs de compilation (à partir du JLS):

On peut s'attendre à ce que l'instruction if soit gérée de la manière suivante:

• Une instruction if-then peut se terminer normalement ssi au moins l'une des conditions suivantes est vraie:

  • L'instruction if-then est accessible et l'expression de condition n'est pas une expression constante dont la valeur est true.

  • L'instruction then peut se terminer normalement.

  L'instruction then est accessible ssi l'instruction if-then est accessible et l'expression de condition n'est pas une expression constante dont la valeur est fausse.

• Une instruction if-then-else peut se terminer normalement si l'instruction then peut se terminer normalement ou si l'instruction else peut se terminer normalement.

  • L'instruction then est accessible ssi l'instruction if-then-else est accessible et l'expression de condition n'est pas une expression constante dont la valeur est fausse.

  • L'instruction else est accessible ssi l'instruction if-then-else est accessible et l'expression de condition n'est pas une expression constante dont la valeur est true.

Cette approche serait cohérente avec le traitement des autres structures de contrôle. Cependant, afin de permettre l'utilisation pratique de l'instruction if à des fins de "compilation conditionnelle", les règles réelles diffèrent.

À titre d'exemple, l'instruction suivante entraîne une erreur de compilation:

while (false) { x=3; }parce que l'instruction x=3;n'est pas accessible; mais le cas superficiellement similaire:

if (false) { x=3; }n'entraîne pas d'erreur de compilation. Un compilateur d'optimisation peut réaliser que l'instruction x=3;ne sera jamais exécutée et peut choisir d'omettre le code de cette instruction du fichier de classe généré, mais l'instructionx=3; n'est pas considérée comme "inaccessible" au sens technique spécifié ici.

La justification de ce traitement différent est de permettre aux programmeurs de définir des «variables de drapeau» telles que:

static final boolean DEBUG = false; puis écrivez du code tel que:

if (DEBUG) { x=3; } L'idée est qu'il devrait être possible de changer la valeur de DEBUG de false à true ou de true à false, puis de compiler le code correctement sans aucune autre modification du texte du programme.

Pourquoi l'instruction de rupture conditionnelle entraîne-t-elle une erreur du compilateur?

Comme indiqué dans les règles d'accessibilité de boucle, une boucle while peut également se terminer normalement si elle contient une instruction break accessible. Étant donné que les règles de joignabilité d'une ifde déclaration alors l' article ne prend pas l'état du ifcompte du tout, une telle condition ifdéclaration est alors clause est toujours considérée comme atteignable.

Si le breakest accessible, le code après la boucle est à nouveau considéré comme accessible. Puisqu'il n'y a pas de code accessible qui entraîne une interruption brutale après la boucle, la méthode est alors considérée comme capable de se terminer normalement, et donc le compilateur la signale comme une erreur.