Module: Ibex::NormalizeParameterLowering

Included in:
Normalizer
Defined in:
lib/ibex/normalize/parameter_lowering.rb,
sig/ibex/normalize/parameter_lowering.rbs

Overview

Resumable, source-ordered lowering for specialized parameter alternatives.

Instance Method Summary collapse

Instance Method Details

#advance_parameter_alternative(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame) -> void

Parameters:

  • frame (Hash[Symbol, untyped]) 


9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 9

def advance_parameter_alternative(frame)
  # @type self: Normalizer
  with_parameter_frame_context(frame) do
    operations = frame.fetch(:operations)
    if operations.any?
      process_parameter_operation(frame, operations.pop)
    elsif parameter_items_remaining?(frame)
      start_parameter_item(frame)
    else
      finish_parameter_alternative(frame)
    end
  end
end

#finish_parameter_alternative(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame) -> void

Parameters:

  • frame (Hash[Symbol, untyped]) 


115
116
117
118
119
120
121
122
123
124
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 115

def finish_parameter_alternative(frame)
  # @type self: Normalizer
  _template, rule, alternative = frame.fetch(:current)
  action = normalize_action(alternative.action, frame.fetch(:named_refs))
  add_production(
    rule.lhs, frame.fetch(:rhs), action, alternative.precedence,
    { kind: :user, loc: alternative.loc.to_h }, rule.documentation
  )
  clear_parameter_alternative(frame)
end

#finish_parameter_item(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void

Parameters:

  • frame (Hash[Symbol, untyped])
  • item (Frontend::AST::item) 


107
108
109
110
111
112
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 107

def finish_parameter_item(frame, item)
  # @type self: Normalizer
  rhs = frame.fetch(:rhs)
  rhs << frame.fetch(:values).pop
  add_named_reference(item, frame.fetch(:named_refs), rhs.length - 1)
end

#lower_parameter_call(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void

Parameters:



100
101
102
103
104
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 100

def lower_parameter_call(frame, item)
  # @type self: Normalizer
  helper, = schedule_parameter_specialization(item)
  frame.fetch(:values) << helper
end

#lower_parameter_item(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void

Parameters:

  • frame (Hash[Symbol, untyped])
  • item (Frontend::AST::item) 


81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 81

def lower_parameter_item(frame, item)
  # @type self: Normalizer
  case item
  when Frontend::AST::SymbolReference
    frame.fetch(:values) << symbol_for_reference(item).name
  when Frontend::AST::ParameterizedReference
    lower_parameter_call(frame, item)
  when Frontend::AST::Group
    lower_parameter_group(frame, item)
  when Frontend::AST::Optional, Frontend::AST::Star, Frontend::AST::Plus
    lower_parameter_suffix(frame, item)
  when Frontend::AST::SeparatedList
    lower_parameter_separated_list(frame, item)
  else
    fail_at(item.loc, "unsupported nested EBNF expression")
  end
end

#parameter_items_remaining?(frame) ⇒ Boolean

RBS:

  • (Hash[Symbol, untyped] frame) -> bool

Parameters:

  • frame (Hash[Symbol, untyped])

Returns:

  • (Boolean) 


41
42
43
44
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 41

def parameter_items_remaining?(frame)
  _template, _rule, alternative = frame.fetch(:current)
  frame.fetch(:item_index) < alternative.items.length
end

#process_parameter_operation(frame, operation) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void

Parameters:

  • frame (Hash[Symbol, untyped])
  • operation (Array[untyped]) 


63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 63

def process_parameter_operation(frame, operation)
  # @type self: Normalizer
  kind, *arguments = operation
  case kind
  when :item then lower_parameter_item(frame, arguments.fetch(0))
  when :finish_item then finish_parameter_item(frame, arguments.fetch(0))
  when :value then frame.fetch(:values) << arguments.fetch(0)
  when :finish_suffix then finish_parameter_suffix(frame, arguments.fetch(0))
  when :finish_separated then finish_parameter_separated_list(frame, arguments.fetch(0))
  when :group_alternative
    start_parameter_group_alternative(frame, arguments.fetch(0), arguments.fetch(1), arguments.fetch(2))
  when :finish_group_alternative
    finish_parameter_group_alternative(frame, arguments.fetch(0), arguments.fetch(1), arguments.fetch(2))
  else raise Ibex::Error, "internal parameter lowering operation #{kind.inspect}"
  end
end

#start_parameter_item(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame) -> void

Parameters:

  • frame (Hash[Symbol, untyped]) 


47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 47

def start_parameter_item(frame)
  # @type self: Normalizer
  _template, _rule, alternative = frame.fetch(:current)
  index = frame.fetch(:item_index)
  item = alternative.items.fetch(index)
  frame[:item_index] = index + 1
  if item.is_a?(Frontend::AST::InlineAction)
    frame.fetch(:rhs) << expand_inline_action(
      item, frame.fetch(:rhs).length, frame.fetch(:named_refs)
    )
  else
    frame.fetch(:operations).push([:finish_item, item], [:item, item])
  end
end

#with_parameter_frame_context(frame) { ... } ⇒ void

This method returns an undefined value.

RBS:

  • (Hash[Symbol, untyped] frame) { () -> void } -> void

Parameters:

  • frame (Hash[Symbol, untyped])

Yields:

Yield Returns:

  • (void) 


24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 24

def with_parameter_frame_context(frame)
  # @type self: Normalizer
  template, = frame.fetch(:current)
  previous_chain = @current_include_chain
  previous_expansion = @current_parameter_expansion
  reference = frame.fetch(:reference)
  @current_include_chain = @resolution&.include_chain_for(template) || []
  @current_parameter_expansion = {
    rule: reference.name, arguments: frame.fetch(:rendered_arguments)
  }
  yield
ensure
  @current_include_chain = previous_chain
  @current_parameter_expansion = previous_expansion
end