class RuboCop::Cop::Sorbet::EnforceSignatures

  • ‘ReturnTypePlaceholder`: placeholders used for return types (default: ’T.untyped’)
    * ‘ParameterTypePlaceholder`: placeholders used for parameter types (default: ’T.untyped’)
    You can configure the placeholders used by changing the following options:
    “‘
    def foo(a, b, c); end
    sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped)
    “`
    Will be corrected as:
    “`
    def foo(a, b, c); end
    “`
    It also suggest an autocorrect with placeholders so the following code:
    This cop checks that every method definition and attribute accessor has a Sorbet signature.

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    suggest = SigSuggestion.new(node.loc.column, param_type_placeholder, return_type_placeholder)
    if node.is_a?(RuboCop::AST::DefNode) # def something
      node.arguments.each do |arg|
        suggest.params << arg.children.first
      end
    elsif accessor?(node) # attr reader, writer, accessor
      method = node.children[1]
      symbol = node.children[2]
      suggest.params << symbol.value if symbol && (method == :attr_writer || method == :attr_accessor)
      suggest.returns = 'void' if method == :attr_writer
    end
    corrector.insert_before(node.loc.expression, suggest.to_autocorrect)
  end
end

def check_node(node) 

def check_node(node)
  prev = previous_node(node)
  unless signature?(prev)
    add_offense(
      node,
      message: "Each method is required to have a signature."
    )
  end
end

def on_def(node) 

def on_def(node)
  check_node(node)
end

def on_defs(node) 

def on_defs(node)
  check_node(node)
end

def on_send(node) 

def on_send(node)
  return unless accessor?(node)
  check_node(node)
end

def param_type_placeholder 

def param_type_placeholder
  cop_config['ParameterTypePlaceholder'] || 'T.untyped'
end

def previous_node(node) 

def previous_node(node)
  parent = node.parent
  return nil unless parent
  parent.children[node.sibling_index - 1]
end

def return_type_placeholder 

def return_type_placeholder
  cop_config['ReturnTypePlaceholder'] || 'T.untyped'
end