rupkl 0.1.0 → 0.3.0

data/lib/rupkl/node/method_definition.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class MethodParam
+      include NodeCommon
+
+      def initialize(parent, name, type, position)
+        super
+        @name = name
+        @type = type
+      end
+
+      attr_reader :name
+      attr_reader :type
+
+      def check_type(value, context, position)
+        type&.check_type(value, context, position)
+      end
+
+      def varparam?
+        false
+      end
+    end
+
+    class VariadicMethodParam < MethodParam
+      def check_type(values, context, position)
+        values.each { |v| super(v, context, position) }
+      end
+
+      def varparam?
+        true
+      end
+    end
+
+    class MethodDefinition
+      include NodeCommon
+
+      def initialize(parent, name, params, type, body, position)
+        super(parent, name, *params, type, body, position)
+        @name = name
+        @params = params
+        @type = type
+        @body = body&.copy # reset `#parent` handle
+      end
+
+      attr_reader :name
+      attr_reader :params
+      attr_reader :type
+      attr_reader :body
+
+      def call(receiver, arguments, context, parent, position)
+        args = evaluate_arguments(arguments, context, position)
+        execute_method(receiver, args, parent, position)
+      end
+
+      def coexistable?(other)
+        name != other.name
+      end
+
+      private
+
+      def evaluate_arguments(arguments, context, position)
+        check_arity(arguments, position)
+
+        params&.each_with_index&.to_h do |param, i|
+          arg =
+            if param.varparam?
+              Array(arguments&.[](i..))
+            else
+              arguments&.[](i)
+            end
+          evaluate_argument(param, arg, context)
+        end
+      end
+
+      def check_arity(arguments, position)
+        n_args = arguments&.size || 0
+        n_params = n_params_range
+        return if n_args in ^n_params
+
+        m = "expected #{n_params} method arguments but got #{n_args}"
+        raise EvaluationError.new(m, position)
+      end
+
+      def n_params_range
+        n_params = params&.size || 0
+        params&.last&.varparam? && (n_params - 1..) || n_params
+      end
+
+      def evaluate_argument(param, arg, context)
+        value =
+          if param.varparam?
+            arg.map { _1.evaluate(context) }
+          else
+            arg.evaluate(context)
+          end
+        param.check_type(value, context, position)
+        [param.name, value]
+      end
+
+      def execute_method(receiver, arguments, parent, position)
+        context = create_call_context(receiver, arguments)
+        execute_body(context)
+          .copy(parent, position) # set parent and position given from the caller
+      end
+
+      def create_call_context(receiver, arguments)
+        local_context = MethodCallContext.new(arguments)
+        method_context = current_context
+        if receiver
+          Context.new([*method_context.scopes, local_context], [receiver])
+        else
+          method_context.push_scope(local_context)
+        end
+      end
+
+      def execute_body(context)
+        body
+          .evaluate(context)
+          .tap { type&.check_type(_1, context, position) }
+      end
+    end
+
+    class MethodCallContext
+      include NodeCommon
+      include MemberFinder
+
+      def initialize(arguments)
+        @properties =
+          arguments&.map do |(name, value)|
+            ObjectProperty.new(nil, name, value, nil, nil)
+          end
+        super(nil, *@properties, nil)
+      end
+
+      attr_reader :properties
+    end
+
+    class BuiltinMethodTypeChecker
+      include TypeCommon
+
+      def initialize(klass)
+        super(nil, nil)
+        @klass = klass
+      end
+
+      private
+
+      def match_type?(klass, _context)
+        klass <= @klass
+      end
+    end
+
+    class BuiltinMethodParams < MethodParam
+      def initialize(name, klass)
+        id = Identifier.new(nil, name, nil)
+        type = BuiltinMethodTypeChecker.new(klass)
+        super(nil, id, type, nil)
+      end
+    end
+
+    class BuiltinVariadicMethodParam < VariadicMethodParam
+      def initialize(name, klass)
+        id = Identifier.new(nil, name, nil)
+        type = BuiltinMethodTypeChecker.new(klass)
+        super(nil, id, type, nil)
+      end
+    end
+
+    class BuiltinMethodDefinition < MethodDefinition
+      def initialize(name, **params, &body)
+        id = Identifier.new(nil, name, nil)
+        list = param_list(params)
+        super(nil, id, list, nil, nil, nil)
+        @body = body
+      end
+
+      def execute_method(receiver, arguments, parent, position)
+        args = arguments&.transform_keys(&:to_sym)
+        receiver
+          .instance_exec(args, parent, position, &body)
+      end
+
+      private
+
+      def param_list(params)
+        params.map do |name, type|
+          case type
+          in [klass, { varparams: true }]
+            BuiltinVariadicMethodParam.new(name, klass)
+          else
+            BuiltinMethodParams.new(name, type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rupkl/node/node_common.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module NodeCommon
+      def initialize(parent, *children, position)
+        @position = position
+        parent&.add_child(self)
+        children.each { add_child(_1) }
+      end
+
+      attr_reader :parent
+      attr_reader :children
+      attr_reader :position
+
+      def resolve_reference(_context = nil)
+        self
+      end
+
+      def resolve_structure(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        evaluate(context).to_ruby(context)
+      end
+
+      def to_string(context = nil)
+        evaluate(context).to_string(context)
+      end
+
+      def to_pkl_string(context = nil)
+        evaluate(context).to_pkl_string(context)
+      end
+
+      def add_child(child)
+        return unless child
+
+        child.parent ||
+          child.instance_exec(self) { @parent = _1 }
+
+        @children&.any? { _1.equal?(child) } ||
+          (@children ||= []) << child
+      end
+
+      def copy(parent = nil, position = @position)
+        copied_children = children&.map(&:copy)
+        self.class.new(parent, *copied_children, position)
+      end
+
+      def current_context
+        parent&.current_context
+      end
+
+      def structure?
+        false
+      end
+
+      private
+
+      INVALID_STRING = String.new('?').freeze
+
+      def invalid_string
+        INVALID_STRING
+      end
+
+      def invalid_string?(string)
+        string.equal?(INVALID_STRING)
+      end
+
+      def exec_on(context)
+        yield(context || current_context)
+      end
+    end
+  end
+end

data/lib/rupkl/node/null.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Null < Any
+      include ValueCommon
+      include Operatable
+
+      uninstantiable_class
+
+      def initialize(parent, position)
+        super(parent, nil, position)
+      end
+
+      def to_string(_context = nil)
+        'null'
+      end
+
+      def null?
+        true
+      end
+    end
+  end
+end

data/lib/rupkl/node/number.rb

@@ -2,19 +2,173 @@
 
 module RuPkl
   module Node
-    class Number
+    class Number < Any
       include ValueCommon
+      include Operatable
 
-      def evaluate(_scopes)
-        self
+      abstract_class
+      uninstantiable_class
+
+      def u_op_minus(position)
+        self.class.new(nil, -value, position)
+      end
+
+      {
+        b_op_exp: [:**, false], b_op_div: [:/, false],
+        b_op_truncating_div: [:/, true], b_op_rem: [:%, false],
+        b_op_add: [:+, false], b_op_sub: [:-, false]
+      }.each do |method_name, (op, result_int)|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_exp(r_operand, position)
+          #   b_op_arithmetic(:'**', r_operand, false, position)
+          # end
+          def #{method_name}(r_operand, position)
+            b_op_arithmetic(:'#{op}', r_operand, #{result_int}, position)
+          end
+        M
+      end
+
+      def b_op_mul(r_operand, position)
+        case r_operand
+        when Number then b_op_arithmetic(:*, r_operand, false, position)
+        else r_operand.b_op_mul(self, position)
+        end
+      end
+
+      {
+        b_op_lt: :<, b_op_gt: :>,
+        b_op_le: :<=, b_op_ge: :>=,
+        b_op_eq: :==, b_op_ne: :'!='
+      }.each do |method_name, op|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_lt(r_operand, position)
+          #   l, r = coerce(:'<', r_operand)
+          #   result = l < r
+          #   Boolean.new(nil, result, position)
+          # end
+          def #{method_name}(r_operand, position)
+            l, r = coerce(:'#{op}', r_operand)
+            result = l #{op} r
+            Boolean.new(nil, result, position)
+          end
+        M
+      end
+
+      define_builtin_property(:sign) do
+        result =
+          case value
+          when :positive?.to_proc then 1
+          when :negative?.to_proc then -1
+          else value
+          end
+        self.class.new(self, result, position)
+      end
+
+      [
+        :b, :kb, :kib, :mb, :mib, :gb, :gib, :tb, :tib, :pb, :pib
+      ].each do |unit|
+        class_eval(<<~P, __FILE__, __LINE__ + 1)
+          # define_builtin_property(:b) do
+          #   DataSize.new(self, self, :b, position)
+          # end
+          define_builtin_property(:#{unit}) do
+            DataSize.new(self, self, :#{unit}, position)
+          end
+        P
+      end
+
+      [:ns, :us, :ms, :s, :min, :h, :d].each do |unit|
+        class_eval(<<~P, __FILE__, __LINE__ + 1)
+          # define_builtin_property(:ns) do
+          #   Duration.new(self, self, :ns, position)
+          # end
+          define_builtin_property(:#{unit}) do
+            Duration.new(self, self, :#{unit}, position)
+          end
+        P
+      end
+
+      define_builtin_property(:abs) do
+        self.class.new(self, value.abs, position)
+      end
+
+      define_builtin_property(:ceil) do
+        result = value.finite? && value.ceil || value
+        self.class.new(self, result, position)
+      end
+
+      define_builtin_property(:floor) do
+        result = value.finite? && value.floor || value
+        self.class.new(self, result, position)
+      end
+
+      define_builtin_property(:isPositive) do
+        result = value.zero? || value.positive?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:isFinite) do
+        Boolean.new(self, value.finite?, position)
+      end
+
+      define_builtin_property(:isInfinite) do
+        result = value.infinite? && true || false
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:isNaN) do
+        result = !value.integer? && value.nan?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:isNonZero) do
+        Boolean.new(self, !value.zero?, position)
+      end
+
+      define_builtin_method(:toString) do |_, parent, position|
+        String.new(parent, value.to_s, nil, position)
+      end
+
+      define_builtin_method(:toInt) do |_, parent, position|
+        Int.new(parent, value.to_i, position)
+      end
+
+      define_builtin_method(:toFloat) do |_, parent, position|
+        Float.new(parent, value.to_f, position)
+      end
+
+      define_builtin_method(:round) do |_, parent, position|
+        result = value.finite? && value.round || value
+        self.class.new(parent, result, position)
+      end
+
+      define_builtin_method(:truncate) do |_, parent, position|
+        result = value.finite? && value.truncate || value
+        self.class.new(parent, result, position)
       end
 
-      def undefined_operator?(operator)
-        [:[], :!, :'&&', :'||'].include?(operator)
+      define_builtin_method(
+        :isBetween, first: Number, last: Number
+      ) do |args, parent, position|
+        f = args[:first].value
+        l = args[:last].value
+        result =
+          [f, l, value].all? { _1.finite? || _1.infinite? } &&
+          (f..l).include?(value)
+        Boolean.new(parent, result, position)
       end
 
-      def invalid_r_operand?(operand)
-        !operand.is_a?(Number)
+      private
+
+      def defined_operator?(operator)
+        [:[], :'!@', :'&&', :'||'].none?(operator)
+      end
+
+      def valid_r_operand?(operator, operand)
+        case operator
+        when :* then operand in Number | DataSize | Duration
+        else operand in Number
+        end
       end
 
       def coerce(operator, r_operand)
@@ -26,15 +180,79 @@ module RuPkl
       end
 
       def force_float?(operator, r_operand)
-        operator == :/ ||
-          operator != :'~/' && [self, r_operand].any?(Float)
+        operator == :/ || [self, r_operand].any?(Float)
+      end
+
+      def b_op_arithmetic(operator, r_operand, result_int, position)
+        l, r = coerce(operator, r_operand)
+        result = l.__send__(operator, r)
+        if result_int || result.integer?
+          Int.new(nil, result, position)
+        else
+          Float.new(nil, result, position)
+        end
       end
     end
 
-    class Integer < Number
+    class Int < Number
+      def initialize(parent, value, position)
+        super(parent, value.to_i, position)
+      end
+
+      uninstantiable_class
+
+      define_builtin_property(:isEven) do
+        Boolean.new(self, value.even?, position)
+      end
+
+      define_builtin_property(:isOdd) do
+        Boolean.new(self, value.odd?, position)
+      end
+
+      define_builtin_property(:inv) do
+        self.class.new(self, ~value, position)
+      end
+
+      define_builtin_method(:shl, n: Int) do |args, parent, position|
+        result = value << args[:n].value
+        self.class.new(parent, result, position)
+      end
+
+      define_builtin_method(:shr, n: Int) do |args, parent, position|
+        result = value >> args[:n].value
+        self.class.new(parent, result, position)
+      end
+
+      define_builtin_method(:ushr, n: Int) do |args, parent, position|
+        result =
+          if value.negative?
+            mask = (1 << 63) - 1
+            args[:n].value.times.inject(value) { |v, _| (v >> 1) & mask }
+          else
+            value >> args[:n].value
+          end
+        self.class.new(parent, result, position)
+      end
+
+      define_builtin_method(:and, n: Int) do |args, parent, position|
+        self.class.new(parent, value & args[:n].value, position)
+      end
+
+      define_builtin_method(:or, n: Int) do |args, parent, position|
+        self.class.new(parent, value | args[:n].value, position)
+      end
+
+      define_builtin_method(:xor, n: Int) do |args, parent, position|
+        self.class.new(parent, value ^ args[:n].value, position)
+      end
     end
 
     class Float < Number
+      def initialize(parent, value, position)
+        super(parent, value.to_f, position)
+      end
+
+      uninstantiable_class
     end
   end
 end