arpaka 1.0.0 → 2.0.0

data/lib/arpaka/runtime/builder.rb.erb

@@ -1,323 +0,0 @@
-class Builder
-  RULES = <%= rules.inspect %>.to_h { |rule| [rule.fetch("id"), rule.freeze] }.freeze
-  private_constant :RULES
-
-  def initialize
-    @locals = {}
-  end
-
-  def program(statements)
-    AST::Program.new(statements.freeze)
-  end
-
-  def integer(value)
-    raise ArgumentError, "tINTEGER requires an Integer value" unless value.is_a?(Integer)
-    AST::Literal.new(value)
-  end
-
-  def float(value)
-    raise ArgumentError, "tFLOAT requires a Float value" unless value.is_a?(Float)
-    AST::Literal.new(value)
-  end
-
-  def literal(value)
-    AST::Literal.new(value)
-  end
-
-  def reserved_word(value)
-    value.to_sym
-  end
-
-  def binary(operator, left, right)
-    AST::Binary.new(operator, left, right)
-  end
-
-  def operator(value)
-    value.to_sym
-  end
-
-  def range(operator, begin_value, end_value)
-    AST::RangeLiteral.new(operator, begin_value, end_value)
-  end
-
-  def ternary(condition, then_value, else_value)
-    AST::Ternary.new(condition, then_value, else_value)
-  end
-
-  def call(name, arguments)
-    AST::Call.new(name, arguments.freeze)
-  end
-
-  def receiver_call(receiver, operator, name, arguments)
-    AST::ReceiverCall.new(receiver, operator, name, (arguments || []).freeze)
-  end
-
-  def block_call(call, body)
-    AST::BlockCall.new(call, body_nodes(body))
-  end
-
-  def append_arguments(arguments, argument)
-    list = arguments.is_a?(Array) ? arguments : [arguments]
-    (list + [argument]).freeze
-  end
-
-  def string(value)
-    if value.is_a?(Array)
-      return AST::InterpolatedString.new(value.freeze) if value.any? { |part| !part.is_a?(String) }
-      value = value.join
-    end
-    AST::StringLiteral.new(value.to_s)
-  end
-
-  def regexp(value)
-    AST::RegexpLiteral.new(value.is_a?(Array) ? value.join : value.to_s)
-  end
-
-  def xstring(value)
-    AST::XStringLiteral.new(value.is_a?(Array) ? value.join : value.to_s)
-  end
-
-  def for_node(variable, enumerable, body)
-    AST::For.new(variable, enumerable, body)
-  end
-
-  def def_node(name, arguments, body)
-    AST::Def.new(name.to_sym, (arguments || []).freeze, body || [].freeze)
-  end
-<% if runtime.fetch("builder_methods", []).include?("singleton_method") -%>
-  def singleton_method_node(receiver, name, arguments, body)
-    AST::SingletonMethodDef.new(receiver, name.to_sym, (arguments || []).freeze,
-      body_nodes(body))
-  end
-<% end -%>
-
-  def class_node(name, superclass, body)
-    AST::ClassDef.new(name.to_sym, superclass, body_nodes(body))
-  end
-
-  def module_node(name, body)
-    AST::ModuleDef.new(name.to_sym, body_nodes(body))
-  end
-<% if runtime.fetch("builder_methods", []).include?("singleton_class") -%>
-  def singleton_class_node(receiver, body)
-    AST::SingletonClassDef.new(receiver, body_nodes(body))
-  end
-<% end -%>
-
-  def body_nodes(body)
-    value = body
-    while value.is_a?(Array) && value.length == 1 && value.first.is_a?(Array)
-      value = value.first
-    end
-    value || [].freeze
-  end
-
-  def symbol(value)
-    value = value.map { |part| part.is_a?(String) ? part : part.to_s }.join if value.is_a?(Array)
-    value = value.name if value.is_a?(AST::Variable)
-    AST::Literal.new(value.to_sym)
-  end
-
-  def join_strings(parts)
-    parts
-  end
-
-  def interpolation(value)
-    value.is_a?(Array) && value.length == 1 ? value.first : value
-  end
-
-  def concat_strings(left, right)
-    left_parts = left.is_a?(AST::InterpolatedString) ? left.parts : [left.value]
-    right_parts = right.is_a?(AST::InterpolatedString) ? right.parts : [right.value]
-    parts = left_parts + right_parts
-    parts.all? { |part| part.is_a?(String) } ? AST::StringLiteral.new(parts.join) : AST::InterpolatedString.new(parts.freeze)
-  end
-
-  def index(receiver, arguments)
-    AST::Index.new(receiver, arguments.freeze)
-  end
-
-  def loop(kind, condition, body)
-    AST::Loop.new(kind, condition, body)
-  end
-
-  def control(kind)
-    AST::Control.new(kind)
-  end
-
-  def variable(kind, name)
-    AST::Variable.new(kind, name.is_a?(String) ? name.to_sym : name)
-  end
-
-  def rescue_modifier(expression, fallback)
-    AST::Rescue.new(expression, fallback)
-  end
-
-  def when_node(patterns, body)
-    AST::When.new(patterns.freeze, body)
-  end
-
-  def case_node(expression, whens, else_body)
-    AST::Case.new(expression, whens.freeze, else_body)
-  end
-
-  def case_clauses(value)
-    value.is_a?(Array) ? value : [value]
-  end
-
-  def case_parts(value)
-    values = case_clauses(value)
-    if values.all? { |item| item.is_a?(AST::When) }
-      [values, nil]
-    else
-      [values.grep(AST::When), values.reject { |item| item.is_a?(AST::When) }]
-    end
-  end
-
-  def case_chain(when_node, rest)
-    [when_node] + (rest.nil? ? [] : case_clauses(rest))
-  end
-
-  def lambda_node(arguments, body)
-    AST::Lambda.new((arguments || []).freeze, body_nodes(body))
-  end
-<% if runtime.fetch("builder_methods", []).include?("rescue") -%>
-  def body_statement(body, clauses, else_body, ensure_body)
-    clauses = clauses.nil? ? [] : Array(clauses)
-    if clauses.empty? && else_body.nil? && ensure_body.nil?
-      body_nodes(body)
-    else
-      full_rescue(body, clauses, else_body, ensure_body)
-    end
-  end
-
-  def rescue_chain(clause, rest)
-    [clause] + (rest.nil? ? [] : Array(rest))
-  end
-
-  def pattern(kind, values)
-    AST::Pattern.new(kind.to_sym, Array(values).freeze)
-  end
-
-  def rescue_clause(exceptions, variable, body)
-    AST::RescueClause.new(Array(exceptions).freeze, variable, body_nodes(body))
-  end
-
-  def full_rescue(body, clauses, else_body, ensure_body)
-    AST::FullRescue.new(body_nodes(body), Array(clauses).freeze,
-      else_body.nil? ? nil : body_nodes(else_body),
-      ensure_body.nil? ? nil : body_nodes(ensure_body))
-  end
-
-  def begin_block(body)
-    AST::BeginBlock.new(body_nodes(body))
-  end
-
-  def end_block(body)
-    AST::EndBlock.new(body_nodes(body))
-  end
-<% end -%>
-
-  def unary(operator, operand)
-    AST::Unary.new(operator, operand)
-  end
-
-  def if_node(condition, then_body, else_body)
-    AST::If.new(condition, then_body, else_body)
-  end
-
-  def unless_node(condition, then_body, else_body)
-    AST::If.new(AST::Unary.new(:!, condition), then_body, else_body)
-  end
-
-  def elsif_node(condition, then_body, else_body)
-    AST::If.new(condition, then_body, else_body)
-  end
-
-  def parentheses(statements, rule_id)
-    return statements.first if statements.length == 1
-    AST::Sequence.new(statements.freeze)
-  end
-
-  def identifier(value)
-    unless value.is_a?(Symbol) || value.is_a?(String)
-      raise ArgumentError, "tIDENTIFIER requires a Symbol or String value"
-    end
-    value.to_sym
-  end
-
-  def declare_local(name)
-    @locals[name] = true
-    name
-  end
-
-  def read_local(name)
-    return name if name.is_a?(AST::Variable)
-    (@locals.key?(name) ? AST::LocalRead : AST::BareCall).new(name)
-  end
-
-  def assign(name, value)
-    AST::LocalWrite.new(name, value)
-  end
-<% if runtime.fetch("builder_methods", []).include?("assignment") -%>
-  def assignment(name, value)
-    if name.is_a?(AST::Field) || name.is_a?(AST::Index)
-      AST::Assignment.new(name, value)
-    else
-      AST::LocalWrite.new(name, value)
-    end
-  end
-
-  def opassign(target, operator, value)
-    AST::OpAssign.new(target, operator.to_sym, value)
-  end
-
-  def multiple_assign(targets, value)
-    AST::MultipleAssign.new(Array(targets).freeze, value)
-  end
-
-  def field(receiver, operator, name)
-    AST::Field.new(receiver, operator.to_sym, name.to_sym)
-  end
-
-  def alias_node(new_name, old_name)
-    AST::Alias.new(new_name, old_name)
-  end
-
-  def undef_node(names)
-    AST::Undef.new(Array(names).freeze)
-  end
-<% end -%>
-
-  def array(elements)
-    AST::ArrayLiteral.new(elements.freeze)
-  end
-
-  def word_array(elements, symbols: false)
-    elements ||= []
-    elements = elements.elements if elements.is_a?(AST::ArrayLiteral)
-    values = elements.map do |value|
-      value = value.value if value.is_a?(AST::StringLiteral)
-      symbols ? value.to_sym : AST::StringLiteral.new(value.to_s)
-    end
-    AST::ArrayLiteral.new(values.freeze)
-  end
-
-  def hash(pairs)
-    AST::HashLiteral.new(pairs.freeze)
-  end
-
-  def pair(key, value)
-    AST::Pair.new(key, value)
-  end
-
-  def append(list, value)
-    value.nil? ? list : (list + [value]).freeze
-  end
-
-  def unsupported(id)
-    rule = RULES.fetch(id)
-    raise UnsupportedSyntax.new(rule.fetch("rule"), rule.fetch("line"))
-  end
-end
-private_constant :Builder