rupkl 0.2.0 → 0.3.0

data/lib/rupkl/node/member_finder.rb

@@ -4,7 +4,7 @@ module RuPkl
   module Node
     module MemberFinder
       def property(name)
-        value = find_property(name)
+        value = find_property(name)&.value
         return value if value
 
         super if self.class <= Any
@@ -22,17 +22,13 @@ module RuPkl
       def find_property(name)
         return unless respond_to?(:properties)
 
-        properties
-          &.find { _1.name == name }
-          &.value
+        properties&.find { _1.name == name }
       end
 
       def find_entry(key)
         return unless respond_to?(:entries)
 
-        entries
-          &.find { _1.key == key }
-          &.value
+        entries&.find { _1.key == key }
       end
 
       def find_element(index)
@@ -40,9 +36,7 @@ module RuPkl
         return unless elements
         return unless index.value.is_a?(::Integer)
 
-        elements
-          .find.with_index { |_, i| i == index.value }
-          &.value
+        elements.find.with_index { |_, i| i == index.value }
       end
 
       def find_pkl_method(name)

data/lib/rupkl/node/member_reference.rb

@@ -22,17 +22,19 @@ module RuPkl
 
       def evaluate(context = nil)
         do_evaluate do
-          resolve_member_reference(context, member, receiver, nullable?).evaluate
+          result = resolve_member_reference(context, member, receiver, nullable?)
+          result.evaluate
         end
       end
 
       def resolve_reference(context = nil)
         do_evaluate do
-          resolve_member_reference(context, member, receiver, nullable?).resolve_reference
+          result = resolve_member_reference(context, member, receiver, nullable?)
+          result.resolve_reference
         end
       end
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         self
           .class.new(parent, receiver&.copy, member&.copy, nullable?, position)
           .tap { copy_scope_index(_1) }

data/lib/rupkl/node/method_call.rb

@@ -30,7 +30,7 @@ module RuPkl
         end
       end
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         copied_args = arguments&.map(&:copy)
         self.class
           .new(parent, receiver&.copy, method_name, copied_args, nullable?, position)
@@ -56,8 +56,7 @@ module RuPkl
 
       def execute_method(pkl_method, receiver, context)
         pkl_method
-          .call(receiver, arguments, context, position)
-          .tap { parent&.add_child(_1) }
+          .call(receiver, arguments, context, parent, position)
       end
     end
   end

data/lib/rupkl/node/method_definition.rb

@@ -17,6 +17,20 @@ module RuPkl
       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
@@ -35,9 +49,13 @@ module RuPkl
       attr_reader :type
       attr_reader :body
 
-      def call(receiver, arguments, context, position)
+      def call(receiver, arguments, context, parent, position)
         args = evaluate_arguments(arguments, context, position)
-        execute_method(receiver, args)
+        execute_method(receiver, args, parent, position)
+      end
+
+      def coexistable?(other)
+        name != other.name
       end
 
       private
@@ -45,29 +63,46 @@ module RuPkl
       def evaluate_arguments(arguments, context, position)
         check_arity(arguments, position)
 
-        arguments&.zip(params)&.map do |arg, param|
-          evaluate_argument(arg, param, context)
+        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 evaluate_argument(arg, param, context)
-        value = arg.evaluate(context)
-        param.check_type(value, context, position)
-        [param.name, value]
-      end
-
       def check_arity(arguments, position)
         n_args = arguments&.size || 0
-        n_params = params&.size || 0
-        return if n_args == n_params
+        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 execute_method(receiver, arguments)
+      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)
@@ -94,7 +129,7 @@ module RuPkl
       def initialize(arguments)
         @properties =
           arguments&.map do |(name, value)|
-            ObjectProperty.new(nil, name, value, nil)
+            ObjectProperty.new(nil, name, value, nil, nil)
           end
         super(nil, *@properties, nil)
       end
@@ -125,18 +160,39 @@ module RuPkl
       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)
-        param_list = params.map { |n, t| BuiltinMethodParams.new(n, t) }
         id = Identifier.new(nil, name, nil)
