Ruby Issue Tracking System: Issueshttps://bugs.ruby-lang.org/https://bugs.ruby-lang.org/favicon.ico?17113305112022-01-27T14:30:12ZRuby Issue Tracking System
Redmine Ruby master - Bug #18553 (Closed): Memory leak on compiling method call with kwargshttps://bugs.ruby-lang.org/issues/185532022-01-27T14:30:12Zibylich (Ilya Bylich)ibylich@gmail.com
<p>The following code produces a memory leak:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span><span class="p">(</span><span class="ss">foo: </span><span class="mi">1</span><span class="p">)</span>
</code></pre>
<p>It comes from the allocation in <code>compile.c</code>:</p>
<pre><code class="c syntaxhl" data-language="c"><span class="k">struct</span> <span class="n">rb_callinfo_kwarg</span> <span class="o">*</span><span class="n">kw_arg</span> <span class="o">=</span>
<span class="n">rb_xmalloc_mul_add</span><span class="p">(</span><span class="n">len</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">VALUE</span><span class="p">),</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">rb_callinfo_kwarg</span><span class="p">));</span>
</code></pre>
<p>Later it's packed into <code>struct rb_callinfo</code>, but <code>imemo_callinfo</code> is a GC-managed object that has no <code>free</code> calls in <code>obj_free</code> function in gc.c.</p>
<p><a href="https://github.com/ruby/ruby/pull/5488/files#diff-d1cee85c3b0e24a64519c11150abe26fd0b5d8628a23d356dd0b535ac4595d49R3397" class="external">I've tried to fix it</a> by calling <code>free</code> on <code>callinfo->kwarg</code> and it fixed leak in <code>./miniruby -e 'p(foo: 1)'</code>, but it breaks <code>make install</code>. My addition causes a double-free error, looks like either <code>callinfo</code> or <code>callinfo->kwarg</code> is shared between multiple objects.<br>
<code>kwarg</code> field is a <code>const</code> pointer, so that's somewhat expected (I was under impression that <code>const</code> qualifier is redundant) :)</p>
<p>I'm pretty sure old versions of Ruby are also affected by this memory leak.</p> Ruby master - Bug #18516 (Closed): Memory leak on aliasing method to itselfhttps://bugs.ruby-lang.org/issues/185162022-01-26T13:22:34Zibylich (Ilya Bylich)ibylich@gmail.com
<p>The following code produces a memory leak:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">A</span>
<span class="mi">1</span><span class="p">.</span><span class="nf">upto</span><span class="p">(</span><span class="no">Float</span><span class="o">::</span><span class="no">INFINITY</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">i</span><span class="o">|</span>
<span class="n">define_method</span><span class="p">(</span><span class="ss">:"foo_</span><span class="si">#{</span><span class="n">i</span><span class="si">}</span><span class="ss">"</span><span class="p">)</span> <span class="p">{}</span>
<span class="k">alias</span> <span class="ss">:"foo_</span><span class="si">#{</span><span class="n">i</span><span class="si">}</span><span class="ss">"</span> <span class="ss">:"foo_</span><span class="si">#{</span><span class="n">i</span><span class="si">}</span><span class="ss">"</span>
<span class="n">remove_method</span> <span class="ss">:"foo_</span><span class="si">#{</span><span class="n">i</span><span class="si">}</span><span class="ss">"</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>It is very artificial, but it's required for LSAN/Valgrind integration.</p>
<p>The reason why it leaks is the following:</p>
<ul>
<li>alias foo foo increments alias_count even if no alias is created</li>
<li>later during GC rb_free_method_entry is called that in turn calls rb_method_definition_release that calls free only if alias_count + complemented_count == 0.</li>
<li>In this particular case alias_count is 1, and so no cleanup happens.</li>
</ul>
<p>I've been asked to create tickets for memory leaks that I find during LSAN integration if the leak affects previous versions of Ruby. From what I see it does.</p>
<p>Possible fix: <a href="https://github.com/ruby/ruby/pull/5492" class="external">https://github.com/ruby/ruby/pull/5492</a>. But like I mentioned in PR I'm not sure if it's correct, <a class="user active user-mention" href="https://bugs.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a> mentioned in <a href="https://github.com/ruby/ruby/pull/5488" class="external">my main PR</a> aliasing method to itself is used to swallow some warning on method redefinition, but I don't what's the case there.</p> Ruby master - Bug #17431 (Closed): paren_nest is not reset in parse.y after "foo.[]= value"https://bugs.ruby-lang.org/issues/174312020-12-23T15:34:43Zibylich (Ilya Bylich)ibylich@gmail.com
<p><code>p->lex.paren_nest</code> is equal to 1 after the following code:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">self</span><span class="p">.</span><span class="nf">[</span><span class="p">]</span><span class="o">=</span> <span class="n">foo</span>
</code></pre>
<p><code>paren_nest</code> is used to differentiate <code>...</code> for ranges/forwarded arguments, and so <code>./miniruby -we 'foo.[]= bar, ...'</code> gives no <code>... at EOL, should be parenthesized?</code> warning (<code>./miniruby -we 'foo.x= bar, ...'</code> does).</p>
<p>Also it's used to differentiate <code>kDO</code> vs <code>kDO_LAMBDA</code>, so I believe there are code samples with lambdas and <code>.[]=</code> calls that can't be handled by Ruby but are technically valid.</p> Ruby master - Bug #16841 (Closed): Some syntax errors are thrown from compile.chttps://bugs.ruby-lang.org/issues/168412020-05-08T11:30:02Zibylich (Ilya Bylich)ibylich@gmail.com
<p><code>compile.c</code> has a few places where it raises <code>SyntaxError</code>. Because of that <code>ruby -c</code>, Ripper and <code>RubyVM::AbstractSyntaxTree</code> don't catch them:</p>
<pre><code class="sh syntaxhl" data-language="sh"><span class="o">></span> ruby <span class="nt">-vce</span> <span class="s1">'class X; break; end'</span>
ruby 2.7.1p83 <span class="o">(</span>2020-03-31 revision a0c7c23c9c<span class="o">)</span> <span class="o">[</span>x86_64-darwin19]
Syntax OK
</code></pre>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="mf">2.7</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span><span class="mo">001</span> <span class="o">></span> <span class="nb">require</span> <span class="s1">'ripper'</span>
<span class="o">=></span> <span class="kp">false</span>
<span class="mf">2.7</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span><span class="mo">002</span> <span class="o">></span> <span class="no">Ripper</span><span class="p">.</span><span class="nf">sexp</span><span class="p">(</span><span class="s1">'class X; break; end'</span><span class="p">)</span>
<span class="o">=></span> <span class="p">[</span><span class="ss">:program</span><span class="p">,</span> <span class="p">[[</span><span class="ss">:class</span><span class="p">,</span> <span class="p">[</span><span class="ss">:const_ref</span><span class="p">,</span> <span class="p">[</span><span class="ss">:@const</span><span class="p">,</span> <span class="s2">"X"</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]],</span> <span class="kp">nil</span><span class="p">,</span> <span class="p">[</span><span class="ss">:bodystmt</span><span class="p">,</span> <span class="p">[[</span><span class="ss">:void_stmt</span><span class="p">],</span> <span class="p">[</span><span class="ss">:break</span><span class="p">,</span> <span class="p">[]]],</span> <span class="kp">nil</span><span class="p">,</span> <span class="kp">nil</span><span class="p">,</span> <span class="kp">nil</span><span class="p">]]]]</span>
<span class="mf">2.7</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span><span class="mo">003</span> <span class="o">></span> <span class="no">RubyVM</span><span class="o">::</span><span class="no">AbstractSyntaxTree</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="s1">'class X; break; end'</span><span class="p">)</span>
<span class="o">=></span> <span class="c1">#<RubyVM::AbstractSyntaxTree::Node:SCOPE@1:0-1:19></span>
</code></pre>
<p>I've changed locally <code>assert_valid_syntax</code> to use <code>RubyVM::AbstractSyntaxTree</code> for parsing and got ~5 failing tests (like <code>Invalid next/break/redo</code> and one more related to pattern matching).</p>
<p>I started playing with <code>parse.y</code> yesterday but then I quickly realized that to reject such code we need some information about scopes (basically something like a stack of scopes).<br>
This way we could reject <code>break</code> if we are not directly in block/lambda/loop.<br>
But then I realized that we can't properly collect stack elements (by doing something like <code>scopes.push(<scope name>)</code>) for post-loops:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">break</span> <span class="k">while</span> <span class="kp">true</span>
</code></pre>
<p>because the rule is</p>
<pre><code>| stmt modifier_while expr_value
</code></pre>
<p>and adding something like <code>{ push_context(p, IN_LOOP) }</code> in front of it causes a ton of shift/reduce conflicts (which makes a lot of sense). Is it the reason why these cases are rejected during compilation?</p>
<p>If so, is there any simple way to reject it in the grammar? Maybe some kind of the AST post-processor? But then I guess we need a separate version for Ripper, right?</p> Ruby master - Bug #16343 (Closed): Inconsistent behavior of 'circular argument reference' errorhttps://bugs.ruby-lang.org/issues/163432019-11-11T18:28:01Zibylich (Ilya Bylich)ibylich@gmail.com
<p>The following code gives a syntax error:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">m</span> <span class="p">{</span> <span class="o">|</span><span class="n">foo</span> <span class="o">=</span> <span class="nb">proc</span> <span class="p">{</span> <span class="o">||</span> <span class="n">foo</span> <span class="p">}</span><span class="o">|</span> <span class="p">}</span>
<span class="c1"># => SyntaxError (-e:14: circular argument reference - foo)</span>
</code></pre>
<p>But this code is valid:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">m</span> <span class="p">{</span> <span class="o">|</span><span class="n">foo</span> <span class="o">=</span> <span class="nb">proc</span> <span class="p">{</span> <span class="o">|</span><span class="n">bar</span><span class="o">|</span> <span class="n">foo</span> <span class="p">}</span><span class="o">|</span> <span class="p">}</span>
</code></pre>
<p>Is it intentional? <code>foo</code> becomes a proc that returns itself, so there must be a circular dependency</p> Ruby master - Bug #16248 (Closed): Unclear semantics of the "numbered parameter is already used" ...https://bugs.ruby-lang.org/issues/162482019-10-10T00:42:45Zibylich (Ilya Bylich)ibylich@gmail.com
<p>Numbered parameters now have an underscore as a prefix:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">-></span><span class="p">{</span> <span class="n">_1</span> <span class="p">}.</span><span class="nf">call</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="o">=></span> <span class="mi">1</span>
</code></pre>
<p>And it's not allowed to use them in a block if an outer block also uses them:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">-></span><span class="p">{</span> <span class="n">_1</span><span class="p">;</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">}</span> <span class="p">}</span>
<span class="no">SyntaxError</span> <span class="p">((</span><span class="n">irb</span><span class="p">):</span><span class="mi">4</span><span class="p">:</span> <span class="n">numbered</span> <span class="n">parameter</span> <span class="n">is</span> <span class="n">already</span> <span class="n">used</span> <span class="k">in</span><span class="p">)</span>
<span class="p">(</span><span class="n">irb</span><span class="p">):</span><span class="mi">4</span><span class="p">:</span> <span class="n">outer</span> <span class="n">block</span> <span class="n">here</span>
<span class="o">-></span><span class="p">{</span> <span class="n">_1</span><span class="p">;</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">}</span> <span class="p">}</span>
<span class="o">^~</span>
</code></pre>
<p>even if the usage goes after declaring an inner block with numbered params:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">-></span><span class="p">{</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">};</span> <span class="n">_1</span> <span class="p">}</span>
<span class="no">SyntaxError</span> <span class="p">((</span><span class="n">irb</span><span class="p">):</span><span class="mi">5</span><span class="p">:</span> <span class="n">numbered</span> <span class="n">parameter</span> <span class="n">is</span> <span class="n">already</span> <span class="n">used</span> <span class="k">in</span><span class="p">)</span>
<span class="p">(</span><span class="n">irb</span><span class="p">):</span><span class="mi">5</span><span class="p">:</span> <span class="n">inner</span> <span class="n">block</span> <span class="n">here</span>
<span class="o">-></span><span class="p">{</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">};</span> <span class="n">_1</span> <span class="p">}</span>
<span class="o">^~</span>
</code></pre>
<p>So far it's clear. Then comes the second part: if you wrap an inner block into a method you get a valid syntax:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">-></span><span class="p">{</span> <span class="k">def</span> <span class="nf">m</span><span class="p">;</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">};</span> <span class="k">end</span><span class="p">;</span> <span class="n">_1</span> <span class="p">}</span>
<span class="o">=></span> <span class="c1">#<Proc:0x00007f8666a25168 (irb):7 (lambda)></span>
</code></pre>
<p>but if you swap block statements you get an error:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">></span><span class="p">{</span> <span class="n">_1</span><span class="p">;</span> <span class="k">def</span> <span class="nf">m</span><span class="p">;</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">};</span> <span class="k">end</span> <span class="p">}</span>
<span class="no">SyntaxError</span> <span class="p">((</span><span class="n">irb</span><span class="p">):</span><span class="mi">6</span><span class="p">:</span> <span class="n">numbered</span> <span class="n">parameter</span> <span class="n">is</span> <span class="n">already</span> <span class="n">used</span> <span class="k">in</span><span class="p">)</span>
<span class="p">(</span><span class="n">irb</span><span class="p">):</span><span class="mi">6</span><span class="p">:</span> <span class="n">outer</span> <span class="n">block</span> <span class="n">here</span>
<span class="o">-></span><span class="p">{</span> <span class="n">_1</span><span class="p">;</span> <span class="k">def</span> <span class="nf">m</span><span class="p">;</span> <span class="o">-></span><span class="p">{</span><span class="n">_2</span><span class="p">};</span> <span class="k">end</span> <span class="p">}</span>
<span class="o">^~</span>
</code></pre>
<p>It looks like a consistency issue to me. Is there a strict rule that defines what is valid what is not?</p> Ruby master - Bug #15880 (Rejected): Wrong precedence of the if modifier in pattern matchinghttps://bugs.ruby-lang.org/issues/158802019-05-27T13:51:52Zibylich (Ilya Bylich)ibylich@gmail.com
<p>When "If" is used as an "If modifier" it runs before the expression that it wraps:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">=></span> <span class="nb">puts</span> <span class="mi">1</span> <span class="k">if</span> <span class="p">(</span><span class="nb">puts</span> <span class="mi">2</span><span class="p">;</span> <span class="kp">true</span><span class="p">)</span>
<span class="mi">2</span>
<span class="mi">1</span>
</code></pre>
<p>However, when it's used in the pattern matching destructuring runs first:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">A</span>
<span class="k">def</span> <span class="nf">deconstruct</span>
<span class="nb">puts</span> <span class="s1">'deconstruct called'</span>
<span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="nb">p</span> <span class="k">case</span> <span class="no">A</span><span class="p">.</span><span class="nf">new</span>
<span class="k">in</span> <span class="no">A</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">if</span> <span class="p">(</span><span class="nb">puts</span> <span class="s1">'if check'</span><span class="p">;</span> <span class="kp">true</span><span class="p">)</span>
<span class="s1">'yes'</span>
<span class="k">else</span>
<span class="s1">'no'</span>
<span class="k">end</span>
<span class="c1"># prints</span>
<span class="c1"># deconstruct called</span>
<span class="c1"># if check</span>
<span class="c1"># "yes"</span>
</code></pre>
<p>I personally think that it's very confusing as it doesn't reflect the code. I assumed it to not run destructuring if the check returns <code>false</code> (especially because destructuring is allowed to have side-effects)</p> Ruby master - Bug #15789 (Closed): Parse error when numbered parameter is used in a lambda that i...https://bugs.ruby-lang.org/issues/157892019-04-24T16:18:04Zibylich (Ilya Bylich)ibylich@gmail.com
<p>Sorry if the name of the ticket is not desccriptive</p>
<p>While working on backporting these commits into a parser gem:<br>
<a href="https://github.com/ruby/ruby/commit/6ca9e7cc0785c33f6d382176dbd79d6c91db72fe" class="external">https://github.com/ruby/ruby/commit/6ca9e7cc0785c33f6d382176dbd79d6c91db72fe</a><br>
<a href="https://github.com/ruby/ruby/commit/ae07b66aaa092c59ac9d544c9b582712290dc357" class="external">https://github.com/ruby/ruby/commit/ae07b66aaa092c59ac9d544c9b582712290dc357</a></p>
<p>... I've found a weird case that throws a SyntaxError:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">></span> <span class="k">def</span> <span class="nf">m</span><span class="p">(</span><span class="n">a</span> <span class="o">=</span> <span class="o">-></span><span class="p">{</span><span class="err">@</span><span class="mi">1</span><span class="p">});</span> <span class="k">end</span>
<span class="no">SyntaxError</span> <span class="p">((</span><span class="n">irb</span><span class="p">):</span><span class="mi">10</span><span class="p">:</span> <span class="n">ordinary</span> <span class="n">parameter</span> <span class="n">is</span> <span class="n">defined</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">m</span><span class="p">(</span><span class="n">a</span> <span class="o">=</span> <span class="o">-></span><span class="p">{</span><span class="err">@</span><span class="mi">1</span><span class="p">});</span> <span class="k">end</span>
<span class="o">^~</span>
</code></pre>
<p>And same errors gets thrown when I pass a lambda with numparams to lambda optarg:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">></span> <span class="o">-></span><span class="p">(</span><span class="n">optarg</span> <span class="o">=</span> <span class="o">-></span><span class="p">{</span><span class="err">@</span><span class="mi">1</span><span class="p">})</span> <span class="p">{}</span>
<span class="no">SyntaxError</span> <span class="p">((</span><span class="n">irb</span><span class="p">):</span><span class="mi">1</span><span class="p">:</span> <span class="n">ordinary</span> <span class="n">parameter</span> <span class="n">is</span> <span class="n">defined</span><span class="p">)</span>
<span class="o">-></span><span class="p">(</span><span class="n">optarg</span> <span class="o">=</span> <span class="o">-></span><span class="p">{</span><span class="err">@</span><span class="mi">1</span><span class="p">})</span> <span class="p">{}</span>
<span class="o">^~</span>
</code></pre>
<p>I guess the reason for that is that p->max_numparam should be organized as a stack, not a plain shared value.</p> Ruby master - Bug #15525 (Closed): Complex(nil, exception: false) and Rational(nil, exception: fa...https://bugs.ruby-lang.org/issues/155252019-01-11T14:16:41Zibylich (Ilya Bylich)ibylich@gmail.com
<p>Each line below raises an error</p>
<pre><code>Complex(:sym, 0, exception: false) # TypeError (not a real)
Complex(nil, exception: false) # TypeError (can't convert nil into Complex)
Complex(0, nil, exception: false) # TypeError (can't convert nil into Complex)
Complex(nil, 0, exception: false) # TypeError (can't convert nil into Complex)
Rational(nil, exception: false) # TypeError (can't convert nil into Rational)
Rational(nil, nil, exception: false) # TypeError (can't convert nil into Rational)
</code></pre>
<p>Looks like a bug, <code>Integer(nil, exception: false)</code> and <code>Float(nil, exception: false)</code> are not affected, both return <code>nil</code></p>
<p>Also <code>Integer(arg, exception: false)</code> raises an error for:</p>
<pre><code>Integer(Float::NAN, exception: false) # FloatDomainError (NaN)
Integer(Float::INFINITY, exception: false) # FloatDomainError (Infinity)
Integer(-Float::INFINITY, exception: false) # FloatDomainError (-Infinity)
</code></pre> Ruby master - Bug #14690 (Closed): Invalid CMDARG state after command_args followed by tLBRACE_ARGhttps://bugs.ruby-lang.org/issues/146902018-04-16T12:33:39Zibylich (Ilya Bylich)ibylich@gmail.com
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">assert_valid_syntax</span><span class="p">(</span><span class="s1">'let () { m(a) do; end }'</span><span class="p">)</span>
</code></pre>
<p>The patch that fixes it is attached.</p>
<p>tLBRACE_ARG does "CMDARG_PUSH(0)" in the lexer and then the parser leaves the "command_args" rule. The parser does "CMDARG_POP" to remove 1 from the top of the "CMDARG", but the thing here is that there's a 0 on top (the one pushed by tLBRACE_ARG) and the parser pops a wrong value. If the next token is tLBRACE_ARG the parser should pop 2nd top value (like "tmp = pop; pop; push(tmp)").</p>
<p>From what I understand that's the only token that can mutate "CMDARG" in the lexer and that can be emitted after command args.</p>
<p>I've found it during stress-testing a parser gem and that's the only issue that I was able to find so far.</p> Ruby master - Feature #14506 (Closed): Possible bug in cmdarg_stackhttps://bugs.ruby-lang.org/issues/145062018-02-21T17:26:09Zibylich (Ilya Bylich)ibylich@gmail.com
<p>cmdarg stack is a stack of bytes that has 1 on top of it when the parser is in the command mode.</p>
<p>But for this code:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">a</span> <span class="n">b</span><span class="p">(</span><span class="n">c</span> <span class="n">d</span><span class="p">),</span> <span class="s2">"x"</span> <span class="k">do</span> <span class="k">end</span>
</code></pre>
<p>And this line in parse.y:</p>
<pre><code class="c syntaxhl" data-language="c"><span class="o">></span> <span class="n">SHOW_BITSTACK</span><span class="p">(</span><span class="n">p</span><span class="o">-></span><span class="n">cmdarg_stack</span><span class="p">,</span> <span class="s">"BEFORE kDO_BLOCK"</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">CMDARG_P</span><span class="p">()</span> <span class="o">&&</span> <span class="o">!</span><span class="n">IS_lex_state_for</span><span class="p">(</span><span class="n">state</span><span class="p">,</span> <span class="n">EXPR_CMDARG</span><span class="p">))</span>
<span class="k">return</span> <span class="n">keyword_do_block</span><span class="p">;</span>
</code></pre>
<p>It prints:</p>
<pre><code class="text syntaxhl" data-language="text">$ dev-ruby -vye 'a b(c d), "x" do end' | grep -E "kDO_BLOCK"
BEFORE kDO_BLOCK: 10 at line 7461
</code></pre>
<p>So CMDARG_P is false. I understand that 'keyword_do_block" is handled later in the "if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))" section, but is it possible to change parser to rely only on cmdarg stack?</p> Ruby master - Bug #14110 (Closed): Ruby 2.5.0.dev (from trunk) still doesn't support zero unicode...https://bugs.ruby-lang.org/issues/141102017-11-15T17:48:08Zibylich (Ilya Bylich)ibylich@gmail.com
<p>Hi,</p>
<p>This commit - <a href="https://github.com/ruby/ruby/commit/7e8b910" class="external">https://github.com/ruby/ruby/commit/7e8b910</a> - according to its commit message should allow zero unicode codepoints, i.e.</p>
<pre><code>$ cat test.rb
p "\u{}"
$ ./ruby -v
ruby 2.5.0dev (2017-11-14 trunk 60757) [x86_64-darwin17]
$ ./ruby test.rb
test.rb:1: invalid Unicode escape
p "\u{}"
^
</code></pre>
<p>Shouldn't it be supported now? Because the test that was removed (that zero codepoints are not supported) is still passing.<br>
Thanks.</p>