Class: RuboCop::Cop::Sorbet::BuggyObsoleteStrictMemoization

Inherits:
Base
  • Object
show all
Extended by:
AutoCorrector
Includes:
Alignment, LineLengthHelp, MatchRange, RangeHelp, TargetSorbetVersion
Defined in:
lib/rubocop/cop/sorbet/buggy_obsolete_strict_memoization.rb

Overview

Checks for the a mistaken variant of the “obsolete memoization pattern” that used to be required for older Sorbet versions in ‘#typed: strict` files. The mistaken variant would overwrite the ivar with `nil` on every call, causing the memoized value to be discarded and recomputed on every call.

This cop will correct it to read from the ivar instead of ‘nil`, which will memoize it correctly.

The result of this correction will be the “obsolete memoization pattern”, which can further be corrected by the ‘Sorbet/ObsoleteStrictMemoization` cop.

See ‘Sorbet/ObsoleteStrictMemoization` for more details.

Examples:

# bad
sig { returns(Foo) }
def foo
  # This `nil` is likely a mistake, causing the memoized value to be discarded and recomputed on every call.
  @foo = T.let(nil, T.nilable(Foo))
  @foo ||= some_computation
end

# good
sig { returns(Foo) }
def foo
  # This will now memoize the value as was likely intended, so `some_computation` is only ever called once.
  # ⚠️If `some_computation` has side effects, this might be a breaking change!
  @foo = T.let(@foo, T.nilable(Foo))
  @foo ||= some_computation
end

See Also:

  • Sorbet/ObsoleteStrictMemoization

Cop Safety Information:

  • If the computation being memoized had side effects, calling it only once (instead of once on every call to the affected method) can be observed, and might be a breaking change.

Constant Summary collapse

MSG = 
"This might be a mistaken variant of the two-stage workaround that used to be needed for memoization " \
"in `#typed: strict` files. See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization."

Instance Method Summary collapse

Methods included from TargetSorbetVersion

#enabled_for_sorbet_static_version?, included, #read_sorbet_static_version_from_bundler_lock_file, #sorbet_enabled?, #target_sorbet_static_version_from_bundler_lock_file

Instance Method Details

#buggy_legacy_memoization_pattern?(node) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
 
# File 'lib/rubocop/cop/sorbet/buggy_obsolete_strict_memoization.rb', line 55

def_node_matcher :buggy_legacy_memoization_pattern?, <<~PATTERN
  (begin
    ...                                                       # Ignore any other lines that come first.
    (ivasgn $_ivar                                           # First line: @_ivar = ...
      (send                                                   # T.let(_ivar, T.nilable(_ivar_type))
        (const {nil? cbase} :T) :let
        $nil
        (send (const {nil? cbase} :T) :nilable _ivar_type))) # T.nilable(_ivar_type)
    (or-asgn (ivasgn _ivar) _initialization_expr))          # Second line: @_ivar ||= _initialization_expr
PATTERN

#on_begin(node) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
 
# File 'lib/rubocop/cop/sorbet/buggy_obsolete_strict_memoization.rb', line 66

def on_begin(node)
  buggy_legacy_memoization_pattern?(node) do |ivar, nil_node|
    add_offense(nil_node) do |corrector|
      corrector.replace(
        range_between(nil_node.source_range.begin_pos, nil_node.source_range.end_pos),
        ivar,
      )
    end
  end
end

#relevant_file?(file) ⇒ Boolean

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/rubocop/cop/sorbet/buggy_obsolete_strict_memoization.rb', line 77

def relevant_file?(file)
  super && sorbet_enabled?
end