diff --git a/Src/Ruby/Compiler/Ast/Definitions/MethodDefinition.cs b/Src/Ruby/Compiler/Ast/Definitions/MethodDefinition.cs
index 41a14c0f..61b2b56e 100644
--- a/Src/Ruby/Compiler/Ast/Definitions/MethodDefinition.cs
+++ b/Src/Ruby/Compiler/Ast/Definitions/MethodDefinition.cs
@@ -521,6 +521,18 @@ internal static bool IsNeverParkedIterator(string/*!*/ name) {
///
internal static readonly bool LightInterpolationEnabled = Environment.GetEnvironmentVariable("IR_LIGHT_INTERPOLATION") != "0";
+ ///
+ /// IR_LIGHT_HASH=0 keeps every method with a Hash literal (`{a: x}', `{}') out of light frames (see IsScopeFree and
+ /// LightFrameRewriter.ScopeOperandIndex).
+ ///
+ internal static readonly bool LightHashEnabled = Environment.GetEnvironmentVariable("IR_LIGHT_HASH") != "0";
+
+ ///
+ /// IR_LIGHT_KEYWORD_HASH=0 keeps every method that passes keywords (`f(a: x)') out of light frames (see IsScopeFree and
+ /// LightFrameRewriter.ScopeOperandIndex).
+ ///
+ internal static readonly bool LightKeywordHashEnabled = Environment.GetEnvironmentVariable("IR_LIGHT_KEYWORD_HASH") != "0";
+
private static readonly bool LightFramesWhy = Environment.GetEnvironmentVariable("IR_LIGHT_FRAMES") == "why";
private static readonly bool LightFramesVerbose = LightFramesWhy || Environment.GetEnvironmentVariable("IR_LIGHT_FRAMES") == "verbose";
@@ -634,7 +646,7 @@ private Expression FirstNotScopeFree(bool blockLiterals) {
if (statements != null) {
bool first = true;
foreach (var statement in statements) {
- if (!IsScopeFree(statement, blockLiterals) && !(first && IsBlockGuard(statement))) {
+ if (!IsScopeFree(statement, blockLiterals, null) && !(first && IsBlockGuard(statement))) {
return statement;
}
first = false;
@@ -645,7 +657,9 @@ private Expression FirstNotScopeFree(bool blockLiterals) {
///
/// IR_LIGHT_FRAMES=why: what IsLightFrameCandidate refused - the parameters, a rescue/ensure, or the first statement
- /// that is not scope-free (its node type and line). Null if it is a candidate.
+ /// that is not scope-free: its node type and line, then the construct inside it that IsScopeFree refused
+ /// (`IfExpression at line 12: GlobalVariable'), since the statement alone does not say what to teach the frames next.
+ /// Null if it is a candidate.
///
private string WhyNotLightFrameCandidate() {
if (!AreLightOptionals() || _parameters.Unsplat != null && !LightRestEnabled || _parameters.SuperSplat != null ||
@@ -663,7 +677,8 @@ private string WhyNotLightFrameCandidate() {
if (FirstNotScopeFree(false) != null) {
var statement = FirstNotScopeFree(LightBlocksEnabled);
if (statement != null) {
- return String.Format("{0} at line {1}", statement.GetType().Name, statement.Location.Start.Line);
+ return String.Format("{0} at line {1}: {2}", statement.GetType().Name, statement.Location.Start.Line,
+ WhyNotScopeFree(statement, LightBlocksEnabled));
}
}
return IsLightFrameCandidate() ? null : "parameters";
@@ -702,7 +717,7 @@ private bool AreLightOptionals() {
return false;
}
foreach (var parameter in optional) {
- if (!(parameter.Left is LocalVariable) || !IsScopeFree(parameter.Right, false)) {
+ if (!(parameter.Left is LocalVariable) || !IsScopeFree(parameter.Right, false, null)) {
return false;
}
}
@@ -717,39 +732,62 @@ private bool HasBlockGuard {
}
internal static bool IsScopeFree(Expression/*!*/ node) {
- return IsScopeFree(node, false);
+ return IsScopeFree(node, false, null);
+ }
+
+ // IR_LIGHT_FRAMES=why: names what IsScopeFree refused in the node. Every refusal of a sub-node is its parent's too and
+ // ends the walk, so the reason it records is the innermost one: the decision IsScopeFree took, not a guess from the node.
+ private static string WhyNotScopeFree(Expression/*!*/ node, bool blockLiterals) {
+ var why = new StrongBox();
+ return IsScopeFree(node, blockLiterals, why) ? null : why.Value;
+ }
+
+ // Records the reason of a refusal for WhyNotScopeFree, if it asked (why is null otherwise), and refuses.
+ private static bool Refuse(StrongBox why, string/*!*/ reason) {
+ if (why != null) {
+ why.Value = reason;
+ }
+ return false;
}
// blockLiterals: a call with a literal block is scope-free too (see TransformLightFrame); the block's own body is compiled
// with a scope of its own, made with this frame's scope as its parent, which is then made on demand for it
- private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
+ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals, StrongBox why) {
// `def f = [[[...]]]' a thousand deep: such a body is not worth a light frame, nor a stack overflow to find out
if (!System.Runtime.CompilerServices.RuntimeHelpers.TryEnsureSufficientExecutionStack()) {
- return false;
+ return Refuse(why, "nested too deep");
}
if (node is LocalVariable || node is Literal || node is SelfReference || node is InstanceVariable) {
return true;
}
var constant = node as ConstantVariable;
if (constant != null) {
- return IsCachedConstant(constant);
+ return IsCachedConstant(constant) || Refuse(why, "ConstantVariable with an expression qualifier");
}
var assignment = node as SimpleAssignmentExpression;
if (assignment != null) {
// `@x += @v' is a call of + between a read and a write
- if (!IsScopeFree(assignment.Right, blockLiterals)) {
+ if (!IsScopeFree(assignment.Right, blockLiterals, why)) {
return false;
}
if (assignment.Left is LocalVariable || assignment.Left is InstanceVariable) {
- return assignment.Operation == null || LightCallsEnabled;
+ return assignment.Operation == null || LightCallsEnabled || Refuse(why, "operator assignment (IR_LIGHT_CALLS=0)");
}
// `o.x = v', `a[i] = v' (and their op-assigns): calls of x= and []=
var attribute = assignment.Left as AttributeAccess;
if (attribute != null) {
- return LightCallsEnabled && !attribute.IsSafeNavigation && IsScopeFree(attribute.Qualifier, blockLiterals);
+ if (!LightCallsEnabled || attribute.IsSafeNavigation) {
+ return Refuse(why, LightCallsEnabled ? "assignment to a safe-navigation attribute" : "assignment to an attribute (IR_LIGHT_CALLS=0)");
+ }
+ return IsScopeFree(attribute.Qualifier, blockLiterals, why);
}
var item = assignment.Left as ArrayItemAccess;
- return item != null && LightCallsEnabled && item.Block == null && IsScopeFree(item.Array, blockLiterals) && AreScopeFree(item.Arguments, blockLiterals);
+ if (item == null || !LightCallsEnabled || item.Block != null) {
+ // the reason is built only when it was asked for: this path runs for every method definition
+ return why != null && Refuse(why, item == null ? "assignment to " + assignment.Left.GetType().Name :
+ LightCallsEnabled ? "assignment to an element with a block" : "assignment to an element (IR_LIGHT_CALLS=0)");
+ }
+ return IsScopeFree(item.Array, blockLiterals, why) && AreScopeFree(item.Arguments, blockLiterals, why);
}
// a String literal is a constant, or a copy of one; a Symbol literal is a constant
if (node is StringLiteral) {
@@ -758,7 +796,24 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
if (LightCallsEnabled) {
var array = node as ArrayConstructor;
if (array != null) {
- return AreScopeFree(array.Arguments, blockLiterals);
+ return AreScopeFree(array.Arguments, blockLiterals, why);
+ }
+ // `{a: x}', `{"k" => v}', `{}': the helper a literal is made by takes the scope only for its runtime
+ // (LightFrameRewriter.ScopeOperandIndex), and a String key's frozen copy and the keys' #hash and #eql? are
+ // the runtime's too. `**h' in a literal is a call of Hash#merge on it. The hash a call site builds for its
+ // keywords (`f(a: x)') is made the same way, only marked as keywords, and is an argument of the call like
+ // any other; `f(**h)' is a KeywordSplatMerge, not taken.
+ var hash = node as HashConstructor;
+ if (hash != null) {
+ if (hash.IsKeywordArguments ? !LightKeywordHashEnabled : !LightHashEnabled) {
+ return Refuse(why, hash.IsKeywordArguments ? "HashConstructor (keyword arguments, IR_LIGHT_KEYWORD_HASH=0)" : "HashConstructor (IR_LIGHT_HASH=0)");
+ }
+ foreach (var maplet in hash.Maplets) {
+ if (!IsScopeFree(maplet.Key, blockLiterals, why) || !IsScopeFree(maplet.Value, blockLiterals, why)) {
+ return false;
+ }
+ }
+ return true;
}
// `(a..b)': the Range is made from its bounds and the literal's comparison storage (RubyOps.CreateInclusiveRange);
// Range#initialize checks the stack before the <=> it calls for bounds that are not two Integers. Not in a body
@@ -767,13 +822,16 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
// the scope made on entry (`(a..b)' kept such a body out of light frames until then).
var range = node as RangeExpression;
if (range != null) {
- return !blockLiterals && IsScopeFree(range.Begin, false) && IsScopeFree(range.End, false);
+ if (blockLiterals) {
+ return Refuse(why, "RangeExpression in a body with literal blocks");
+ }
+ return IsScopeFree(range.Begin, false, why) && IsScopeFree(range.End, false, why);
}
// "#{x}" converts each part through a to_s site
var interpolation = node as StringConstructor;
if (interpolation != null && interpolation.Kind == StringKind.Mutable) {
foreach (var part in interpolation.Parts) {
- if (!IsScopeFree(part, blockLiterals)) {
+ if (!IsScopeFree(part, blockLiterals, why)) {
return false;
}
}
@@ -781,20 +839,20 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
}
var loop = node as WhileLoopExpression;
if (loop != null) {
- return IsScopeFree(loop.Condition, blockLiterals) && AreScopeFree(loop.Statements, blockLiterals);
+ return IsScopeFree(loop.Condition, blockLiterals, why) && AreScopeFree(loop.Statements, blockLiterals, why);
}
var caseExpression = node as CaseExpression;
if (caseExpression != null) {
- if (caseExpression.Value != null && !IsScopeFree(caseExpression.Value, blockLiterals) || !AreScopeFree(caseExpression.ElseStatements, blockLiterals)) {
+ if (caseExpression.Value != null && !IsScopeFree(caseExpression.Value, blockLiterals, why) || !AreScopeFree(caseExpression.ElseStatements, blockLiterals, why)) {
return false;
}
foreach (var clause in caseExpression.WhenClauses) {
foreach (var comparison in clause.Comparisons) {
- if (!IsScopeFree(comparison, blockLiterals)) {
+ if (!IsScopeFree(comparison, blockLiterals, why)) {
return false;
}
}
- if (!AreScopeFree(clause.Statements, blockLiterals)) {
+ if (!AreScopeFree(clause.Statements, blockLiterals, why)) {
return false;
}
}
@@ -805,30 +863,36 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
// is given (LightFrameRewriter.LightScopeCall)
var splat = node as SplattedArgument;
if (splat != null) {
- return LightSplatEnabled && IsScopeFree(splat.Argument, blockLiterals);
+ return (LightSplatEnabled || why != null && Refuse(why, node.GetType().Name + " (IR_LIGHT_SPLAT=0)")) && IsScopeFree(splat.Argument, blockLiterals, why);
}
// `inner(&block)': the Proc is the caller's own, or made by #to_proc through a conversion site that takes no
// scope, and the call passes it as an argument (LightFrameRewriter.LightScopeCall)
var call = node as MethodCall;
if (call != null) {
var blockReference = call.Block as BlockReference;
- return (call.Block == null || blockLiterals && call.Block is BlockDefinition ||
- LightBlockPassEnabled && blockReference != null && IsScopeFree(blockReference.Expression, blockLiterals)) &&
- (call.Target == null || IsScopeFree(call.Target, blockLiterals)) && AreScopeFree(call.Arguments, blockLiterals);
+ if (call.Block != null && !(blockLiterals && call.Block is BlockDefinition)) {
+ if (blockReference == null || !LightBlockPassEnabled) {
+ return Refuse(why, blockReference == null ? "call with a literal block" : "call passing a block (IR_LIGHT_BLOCK_PASS=0)");
+ }
+ if (!IsScopeFree(blockReference.Expression, blockLiterals, why)) {
+ return false;
+ }
+ }
+ return (call.Target == null || IsScopeFree(call.Target, blockLiterals, why)) && AreScopeFree(call.Arguments, blockLiterals, why);
}
var conditional = node as ConditionalExpression;
if (conditional != null) {
- return IsScopeFree(conditional.Condition, blockLiterals) && IsScopeFree(conditional.TrueExpression, blockLiterals) &&
- IsScopeFree(conditional.FalseExpression, blockLiterals);
+ return IsScopeFree(conditional.Condition, blockLiterals, why) && IsScopeFree(conditional.TrueExpression, blockLiterals, why) &&
+ IsScopeFree(conditional.FalseExpression, blockLiterals, why);
}
var ifExpression = node as IfExpression;
if (ifExpression != null) {
- if (!IsScopeFree(ifExpression.Condition, blockLiterals) || !AreScopeFree(ifExpression.Body, blockLiterals)) {
+ if (!IsScopeFree(ifExpression.Condition, blockLiterals, why) || !AreScopeFree(ifExpression.Body, blockLiterals, why)) {
return false;
}
if (ifExpression.ElseIfClauses != null) {
foreach (var clause in ifExpression.ElseIfClauses) {
- if (clause.Condition != null && !IsScopeFree(clause.Condition, blockLiterals) || !AreScopeFree(clause.Statements, blockLiterals)) {
+ if (clause.Condition != null && !IsScopeFree(clause.Condition, blockLiterals, why) || !AreScopeFree(clause.Statements, blockLiterals, why)) {
return false;
}
}
@@ -837,31 +901,31 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
}
var unlessExpression = node as UnlessExpression;
if (unlessExpression != null) {
- return IsScopeFree(unlessExpression.Condition, blockLiterals) && AreScopeFree(unlessExpression.Statements, blockLiterals) &&
- (unlessExpression.ElseClause == null || AreScopeFree(unlessExpression.ElseClause.Statements, blockLiterals));
+ return IsScopeFree(unlessExpression.Condition, blockLiterals, why) && AreScopeFree(unlessExpression.Statements, blockLiterals, why) &&
+ (unlessExpression.ElseClause == null || AreScopeFree(unlessExpression.ElseClause.Statements, blockLiterals, why));
}
var and = node as AndExpression;
if (and != null) {
- return IsScopeFree(and.Left, blockLiterals) && IsScopeFree(and.Right, blockLiterals);
+ return IsScopeFree(and.Left, blockLiterals, why) && IsScopeFree(and.Right, blockLiterals, why);
}
var or = node as OrExpression;
if (or != null) {
- return IsScopeFree(or.Left, blockLiterals) && IsScopeFree(or.Right, blockLiterals);
+ return IsScopeFree(or.Left, blockLiterals, why) && IsScopeFree(or.Right, blockLiterals, why);
}
var not = node as NotExpression;
if (not != null) {
- return IsScopeFree(not.Expression, blockLiterals);
+ return IsScopeFree(not.Expression, blockLiterals, why);
}
}
var yieldCall = node as YieldCall;
if (yieldCall != null) {
- return yieldCall.Block == null && AreScopeFree(yieldCall.Arguments, blockLiterals);
+ return (yieldCall.Block == null || Refuse(why, "yield with a block")) && AreScopeFree(yieldCall.Arguments, blockLiterals, why);
}
// `(yield self; self)', the body of an endless def written with several statements
var block = node as BlockExpression;
if (block != null) {
foreach (var statement in block.Statements) {
- if (!IsScopeFree(statement, blockLiterals)) {
+ if (!IsScopeFree(statement, blockLiterals, why)) {
return false;
}
}
@@ -869,9 +933,15 @@ private static bool IsScopeFree(Expression/*!*/ node, bool blockLiterals) {
}
var jump = node as ReturnStatement;
if (jump != null) {
- return AreScopeFree(jump.Arguments, blockLiterals);
+ return AreScopeFree(jump.Arguments, blockLiterals, why);
}
- return false;
+ // a node of a kind not taken at all: its type says what it is, and a Hash says whether it is a call's keywords
+ if (why == null) {
+ return false;
+ }
+ var keywords = node as HashConstructor;
+ return Refuse(why, node.GetType().Name + (keywords != null && keywords.IsKeywordArguments ? " (keyword arguments)" : "") +
+ (LightCallsEnabled ? "" : " (IR_LIGHT_CALLS=0)"));
}
// A, ::A, A::B::C - the reads ConstantVariable.MakeCachedRead makes - not {expr}::A
@@ -880,10 +950,10 @@ private static bool IsCachedConstant(ConstantVariable/*!*/ constant) {
return qualifier == null || (qualifier is ConstantVariable && IsCachedConstant((ConstantVariable)qualifier));
}
- private static bool AreScopeFree(Statements statements, bool blockLiterals) {
+ private static bool AreScopeFree(Statements statements, bool blockLiterals, StrongBox why) {
if (statements != null) {
foreach (var statement in statements) {
- if (!IsScopeFree(statement, blockLiterals)) {
+ if (!IsScopeFree(statement, blockLiterals, why)) {
return false;
}
}
@@ -891,10 +961,10 @@ private static bool AreScopeFree(Statements statements, bool blockLiterals) {
return true;
}
- private static bool AreScopeFree(Arguments arguments, bool blockLiterals) {
+ private static bool AreScopeFree(Arguments arguments, bool blockLiterals, StrongBox why) {
if (arguments != null) {
foreach (var argument in arguments.Expressions) {
- if (!IsScopeFree(argument, blockLiterals)) {
+ if (!IsScopeFree(argument, blockLiterals, why)) {
return false;
}
}
@@ -1016,7 +1086,8 @@ internal LightFrameRewriter(MSA.ParameterExpression/*!*/ scope, MSA.Expression/*
/// The operand of a helper that takes the scope only for what a method scope shares with the scope the method
/// was defined in, so the declaring scope can be passed instead: the runtime (instance variables), and the
/// lexical chain a constant is looked up in - a method scope has no module of its own, so the lookup of one
- /// starts at its parent, which is the declaring scope. -1 for any other helper.
+ /// starts at its parent, which is the declaring scope. And the helpers that make a Hash literal or a call's keyword
+ /// hash (HashConstructor), which read only the runtime's equality comparer from it. -1 for any other helper.
///
private static int ScopeOperandIndex(MethodInfo/*!*/ method) {
if (method == Methods.GetInstanceVariable || method == Methods.IsDefinedInstanceVariable ||
@@ -1029,6 +1100,15 @@ private static int ScopeOperandIndex(MethodInfo/*!*/ method) {
if (method == Methods.SetInstanceVariable) {
return 2;
}
+ if (LightHashEnabled && (method == Methods.MakeHash || method == Methods.MakeSymbolHash1 ||
+ method == Methods.MakeSymbolHash2 || method == Methods.MakeSymbolHash3)) {
+ return 0;
+ }
+ if (LightKeywordHashEnabled && (method == Methods.MakeKeywordArgumentsHash || method == Methods.MakeKeywordArgumentsHash0 ||
+ method == Methods.MakeKeywordArgumentsHash1 || method == Methods.MakeKeywordArgumentsHash2 ||
+ method == Methods.MakeKeywordArgumentsHash3)) {
+ return 0;
+ }
return -1;
}
diff --git a/Util/hash-literal-matrix.rb b/Util/hash-literal-matrix.rb
new file mode 100644
index 00000000..b67e09ed
--- /dev/null
+++ b/Util/hash-literal-matrix.rb
@@ -0,0 +1,514 @@
+# Differential matrix for methods whose body has a Hash literal ({a: x}, {"k" => v}, {}) and run without a
+# scope (a light frame, MethodDefinition.IsLightFrameCandidate). Run it under CRuby and under ./ir.sh with such
+# frames on and off, and with the JIT off, and diff:
+#
+# ruby Util/hash-literal-matrix.rb > /tmp/mri.txt
+# ./ir.sh Util/hash-literal-matrix.rb > /tmp/on.txt
+# IR_LIGHT_HASH=0 ./ir.sh Util/hash-literal-matrix.rb > /tmp/off.txt
+# ./ir.sh -X:NoAdaptiveCompilation Util/hash-literal-matrix.rb > /tmp/interp.txt
+# diff /tmp/mri.txt /tmp/on.txt && diff /tmp/mri.txt /tmp/off.txt && diff /tmp/mri.txt /tmp/interp.txt
+#
+# Every probe runs N times and reports each distinct answer once, so the interpreted body, the compiled one and
+# a site whose rule is already bound all meet the case: each way a literal is compiled (empty, Symbol keys up to
+# three and more, String keys, other keys, `**h'), the order keys and values are evaluated and hashed in,
+# duplicate keys, the String key's frozen copy, the result being a new plain Hash on every call (no default,
+# no compare_by_identity, mutation not seen by the next call), literals in blocks, with yields, in defaults, in
+# loops, recursion, exceptions and their backtraces, defined?, tracing, threads, and the keyword hash a call
+# site builds (`f(a: x)') next to the literal it is not. Sections 7 to 12 are about the call a light frame makes
+# with keywords and about what may outlive it: the callee's visibility, a callee that reads the caller's scope, the
+# callee or a key's #hash changing half way through the N calls, a literal in a method whose scope is parked for
+# its next call, and a refinement in use where the caller is defined.
+#
+# IR_LIGHT_FRAMES=why ./ir.sh Util/hash-literal-matrix.rb 2>&1 >/dev/null | grep -a '^\[light\]'
+#
+# says which of the methods below are light frames.
+
+N = 3000
+
+def t(label)
+ print label.ljust(52), ' => '
+ seen = []
+ begin
+ N.times do |i|
+ v = yield i
+ seen << v unless seen.include?(v)
+ end
+ puts seen.map(&:inspect).join(', ')
+ rescue Exception => e
+ puts "#{seen.map(&:inspect).join(', ')} then #{e.class}: #{e.message[0, 70]}"
+ end
+end
+
+def label(line) = line[/'(?:[^']*[#.])?([^']*)'/, 1]
+
+# ---------------------------------------------------------------- 1. each way a literal is compiled
+
+def h_empty = {}
+def h_sym1(x) = { a: x }
+def h_sym2(x, y) = { a: x, b: y }
+def h_sym3(x, y, z) = { a: x, b: y, c: z }
+def h_sym4(x) = { a: x, b: x, c: x, d: x }
+def h_str(x) = { "k" => x }
+def h_str2(x) = { "k" => x, "l" => x }
+def h_int(x) = { 1 => x, 2.5 => x, nil => x }
+def h_mixed(x) = { a: x, "b" => x, 3 => x }
+def h_key(k, v) = { k => v }
+def h_keys(k1, k2) = { k1 => 1, k2 => 2 }
+def h_short(a, b) = { a:, b: }
+def h_nested(x) = { a: { b: { c: x } }, d: [x, { e: x }] }
+def h_dsplat(o) = { a: 1, **o, b: 2 }
+def h_dsplat_only(o) = { **o }
+def h_dsym(x) = { "a#{x}": 1 }
+def h_ivar(x) = (@h = { v: x }; @h)
+H_CONST = { k: 1 }
+def h_const(x) = { c: H_CONST, x: x }
+
+class ToHash; def to_hash = { th: 1 }; end
+class NotHash; end
+
+t('{}') { h_empty }
+t('{} is a Hash') { h_empty.class }
+t('{a: x}') { h_sym1(1) }
+t('{a: x, b: y}') { h_sym2(1, nil) }
+t('{a:, b:, c:}') { h_sym3(1, 2, 3) }
+t('four Symbol keys') { h_sym4(:v) }
+t('a String key') { h_str(1) }
+t('two String keys') { h_str2(1) }
+t('Integer, Float and nil keys') { h_int(1) }
+t('mixed keys') { h_mixed(1) }
+t('{a:, b:} shorthand') { h_short(1, 2) }
+t('nested') { h_nested(1) }
+t('**h') { h_dsplat({ c: 3 }) }
+t('**h overrides and is overridden') { h_dsplat({ a: 9, b: 9 }) }
+t('**nil') { h_dsplat(nil) }
+t('**to_hash') { h_dsplat(ToHash.new) }
+t('**not a hash') { begin; h_dsplat(NotHash.new); rescue TypeError => e; e.message.sub(/0x\h+/, 'X'); end }
+t('{**h} is a copy') { h = { a: 1 }; r = h_dsplat_only(h); [r, r.equal?(h)] }
+t('dynamic Symbol key') { h_dsym(1) }
+t('stored in an ivar') { h_ivar(1) }
+t('a constant value') { h_const(1) }
+
+# ---------------------------------------------------------------- 2. order and keys
+
+$log = []
+def logged(x) = ($log << x; x)
+class LoudKey
+ attr_reader :n
+ def initialize(n) = @n = n
+ def hash = ($log << "hash#{@n}"; @n.hash)
+ def eql?(o) = ($log << "eql#{@n}"; o.is_a?(LoudKey) && o.n == @n)
+ def inspect = "K#{@n}"
+end
+def o_order = { logged(:k1) => logged(1), logged(:k2) => logged(2), logged(:k3) => logged(3) }
+def o_order4 = { logged("k1") => logged(1), logged(:k2) => logged(2), logged(3) => logged(3), logged(:k4) => logged(4) }
+def o_loud(a, b) = { a => logged(:va), b => logged(:vb) }
+def o_dup(k) = { k => 1, :x => 2, k => 3 }
+def o_dup_str(a, b) = { a => 1, b => 2 }
+
+# the log is copied and the Hash inspected right after the call: comparing answers calls #hash and #eql? again
+t('evaluation order, three') { $log = []; r = o_order; [r, $log.dup] }
+t('evaluation order, four') { $log = []; r = o_order4; [r, $log.dup] }
+t('hash and eql? order') { $log = []; r = o_loud(LoudKey.new(1), LoudKey.new(2)); [r.inspect, $log.dup] }
+t('equal keys: hash and eql?') { $log = []; r = o_loud(LoudKey.new(1), LoudKey.new(1)); [r.inspect, $log.dup] }
+t('duplicate keys keep the last value') { o_dup(:x) }
+t('duplicate keys keep the first key') { a = +"k"; b = +"k"; r = o_dup_str(a, b); [r, r.keys[0].equal?(a)] }
+t('a String key is a frozen copy') { s = +"key"; r = h_key(s, 1); k = r.keys[0]; [k.frozen?, k.equal?(s), s.frozen?, (s << "!")] }
+t('a frozen String key is kept') { s = "fk".freeze; h_key(s, 1).keys[0].equal?(s) }
+# (not whether it is frozen: IronRuby freezes a String subclass key, CRuby 4.0 does not, light frame or not)
+t('a String subclass key') { c = Class.new(String); h_key(c.new("x"), 1).keys[0].class == c }
+t('an Array key') { a = [1]; r = h_key(a, 2); [r, r.keys[0].equal?(a)] }
+t('a NaN key') { r = h_key(Float::NAN, 1); [r.size, r.key?(Float::NAN)] }
+t('0 and 0.0 keys') { h_keys(0, 0.0) }
+t('1 and 1r keys') { h_keys(1, 1r) }
+
+# ---------------------------------------------------------------- 3. the result
+
+def r_fill(n); h = {}; i = 0; while i < n; h[i] = i * i; i += 1; end; h; end
+def r_mutate; h = { a: 1 }; h[:b] = 2; h; end
+def r_cbi; h = {}; h.compare_by_identity; h; end
+def r_cbi_after; {} ; end
+
+t('a new Hash on every call') { h_sym1(1).equal?(h_sym1(1)) }
+t('{} is new on every call') { h_empty.equal?(h_empty) }
+t('mutation does not leak') { r = h_sym1(1); r[:z] = 1; h_sym1(1) }
+t('mutation of {} does not leak') { r = h_empty; r[:z] = 1; h_empty }
+t('filled in a loop') { r_fill(5) }
+t('mutated before return') { r_mutate }
+t('compare_by_identity not inherited') { r_cbi.compare_by_identity?; r_cbi_after.compare_by_identity? }
+t('no default, no default_proc') { r = h_sym1(1); [r.default, r.default_proc, r[:missing]] }
+t('not frozen') { [h_sym1(1).frozen?, h_empty.frozen?, h_str(1).frozen?] }
+t('ordering') { h_sym3(3, 2, 1).to_a }
+t('Symbol keys look up') { r = h_sym4(1); [r[:a], r[:d], r.key?(:c), r.fetch(:b)] }
+t('String keys look up') { r = h_str2(1); [r["k"], r["l"], r.key?("k")] }
+t('rehash after mutating an Array key') { a = [1]; r = h_key(a, 1); a << 2; [r[a], r.rehash[a]] }
+t('instance_variables of the result') { h_sym1(1).instance_variables }
+t('singleton class of the result') { r = h_sym1(1); def r.x = 1; [r.x, h_sym1(1).respond_to?(:x)] }
+
+# ---------------------------------------------------------------- 4. where it is written
+
+def w_block(a) = a.map { |x| { x => x } }
+def w_block_out(a, y) = a.map { |x| { x => y } }
+def w_block_and_hash(a) = [{ n: a.size }, a.map { |x| x * 2 }]
+def w_yield(x) = { a: yield(x) }
+def w_yield2(x) = (h = { a: x }; yield h; h)
+def w_default(x, h = {}) = (h[:x] = x; h)
+def w_default_sym(x, h = { d: 1 }) = (h[:x] = x; h)
+def w_while(n); r = []; i = 0; while i < n; r << { i: i }; i += 1; end; r; end
+def w_case(x)
+ case x
+ when Integer then { int: x }
+ when String then { str: x }
+ else {}
+ end
+end
+def w_if(x) = x ? { t: x } : { f: x }
+def w_and(x) = x && { v: x }
+def w_return(x); return { early: x } if x > 0; { late: x }; end
+def w_arg(x) = w_take({ a: x })
+def w_take(h) = h
+def w_recv(x) = { a: x }.merge({ b: x })
+def w_index(x) = { a: x }[:a]
+def w_send(x) = send(:h_sym1, x)
+def w_attr(o, x) = (o.v = { v: x }; o.v)
+S = Struct.new(:v)
+def w_elem(h, x) = (h[:k] = { v: x }; h)
+def w_range(x) = { r: (1..x) }
+def w_str(x) = { s: "a#{x}" }
+def w_arr(x) = [{ a: x }, [{ b: x }]]
+def w_recur(n) = n == 0 ? {} : { n => w_recur(n - 1) }
+def w_proc(x) = proc { { p: x } }
+def w_lambda(x) = -> { { l: x } }
+define_method(:w_dm) { |x| { dm: x } }
+def w_binding(x) = ({ b: binding.local_variable_get(:x) })
+def w_lvars(x) = { l: local_variables }
+def w_method(x) = { m: __method__ }
+def w_bg(x) = { bg: block_given? }
+def w_caller(x) = { c: caller(0, 1).map { |l| label(l) } }
+def w_eval(x) = eval("{ e: x }")
+def w_inst_eval(x) = instance_eval { { ie: x } }
+
+t('in a block') { w_block([1, 2]) }
+t('in a block, reading an outer local') { w_block_out([1, 2], :y) }
+t('beside a literal block') { w_block_and_hash([1, 2]) }
+t('with yield') { w_yield(2) { |v| v * 3 } }
+t('yields the hash it returns') { w_yield2(1) { |h| h[:y] = 1 } }
+t('{} default') { [w_default(1), w_default(2)] }
+t('{} default given') { h = {}; [w_default(1, h).equal?(h), h] }
+t('{d: 1} default') { [w_default_sym(1), w_default_sym(2)] }
+t('in a while loop') { w_while(3) }
+t('in case/when') { [w_case(1), w_case("s"), w_case(nil)] }
+t('in ?:') { [w_if(1), w_if(nil)] }
+t('in &&') { [w_and(1), w_and(nil)] }
+t('early return') { [w_return(1), w_return(-1)] }
+t('as an argument') { w_arg(1) }
+t('as a receiver') { w_recv(1) }
+t('indexed') { w_index(1) }
+t('through send') { w_send(1) }
+t('attribute assignment') { w_attr(S.new, 1) }
+t('element assignment') { w_elem({}, 1) }
+t('with a Range') { w_range(2) }
+t('with an interpolation') { w_str(2) }
+t('in an Array literal') { w_arr(1) }
+t('recursion') { w_recur(3) }
+t('in a proc called later') { w_proc(1).call }
+t('in a lambda called later') { w_lambda(1).call }
+t('define_method') { w_dm(1) }
+t('with binding') { w_binding(1) }
+t('with local_variables') { w_lvars(1) }
+t('with __method__') { w_method(1) }
+t('with block_given?') { [w_bg(1), w_bg(1) {}] }
+t('with caller') { w_caller(1) }
+t('with eval') { w_eval(1) }
+t('with instance_eval') { w_inst_eval(1) }
+
+# ---------------------------------------------------------------- 5. errors, defined?, tracing, threads
+
+class HashRaises; def hash = raise(IndexError, "hash raised"); end
+def e_value(x) = { a: x.fetch(9) }
+def e_key(x) = { x.fetch(9) => 1 }
+def e_loud(k) = { k => 1 }
+def e_four(x) = { a: 1, b: 2, c: 3, d: x.fetch(9) }
+def e_str(x) = { "s" => x.fetch(9) }
+# (not of a literal whose value calls a missing method: CRuby answers nil, IronRuby "expression", light frame or not)
+def d_lit(x) = defined?({ a: x })
+def d_empty = defined?({})
+def traced(x) = { tr: x }
+
+t('raise in a value') { begin; e_value([]); rescue IndexError => e; [e.message, e.backtrace[0, 3].map { |l| label(l) }]; end }
+t('raise in a key') { begin; e_key([]); rescue IndexError => e; [e.message, e.backtrace[0, 3].map { |l| label(l) }]; end }
+t('raise in #hash of a key') { begin; e_loud(HashRaises.new); rescue IndexError => e; [e.message, e.backtrace[1, 2].map { |l| label(l) }]; end }
+t('raise in a fourth value') { begin; e_four([]); rescue IndexError => e; [e.message, e.backtrace[1, 2].map { |l| label(l) }]; end }
+t('raise in a String-keyed value') { begin; e_str([]); rescue IndexError => e; [e.message, e.backtrace[1, 2].map { |l| label(l) }]; end }
+t('raise line') { begin; e_value([]); rescue IndexError => e; e.backtrace_locations[1].lineno - __LINE__; end }
+t('defined? of a literal') { d_lit(1) }
+t('defined? {}') { d_empty }
+t('TracePoint :call sees it') do
+ seen = []
+ tp = TracePoint.new(:call) { |e| seen << e.method_id if e.method_id == :traced }
+ tp.enable { traced(1) }
+ seen
+end
+t('TracePoint :call, binding') do
+ seen = []
+ tp = TracePoint.new(:call) { |e| seen << e.binding.local_variable_get(:x) if e.method_id == :traced }
+ tp.enable { traced(7) }
+ seen
+end
+t('TracePoint :c_call in a value') do
+ seen = []
+ tp = TracePoint.new(:c_call) { |e| seen << e.method_id if e.method_id == :fdiv }
+ tp.enable { h_sym1(1.fdiv(2)) }
+ seen
+end
+t('after the TracePoint') { traced(-5) }
+t('threads') do |i|
+ i % 100 == 0 ? Array.new(4) { |k| Thread.new { Array.new(50) { |j| h_sym2(k, j) }.last } }.map(&:value) : true
+end
+
+# ---------------------------------------------------------------- 6. the keyword hash of a call site
+
+def kw(a:, b: 2) = [a, b]
+def kw_rest(**o) = o
+def kw_opt(a: 1) = a
+def pos(h) = h
+def pos_rest(*r) = r
+def pos_opt(x = :none, h = {}) = [x, h]
+ruby2_keywords def r2k(*args) = args
+def k_call(x) = kw(a: x)
+def k_call2(x) = kw(a: x, b: x)
+def k_rest(x) = kw_rest(a: x, "s" => x)
+def k_pos(x) = pos(a: x)
+def k_pos_rest(x) = pos_rest(1, a: x)
+def k_opt(x) = pos_opt(a: x)
+def k_dsplat(h) = kw(**h)
+def k_dsplat_more(h) = kw_rest(z: 1, **h)
+def k_empty_dsplat(h) = pos_rest(**h)
+def k_r2k(x) = r2k(a: x)
+def k_lit_vs_kw(x) = [pos_rest({ a: x }), pos_rest(a: x)]
+def k_kw_opt(x) = kw_opt(a: x)
+def k_unknown(x) = kw(a: x, c: x)
+def k_send(x) = send(:kw, a: x)
+def k_yield(x) = yield(a: x)
+def k_block(x) = [x].map { |v| kw(a: v) }
+def k_lib(s) = s.encode("US-ASCII", undef: :replace, invalid: :replace)
+def k_struct(x) = KS.new(a: x)
+KS = Struct.new(:a, keyword_init: true)
+def k_dsplat_nil(x) = kw_rest(**nil)
+class KMM; def method_missing(n, *a, **k) = [n, a, k]; def respond_to_missing?(*) = true; end
+def k_mm(o, x) = o.anything(a: x)
+
+t('f(a: x)') { k_call(1) }
+t('f(a: x, b: y)') { k_call2(1) }
+t('f(a: x, "s" => x) to **o') { k_rest(1) }
+t('f(a: x) to a positional') { r = k_pos(1); [r, r.frozen?] }
+t('f(1, a: x) to *r') { k_pos_rest(1) }
+t('f(a: x) to optionals') { k_opt(1) }
+t('f(**h)') { k_dsplat({ a: 1 }) }
+t('f(**h) does not change h') { h = { a: 1 }; k_dsplat(h); h }
+t('f(z: 1, **h)') { h = { y: 2 }; [k_dsplat_more(h), h] }
+t('f(**{}) passes nothing') { k_empty_dsplat({}) }
+t('ruby2_keywords') { r = k_r2k(1); [r, Hash.ruby2_keywords_hash?(r.last)] }
+t('literal and keywords to *r') { k_lit_vs_kw(1) }
+t('optional keyword') { k_kw_opt(5) }
+t('unknown keyword') { begin; k_unknown(1); rescue ArgumentError => e; e.message; end }
+t('send with keywords') { k_send(1) }
+t('yield with keywords') { k_yield(1) { |**k| k } }
+t('yield keywords to a positional') { k_yield(1) { |h| h } }
+t('keywords in a block') { k_block(1) }
+t('keywords to a library method') { k_lib("aƩ") }
+t('keyword_init Struct') { k_struct(1).a }
+t('**nil') { k_dsplat_nil(1) }
+t('keywords to method_missing') { k_mm(KMM.new, 1) }
+
+def guard
+ yield
+rescue Exception => e
+ "#{e.class}: #{e.message[0, 60]}"
+end
+
+# ---------------------------------------------------------------- 7. the callee's visibility
+# A call a light frame makes with the frame in place of its scope must still be the source's call: private
+# and protected methods, method_missing.
+class Vis
+ def pub(a:) = [:pub, a]
+ def call_priv(x) = priv(a: x)
+ def call_priv_self(x) = self.priv(a: x)
+ def call_prot(o, x) = o.prot(a: x)
+ private def priv(a:) = [:priv, a]
+ protected def prot(a:) = [:prot, a]
+end
+class Other
+ def call_prot(o, x) = o.prot(a: x)
+ def call_priv(o, x) = o.priv(a: x)
+end
+class Missing
+ def method_missing(name, *args, **kw) = [name, args, kw]
+ def respond_to_missing?(*) = true
+ def go(x) = nope(1, a: x)
+ def go_self(x) = self.nope(a: x)
+end
+
+t('private, implicit self') { |i| Vis.new.call_priv(i % 2) }
+t('private, self.') { |i| Vis.new.call_priv_self(i % 2) }
+t('protected, same class') { |i| Vis.new.call_prot(Vis.new, i % 2) }
+t('protected, other class') { |i| guard { Other.new.call_prot(Vis.new, i % 2) } }
+t('private, other class') { |i| guard { Other.new.call_priv(Vis.new, i % 2) } }
+t('method_missing') { |i| Missing.new.go(i % 2) }
+t('method_missing, self.') { |i| Missing.new.go_self(i % 2) }
+
+# ---------------------------------------------------------------- 8. a callee that reads the caller's scope
+def scope_reader(x) = eval("x + 1", binding, __FILE__, __LINE__).then { |v| { v: v } }
+def lvars(x, y = 2) = { names: local_variables, sum: x + y }
+def blk_kw(x) = { given: block_given?, v: Integer(x.to_s, exception: false) }
+def warn_kw(x) = (warn("w", uplevel: 0) if x < 0)
+def raise_kw(x) = raise(ArgumentError, "m#{x}", cause: nil)
+def send_kw(o, x) = o.send(:pub, a: x)
+def psend_kw(o, x) = o.public_send(:pub, a: x)
+def meth_kw(o, x) = o.method(:pub).call(a: x)
+def struct_kw(x) = KS2.new(a: x, b: { c: x })
+KS2 = Struct.new(:a, :b, keyword_init: true)
+t('eval with binding, then a literal') { |i| scope_reader(i % 2) }
+t('local_variables in a literal') { |i| lvars(i % 2) }
+t('block_given? and a keyword call') { |i| [blk_kw(i % 2), blk_kw(i % 2) { }] }
+t('warn with uplevel, not reached') { |i| warn_kw(i % 2) }
+t('raise with cause:') { |i| guard { raise_kw(i % 2) } }
+t('send with keywords') { |i| send_kw(Vis.new, i % 2) }
+t('public_send with keywords') { |i| psend_kw(Vis.new, i % 2) }
+t('Method#call with keywords') { |i| meth_kw(Vis.new, i % 2) }
+t('keyword_init Struct') { |i| struct_kw(i % 2).to_h }
+
+# ---------------------------------------------------------------- 9. the callee changes in the middle
+# The site's rule is bound by then: each change must be seen by the next call.
+class Chg
+ def f(a:) = [:v1, a]
+ def go(x) = f(a: x)
+ def go_lit(x) = f(**{ a: x })
+end
+c = Chg.new
+t('callee redefined half way') do |i|
+ Chg.class_eval { def f(a:, b: 9) = [:v2, a, b] } if i == N / 2
+ c.go(i % 2)
+end
+t('callee made private half way') do |i|
+ Chg.send(:private, :f) if i == N / 2
+ c.go(i % 2)
+end
+t('singleton method half way') do |i|
+ c.define_singleton_method(:f) { |a:| [:single, a] } if i == N / 2
+ c.go(i % 2)
+end
+t('callee takes a positional Hash half way') do |i|
+ Chg.class_eval { def f(h = nil, **k) = [:v3, h, k] } if i == N / 2
+ Chg.new.go(i % 2)
+end
+t('callee removed half way') do |i|
+ Chg.send(:remove_method, :f) if i == N / 2
+ guard { Chg.new.go(i % 2) }
+end
+class Chg2
+ def f(a:) = a
+ def go(x) = f(a: x)
+end
+t('callee replaced by one that reads the scope') do |i|
+ Chg2.class_eval { def f(a:) = block_given? ? [:blk, a] : [:none, a] } if i == N / 2
+ [Chg2.new.go(i % 2), Chg2.new.go(i % 2) { }]
+end
+t('unknown keyword after a redefinition') do |i|
+ Chg2.class_eval { def f(b:) = b } if i == N / 2
+ guard { Chg2.new.go(i % 2) }
+end
+
+
+# ---------------------------------------------------------------- 10. a literal whose pieces change under it
+class HK
+ attr_reader :v
+ def initialize(v) = @v = v
+ def hash = @v.hash
+ def eql?(o) = o.is_a?(HK) && @v == o.v
+end
+def two(a, b) = { a => 1, b => 2 }
+t('keys that are eql? or not') { |i| two(HK.new(1), HK.new(i % 2)).size }
+t('#hash redefined half way') do |i|
+ HK.class_eval { def hash = 7 } if i == N / 2
+ two(HK.new(1), HK.new(i % 2)).size
+end
+t('#eql? redefined half way') do |i|
+ HK.class_eval { def eql?(o) = false } if i == N / 2
+ two(HK.new(1), HK.new(1)).size
+end
+t('String#freeze redefined') do |i|
+ String.class_eval { alias_method :__f, :freeze; def freeze = __f } if i == N / 2
+ s = +"k"
+ h = { s => i % 2 }
+ [h.keys[0].frozen?, s.frozen?, h.keys[0].equal?(s)]
+end
+t('Hash.new redefined, a literal does not call it') do |i|
+ Hash.singleton_class.class_eval { alias_method :__n, :new; def new(*) = raise("called") } if i == N / 2
+ r = guard { { a: i % 2 } }
+ Hash.singleton_class.class_eval { alias_method :new, :__n } if i == N - 1
+ r
+end
+
+# ---------------------------------------------------------------- 11. a literal in a method whose scope is parked
+# A method whose literal blocks all reuse their Procs keeps its scope for its next call (IR_PARKED_SCOPES,
+# Util/parked-scope-matrix.rb). With a Hash literal or keywords in it, it is a light frame that parks: nothing of
+# one call may show in the next, whether the call returned, raised, threw or returned from the block.
+class ParkedLit
+ def initialize = @s = [1, 2, 3]
+ def each = 3.times { |i| yield @s[i] }
+ def each_lit = 3.times { |i| yield({ i: i, v: @s[i] }) }
+ def each_kw = 3.times { |i| yield(i: i, v: @s[i]) }
+ def lit_local(x); h = { n: x }; 3.times { |i| h[:n] += @s[i] }; h; end
+ def lit_in_block(x); r = nil; 3.times { |i| r = { x => i } }; r; end
+ def lit_default(x, h = {}); 3.times { |i| h[i] = x }; h; end
+ def kw_out(x); r = 0; 3.times { |i| r += kw(a: x, b: i) }; r; end
+ def kw(a:, b: 0) = a + b
+ def keep(x); h = { x: x }; 3.times { |i| h[i] = binding if i == 1 }; h; end
+ def lam(x) = { f: [0, 1, 2].map { |i| -> { i + x } } }
+ def raise_mid(x); h = { x: x }; 3.times { |i| raise IndexError, h.inspect if i == x }; h; end
+ def thrown(x); h = { x: x }; 3.times { |i| throw :out, h if i == x }; h; end
+ def early(x); h = { x: x }; 3.times { |i| return h.merge(i: i) if i == x }; h; end
+ def rec(n); h = { n: n }; 1.times { |_| h[:d] = n > 0 ? rec(n - 1) : nil }; h; end
+end
+
+v = ParkedLit.new
+t('yield a literal from a parked block') { |i| a = []; v.each_lit { |h| a << h }; [a, a.map(&:object_id).uniq.size] }
+t('yield keywords from a parked block') { |i| a = []; v.each_kw { |**h| a << h }; a }
+t('a literal in a local, changed by the block') { |i| v.lit_local(i % 2) }
+t('the result is not the next call\'s') { |i| r = v.lit_local(0); r[:n] += 100; [r, v.lit_local(0)] }
+t('a literal made in the block') { |i| v.lit_in_block(i % 2) }
+t('a `{}\' default') { |i| [v.lit_default(i % 2), v.lit_default(1).equal?(v.lit_default(1))] }
+t('a default given by the caller') { |i| h = { z: 1 }; v.lit_default(i % 2, h).equal?(h) }
+t('keywords from a parked block') { |i| v.kw_out(i % 2) }
+t('binding kept, each call its own literal') do |i|
+ b1 = v.keep(1)[1]; b2 = v.keep(2)[1]
+ [b1.local_variable_get(:h)[:x], b2.local_variable_get(:h)[:x], b1.local_variable_get(:h).equal?(b2.local_variable_get(:h)), b1.local_variable_get(:x)]
+end
+t('lambdas in a literal') { |i| a = v.lam(i % 2)[:f]; b = v.lam(10)[:f]; [a.map(&:call), b.map(&:call)] }
+t('raise in the block, then a normal call') { |i| r = (v.raise_mid(i % 4) rescue $!.message); [r, v.raise_mid(9)] }
+t('throw from the block') { |i| [catch(:out) { v.thrown(i % 4) }, v.thrown(9)] }
+t('return from the block') { |i| [v.early(i % 4), v.early(9)] }
+t('recursion through the block') { |i| v.rec(3) }
+t('threads') do |i|
+ next :skipped unless i % 500 == 0
+ pvt_r = Array.new(4) { |pvt_k| Thread.new { Array.new(50) { v.lit_local(pvt_k) } } }.map(&:value)
+ pvt_r.map(&:uniq)
+end
+
+# ---------------------------------------------------------------- 12. a refinement where the caller is defined
+# Last in the file: a method defined where a refinement is in use is never a light frame, so every
+# method after `using' is one with a scope.
+module Loud
+ refine String do
+ def center(width, pad = " ", loud: false) = loud ? "LOUD" : super(width, pad)
+ def tag(a:) = "refined #{a}"
+ end
+end
+class String; def tag(a:) = "plain #{a}"; end
+def unrefined_tag(s, x) = s.tag(a: x)
+using Loud
+def refined_tag(s, x) = s.tag(a: x)
+def refined_center(s) = s.center(5, loud: true)
+t('unrefined caller') { |i| unrefined_tag("s", i % 2) }
+t('refined caller') { |i| refined_tag("s", i % 2) }
+t('refined, keyword only it knows') { |_| refined_center("s") }
diff --git a/Util/perf/LEDGER.md b/Util/perf/LEDGER.md
index ca5e1a23..122a2bdd 100644
--- a/Util/perf/LEDGER.md
+++ b/Util/perf/LEDGER.md
@@ -778,8 +778,7 @@ loop of its own): `b.local_variable_set(:x, 1)` 0.1 -> 436, `erb.result_with_has
SOM's `Vector#each` over 4 elements ran at 0.98-1.05 of before and over 100 at
1.00-1.15 (round nine). Closed. What DeltaBlue pays is in gap 14.
9. **Light frames still exclude** a `while` with a `break` in it (`Array#take_while`),
- an empty Hash literal `{}` (found on `Array#to_h`;
- `::Hash.new` is scope-free but calls a redefined Hash.new), `super` (6 hot `initialize`
+ `super` (6 hot `initialize`
methods; also `Array#sum` without a block, 5.3x CRuby, whose rare path is `super`), `rescue`,
keywords, `$~` and regex literals.
`IR_LIGHT_FRAMES=why` lists them. Also a Range per `(a..b).each`, and
@@ -790,14 +789,37 @@ loop of its own): `b.local_variable_set(:x, 1)` 0.1 -> 436, `erb.result_with_has
(`inner(&block)`, `map(&:sym)`; `IR_LIGHT_BLOCK_PASS=0`, see Landed, perf/blockpass), nor
one that splats a value (`inner(*args)`, `[*a]`, `yield(*a)`; `IR_LIGHT_SPLAT=0`, see
Landed, perf/splat), nor an interpolation (`"a#{x}"`; `IR_LIGHT_INTERPOLATION=0`, see
- Landed, perf/interp; a block that interpolates still makes its scope);
+ Landed, perf/interp; a block that interpolates still makes its scope), nor a Hash
+ literal or the keywords of a call (`{a: x}`, `{}`, `f(a: x)`; `IR_LIGHT_HASH=0`,
+ `IR_LIGHT_KEYWORD_HASH=0`, see Landed, perf/hashlit; `f(**h)` is still out);
Util/block-given-matrix.rb, Util/light-rest-matrix.rb, Util/block-pass-matrix.rb,
- Util/splat-pass-matrix.rb and Util/interpolation-matrix.rb are their matrices.
- What the census names next (2026-11-19, 28,335 methods): "optional, splat or post
- parameters" 1,525, `super` 755, `rescue`/`ensure` 475, and 167 candidates that still
- need their scope after the rewrite (in the prelude `Enumerable#zip`,
- `Enumerator::Lazy#zip`, `Enumerator#__size_from_target__`, `Process#detach`,
- `Process.waitall`; nobody has looked at what refuses them). A method with both a literal block and a passed one still makes its scope
+ Util/splat-pass-matrix.rb, Util/interpolation-matrix.rb and Util/hash-literal-matrix.rb
+ are their matrices.
+ What the census names next (2026-11-19 after perf/hashlit, 28,335 methods, 6,542 of
+ them not light). By its first table: keyword parameters 1,257 (37 of them the
+ prelude's, none AWFY's), `rescue`/`ensure` 478, 185 candidates that still need their
+ scope after the rewrite (in the prelude `Enumerable#zip`, `Enumerator::Lazy#zip`,
+ `Enumerator#__size_from_target__`, `Process#detach`, `Process.waitall`,
+ `__errno_class__`; nine of them were looked at in perf/hashlit and are a `rescue`
+ inside a literal block, `a.map { |x| begin; x; rescue; end }`, by the subagent's probe), and other optional,
+ splat or post parameters 176.
+ The rest are refused by a statement of the body, and the census's second table says
+ for which construct inside it: `super` 1,054, a regex literal 1,008, a parallel
+ assignment 661, a `begin ... end` block 523 (the table calls it Body), `break` 268
+ (258 of them in a `while`), `defined?` 190, a global variable 158, a Range literal in a
+ body with literal blocks 138, a class variable 86, a qualified constant 76, a lambda
+ literal 47, a `rescue` modifier 43. (The lines grew when Hash literals left: a method
+ is counted under the first construct that refuses it.)
+ Where it matters: the prelude's 191 are keyword parameters 37, a `begin` block 27, a
+ parallel assignment 24, `defined?` 23, `super` 16, a regex 12, a `rescue` modifier 10;
+ AWFY's 21 are a Range
+ literal that receives `each` with a block 12 (`Vector#each`, `Sieve#sieve`; the scope
+ is made for the block anyway, so letting the Range in buys nothing by itself), `super`
+ 6 (five DeltaBlue constraints' `initialize`, Richards' TaskControlBlock), a
+ `begin ... end while` 2 (Json's `read_object`, `read_array`) and a regex 1. Not looked into, from reading
+ `IsScopeFree`: a regex literal is refused by itself
+ although `$~` is written by the call that matches; `defined?(@x)` is refused.
+ A method with both a literal block and a passed one still makes its scope
for the passed one's call (LightScopeCall leaves calls with a block to BlockLiterals).
10. **`!=` outside the method JIT is two dispatches**: `BasicObject#!=` calls `==`
@@ -1128,7 +1150,7 @@ loop of its own): `b.local_variable_set(:x, 1)` 0.1 -> 436, `erb.result_with_has
`def o.x` invalidates, counted (rules rebuilt, typed bodies respecialized), on
`ostruct` of `app-shapes.rb`.
-21. **Three differences from CRuby in interpolation**, found by the probes of
+33. **Three differences from CRuby in interpolation**, found by the probes of
`Util/interpolation-matrix.rb` on the build before perf/interp and left as they were
(the matrix avoids them); not speed gaps. When a part's `to_s` raises, the backtrace
names the method's first line for that frame where CRuby names the interpolation's own
@@ -1136,9 +1158,150 @@ loop of its own): `b.local_variable_set(:x, 1)` 0.1 -> 436, `erb.result_with_has
without a scope. A TracePoint `:line` event is reported for the body of an endless
`def`, CRuby reports none. And with a refinement of `Symbol#to_s` in use, `"#{:s}"` asks
the refined `to_s`; CRuby answers `"s"` without asking it.
+34. **Two differences from CRuby in Hash literals**, found by the probes of
+ `Util/hash-literal-matrix.rb` on the build before perf/hashlit and left as they were
+ (the matrix leaves them out, with a comment); not speed gaps. A key that is an
+ instance of a String subclass is copied and frozen (`k = MyS.new("k"); h = {k => 1}`:
+ `h.keys[0].frozen?` is true and it is not `k`); CRuby 4.0 keeps `k` itself, unfrozen,
+ and copies only a plain String. The same with `h[k] = 1`. And `defined?({a: 1.nope})`
+ is `"expression"` where CRuby says nil, as both say for `defined?([1.nope])`.
## Landed
+- **perf/hashlit (/perf-step, 2026-11-19) - a method with a Hash literal, or one that
+ passes keywords, runs without a scope** (`{a: x}`, `{"k" => v}`, `{}`, `f(a: x)`;
+ `IR_LIGHT_HASH=0` and `IR_LIGHT_KEYWORD_HASH=0` turn each off). `IsScopeFree` had no
+ case for a HashConstructor, so one anywhere in a body sent the method to the final
+ refusal, while an Array literal was taken element by element. The helpers a literal
+ and a call's keyword hash compile to (`RubyOps.MakeHash`, `MakeSymbolHash1..3`,
+ `MakeKeywordArgumentsHash`, `MakeKeywordArgumentsHash0..3`) take the scope only for
+ the runtime's equality comparer, so the rewriter now passes them the declaring scope,
+ as it does for instance variables and constants (`ScopeOperandIndex`), and the filter
+ takes a Hash whose keys and values are scope-free. `**h` in a literal already was a
+ call of `Hash#merge`; `f(**h)` (KeywordSplatMerge) and the defaults of keyword
+ parameters are not taken. Two commits, the keywords second, so either reverts alone.
+ light frames 71.7% -> 76.9% (20,318 -> 21,793), light blocks 7,389 -> 7,724, JIT
+ compiles, maybe and never unchanged (Src/StdLib + AWFY, 28,335 methods; 1,475 methods
+ moved up, none down: 807 for the literal, 148 of those a `h = {}` default, and 668 for
+ the keywords). 42 of them are the prelude's, among them
+ `group_by`, `uniq`, `tally`, `uniq!`, six `to_h`, `transform_keys`, `slice`, `fetch`,
+ `to_set`, `transform_values!`, `__check_frozen__`; none is AWFY's, whose methods
+ write no Hash literal, so the AWFY table is not expected to move.
+ 131 of the 789 the literal kept out did not move with the first commit: another
+ construct keeps them (parallel assignment, a regex, `super`, a global variable).
+ Checked, by the subagent and again by me on its build: `Util/hash-literal-matrix.rb`
+ (new, 111 probes) prints CRuby 4.0's output on the build before, the new one, with
+ each switch off and both, with `-X:NoAdaptiveCompilation` and with `IR_LIGHT_FRAMES=0`;
+ the interpolation, splat-pass, block-pass, light-rest and block-given matrices print
+ CRuby's on both builds; `census.rb -c` against traced runs of Richards and Json says
+ 0 differ; the merged build's census is the worktree's row for row.
+ Instructions per call (`ab.rb -i`, the subagent's run, not repeated): `{a: x}` 1,663
+ -> 1,360, `{a: x, b: x}` 1,761 -> 1,449, `{}` filled with two keys 2,220 -> 1,964,
+ `{"k" => x}` 2,010 -> 1,797, `f(a: x)` to a keyword 1,161 -> 893, two keywords to
+ `**o` 2,692 -> 2,466, a control without a Hash 910 -> 872 (within its spread).
+ Found on the way: gap 34.
+
+ Gated on 2026-11-20 together with perf/why, the branch at 9f8bc1a7 against master at
+ 084b09cf, both Release net10.0, 8 cores, load 1.1 to 1.7 (`/perf-gate`): **PASS**.
+ - IronRuby.Tests: the same one failure on both trees (`Exception_CauseRaisedInClause1`,
+ master's, Release only).
+ - Seventeen matrices (hash-literal, interpolation, block-given, light-rest, block-pass,
+ splat-pass, hot-shapes, hash-order, hash-struct, callable-parameters, raise,
+ full-message, refinement, refinement-binding, jit, jit-calls, set-backtrace), each as
+ built, with `IR_LIGHT_HASH=0 IR_LIGHT_KEYWORD_HASH=0`, with `IR_LIGHT_FRAMES=0` and
+ with `-X:NoJIT -X:NoOSR`: the branch prints what master prints in all 68 runs (the
+ one line of callable-parameters that differs is a `source_location` with the tree's
+ own path in it), and CRuby's output wherever master does.
+ - The four questions. A million deep through a literal's value, its String key, a key's
+ `#hash`, a keyword call to a required keyword, to `**o`, from a block and inside a
+ literal: SystemStackError each time and the process alive, as on master. Visibility,
+ a callee that reads the caller's scope, a callee and a key's `#hash` changing half
+ way, and a refinement in use where the caller is defined are sections 7 to 11 of
+ `Util/hash-literal-matrix.rb` (31 probes, 148 lines in all): CRuby's output on both
+ trees and in every mode above and with `-X:NoAdaptiveCompilation`; `IR_LIGHT_FRAMES=why`
+ names 113 of the file's methods as light frames on the branch and 21 on master, the
+ new callers among them. The first version of these probes tested less than it
+ said: a `using` in the middle of the file kept every later method out of light
+ frames, and the methods that recursed through a keyword call had keyword parameters
+ of their own. The refinement section is last for that reason.
+ - ruby/spec, all five suites (`Util/ci-sweep.sh`, then `sweep-check.rb`): 32,680
+ examples, 45 failing, every one listed, none new, no file without a summary.
+ - Time on the shapes it is about (`ab.rb -r 5`, on-CPU ns per call, the branch with
+ both switches off -> on; CRuby 4.0.9 in the same rounds): `{a: x}` 162 -> 118 (CRuby
+ 92), `{a: x, b: x}` 213 -> 140 (108), `{}` filled with two keys 214 -> 172 (133),
+ `{"k" => x}` 244 -> 175 (97), `f(a: x)` to a keyword 104 -> 72 (60), two keywords to
+ `**o` 288 -> 242 (155), `to_h` with a block 528 -> 480 (123). `tally`, `group_by`,
+ `uniq` with a block and the two controls overlap: the prelude's methods that moved
+ spend their time elsewhere. Instructions per call agree (`ab.rb -i`: 0.82, 0.74,
+ 0.92, 0.78, 0.79, 0.86 on the first six; master counts what the switches-off build
+ counts).
+ - AWFY, `awfy.rb 12` in both column orders, no FAIL: geomean branch/master 1.002 and
+ 1.014; nothing is more than 5% slower in both orders (Richards and NBody are 5.5%
+ and 5.9% slower in the order where the branch ran first and 1.8% and 0.2% faster in
+ the other). As expected: none of AWFY's methods moved.
+ - `micro-table.rb` three times, once with the columns the other way round: `empty` was
+ 6 to 8% slower on the branch in all three, `while10` and `selfcall` in two. Each in
+ a process of its own (`ab.rb ... -- NAME`): the same instructions per call on both
+ trees to two parts in a thousand (342.4 and 341.8, 791.2 and 790.9, 596.2 and 595.8)
+ and the same time over eight alternating rounds (27.5 and 26.7 ns, 68.0 and 68.0,
+ 46.3 and 46.4). So it is the state the table's earlier shapes leave the process in,
+ as in round eight, and not a cost of the change, which decides only what is
+ compiled.
+ - Start-up, `-e 1`, best of ten: 1,148 ms on master, 1,177 on the branch (+2.5%).
+ Not measured: TruffleRuby (not installed here), net11.0, Debug.
+
+ Gated again the same day, after master's parked scopes (perf/park) were merged into the
+ branch: the branch at 2a516b4d against master at 1522386b, both Release net10.0, load
+ 1.0 to 1.6 during the timing: **PASS**. The two changes meet in `MethodDefinition.cs`: a
+ method that is a light frame only because of this change may now also park its scope.
+ - IronRuby.Tests: `PASSED` on both trees, 1,290 tests each, with
+ `MutableString_CopyOnWrite3` left out on both. Its reader starves against the writer
+ on a Release build on this machine (past 100 s in 8 of 8 runs alone, four on each
+ tree, and on Release builds of two days before): master's, and none of this code.
+ - Twenty-one matrices, the seventeen above and parked-scope, block-scope-reuse,
+ block-loop and binding-lvar, each as built, with `IR_LIGHT_HASH=0
+ IR_LIGHT_KEYWORD_HASH=0`, with `IR_LIGHT_FRAMES=0`, with `IR_PARKED_SCOPES=0` and with
+ `-X:NoJIT -X:NoOSR`: the branch prints what master prints in all 105 runs.
+ - A literal in a method whose scope is parked is section 11 of
+ `Util/hash-literal-matrix.rb` (15 probes): CRuby's output on both trees and in the
+ five modes. `IR_PARKED_SCOPES=verbose` on them: 11 methods park as light frames and 1
+ with a scope on the branch, 4 and 8 on master, so the probes run the path they are
+ about. The first version of them did not: `(0..2).each` in a body with literal blocks
+ keeps the method out of light frames, so they use `3.times`. The million-deep probes
+ and the 31 probes of visibility, scope readers and callees changing half way print
+ what master prints in the same modes.
+ - Census on the merged trees, 28,337 methods: light frames 20,318 -> 21,793 (+1,475),
+ JIT compiles 2,979, maybe 2,771 and never 22,587 on both.
+ - ruby/spec, all five suites: 32,680 examples, 45 failing, every one listed, none new,
+ no file without a summary.
+ - Time on the shapes (`ab.rb -r 5`, switches off -> on; CRuby 4.0.10): `{a: x}` 160 ->
+ 120 (CRuby 92), `{a: x, b: x}` 214 -> 142 (108), `{}` filled 218 -> 175 (134),
+ `{"k" => x}` 240 -> 174 (96), `f(a: x)` 104 -> 70 (60), two keywords to `**o` 278 ->
+ 244 (154), `tally` 368 -> 336 (250), `uniq` with a block 768 -> 656 (320); `to_h`,
+ `group_by` and the two controls overlap. Instructions per call: 0.82, 0.75, 0.93,
+ 0.80, 0.77, 0.89 on the first six, 0.89 on `tally`.
+ - AWFY, `awfy.rb 12` in both column orders, no FAIL: geomean branch/master 1.005 and
+ 0.995. The largest single difference is Bounce, 3.6% slower in one order and 0.6% in
+ the other.
+ - `micro-table.rb` three times, once reversed: no line is more than 5% slower in all
+ three; `nil?` is in two (14% and 9%). In a process of its own it counts 502.1 and
+ 501.8 instructions per call and takes 41.3 and 40.0 ns over eight alternating rounds.
+ - Start-up, best of ten: 1,167 ms on master, 1,204 on the branch (+3.2%).
+
+- **perf/why (/perf-step, 2026-11-19) - a find-out step: the census names the construct
+ that keeps a method out of light frames.** `IR_LIGHT_FRAMES=why` and the census said
+ only which statement of a body was not scope-free (`IfExpression at line 12`), so its
+ three largest lines after the parameters were statement names, and nobody could say
+ which decision of `IsScopeFree` kept 5,704 methods out. `IsScopeFree` now takes a box
+ for the reason, null on the normal path, and a refusal records what it refused
+ (`IfExpression at line 12: GlobalVariable`); the reason's text is built only when asked
+ for. `census.rb` has a second table, "not a light frame: the construct". Nothing was
+ meant to move and nothing did: of the 28,335 rows of the census 0 differ outside
+ `light_why`, and the 5,704 that had a line number are the old text plus the construct
+ (my own comparison of the two TSVs; the merged build's census is the worktree's byte
+ for byte). The interpolation, block-pass and splat-pass matrices print CRuby's output
+ on the merged build. Gated on 2026-11-20 with perf/hashlit (above). Not checked: the
+ texts that only appear with a switch off. What it found is under gap 9.
- **perf/bindlv (round twenty-eight, 2026-11-19, 3820abf2, merged in 508f543d) - `Binding#local_variable_get`,
`_set`, `_defined?` and `local_variables` without `eval`** (gap 30). The prelude's four
methods were each one or two `eval`s of source text; the slot access is now
diff --git a/Util/perf/census.rb b/Util/perf/census.rb
index 61111e6c..98174558 100644
--- a/Util/perf/census.rb
+++ b/Util/perf/census.rb
@@ -108,8 +108,11 @@
pct = ->(n, of) { of.zero? ? '-' : format('%5.1f%%', 100.0 * n / of) }
jit_text = ->(m) { m[:jit] == 'compiles' ? "compiles#{m[:jit_types].to_s.empty? ? '' : " (#{m[:jit_types]})"}" : "#{m[:jit]} (#{m[:jit_why]})" }
light_text = ->(m) { m[:light] ? 'light' : "scope (#{m[:light_why]})" }
-# "MethodCall at line 12" and "MethodCall each (self)" count as one reason; the rest is the detail
-light_kind = ->(m) { m[:light_why].to_s.sub(/ at line \d+\z/, '') }
+# "MethodCall at line 12: GlobalVariable" is the statement (MethodCall), where it is, and the construct inside it that
+# IsScopeFree refused (GlobalVariable): the first table counts statements, the second constructs, whatever statement
+# holds them - the statement alone did not say what to teach the frames next
+light_kind = ->(m) { m[:light_why].to_s.sub(/ at line \d+(: .*)?\z/m, '') }
+light_construct = ->(m) { m[:light_why].to_s[/ at line \d+: (.*)\z/m, 1] }
jit_detail = lambda do |m|
why, kind = m[:jit_why].to_s, m[:jit_kind].to_s
why.start_with?(kind) ? why[kind.size..].sub(/\A[: ]+/, '') : why
@@ -171,6 +174,7 @@
table.('JIT maybe: where the typed body stopped without a profile', by_jit.fetch('maybe', []), ->(m) { m[:jit_kind].to_s }, jit_detail)
table.('not a light frame: why', methods.reject { |m| m[:light] }, light_kind)
+table.('not a light frame: the construct', methods.reject { |m| m[:light] || light_construct.(m).nil? }, light_construct, light_kind)
if list
puts '', 'methods'