class SyntaxTree::BodyStmt

Experimental RBS support (using type sampling data from the type_fusion project). 

# sig/syntax_tree/node.rbs

class SyntaxTree::BodyStmt < SyntaxTree::Node
  def accept: (Visitor visitor) -> untyped
  def bind: (SyntaxTree::Parser parser, Integer start_char, Integer start_column, Integer end_char, Integer end_column) -> untyped
  def child_nodes: () -> untyped
  def initialize: (statements: SyntaxTree::Statements, rescue_clause: nil, else_keyword: nil, else_clause: nil, ensure_clause: nil, location: SyntaxTree::Location) -> void
end

report back down into this one where it goes.
doesn’t necessarily know where it started. So the parent node needs to
bodystmt can’t actually determine its bounds appropriately because it

def ===(other) 

def ===(other)
  other.is_a?(BodyStmt) && statements === other.statements &&
    rescue_clause === other.rescue_clause &&
    else_keyword === other.else_keyword &&
    else_clause === other.else_clause &&
    ensure_clause === other.ensure_clause
end

def accept(visitor)

Experimental RBS support (using type sampling data from the type_fusion project). 

def accept: (Visitor visitor) -> untyped

This signature was generated using 6 samples from 1 application. 

def accept(visitor)
  visitor.visit_bodystmt(self)
end

def bind(parser, start_char, start_column, end_char, end_column)

Experimental RBS support (using type sampling data from the type_fusion project). 

def bind: (SyntaxTree::Parser parser, Integer start_char, Integer start_column, Integer end_char, Integer end_column) -> untyped

This signature was generated using 12 samples from 1 application. 

def bind(parser, start_char, start_column, end_char, end_column)
  rescue_clause = self.rescue_clause
  @location =
    Location.new(
      start_line: location.start_line,
      start_char: start_char,
      start_column: start_column,
      end_line: location.end_line,
      end_char: end_char,
      end_column: end_column
    )
  # Here we're going to determine the bounds for the statements
  consequent = rescue_clause || else_clause || ensure_clause
  statements.bind(
    parser,
    start_char,
    start_column,
    consequent ? consequent.location.start_char : end_char,
    consequent ? consequent.location.start_column : end_column
  )
  # Next we're going to determine the rescue clause if there is one
  if rescue_clause
    consequent = else_clause || ensure_clause
    rescue_clause.bind_end(
      consequent ? consequent.location.start_char : end_char,
      consequent ? consequent.location.start_column : end_column
    )
  end
end

def child_nodes

Experimental RBS support (using type sampling data from the type_fusion project). 

def child_nodes: () -> untyped

This signature was generated using 11 samples from 1 application. 

def child_nodes
  [statements, rescue_clause, else_keyword, else_clause, ensure_clause]
end

def copy( 

def copy(
  statements: nil,
  rescue_clause: nil,
  else_keyword: nil,
  else_clause: nil,
  ensure_clause: nil,
  location: nil
)
  node =
    BodyStmt.new(
      statements: statements || self.statements,
      rescue_clause: rescue_clause || self.rescue_clause,
      else_keyword: else_keyword || self.else_keyword,
      else_clause: else_clause || self.else_clause,
      ensure_clause: ensure_clause || self.ensure_clause,
      location: location || self.location
    )
  node.comments.concat(comments.map(&:copy))
  node
end

def deconstruct_keys(_keys) 

def deconstruct_keys(_keys)
  {
    statements: statements,
    rescue_clause: rescue_clause,
    else_keyword: else_keyword,
    else_clause: else_clause,
    ensure_clause: ensure_clause,
    location: location,
    comments: comments
  }
end

def empty? 

def empty?
  statements.empty? && !rescue_clause && !else_clause && !ensure_clause
end

def format(q) 

def format(q)
  q.group do
    q.format(statements) unless statements.empty?
    if rescue_clause
      q.nest(-2) do
        q.breakable_force
        q.format(rescue_clause)
      end
    end
    if else_clause
      q.nest(-2) do
        q.breakable_force
        q.format(else_keyword)
      end
      unless else_clause.empty?
        q.breakable_force
        q.format(else_clause)
      end
    end
    if ensure_clause
      q.nest(-2) do
        q.breakable_force
        q.format(ensure_clause)
      end
    end
  end
end

def initialize(

Experimental RBS support (using type sampling data from the type_fusion project). 

def initialize: (statements: SyntaxTree::Statements, rescue_clause: nil, else_keyword: nil, else_clause: nil, ensure_clause: nil, location: SyntaxTree::Location) -> void

This signature was generated using 13 samples from 1 application. 

def initialize(
  statements:,
  rescue_clause:,
  else_keyword:,
  else_clause:,
  ensure_clause:,
  location:
)
  @statements = statements
  @rescue_clause = rescue_clause
  @else_keyword = else_keyword
  @else_clause = else_clause
  @ensure_clause = ensure_clause
  @location = location
  @comments = []
end