remove weird special inline treatment, simplify inline cost computation

Author: aviatesk

base/compiler/optimize.jl

@@ -174,25 +174,6 @@ const TOP_TUPLE = GlobalRef(Core, :tuple)
 
 _topmod(sv::OptimizationState) = _topmod(sv.mod)
 
-function isinlineable(m::Method, me::OptimizationState, params::OptimizationParams, union_penalties::Bool, bonus::Int=0)
-    # compute the cost (size) of inlining this code
-    cost_threshold = params.inline_cost_threshold
-    if m.module === _topmod(m.module)
-        # a few functions get special treatment
-        name = m.name
-        sig = m.sig
-        if ((name === :+ || name === :* || name === :min || name === :max) &&
-            isa(sig,DataType) &&
-            sig === Tuple{sig.parameters[1],Any,Any,Any,Vararg{Any}})
-            return true
-        elseif (name === :iterate || name === :unsafe_convert ||
-                name === :cconvert)
-            cost_threshold *= 4
-        end
-    end
-    return inline_worthy(me.ir::IRCode, params, union_penalties, cost_threshold + bonus)
-end
-
 is_stmt_inline(stmt_flag::UInt8)      = stmt_flag & IR_FLAG_INLINE      ≠ 0
 is_stmt_noinline(stmt_flag::UInt8)    = stmt_flag & IR_FLAG_NOINLINE    ≠ 0
 is_stmt_throw_block(stmt_flag::UInt8) = stmt_flag & IR_FLAG_THROW_BLOCK ≠ 0
@@ -292,19 +273,27 @@ function finish(interp::AbstractInterpreter, opt::OptimizationState, params::Opt
         if src.inlineable && isdispatchtuple(specTypes)
             # obey @inline declaration if a dispatch barrier would not help
         else
-            bonus = 0
+            # compute the cost (size) of inlining this code
+            cost_threshold = default = params.inline_cost_threshold
             if result ⊑ Tuple && !isconcretetype(widenconst(result))
-                bonus = params.inline_tupleret_bonus
+                cost_threshold += params.inline_tupleret_bonus
             end
+            # if the method is declared as `@inline`, increase the cost threshold 20x
             if src.inlineable
-                # For functions declared @inline, increase the cost threshold 20x
-                bonus += params.inline_cost_threshold*19
+                cost_threshold += 19*default
             end
-            src.inlineable = isinlineable(def, opt, params, union_penalties, bonus)
+            # a few functions get special treatment
+            if def.module === _topmod(def.module)
+                name = def.name
+                if name === :iterate || name === :unsafe_convert || name === :cconvert
+                    cost_threshold += 4*default
+                end
+            end
+            src.inlineable = inline_worthy(ir, params, union_penalties, cost_threshold)
         end
     end
 
-    nothing
+    return nothing
 end
 
 # run the optimization work

base/operators.jl

@@ -636,7 +636,7 @@ for op in (:+, :*, :&, :|, :xor, :min, :max, :kron)
         # note: these definitions must not cause a dispatch loop when +(a,b) is
         # not defined, and must only try to call 2-argument definitions, so
         # that defining +(a,b) is sufficient for full functionality.
-        ($op)(a, b, c, xs...) = afoldl($op, ($op)(($op)(a,b),c), xs...)
+        ($op)(a, b, c, xs...) = (@inline; afoldl($op, ($op)(($op)(a,b),c), xs...))
         # a further concern is that it's easy for a type like (Int,Int...)
         # to match many definitions, so we need to keep the number of
         # definitions down to avoid losing type information.

doc/src/devdocs/inference.md

@@ -53,12 +53,8 @@ ci = (@code_typed convert(Int, UInt(1)))[1]
 
 Much of the hardest work for inlining runs in `ssa_inlining_pass!`.
 However, if your question is "why didn't my function inline?"
-then you will most likely be interested in `isinlineable` and its
-primary callee, `inline_worthy`.
-`isinlineable` handles a number of special cases
-(e.g., critical functions like `iterate`).
-The main decision-making happens in `inline_worthy`,
-which returns `true` if the function should be inlined.
+then you will most likely be interested in `inline_worthy`,
+which makes a decision to inline the function call or not.
 
 `inline_worthy` implements a cost-model, where "cheap" functions get
 inlined; more specifically, we inline functions if their anticipated