| /** |
| * Find side-effects of expressions. |
| * |
| * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved |
| * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) |
| * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) |
| * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/sideeffect.d, _sideeffect.d) |
| * Documentation: https://dlang.org/phobos/dmd_sideeffect.html |
| * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/sideeffect.d |
| */ |
| |
| module dmd.sideeffect; |
| |
| import dmd.apply; |
| import dmd.astenums; |
| import dmd.declaration; |
| import dmd.dscope; |
| import dmd.expression; |
| import dmd.expressionsem; |
| import dmd.func; |
| import dmd.globals; |
| import dmd.identifier; |
| import dmd.init; |
| import dmd.mtype; |
| import dmd.tokens; |
| import dmd.visitor; |
| |
| /************************************************** |
| * Front-end expression rewriting should create temporary variables for |
| * non trivial sub-expressions in order to: |
| * 1. save evaluation order |
| * 2. prevent sharing of sub-expression in AST |
| */ |
| extern (C++) bool isTrivialExp(Expression e) |
| { |
| extern (C++) final class IsTrivialExp : StoppableVisitor |
| { |
| alias visit = typeof(super).visit; |
| public: |
| extern (D) this() scope |
| { |
| } |
| |
| override void visit(Expression e) |
| { |
| /* https://issues.dlang.org/show_bug.cgi?id=11201 |
| * CallExp is always non trivial expression, |
| * especially for inlining. |
| */ |
| if (e.op == EXP.call) |
| { |
| stop = true; |
| return; |
| } |
| // stop walking if we determine this expression has side effects |
| stop = lambdaHasSideEffect(e); |
| } |
| } |
| |
| scope IsTrivialExp v = new IsTrivialExp(); |
| return walkPostorder(e, v) == false; |
| } |
| |
| /******************************************** |
| * Determine if Expression has any side effects. |
| * |
| * Params: |
| * e = the expression |
| * assumeImpureCalls = whether function calls should always be assumed to |
| * be impure (e.g. debug is allowed to violate purity) |
| */ |
| extern (C++) bool hasSideEffect(Expression e, bool assumeImpureCalls = false) |
| { |
| extern (C++) final class LambdaHasSideEffect : StoppableVisitor |
| { |
| alias visit = typeof(super).visit; |
| public: |
| extern (D) this() scope |
| { |
| } |
| |
| override void visit(Expression e) |
| { |
| // stop walking if we determine this expression has side effects |
| stop = lambdaHasSideEffect(e, assumeImpureCalls); |
| } |
| } |
| |
| scope LambdaHasSideEffect v = new LambdaHasSideEffect(); |
| return walkPostorder(e, v); |
| } |
| |
| /******************************************** |
| * Determine if the call of f, or function type or delegate type t1, has any side effects. |
| * Returns: |
| * 0 has any side effects |
| * 1 nothrow + strongly pure |
| * 2 nothrow + strongly pure + only immutable indirections in the return |
| * type |
| */ |
| int callSideEffectLevel(FuncDeclaration f) |
| { |
| /* https://issues.dlang.org/show_bug.cgi?id=12760 |
| * ctor call always has side effects. |
| */ |
| if (f.isCtorDeclaration()) |
| return 0; |
| assert(f.type.ty == Tfunction); |
| TypeFunction tf = cast(TypeFunction)f.type; |
| if (!tf.isnothrow) |
| return 0; |
| final switch (f.isPure()) |
| { |
| case PURE.impure: |
| case PURE.fwdref: |
| case PURE.weak: |
| return 0; |
| |
| case PURE.const_: |
| return mutabilityOfType(tf.isref, tf.next) == 2 ? 2 : 1; |
| } |
| } |
| |
| int callSideEffectLevel(Type t) |
| { |
| t = t.toBasetype(); |
| TypeFunction tf; |
| if (t.ty == Tdelegate) |
| tf = cast(TypeFunction)(cast(TypeDelegate)t).next; |
| else |
| { |
| assert(t.ty == Tfunction); |
| tf = cast(TypeFunction)t; |
| } |
| if (!tf.isnothrow) // function can throw |
| return 0; |
| |
| tf.purityLevel(); |
| PURE purity = tf.purity; |
| if (t.ty == Tdelegate && purity > PURE.weak) |
| { |
| if (tf.isMutable()) |
| purity = PURE.weak; |
| else if (!tf.isImmutable()) |
| purity = PURE.const_; |
| } |
| |
| if (purity == PURE.const_) |
| return mutabilityOfType(tf.isref, tf.next) == 2 ? 2 : 1; |
| |
| return 0; |
| } |
| |
| private bool lambdaHasSideEffect(Expression e, bool assumeImpureCalls = false) |
| { |
| switch (e.op) |
| { |
| // Sort the cases by most frequently used first |
| case EXP.assign: |
| case EXP.plusPlus: |
| case EXP.minusMinus: |
| case EXP.declaration: |
| case EXP.construct: |
| case EXP.blit: |
| case EXP.addAssign: |
| case EXP.minAssign: |
| case EXP.concatenateAssign: |
| case EXP.concatenateElemAssign: |
| case EXP.concatenateDcharAssign: |
| case EXP.mulAssign: |
| case EXP.divAssign: |
| case EXP.modAssign: |
| case EXP.leftShiftAssign: |
| case EXP.rightShiftAssign: |
| case EXP.unsignedRightShiftAssign: |
| case EXP.andAssign: |
| case EXP.orAssign: |
| case EXP.xorAssign: |
| case EXP.powAssign: |
| case EXP.in_: |
| case EXP.remove: |
| case EXP.assert_: |
| case EXP.halt: |
| case EXP.throw_: |
| case EXP.delete_: |
| case EXP.new_: |
| case EXP.newAnonymousClass: |
| return true; |
| case EXP.call: |
| { |
| if (assumeImpureCalls) |
| return true; |
| |
| if (e.type && e.type.ty == Tnoreturn) |
| return true; |
| |
| CallExp ce = cast(CallExp)e; |
| /* Calling a function or delegate that is pure nothrow |
| * has no side effects. |
| */ |
| if (ce.e1.type) |
| { |
| Type t = ce.e1.type.toBasetype(); |
| if (t.ty == Tdelegate) |
| t = (cast(TypeDelegate)t).next; |
| |
| const level = t.ty == Tfunction && (ce.f ? callSideEffectLevel(ce.f) : callSideEffectLevel(ce.e1.type)); |
| if (level == 0) // 0 means the function has a side effect |
| return true; |
| } |
| break; |
| } |
| case EXP.cast_: |
| { |
| CastExp ce = cast(CastExp)e; |
| /* if: |
| * cast(classtype)func() // because it may throw |
| */ |
| if (ce.to.ty == Tclass && ce.e1.op == EXP.call && ce.e1.type.ty == Tclass) |
| return true; |
| break; |
| } |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| /*********************************** |
| * The result of this expression will be discarded. |
| * Print error messages if the operation has no side effects (and hence is meaningless). |
| * Returns: |
| * true if expression has no side effects |
| */ |
| bool discardValue(Expression e) |
| { |
| if (lambdaHasSideEffect(e)) // check side-effect shallowly |
| return false; |
| switch (e.op) |
| { |
| case EXP.cast_: |
| { |
| CastExp ce = cast(CastExp)e; |
| if (ce.to.equals(Type.tvoid)) |
| { |
| /* |
| * Don't complain about an expression with no effect if it was cast to void |
| */ |
| return false; |
| } |
| break; // complain |
| } |
| // Assumption that error => no side effect |
| case EXP.error: |
| return true; |
| case EXP.variable: |
| { |
| VarDeclaration v = (cast(VarExp)e).var.isVarDeclaration(); |
| if (v && (v.storage_class & STC.temp)) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=5810 |
| // Don't complain about an internal generated variable. |
| return false; |
| } |
| break; |
| } |
| case EXP.call: |
| /* Issue 3882: */ |
| if (global.params.warnings != DiagnosticReporting.off && !global.gag) |
| { |
| CallExp ce = cast(CallExp)e; |
| if (e.type.ty == Tvoid) |
| { |
| /* Don't complain about calling void-returning functions with no side-effect, |
| * because purity and nothrow are inferred, and because some of the |
| * runtime library depends on it. Needs more investigation. |
| * |
| * One possible solution is to restrict this message to only be called in hierarchies that |
| * never call assert (and or not called from inside unittest blocks) |
| */ |
| } |
| else if (ce.e1.type) |
| { |
| Type t = ce.e1.type.toBasetype(); |
| if (t.ty == Tdelegate) |
| t = (cast(TypeDelegate)t).next; |
| if (t.ty == Tfunction && (ce.f ? callSideEffectLevel(ce.f) : callSideEffectLevel(ce.e1.type)) > 0) |
| { |
| const(char)* s; |
| if (ce.f) |
| s = ce.f.toPrettyChars(); |
| else if (ce.e1.op == EXP.star) |
| { |
| // print 'fp' if ce.e1 is (*fp) |
| s = (cast(PtrExp)ce.e1).e1.toChars(); |
| } |
| else |
| s = ce.e1.toChars(); |
| e.warning("calling `%s` without side effects discards return value of type `%s`; prepend a `cast(void)` if intentional", s, e.type.toChars()); |
| } |
| } |
| } |
| return false; |
| case EXP.andAnd: |
| case EXP.orOr: |
| { |
| LogicalExp aae = cast(LogicalExp)e; |
| return discardValue(aae.e2); |
| } |
| case EXP.question: |
| { |
| CondExp ce = cast(CondExp)e; |
| /* https://issues.dlang.org/show_bug.cgi?id=6178 |
| * https://issues.dlang.org/show_bug.cgi?id=14089 |
| * Either CondExp::e1 or e2 may have |
| * redundant expression to make those types common. For example: |
| * |
| * struct S { this(int n); int v; alias v this; } |
| * S[int] aa; |
| * aa[1] = 0; |
| * |
| * The last assignment statement will be rewitten to: |
| * |
| * 1 in aa ? aa[1].value = 0 : (aa[1] = 0, aa[1].this(0)).value; |
| * |
| * The last DotVarExp is necessary to take assigned value. |
| * |
| * int value = (aa[1] = 0); // value = aa[1].value |
| * |
| * To avoid false error, discardValue() should be called only when |
| * the both tops of e1 and e2 have actually no side effects. |
| */ |
| if (!lambdaHasSideEffect(ce.e1) && !lambdaHasSideEffect(ce.e2)) |
| { |
| return discardValue(ce.e1) | |
| discardValue(ce.e2); |
| } |
| return false; |
| } |
| case EXP.comma: |
| { |
| CommaExp ce = cast(CommaExp)e; |
| // Don't complain about compiler-generated comma expressions |
| if (ce.isGenerated) |
| return false; |
| |
| // Don't check e1 until we cast(void) the a,b code generation. |
| // This is concretely done in expressionSemantic, if a CommaExp has Tvoid as type |
| return discardValue(ce.e2); |
| } |
| case EXP.tuple: |
| /* Pass without complaint if any of the tuple elements have side effects. |
| * Ideally any tuple elements with no side effects should raise an error, |
| * this needs more investigation as to what is the right thing to do. |
| */ |
| if (!hasSideEffect(e)) |
| break; |
| return false; |
| case EXP.identity, EXP.notIdentity: |
| case EXP.equal, EXP.notEqual: |
| /* |
| `[side effect] == 0` |
| Technically has a side effect but is clearly wrong; |
| */ |
| BinExp tmp = e.isBinExp(); |
| assert(tmp); |
| |
| e.error("the result of the equality expression `%s` is discarded", e.toChars()); |
| bool seenSideEffect = false; |
| foreach(expr; [tmp.e1, tmp.e2]) |
| { |
| if (hasSideEffect(expr)) { |
| expr.errorSupplemental("note that `%s` may have a side effect", expr.toChars()); |
| seenSideEffect |= true; |
| } |
| } |
| return !seenSideEffect; |
| default: |
| break; |
| } |
| e.error("`%s` has no effect", e.toChars()); |
| return true; |
| } |
| |
| /************************************************** |
| * Build a temporary variable to copy the value of e into. |
| * Params: |
| * stc = storage classes will be added to the made temporary variable |
| * name = name for temporary variable |
| * e = original expression |
| * Returns: |
| * Newly created temporary variable. |
| */ |
| VarDeclaration copyToTemp(StorageClass stc, const char[] name, Expression e) |
| { |
| assert(name[0] == '_' && name[1] == '_'); |
| auto vd = new VarDeclaration(e.loc, e.type, |
| Identifier.generateId(name), |
| new ExpInitializer(e.loc, e)); |
| vd.storage_class = stc | STC.temp | STC.ctfe; // temporary is always CTFEable |
| return vd; |
| } |
| |
| /************************************************** |
| * Build a temporary variable to extract e's evaluation, if e is not trivial. |
| * Params: |
| * sc = scope |
| * name = name for temporary variable |
| * e0 = a new side effect part will be appended to it. |
| * e = original expression |
| * alwaysCopy = if true, build new temporary variable even if e is trivial. |
| * Returns: |
| * When e is trivial and alwaysCopy == false, e itself is returned. |
| * Otherwise, a new VarExp is returned. |
| * Note: |
| * e's lvalue-ness will be handled well by STC.ref_ or STC.rvalue. |
| */ |
| Expression extractSideEffect(Scope* sc, const char[] name, |
| ref Expression e0, Expression e, bool alwaysCopy = false) |
| { |
| //printf("extractSideEffect(e: %s)\n", e.toChars()); |
| |
| /* The trouble here is that if CTFE is running, extracting the side effect |
| * results in an assignment, and then the interpreter says it cannot evaluate the |
| * side effect assignment variable. But we don't have to worry about side |
| * effects in function calls anyway, because then they won't CTFE. |
| * https://issues.dlang.org/show_bug.cgi?id=17145 |
| */ |
| if (!alwaysCopy && |
| ((sc.flags & SCOPE.ctfe) ? !hasSideEffect(e) : isTrivialExp(e))) |
| return e; |
| |
| auto vd = copyToTemp(0, name, e); |
| vd.storage_class |= e.isLvalue() ? STC.ref_ : STC.rvalue; |
| |
| e0 = Expression.combine(e0, new DeclarationExp(vd.loc, vd) |
| .expressionSemantic(sc)); |
| |
| return new VarExp(vd.loc, vd) |
| .expressionSemantic(sc); |
| } |
