gcc/d/dmd/blockexit.d

   1 /**
   2  * Find out in what ways control flow can exit a statement block.
   3  *
   4  * Copyright:   Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
   5  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   6  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   7  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/blockexit.d, _blockexit.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_blockexit.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/blockexit.d
  10  */
  11
  12 module dmd.blockexit;
  13
  14 import core.stdc.stdio;
  15
  16 import dmd.arraytypes;
  17 import dmd.astenums;
  18 import dmd.canthrow;
  19 import dmd.dclass;
  20 import dmd.declaration;
  21 import dmd.errorsink;
  22 import dmd.expression;
  23 import dmd.func;
  24 import dmd.globals;
  25 import dmd.id;
  26 import dmd.identifier;
  27 import dmd.location;
  28 import dmd.mtype;
  29 import dmd.statement;
  30 import dmd.tokens;
  31
  32 /**
  33  * BE stands for BlockExit.
  34  *
  35  * It indicates if a statement does transfer control to another block.
  36  * A block is a sequence of statements enclosed in { }
  37  */
  38 enum BE : int
  39 {
  40     none      = 0,
  41     fallthru  = 1,
  42     throw_    = 2,
  43     return_   = 4,
  44     goto_     = 8,
  45     halt      = 0x10,
  46     break_    = 0x20,
  47     continue_ = 0x40,
  48     errthrow  = 0x80,
  49     any       = (fallthru | throw_ | return_ | goto_ | halt),
  50 }
  51
  52
  53 /*********************************************
  54  * Determine mask of ways that a statement can exit.
  55  *
  56  * Only valid after semantic analysis.
  57  * Params:
  58  *   s = statement to check for block exit status
  59  *   func = function that statement s is in
  60  *   eSink = generate an error if it throws
  61  * Returns:
  62  *   BE.xxxx
  63  */
  64 int blockExit(Statement s, FuncDeclaration func, ErrorSink eSink)
  65 {
  66         int result = BE.none;
  67
  68         void visitDefaultCase(Statement s)
  69         {
  70             printf("Statement::blockExit(%p)\n", s);
  71             printf("%s\n", s.toChars());
  72             assert(0);
  73         }
  74
  75         void visitError(ErrorStatement s)
  76         {
  77             result = BE.none;
  78         }
  79
  80         void visitExp(ExpStatement s)
  81         {
  82             result = BE.fallthru;
  83             if (s.exp)
  84             {
  85                 if (s.exp.op == EXP.halt)
  86                 {
  87                     result = BE.halt;
  88                     return;
  89                 }
  90                 if (AssertExp a = s.exp.isAssertExp())
  91                 {
  92                     if (a.e1.toBool().hasValue(false)) // if it's an assert(0)
  93                     {
  94                         result = BE.halt;
  95                         return;
  96                     }
  97                 }
  98                 if (s.exp.type && s.exp.type.toBasetype().isTypeNoreturn())
  99                     result = BE.halt;
 100
 101                 result |= canThrow(s.exp, func, eSink);
 102             }
 103         }
 104
 105         void visitDtorExp(DtorExpStatement s)
 106         {
 107             visitExp(s);
 108         }
 109
 110         void visitMixin(MixinStatement s)
 111         {
 112             assert(global.errors);
 113             result = BE.fallthru;
 114         }
 115
 116         void visitCompound(CompoundStatement cs)
 117         {
 118             //printf("CompoundStatement.blockExit(%p) %d result = x%X\n", cs, cs.statements.length, result);
 119             result = BE.fallthru;
 120             Statement slast = null;
 121             foreach (s; *cs.statements)
 122             {
 123                 if (s)
 124                 {
 125                     //printf("result = x%x\n", result);
 126                     //printf("s: %s\n", s.toChars());
 127                     if (result & BE.fallthru && slast)
 128                     {
 129                         slast = slast.last();
 130                         if (slast && (slast.isCaseStatement() || slast.isDefaultStatement()) && (s.isCaseStatement() || s.isDefaultStatement()))
 131                         {
 132                             // Allow if last case/default was empty
 133                             CaseStatement sc = slast.isCaseStatement();
 134                             DefaultStatement sd = slast.isDefaultStatement();
 135                             auto sl = (sc ? sc.statement : (sd ? sd.statement : null));
 136
 137                             if (sl && (!sl.hasCode() || sl.isErrorStatement()))
 138                             {
 139                             }
 140                             else if (func.getModule().filetype != FileType.c)
 141                             {
 142                                 const(char)* gototype = s.isCaseStatement() ? "case" : "default";
 143                                 // @@@DEPRECATED_2.110@@@ https://issues.dlang.org/show_bug.cgi?id=22999
 144                                 // Deprecated in 2.100
 145                                 // Make an error in 2.110
 146                                 if (sl && sl.isCaseStatement())
 147                                     global.errorSink.deprecation(s.loc, "switch case fallthrough - use 'goto %s;' if intended", gototype);
 148                                 else
 149                                     global.errorSink.error(s.loc, "switch case fallthrough - use 'goto %s;' if intended", gototype);
 150                             }
 151                         }
 152                     }
 153
 154                     if ((result & BE.fallthru) || s.comeFrom())
 155                     {
 156                         result &= ~BE.fallthru;
 157                         result |= blockExit(s, func, eSink);
 158                     }
 159                     slast = s;
 160                 }
 161             }
 162         }
 163
 164         void visitUnrolledLoop(UnrolledLoopStatement uls)
 165         {
 166             result = BE.fallthru;
 167             foreach (s; *uls.statements)
 168             {
 169                 if (s)
 170                 {
 171                     int r = blockExit(s, func, eSink);
 172                     result |= r & ~(BE.break_ | BE.continue_ | BE.fallthru);
 173                     if ((r & (BE.fallthru | BE.continue_ | BE.break_)) == 0)
 174                         result &= ~BE.fallthru;
 175                 }
 176             }
 177         }
 178
 179         void visitScope(ScopeStatement s)
 180         {
 181             //printf("ScopeStatement::blockExit(%p)\n", s.statement);
 182             result = blockExit(s.statement, func, eSink);
 183         }
 184
 185         void visitWhile(WhileStatement s)
 186         {
 187             assert(global.errors);
 188             result = BE.fallthru;
 189         }
 190
 191         void visitDo(DoStatement s)
 192         {
 193             if (s._body)
 194             {
 195                 result = blockExit(s._body, func, eSink);
 196                 if (result == BE.break_)
 197                 {
 198                     result = BE.fallthru;
 199                     return;
 200                 }
 201                 if (result & BE.continue_)
 202                     result |= BE.fallthru;
 203             }
 204             else
 205                 result = BE.fallthru;
 206             if (result & BE.fallthru)
 207             {
 208                 result |= canThrow(s.condition, func, eSink);
 209
 210                 if (!(result & BE.break_) && s.condition.toBool().hasValue(true))
 211                     result &= ~BE.fallthru;
 212             }
 213             result &= ~(BE.break_ | BE.continue_);
 214         }
 215
 216         void visitFor(ForStatement s)
 217         {
 218             result = BE.fallthru;
 219             if (s._init)
 220             {
 221                 result = blockExit(s._init, func, eSink);
 222                 if (!(result & BE.fallthru))
 223                     return;
 224             }
 225             if (s.condition)
 226             {
 227                 result |= canThrow(s.condition, func, eSink);
 228
 229                 const opt = s.condition.toBool();
 230                 if (opt.hasValue(true))
 231                     result &= ~BE.fallthru;
 232                 else if (opt.hasValue(false))
 233                     return;
 234             }
 235             else
 236                 result &= ~BE.fallthru; // the body must do the exiting
 237             if (s._body)
 238             {
 239                 int r = blockExit(s._body, func, eSink);
 240                 if (r & (BE.break_ | BE.goto_))
 241                     result |= BE.fallthru;
 242                 result |= r & ~(BE.fallthru | BE.break_ | BE.continue_);
 243             }
 244             if (s.increment)
 245                 result |= canThrow(s.increment, func, eSink);
 246         }
 247
 248         void visitForeach(ForeachStatement s)
 249         {
 250             result = BE.fallthru;
 251             result |= canThrow(s.aggr, func, eSink);
 252
 253             if (s._body)
 254                 result |= blockExit(s._body, func, eSink) & ~(BE.break_ | BE.continue_);
 255         }
 256
 257         void visitForeachRange(ForeachRangeStatement s)
 258         {
 259             assert(global.errors);
 260             result = BE.fallthru;
 261         }
 262
 263         void visitIf(IfStatement s)
 264         {
 265             //printf("IfStatement::blockExit(%p)\n", s);
 266             result = BE.none;
 267             result |= canThrow(s.condition, func, eSink);
 268
 269             const opt = s.condition.toBool();
 270             if (opt.hasValue(true))
 271             {
 272                 result |= blockExit(s.ifbody, func, eSink);
 273             }
 274             else if (opt.hasValue(false))
 275             {
 276                 result |= blockExit(s.elsebody, func, eSink);
 277             }
 278             else
 279             {
 280                 result |= blockExit(s.ifbody, func, eSink);
 281                 result |= blockExit(s.elsebody, func, eSink);
 282             }
 283             //printf("IfStatement::blockExit(%p) = x%x\n", s, result);
 284         }
 285
 286         void visitConditional(ConditionalStatement s)
 287         {
 288             result = blockExit(s.ifbody, func, eSink);
 289             if (s.elsebody)
 290                 result |= blockExit(s.elsebody, func, eSink);
 291         }
 292
 293         void visitPragma(PragmaStatement s)
 294         {
 295             result = BE.fallthru;
 296         }
 297
 298         void visitStaticAssert(StaticAssertStatement s)
 299         {
 300             result = BE.fallthru;
 301         }
 302
 303         void visitSwitch(SwitchStatement s)
 304         {
 305             result = BE.none;
 306             result |= canThrow(s.condition, func, eSink);
 307
 308             if (s._body)
 309             {
 310                 result |= blockExit(s._body, func, eSink);
 311                 if (result & BE.break_)
 312                 {
 313                     result |= BE.fallthru;
 314                     result &= ~BE.break_;
 315                 }
 316             }
 317             else
 318                 result |= BE.fallthru;
 319         }
 320
 321         void visitCase(CaseStatement s)
 322         {
 323             result = blockExit(s.statement, func, eSink);
 324         }
 325
 326         void visitDefault(DefaultStatement s)
 327         {
 328             result = blockExit(s.statement, func, eSink);
 329         }
 330
 331         void visitGotoDefault(GotoDefaultStatement s)
 332         {
 333             result = BE.goto_;
 334         }
 335
 336         void visitGotoCase(GotoCaseStatement s)
 337         {
 338             result = BE.goto_;
 339         }
 340
 341         void visitSwitchError(SwitchErrorStatement s)
 342         {
 343             // Switch errors are non-recoverable
 344             result = BE.halt;
 345         }
 346
 347         void visitReturn(ReturnStatement s)
 348         {
 349             result = BE.return_;
 350             if (s.exp)
 351                 result |= canThrow(s.exp, func, eSink);
 352         }
 353
 354         void visitBreak(BreakStatement s)
 355         {
 356             //printf("BreakStatement::blockExit(%p) = x%x\n", s, s.ident ? BE.goto_ : BE.break_);
 357             result = s.ident ? BE.goto_ : BE.break_;
 358         }
 359
 360         void visitContinue(ContinueStatement s)
 361         {
 362             result = s.ident ? BE.continue_ | BE.goto_ : BE.continue_;
 363         }
 364
 365         void visitSynchronized(SynchronizedStatement s)
 366         {
 367             result = blockExit(s._body, func, eSink);
 368         }
 369
 370         void visitWith(WithStatement s)
 371         {
 372             result = BE.none;
 373             result |= canThrow(s.exp, func, eSink);
 374             result |= blockExit(s._body, func, eSink);
 375         }
 376
 377         void visitTryCatch(TryCatchStatement s)
 378         {
 379             assert(s._body);
 380             result = blockExit(s._body, func, null);
 381
 382             int catchresult = 0;
 383             foreach (c; *s.catches)
 384             {
 385                 if (c.type == Type.terror)
 386                     continue;
 387
 388                 int cresult = blockExit(c.handler, func, eSink);
 389
 390                 /* If we're catching Object, then there is no throwing
 391                  */
 392                 Identifier id = c.type.toBasetype().isClassHandle().ident;
 393                 if (c.internalCatch && (cresult & BE.fallthru))
 394                 {
 395                     // https://issues.dlang.org/show_bug.cgi?id=11542
 396                     // leave blockExit flags of the body
 397                     cresult &= ~BE.fallthru;
 398                 }
 399                 else if (id == Id.Object || id == Id.Throwable)
 400                 {
 401                     result &= ~(BE.throw_ | BE.errthrow);
 402                 }
 403                 else if (id == Id.Exception)
 404                 {
 405                     result &= ~BE.throw_;
 406                 }
 407                 catchresult |= cresult;
 408             }
 409             if (eSink && (result & BE.throw_))
 410             {
 411                 // now explain why this is nothrow
 412                 blockExit(s._body, func, eSink);
 413             }
 414             result |= catchresult;
 415         }
 416
 417         void visitTryFinally(TryFinallyStatement s)
 418         {
 419             result = BE.fallthru;
 420             if (s._body)
 421                 result = blockExit(s._body, func, null);
 422
 423             // check finally body as well, it may throw (bug #4082)
 424             int finalresult = BE.fallthru;
 425             if (s.finalbody)
 426                 finalresult = blockExit(s.finalbody, func, null);
 427
 428             // If either body or finalbody halts
 429             if (result == BE.halt)
 430                 finalresult = BE.none;
 431             if (finalresult == BE.halt)
 432                 result = BE.none;
 433
 434             if (eSink)
 435             {
 436                 // now explain why this is nothrow
 437                 if (s._body && (result & BE.throw_))
 438                     blockExit(s._body, func, eSink);
 439                 if (s.finalbody && (finalresult & BE.throw_))
 440                     blockExit(s.finalbody, func, eSink);
 441             }
 442
 443             if (!(finalresult & BE.fallthru))
 444                 result &= ~BE.fallthru;
 445             result |= finalresult & ~BE.fallthru;
 446         }
 447
 448         void visitScopeGuard(ScopeGuardStatement s)
 449         {
 450             // At this point, this statement is just an empty placeholder
 451             result = BE.fallthru;
 452         }
 453
 454         void visitThrow(ThrowStatement s)
 455         {
 456             if (s.internalThrow)
 457             {
 458                 // https://issues.dlang.org/show_bug.cgi?id=8675
 459                 // Allow throwing 'Throwable' object even if eSink.
 460                 result = BE.fallthru;
 461                 return;
 462             }
 463
 464             result = checkThrow(s.loc, s.exp, func, eSink);
 465         }
 466
 467         void visitGoto(GotoStatement s)
 468         {
 469             //printf("GotoStatement::blockExit(%p)\n", s);
 470             result = BE.goto_;
 471         }
 472
 473         void visitLabel(LabelStatement s)
 474         {
 475             //printf("LabelStatement::blockExit(%p)\n", s);
 476             result = blockExit(s.statement, func, eSink);
 477             if (s.breaks)
 478                 result |= BE.fallthru;
 479         }
 480
 481         void visitCompoundAsm(CompoundAsmStatement s)
 482         {
 483             // Assume the worst
 484             result = BE.fallthru | BE.return_ | BE.goto_ | BE.halt;
 485             if (!(s.stc & STC.nothrow_))
 486             {
 487                 if(func)
 488                     func.setThrow(s.loc, "`asm` statement is assumed to throw - mark it with `nothrow` if it does not");
 489                 if (eSink)
 490                     eSink.error(s.loc, "`asm` statement is assumed to throw - mark it with `nothrow` if it does not"); // TODO
 491                 else
 492                     result |= BE.throw_;
 493             }
 494         }
 495
 496         void visitImport(ImportStatement s)
 497         {
 498             result = BE.fallthru;
 499         }
 500
 501     if (!s)
 502         return BE.fallthru;
 503     mixin VisitStatement!void visit;
 504     visit.VisitStatement(s);
 505     return result;
 506 }
 507
 508 /++
 509  + Checks whether `throw <exp>` throws an `Exception` or an `Error`
 510  + and raises an error if this violates `nothrow`.
 511  +
 512  + Params:
 513  +   loc          = location of the `throw`
 514  +   exp          = expression yielding the throwable
 515  +   eSink        = if !null then inside of a `nothrow` scope
 516  +   func         = function containing the `throw`
 517  +
 518  + Returns: `BE.[err]throw` depending on the type of `exp`
 519  +/
 520 BE checkThrow(ref const Loc loc, Expression exp, FuncDeclaration func, ErrorSink eSink)
 521 {
 522     Type t = exp.type.toBasetype();
 523     ClassDeclaration cd = t.isClassHandle();
 524     assert(cd);
 525
 526     if (cd.isErrorException())
 527     {
 528         return BE.errthrow;
 529     }
 530     if (eSink)
 531         eSink.error(loc, "`%s` is thrown but not caught", exp.type.toChars());
 532     else if (func)
 533         func.setThrow(loc, "`%s` is thrown but not caught", exp.type);
 534
 535     return BE.throw_;
 536 }