Class: MilkTea::CompileTime::Evaluator

Inherits:

Object

• Object
• MilkTea::CompileTime::Evaluator

Defined in:

lib/milk_tea/core/compile_time.rb

Instance Method Summary

• #evaluate(expression) ⇒ Object
• #evaluate_binary(expression) ⇒ Object
• #evaluate_unary(expression) ⇒ Object
• #initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil) ⇒ Evaluator constructor

  A new instance of Evaluator.

• #resolve_layout_type(type_ref) ⇒ Object
• #zero_numeric?(value) ⇒ Boolean

Constructor Details

#initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil) ⇒ Evaluator

Returns a new instance of Evaluator.

# File 'lib/milk_tea/core/compile_time.rb', line 68

def initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
  @resolve_identifier = resolve_identifier
  @resolve_member_access = resolve_member_access
  @resolve_type_ref = resolve_type_ref
  @resolve_call = resolve_call
end

Instance Method Details

#evaluate(expression) ⇒ Object

# File 'lib/milk_tea/core/compile_time.rb', line 75

def evaluate(expression)
  case expression
  when AST::ErrorExpr
    nil
  when AST::ExpressionList
    expression.elements.filter_map { |element| evaluate(element) }
  when AST::RangeExpr
    start_val = evaluate(expression.start_expr)
    end_val = evaluate(expression.end_expr)
    start_val.is_a?(Integer) && end_val.is_a?(Integer) ? (start_val...end_val).to_a : nil
  when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
    expression.value
  when AST::StringLiteral
    expression.value
  when AST::Identifier
    @resolve_identifier&.call(expression)
  when AST::MemberAccess
    @resolve_member_access&.call(expression)
  when AST::Call
    @resolve_call&.call(expression)
  when AST::Specialization
    @resolve_call&.call(expression)
  when AST::SizeofExpr
    type = resolve_layout_type(expression.type)
    type && Layout.size_of(type)
  when AST::AlignofExpr
    type = resolve_layout_type(expression.type)
    type && Layout.alignment_of(type)
  when AST::OffsetofExpr
    type = resolve_layout_type(expression.type)
    if type
      result = Layout.offset_of(type, expression.field)
      return result if result

      id_expr = AST::Identifier.new(name: expression.field)
      value = @resolve_identifier&.call(id_expr)
      if value.is_a?(Types::FieldHandle)
        return Layout.offset_of(type, value.field_name)
      end
    end
    nil
  when AST::UnaryOp
    evaluate_unary(expression)
  when AST::BinaryOp
    evaluate_binary(expression)
  when AST::IfExpr
    condition = evaluate(expression.condition)
    return unless CompileTime.boolean_value?(condition)

    evaluate(condition ? expression.then_expression : expression.else_expression)
  else
    nil
  end
end

#evaluate_binary(expression) ⇒ Object

# File 'lib/milk_tea/core/compile_time.rb', line 166

def evaluate_binary(expression)
  left = evaluate(expression.left)

  case expression.operator
  when "and"
    return unless CompileTime.boolean_value?(left)
    return false if left == false

    right = evaluate(expression.right)
    return right if CompileTime.boolean_value?(right)

    return nil
  when "or"
    return unless CompileTime.boolean_value?(left)
    return true if left == true

    right = evaluate(expression.right)
    return right if CompileTime.boolean_value?(right)

    return nil
  end

  right = evaluate(expression.right)

  case expression.operator
  when ".."
    left.is_a?(Integer) && right.is_a?(Integer) ? (left...right).to_a : nil
  when "=="
    CompileTime.equality_result(left, right)
  when "!="
    result = CompileTime.equality_result(left, right)
    result.nil? ? nil : !result
  when "+"
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
  when "-"
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
  when "*"
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
  when "/"
    return unless left.is_a?(Numeric) && right.is_a?(Numeric)
    raise Error, "division by zero" if zero_numeric?(right)

    left / right
  when "%"
    return unless left.is_a?(Integer) && right.is_a?(Integer)
    raise Error, "modulo by zero" if right.zero?

    left % right
  when "<<"
    left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
  when ">>"
    left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
  when "&"
    left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
  when "|"
    left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
  when "^"
    left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
  when "<"
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left < right : nil
  when "<="
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left <= right : nil
  when ">"
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left > right : nil
  when ">="
    left.is_a?(Numeric) && right.is_a?(Numeric) ? left >= right : nil
  end
end

#evaluate_unary(expression) ⇒ Object

# File 'lib/milk_tea/core/compile_time.rb', line 151

def evaluate_unary(expression)
  operand = evaluate(expression.operand)

  case expression.operator
  when "+"
    operand.is_a?(Numeric) ? operand : nil
  when "-"
    operand.is_a?(Numeric) ? -operand : nil
  when "~"
    operand.is_a?(Integer) ? ~operand : nil
  when "not"
    CompileTime.boolean_value?(operand) ? !operand : nil
  end
end

#resolve_layout_type(type_ref) ⇒ Object

# File 'lib/milk_tea/core/compile_time.rb', line 130

def resolve_layout_type(type_ref)
  result = begin
    @resolve_type_ref&.call(type_ref)
  rescue SemanticError
    nil
  end
  return result if result

  return unless type_ref.respond_to?(:name) && type_ref.name.parts.length >= 1

  expression = ::MilkTea::AST.build_chain_from_parts(type_ref.name.parts)
  return unless expression

  value = evaluate(expression)
  return value if value.is_a?(Types::Struct) || value.is_a?(Types::Primitive) ||
    value.is_a?(Types::Union) || value.is_a?(Types::Nullable) ||
    value.is_a?(Types::StructInstance)

  nil
end

#zero_numeric?(value) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/milk_tea/core/compile_time.rb', line 235

def zero_numeric?(value)
  (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
end