class SyntaxTree::ArrayLiteral

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

# sig/syntax_tree/node.rbs

class SyntaxTree::ArrayLiteral < SyntaxTree::Node
  def accept: (Visitor visitor) -> untyped
  def child_nodes: () -> untyped
  def initialize: (lbracket: SyntaxTree::LBracket, contents: SyntaxTree::Args?, location: SyntaxTree::Location) -> void
end


[one, two, three]
[]
elements.
ArrayLiteral represents an array literal, which can optionally contain

def ===(other) 

def ===(other)
  other.is_a?(ArrayLiteral) && lbracket === other.lbracket &&
    contents === other.contents
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 7 samples from 1 application. 

def accept(visitor)
  visitor.visit_array(self)
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 4 samples from 1 application. 

def child_nodes
  [lbracket, contents]
end

def copy(lbracket: nil, contents: nil, location: nil) 

def copy(lbracket: nil, contents: nil, location: nil)
  node =
    ArrayLiteral.new(
      lbracket: lbracket || self.lbracket,
      contents: contents || self.contents,
      location: location || self.location
    )
  node.comments.concat(comments.map(&:copy))
  node
end

def deconstruct_keys(_keys) 

def deconstruct_keys(_keys)
  {
    lbracket: lbracket,
    contents: contents,
    location: location,
    comments: comments
  }
end

def empty_with_comments?

to do some special printing to ensure they get indented correctly.
If we have an empty array that contains only comments, then we're going 
def empty_with_comments?
  contents.nil? && lbracket.comments.any? &&
    lbracket.comments.none?(&:inline?)
end

def format(q) 

def format(q)
  lbracket = self.lbracket
  contents = self.contents
  if lbracket.is_a?(LBracket) && lbracket.comments.empty? && contents &&
       contents.comments.empty? && contents.parts.length > 1
    if qwords?
      QWordsFormatter.new(contents).format(q)
      return
    end
    if qsymbols?
      QSymbolsFormatter.new(contents).format(q)
      return
    end
  end
  if empty_with_comments?
    EmptyWithCommentsFormatter.new(lbracket).format(q)
    return
  end
  q.group do
    q.format(lbracket)
    if contents
      q.indent do
        q.breakable_empty
        q.format(contents)
        q.if_break { q.text(",") } if q.trailing_comma?
      end
    end
    q.breakable_empty
    q.text("]")
  end
end

def initialize(lbracket:, contents:, location:)

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

def initialize: (lbracket: SyntaxTree::LBracket, contents: SyntaxTree::Args?, location: SyntaxTree::Location) -> void

This signature was generated using 8 samples from 1 application. 

def initialize(lbracket:, contents:, location:)
  @lbracket = lbracket
  @contents = contents
  @location = location
  @comments = []
end

def qsymbols? 

def qsymbols?
  contents.parts.all? do |part|
    part.is_a?(SymbolLiteral) && part.comments.empty?
  end
end

def qwords? 

def qwords?
  contents.parts.all? do |part|
    case part
    when StringLiteral
      part.comments.empty? && part.parts.length == 1 &&
        part.parts.first.is_a?(TStringContent) &&
        !part.parts.first.value.match?(/[\s\[\]\\]/)
    when CHAR
      !part.value.match?(/[\[\]\\]/)
    else
      false
    end
  end
end