-        super(nil, id, param_list, nil, nil, 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 execute_method(receiver, arguments)
-        receiver.instance_exec(*arguments&.map(&:last), &body)
+      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

data/lib/rupkl/node/node_common.rb

@@ -43,7 +43,7 @@ module RuPkl
           (@children ||= []) << child
       end
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         copied_children = children&.map(&:copy)
         self.class.new(parent, *copied_children, position)
       end

data/lib/rupkl/node/null.rb

@@ -4,6 +4,7 @@ module RuPkl
   module Node
     class Null < Any
       include ValueCommon
+      include Operatable
 
       uninstantiable_class
 
@@ -15,10 +16,6 @@ module RuPkl
         'null'
       end
 
-      def undefined_operator?(operator)
-        [:==, :'!='].none?(operator)
-      end
-
       def null?
         true
       end

data/lib/rupkl/node/number.rb

@@ -4,31 +4,56 @@ module RuPkl
   module Node
     class Number < Any
       include ValueCommon
+      include Operatable
 
-      def undefined_operator?(operator)
-        [:[], :!, :'&&', :'||'].include?(operator)
+      abstract_class
+      uninstantiable_class
+
+      def u_op_minus(position)
+        self.class.new(nil, -value, position)
       end
 
-      def invalid_r_operand?(operand)
-        !operand.is_a?(Number)
+      {
+        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 coerce(operator, r_operand)
-        if force_float?(operator, r_operand)
-          [value.to_f, r_operand.value.to_f]
-        else
-          [value.to_i, r_operand.value.to_i]
+      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
 
-      def force_float?(operator, r_operand)
-        operator == :/ ||
-          operator != :'~/' && [self, r_operand].any?(Float)
+      {
+        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
 
-      abstract_class
-      uninstantiable_class
-
       define_builtin_property(:sign) do
         result =
           case value
@@ -39,6 +64,30 @@ module RuPkl
         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
@@ -76,33 +125,72 @@ module RuPkl
         Boolean.new(self, !value.zero?, position)
       end
 
-      define_builtin_method(:toString) do
-        String.new(nil, value.to_s, nil, position)
+      define_builtin_method(:toString) do |_, parent, position|
+        String.new(parent, value.to_s, nil, position)
       end
 
-      define_builtin_method(:toInt) do
-        Int.new(nil, value.to_i, position)
+      define_builtin_method(:toInt) do |_, parent, position|
+        Int.new(parent, value.to_i, position)
       end
 
-      define_builtin_method(:toFloat) do
-        Float.new(nil, value.to_f, position)
+      define_builtin_method(:toFloat) do |_, parent, position|
+        Float.new(parent, value.to_f, position)
       end
 
-      define_builtin_method(:round) do
+      define_builtin_method(:round) do |_, parent, position|
         result = value.finite? && value.round || value
-        self.class.new(nil, result, position)
+        self.class.new(parent, result, position)
       end
 
-      define_builtin_method(:truncate) do
+      define_builtin_method(:truncate) do |_, parent, position|
         result = value.finite? && value.truncate || value
-        self.class.new(nil, result, position)
+        self.class.new(parent, result, position)
       end
 
-      define_builtin_method(:isBetween, first: Number, last: Number) do |f, l|
+      define_builtin_method(
+        :isBetween, first: Number, last: Number
+      ) do |args, parent, position|
+        f = args[:first].value
+        l = args[:last].value
         result =
-          [f.value, l.value, value].all? { _1.finite? || _1.infinite? } &&
-          (f.value..l.value).include?(value)
-        Boolean.new(nil, result, position)
+          [f, l, value].all? { _1.finite? || _1.infinite? } &&
+          (f..l).include?(value)
+        Boolean.new(parent, result, position)
+      end
+
+      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)
+        if force_float?(operator, r_operand)
+          [value.to_f, r_operand.value.to_f]
+        else
+          [value.to_i, r_operand.value.to_i]
+        end
+      end
+
+      def force_float?(operator, r_operand)
+        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
 
@@ -125,37 +213,37 @@ module RuPkl
         self.class.new(self, ~value, position)
       end
 
-      define_builtin_method(:shl, n: Int) do |n|
-        result = value << n.value
-        self.class.new(self, result, position)
+      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 |n|
-        result = value >> n.value
-        self.class.new(self, result, position)
+      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 |n|
+      define_builtin_method(:ushr, n: Int) do |args, parent, position|
         result =
           if value.negative?
             mask = (1 << 63) - 1
-            n.value.times.inject(value) { |v, _| (v >> 1) & mask }
+            args[:n].value.times.inject(value) { |v, _| (v >> 1) & mask }
           else
-            value >> n.value
+            value >> args[:n].value
           end
-        self.class.new(self, result, position)
+        self.class.new(parent, result, position)
       end
 
-      define_builtin_method(:and, n: Int) do |n|
-        self.class.new(nil, value & n.value, position)
+      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 |n|
-        self.class.new(nil, value | n.value, position)
+      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 |n|
-        self.class.new(nil, value ^ n.value, position)
+      define_builtin_method(:xor, n: Int) do |args, parent, position|
+        self.class.new(parent, value ^ args[:n].value, position)
       end
     end