rupkl 0.1.0 → 0.2.0

data/lib/rupkl/node/member_reference.rb

@@ -3,43 +3,66 @@
 module RuPkl
   module Node
     class MemberReference
-      def initialize(receiver, member, position)
+      include NodeCommon
+      include ReferenceResolver
+
+      def initialize(parent, receiver, member, nullable, position)
+        super(parent, receiver, member, position)
         @receiver = receiver
         @member = member
-        @position = position
+        @nullable = nullable
       end
 
       attr_reader :receiver
       attr_reader :member
-      attr_reader :position
 
-      def evaluate(scopes)
-        member_node =
-          if receiver
-            find_member([receiver.evaluate(scopes)])
-          else
-            find_member(scopes)
-          end
-        member_node.evaluate(scopes).value
+      def nullable?
+        @nullable
       end
 
-      def to_string(scopes)
-        evaluate(scopes).to_string(nil)
+      def evaluate(context = nil)
+        do_evaluate do
+          resolve_member_reference(context, member, receiver, nullable?).evaluate
+        end
       end
 
-      def to_pkl_string(scopes)
-        evaluate(scopes).to_pkl_string(nil)
+      def resolve_reference(context = nil)
+        do_evaluate do
+          resolve_member_reference(context, member, receiver, nullable?).resolve_reference
+        end
+      end
+
+      def copy(parent = nil)
+        self
+          .class.new(parent, receiver&.copy, member&.copy, nullable?, position)
+          .tap { copy_scope_index(_1) }
       end
 
       private
 
-      def find_member(scopes)
-        scopes.reverse_each do |scope|
-          node = scope&.properties&.find { _1.name.id == member.id }
-          return node if node
-        end
+      def do_evaluate
+        @evaluating &&
+          (raise EvaluationError.new('circular reference is detected', position))
+
+        @evaluating = true
+        result = yield
+        @evaluating = false
+
+        result
+      end
+
+      def ifnone_value(receiver)
+        receiver
+      end
+
+      def get_member_node(scope, target)
+        return unless scope.respond_to?(:property)
+
+        scope.property(target)
+      end
 
-        raise EvaluationError.new("cannot find property '#{member.id}'", position)
+      def unresolve_reference_error(target)
+        EvaluationError.new("cannot find property '#{target.id}'", position)
       end
     end
   end

data/lib/rupkl/node/method_call.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class MethodCall
+      include NodeCommon
+      include ReferenceResolver
+
+      def initialize(parent, receiver, method_name, arguments, nullable, position)
+        super(parent, receiver, method_name, *arguments, position)
+        @receiver = receiver
+        @method_name = method_name
+        @arguments = arguments
+        @nullable = nullable
+      end
+
+      attr_reader :receiver
+      attr_reader :method_name
+      attr_reader :arguments
+
+      def nullable?
+        @nullable
+      end
+
+      def evaluate(context = nil)
+        exec_on(context) do |c|
+          r = evaluate_receiver(receiver, c)
+          m = resolve_member_reference(c, method_name, r, nullable?)
+          m && execute_method(m, r, c) || r
+        end
+      end
+
+      def copy(parent = nil)
+        copied_args = arguments&.map(&:copy)
+        self.class
+          .new(parent, receiver&.copy, method_name, copied_args, nullable?, position)
+          .tap { copy_scope_index(_1) }
+      end
+
+      private
+
+      def ifnone_value(_)
+        nil
+      end
+
+      def get_member_node(scope, target)
+        return unless scope.respond_to?(:pkl_method)
+
+        scope.pkl_method(target)
+      end
+
+      def unresolve_reference_error(target)
+        m = "cannot find method '#{target.id}'"
+        raise EvaluationError.new(m, position)
+      end
+
+      def execute_method(pkl_method, receiver, context)
+        pkl_method
+          .call(receiver, arguments, context, position)
+          .tap { parent&.add_child(_1) }
+      end
+    end
+  end
+end

data/lib/rupkl/node/method_definition.rb

@@ -0,0 +1,143 @@
+# 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
+    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, position)
+        args = evaluate_arguments(arguments, context, position)
+        execute_method(receiver, args)
+      end
+
+      private
+
+      def evaluate_arguments(arguments, context, position)
+        check_arity(arguments, position)
+
+        arguments&.zip(params)&.map do |arg, param|
+          evaluate_argument(arg, param, 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
+
+        m = "expected #{n_params} method arguments but got #{n_args}"
+        raise EvaluationError.new(m, position)
+      end
+
+      def execute_method(receiver, arguments)
+        context = create_call_context(receiver, arguments)
+        execute_body(context)
+      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)
+          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 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)
+        @body = body
+      end
+
+      private
+
+      def execute_method(receiver, arguments)
+        receiver.instance_exec(*arguments&.map(&:last), &body)
+      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)
+        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,27 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Null < Any
+      include ValueCommon
+
+      uninstantiable_class
+
+      def initialize(parent, position)
+        super(parent, nil, position)
+      end
+
+      def to_string(_context = nil)
+        'null'
+      end
+
+      def undefined_operator?(operator)
+        [:==, :'!='].none?(operator)
+      end
+
+      def null?
+        true
+      end
+    end
+  end
+end

data/lib/rupkl/node/number.rb

@@ -2,13 +2,9 @@
 
 module RuPkl
   module Node
-    class Number
+    class Number < Any
       include ValueCommon
 
-      def evaluate(_scopes)
-        self
-      end
-
       def undefined_operator?(operator)
         [:[], :!, :'&&', :'||'].include?(operator)
       end
@@ -29,12 +25,146 @@ module RuPkl
         operator == :/ ||
           operator != :'~/' && [self, r_operand].any?(Float)
       end
+
+      abstract_class
+      uninstantiable_class
+
+      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
+
+      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
+        String.new(nil, value.to_s, nil, position)
+      end
+
+      define_builtin_method(:toInt) do
+        Int.new(nil, value.to_i, position)
+      end
+
+      define_builtin_method(:toFloat) do
+        Float.new(nil, value.to_f, position)
+      end
+
+      define_builtin_method(:round) do
+        result = value.finite? && value.round || value
+        self.class.new(nil, result, position)
+      end
+
+      define_builtin_method(:truncate) do
+        result = value.finite? && value.truncate || value
+        self.class.new(nil, result, position)
+      end
+
+      define_builtin_method(:isBetween, first: Number, last: Number) do |f, l|
+        result =
+          [f.value, l.value, value].all? { _1.finite? || _1.infinite? } &&
+          (f.value..l.value).include?(value)
+        Boolean.new(nil, result, position)
+      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 |n|
+        result = value << n.value
+        self.class.new(self, result, position)
+      end
+
+      define_builtin_method(:shr, n: Int) do |n|
+        result = value >> n.value
+        self.class.new(self, result, position)
+      end
+
+      define_builtin_method(:ushr, n: Int) do |n|
+        result =
+          if value.negative?
+            mask = (1 << 63) - 1
+            n.value.times.inject(value) { |v, _| (v >> 1) & mask }
+          else
+            value >> n.value
+          end
+        self.class.new(self, result, position)
+      end
+
+      define_builtin_method(:and, n: Int) do |n|
+        self.class.new(nil, value & n.value, position)
+      end
+
+      define_builtin_method(:or, n: Int) do |n|
+        self.class.new(nil, value | n.value, position)
+      end
+
+      define_builtin_method(:xor, n: Int) do |n|
+        self.class.new(nil, value ^ 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