Issue #11725 has been updated by Nobuyoshi Nakada.


You run `static_test3` twice, not `static_test4`.

----------------------------------------
Feature #11725: debugging support for frozen string literal
https://bugs.ruby-lang.org/issues/11725#change-55019

* Author: Koichi Sasada
* Status: Closed
* Priority: Normal
* Assignee: Koichi Sasada
----------------------------------------
# Background

Debug frozen string literal is difficult because frozen string can be modified at far from created locations. For example, library X creates one string and modify this string is common situation. Also library X can pass the created string to library Y and also Y passes it to library Z. Clients receives a string from Z, then clients can not understand where the created location and can not debug it.

To help such situation, I introduced --enable-frozen-string-literal-debug option (a command line option and a compile option). This option enable to embed created location information into frozen string and to display RuntimeError message with this location information such as:

```
../../trunk/test.rb:21:in `<main>': can't modify frozen String, created at ../../trunk/test.rb:17 (RuntimeError)
```

(maybe only few people knows about this feature because NEWS doesn't describe it)

# Proposal: Make it as default behavior

At first, I introduced this option as an optional feature because this option seems slow down applications.

However, including this information for sting literals is not so big impact because adding information for each string literal only at compile time. Another drawback is that we can't de-duplicate same frozen strings, but it is trivial issue.

One problem is string interpolation. Adding debug information for such dynamically created strings is not so easy. So I leave --enable-frozen-string-literal-debug for this type of strings. It is too long to use it, so -d or --debug option should enable this feature.

Conclusion:
* adding string literals as default.
* --enable-frozen-string-literal-debug for string interpolation. -d or --debug also enable this feature.

I hope we can change every string literals to frozen strings.

Any comments are welcome.

# Naming

Now, I prefer --debug-frozen-string-literal than --enable-frozen-string-literal-debug.

# Misc: benchmark script and result

```ruby
require 'benchmark'
N = 5_000_000

def static_test1
  "foo"
end

def static_test2
  "foo".freeze
end

line = __LINE__ + 1
RubyVM::InstructionSequence.compile(%q{
  def static_test3
    "foo"
  end
}, __FILE__, __FILE__, line, {frozen_string_literal: true}).eval

line = __LINE__ + 1
RubyVM::InstructionSequence.compile(%q{
  def static_test4
    "foo"
  end
}, __FILE__, __FILE__, line, {frozen_string_literal: true, frozen_string_literal_debug: true}).eval

S = 'baz'
def dynamic_test1
  "foo#{S}bar"
end

def dynamic_test2
  "foo#{S}bar".freeze
end

line = __LINE__ + 1
RubyVM::InstructionSequence.compile(%q{
  def dynamic_test3
    "foo#{S}bar"
  end
}, __FILE__, __FILE__, line, {frozen_string_literal: true}).eval

line = __LINE__ + 1
RubyVM::InstructionSequence.compile(%q{
  def dynamic_test4
    "foo#{S}bar"
  end
}, __FILE__, __FILE__, line, {frozen_string_literal: true, frozen_string_literal_debug: true}).eval

Benchmark.bmbm{|x|
  x.report('STATIC: without freeze'  ){N.times{static_test1}}
  x.report('STATIC: freeze by method'){N.times{static_test2}}
  x.report('STATIC: freeze by pragma'){N.times{static_test3}}
  x.report('STATIC: freeze by pragma/debug'){N.times{static_test3}}
  x.report('DYNAMIC:without freeze'  ){N.times{dynamic_test1}}
  x.report('DYNAMIC:freeze by method'){N.times{dynamic_test2}}
  x.report('DYNAMIC:freeze by pragma'){N.times{dynamic_test3}}
  x.report('DYNAMIC:freeze by pragma/debug'){N.times{dynamic_test4}}
}

# error message check
['static', 'dynamic'].each{|feature|
  (1..4).each{|type|
    begin
      m = "#{feature}_test#{type}"
      send(m) << "str"
    rescue RuntimeError => e
      p [m, e]
    else
      p [m, nil]
    end
  }
}
```
```
                                     user     system      total        real
STATIC: without freeze           0.550000   0.000000   0.550000 (  0.545465)
STATIC: freeze by method         0.330000   0.000000   0.330000 (  0.337528)
STATIC: freeze by pragma         0.360000   0.000000   0.360000 (  0.366031)
STATIC: freeze by pragma/debug   0.360000   0.000000   0.360000 (  0.353534)
DYNAMIC:without freeze           1.230000   0.000000   1.230000 (  1.230027)
DYNAMIC:freeze by method         1.580000   0.000000   1.580000 (  1.585025)
DYNAMIC:freeze by pragma         1.420000   0.000000   1.420000 (  1.424006)
DYNAMIC:freeze by pragma/debug   3.510000   0.000000   3.510000 (  3.510279)

# error message check results
["static_test1", nil]
["static_test2", #<RuntimeError: can't modify frozen String>]
["static_test3", #<RuntimeError: can't modify frozen String, created at ../../trunk/test.rb:15>]
["static_test4", #<RuntimeError: can't modify frozen String, created at ../../trunk/test.rb:22>]
["dynamic_test1", nil]
["dynamic_test2", #<RuntimeError: can't modify frozen String>]
["dynamic_test3", #<RuntimeError: can't modify frozen String>]
["dynamic_test4", #<RuntimeError: can't modify frozen String, created at ../../trunk/test.rb:45>]
```




-- 
https://bugs.ruby-lang.org/