1 /** 2 * Find side-effects of expressions. 3 * 4 * Copyright: Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved 5 * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright) 6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 7 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/sideeffect.d, _sideeffect.d) 8 * Documentation: https://dlang.org/phobos/dmd_sideeffect.html 9 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/sideeffect.d 10 */ 11 12 module dmd.sideeffect; 13 14 import dmd.apply; 15 import dmd.declaration; 16 import dmd.dscope; 17 import dmd.expression; 18 import dmd.expressionsem; 19 import dmd.func; 20 import dmd.globals; 21 import dmd.identifier; 22 import dmd.init; 23 import dmd.mtype; 24 import dmd.tokens; 25 import dmd.visitor; 26 27 /************************************************** 28 * Front-end expression rewriting should create temporary variables for 29 * non trivial sub-expressions in order to: 30 * 1. save evaluation order 31 * 2. prevent sharing of sub-expression in AST 32 */ 33 extern (C++) bool isTrivialExp(Expression e) 34 { 35 extern (C++) final class IsTrivialExp : StoppableVisitor 36 { 37 alias visit = typeof(super).visit; 38 public: 39 extern (D) this() 40 { 41 } 42 43 override void visit(Expression e) 44 { 45 /* https://issues.dlang.org/show_bug.cgi?id=11201 46 * CallExp is always non trivial expression, 47 * especially for inlining. 48 */ 49 if (e.op == TOK.call) 50 { 51 stop = true; 52 return; 53 } 54 // stop walking if we determine this expression has side effects 55 stop = lambdaHasSideEffect(e); 56 } 57 } 58 59 scope IsTrivialExp v = new IsTrivialExp(); 60 return walkPostorder(e, v) == false; 61 } 62 63 /******************************************** 64 * Determine if Expression has any side effects. 65 */ 66 extern (C++) bool hasSideEffect(Expression e) 67 { 68 extern (C++) final class LambdaHasSideEffect : StoppableVisitor 69 { 70 alias visit = typeof(super).visit; 71 public: 72 extern (D) this() 73 { 74 } 75 76 override void visit(Expression e) 77 { 78 // stop walking if we determine this expression has side effects 79 stop = lambdaHasSideEffect(e); 80 } 81 } 82 83 scope LambdaHasSideEffect v = new LambdaHasSideEffect(); 84 return walkPostorder(e, v); 85 } 86 87 /******************************************** 88 * Determine if the call of f, or function type or delegate type t1, has any side effects. 89 * Returns: 90 * 0 has any side effects 91 * 1 nothrow + constant purity 92 * 2 nothrow + strong purity 93 */ 94 int callSideEffectLevel(FuncDeclaration f) 95 { 96 /* https://issues.dlang.org/show_bug.cgi?id=12760 97 * ctor call always has side effects. 98 */ 99 if (f.isCtorDeclaration()) 100 return 0; 101 assert(f.type.ty == Tfunction); 102 TypeFunction tf = cast(TypeFunction)f.type; 103 if (tf.isnothrow) 104 { 105 PURE purity = f.isPure(); 106 if (purity == PURE.strong) 107 return 2; 108 if (purity == PURE.const_) 109 return 1; 110 } 111 return 0; 112 } 113 114 int callSideEffectLevel(Type t) 115 { 116 t = t.toBasetype(); 117 TypeFunction tf; 118 if (t.ty == Tdelegate) 119 tf = cast(TypeFunction)(cast(TypeDelegate)t).next; 120 else 121 { 122 assert(t.ty == Tfunction); 123 tf = cast(TypeFunction)t; 124 } 125 if (!tf.isnothrow) // function can throw 126 return 0; 127 128 tf.purityLevel(); 129 PURE purity = tf.purity; 130 if (t.ty == Tdelegate && purity > PURE.weak) 131 { 132 if (tf.isMutable()) 133 purity = PURE.weak; 134 else if (!tf.isImmutable()) 135 purity = PURE.const_; 136 } 137 138 if (purity == PURE.strong) 139 return 2; 140 if (purity == PURE.const_) 141 return 1; 142 return 0; 143 } 144 145 private bool lambdaHasSideEffect(Expression e) 146 { 147 switch (e.op) 148 { 149 // Sort the cases by most frequently used first 150 case TOK.assign: 151 case TOK.plusPlus: 152 case TOK.minusMinus: 153 case TOK.declaration: 154 case TOK.construct: 155 case TOK.blit: 156 case TOK.addAssign: 157 case TOK.minAssign: 158 case TOK.concatenateAssign: 159 case TOK.concatenateElemAssign: 160 case TOK.concatenateDcharAssign: 161 case TOK.mulAssign: 162 case TOK.divAssign: 163 case TOK.modAssign: 164 case TOK.leftShiftAssign: 165 case TOK.rightShiftAssign: 166 case TOK.unsignedRightShiftAssign: 167 case TOK.andAssign: 168 case TOK.orAssign: 169 case TOK.xorAssign: 170 case TOK.powAssign: 171 case TOK.in_: 172 case TOK.remove: 173 case TOK.assert_: 174 case TOK.halt: 175 case TOK.delete_: 176 case TOK.new_: 177 case TOK.newAnonymousClass: 178 return true; 179 case TOK.call: 180 { 181 CallExp ce = cast(CallExp)e; 182 /* Calling a function or delegate that is pure nothrow 183 * has no side effects. 184 */ 185 if (ce.e1.type) 186 { 187 Type t = ce.e1.type.toBasetype(); 188 if (t.ty == Tdelegate) 189 t = (cast(TypeDelegate)t).next; 190 if (t.ty == Tfunction && (ce.f ? callSideEffectLevel(ce.f) : callSideEffectLevel(ce.e1.type)) > 0) 191 { 192 } 193 else 194 return true; 195 } 196 break; 197 } 198 case TOK.cast_: 199 { 200 CastExp ce = cast(CastExp)e; 201 /* if: 202 * cast(classtype)func() // because it may throw 203 */ 204 if (ce.to.ty == Tclass && ce.e1.op == TOK.call && ce.e1.type.ty == Tclass) 205 return true; 206 break; 207 } 208 default: 209 break; 210 } 211 return false; 212 } 213 214 /*********************************** 215 * The result of this expression will be discarded. 216 * Print error messages if the operation has no side effects (and hence is meaningless). 217 * Returns: 218 * true if expression has no side effects 219 */ 220 bool discardValue(Expression e) 221 { 222 if (lambdaHasSideEffect(e)) // check side-effect shallowly 223 return false; 224 switch (e.op) 225 { 226 case TOK.cast_: 227 { 228 CastExp ce = cast(CastExp)e; 229 if (ce.to.equals(Type.tvoid)) 230 { 231 /* 232 * Don't complain about an expression with no effect if it was cast to void 233 */ 234 return false; 235 } 236 break; // complain 237 } 238 case TOK.error: 239 return false; 240 case TOK.variable: 241 { 242 VarDeclaration v = (cast(VarExp)e).var.isVarDeclaration(); 243 if (v && (v.storage_class & STC.temp)) 244 { 245 // https://issues.dlang.org/show_bug.cgi?id=5810 246 // Don't complain about an internal generated variable. 247 return false; 248 } 249 break; 250 } 251 case TOK.call: 252 /* Issue 3882: */ 253 if (global.params.warnings != DiagnosticReporting.off && !global.gag) 254 { 255 CallExp ce = cast(CallExp)e; 256 if (e.type.ty == Tvoid) 257 { 258 /* Don't complain about calling void-returning functions with no side-effect, 259 * because purity and nothrow are inferred, and because some of the 260 * runtime library depends on it. Needs more investigation. 261 * 262 * One possible solution is to restrict this message to only be called in hierarchies that 263 * never call assert (and or not called from inside unittest blocks) 264 */ 265 } 266 else if (ce.e1.type) 267 { 268 Type t = ce.e1.type.toBasetype(); 269 if (t.ty == Tdelegate) 270 t = (cast(TypeDelegate)t).next; 271 if (t.ty == Tfunction && (ce.f ? callSideEffectLevel(ce.f) : callSideEffectLevel(ce.e1.type)) > 0) 272 { 273 const(char)* s; 274 if (ce.f) 275 s = ce.f.toPrettyChars(); 276 else if (ce.e1.op == TOK.star) 277 { 278 // print 'fp' if ce.e1 is (*fp) 279 s = (cast(PtrExp)ce.e1).e1.toChars(); 280 } 281 else 282 s = ce.e1.toChars(); 283 e.warning("calling `%s` without side effects discards return value of type `%s`; prepend a `cast(void)` if intentional", s, e.type.toChars()); 284 } 285 } 286 } 287 return false; 288 case TOK.andAnd: 289 case TOK.orOr: 290 { 291 LogicalExp aae = cast(LogicalExp)e; 292 return discardValue(aae.e2); 293 } 294 case TOK.question: 295 { 296 CondExp ce = cast(CondExp)e; 297 /* https://issues.dlang.org/show_bug.cgi?id=6178 298 * https://issues.dlang.org/show_bug.cgi?id=14089 299 * Either CondExp::e1 or e2 may have 300 * redundant expression to make those types common. For example: 301 * 302 * struct S { this(int n); int v; alias v this; } 303 * S[int] aa; 304 * aa[1] = 0; 305 * 306 * The last assignment statement will be rewitten to: 307 * 308 * 1 in aa ? aa[1].value = 0 : (aa[1] = 0, aa[1].this(0)).value; 309 * 310 * The last DotVarExp is necessary to take assigned value. 311 * 312 * int value = (aa[1] = 0); // value = aa[1].value 313 * 314 * To avoid false error, discardValue() should be called only when 315 * the both tops of e1 and e2 have actually no side effects. 316 */ 317 if (!lambdaHasSideEffect(ce.e1) && !lambdaHasSideEffect(ce.e2)) 318 { 319 return discardValue(ce.e1) | 320 discardValue(ce.e2); 321 } 322 return false; 323 } 324 case TOK.comma: 325 { 326 CommaExp ce = cast(CommaExp)e; 327 /* Check for compiler-generated code of the form auto __tmp, e, __tmp; 328 * In such cases, only check e for side effect (it's OK for __tmp to have 329 * no side effect). 330 * See https://issues.dlang.org/show_bug.cgi?id=4231 for discussion 331 */ 332 auto fc = firstComma(ce); 333 if (fc.op == TOK.declaration && ce.e2.op == TOK.variable && (cast(DeclarationExp)fc).declaration == (cast(VarExp)ce.e2).var) 334 { 335 return false; 336 } 337 // Don't check e1 until we cast(void) the a,b code generation. 338 // This is concretely done in expressionSemantic, if a CommaExp has Tvoid as type 339 return discardValue(ce.e2); 340 } 341 case TOK.tuple: 342 /* Pass without complaint if any of the tuple elements have side effects. 343 * Ideally any tuple elements with no side effects should raise an error, 344 * this needs more investigation as to what is the right thing to do. 345 */ 346 if (!hasSideEffect(e)) 347 break; 348 return false; 349 default: 350 break; 351 } 352 e.error("`%s` has no effect", e.toChars()); 353 return true; 354 } 355 356 /************************************************** 357 * Build a temporary variable to copy the value of e into. 358 * Params: 359 * stc = storage classes will be added to the made temporary variable 360 * name = name for temporary variable 361 * e = original expression 362 * Returns: 363 * Newly created temporary variable. 364 */ 365 VarDeclaration copyToTemp(StorageClass stc, const char[] name, Expression e) 366 { 367 assert(name[0] == '_' && name[1] == '_'); 368 auto vd = new VarDeclaration(e.loc, e.type, 369 Identifier.generateId(name), 370 new ExpInitializer(e.loc, e)); 371 vd.storage_class = stc | STC.temp | STC.ctfe; // temporary is always CTFEable 372 return vd; 373 } 374 375 /************************************************** 376 * Build a temporary variable to extract e's evaluation, if e is not trivial. 377 * Params: 378 * sc = scope 379 * name = name for temporary variable 380 * e0 = a new side effect part will be appended to it. 381 * e = original expression 382 * alwaysCopy = if true, build new temporary variable even if e is trivial. 383 * Returns: 384 * When e is trivial and alwaysCopy == false, e itself is returned. 385 * Otherwise, a new VarExp is returned. 386 * Note: 387 * e's lvalue-ness will be handled well by STC.ref_ or STC.rvalue. 388 */ 389 Expression extractSideEffect(Scope* sc, const char[] name, 390 ref Expression e0, Expression e, bool alwaysCopy = false) 391 { 392 //printf("extractSideEffect(e: %s)\n", e.toChars()); 393 394 /* The trouble here is that if CTFE is running, extracting the side effect 395 * results in an assignment, and then the interpreter says it cannot evaluate the 396 * side effect assignment variable. But we don't have to worry about side 397 * effects in function calls anyway, because then they won't CTFE. 398 * https://issues.dlang.org/show_bug.cgi?id=17145 399 */ 400 if (!alwaysCopy && 401 ((sc.flags & SCOPE.ctfe) ? !hasSideEffect(e) : isTrivialExp(e))) 402 return e; 403 404 auto vd = copyToTemp(0, name, e); 405 vd.storage_class |= e.isLvalue() ? STC.ref_ : STC.rvalue; 406 407 e0 = Expression.combine(e0, new DeclarationExp(vd.loc, vd) 408 .expressionSemantic(sc)); 409 410 return new VarExp(vd.loc, vd) 411 .expressionSemantic(sc); 412 }