Module: Ibex::Frontend::BootstrapParserParameters

Included in:
BootstrapParser
Defined in:
lib/ibex/frontend/parser/parameters.rb,
sig/ibex/frontend/parser/parameters.rbs

Overview

Parses extended-mode parameter lists and parameterized references during bootstrap.

Instance Method Summary collapse

Instance Method Details

#adjacent_tokens?(left, right) ⇒ Boolean

RBS:

  • (Token left, Token right) -> bool

Parameters:

Returns:

  • (Boolean) 


71
72
73
74
75
76
77
78
79
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 71

def adjacent_tokens?(left, right)
  # @type self: BootstrapParser
  left_span = left.span
  right_span = right.span
  return left_span.end_byte == right_span.start_byte if left_span && right_span

  left.location.line == right.location.line &&
    left.location.column + token_string(left).length == right.location.column
end

#parameter_definition_tail?(tail) ⇒ Boolean

RBS:

  • (Array[Token] tail) -> bool

Parameters:

Returns:

  • (Boolean) 


60
61
62
63
64
65
66
67
68
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 60

def parameter_definition_tail?(tail)
  # @type self: BootstrapParser
  closing = tail.index { |token| token.type == :")" }
  return false unless closing && tail[closing + 1]&.type == :":"

  formals = tail.take(closing)
  !formals.empty? && formals.length.odd? &&
    formals.each_with_index.all? { |token, index| token.type == (index.even? ? :identifier : :",") }
end

#parameterized_call? ⇒ Boolean

RBS:

  • () -> bool

Returns:

  • (Boolean) 


45
46
47
48
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 45

def parameterized_call?
  # @type self: BootstrapParser
  current.type == :identifier && lookahead.type == :"(" && adjacent_tokens?(current, lookahead)
end

#parameterized_rule_start? ⇒ Boolean

RBS:

  • () -> bool

Returns:

  • (Boolean) 


51
52
53
54
55
56
57
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 51

def parameterized_rule_start?
  # @type self: BootstrapParser
  opening = lookahead
  return false unless opening.type == :"(" && adjacent_tokens?(current, opening)

  parameter_definition_tail?(@tokens.drop(@index + 2))
end

#parse_parameterized_reference ⇒ AST::item

RBS:

  • () -> AST::item

Returns:

  • (AST::item) 


23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 23

def parse_parameterized_reference
  # @type self: BootstrapParser
  callee = advance
  opening = expect(:"(")
  extended_only!(opening.location, "parameterized rules")
  arguments = [] #: Array[AST::item]
  unless current.type == :")"
    loop do
      fail_at(current.location, "actions are not valid parameter arguments") if current.type == :action

      arguments << parse_item
      break unless accept(:",")
    end
  end
  expect(:")")
  item = AST::ParameterizedReference.new(
    name: token_string(callee), arguments: arguments, named_reference: parse_named_reference, loc: callee.location
  )
  parse_suffix(item)
end

#parse_rule_parameters(lhs) ⇒ Array[String]

RBS:

  • (Token lhs) -> Array[String]

Parameters:

Returns:

  • (Array[String]) 


10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/ibex/frontend/parser/parameters.rb', line 10

def parse_rule_parameters(lhs)
  # @type self: BootstrapParser
  return [] unless current.type == :"(" && adjacent_tokens?(lhs, current)

  opening = advance
  extended_only!(opening.location, "parameterized rules")
  parameters = [token_string(expect(:identifier))]
  parameters << token_string(expect(:identifier)) while accept(:",")
  expect(:")")
  parameters
end