rbs-relaxed 3.9.0.1

data/lib/rbs/ast/members.rb

@@ -0,0 +1,451 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Members
+      class Base
+      end
+
+      class MethodDefinition < Base
+        class Overload
+          attr_reader :method_type, :annotations
+
+          def initialize(method_type:, annotations:)
+            @method_type = method_type
+            @annotations = annotations
+          end
+
+          def ==(other)
+            other.is_a?(Overload) && other.method_type == method_type && other.annotations == annotations
+          end
+
+          def hash
+            method_type.hash ^ annotations.hash
+          end
+
+          alias eql? ==
+
+          def update(annotations: self.annotations, method_type: self.method_type)
+            Overload.new(annotations: annotations, method_type: method_type)
+          end
+
+          def sub(subst)
+            return self if subst.empty?
+
+            update(method_type: self.method_type.sub(subst))
+          end
+
+          def to_json(state = _ = nil)
+            {
+              annotations: annotations,
+              method_type: method_type
+            }.to_json(state)
+          end
+        end
+
+        attr_reader :name
+        attr_reader :kind
+        attr_reader :overloads
+        attr_reader :annotations
+        attr_reader :location
+        attr_reader :comment
+        attr_reader :overloading
+        attr_reader :visibility
+
+        def initialize(name:, kind:, overloads:, annotations:, location:, comment:, overloading:, visibility:)
+          @name = name
+          @kind = kind
+          @overloads = overloads
+          @annotations = annotations
+          @location = location
+          @comment = comment
+          @overloading = overloading
+          @visibility = visibility
+        end
+
+        def ==(other)
+          other.is_a?(MethodDefinition) &&
+            other.name == name &&
+            other.kind == kind &&
+            other.overloads == overloads &&
+            other.overloading? == overloading? &&
+            other.visibility == visibility
+        end
+
+        alias eql? ==
+
+        def hash
+          name.hash ^ kind.hash ^ overloads.hash ^ overloading?.hash ^ visibility.hash
+        end
+
+        def instance?
+          kind == :instance || kind == :singleton_instance
+        end
+
+        def singleton?
+          kind == :singleton || kind == :singleton_instance
+        end
+
+        def overloading?
+          overloading
+        end
+
+        def update(name: self.name, kind: self.kind, overloads: self.overloads, annotations: self.annotations, location: self.location, comment: self.comment, overloading: self.overloading?, visibility: self.visibility)
+          self.class.new(
+            name: name,
+            kind: kind,
+            overloads: overloads,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            overloading: overloading,
+            visibility: visibility
+          )
+        end
+
+        def to_json(state = _ = nil)
+          {
+            member: :method_definition,
+            name: name,
+            kind: kind,
+            overloads: overloads,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            overloading: overloading?,
+            visibility: visibility
+          }.to_json(state)
+        end
+      end
+
+      module Var
+        attr_reader :name
+        attr_reader :type
+        attr_reader :location
+        attr_reader :comment
+
+        def initialize(name:, type:, location:, comment:)
+          @name = name
+          @type = type
+          @location = location
+          @comment = comment
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && other.name == name && other.type == type
+        end
+
+        alias eql? ==
+
+        def hash
+          name.hash ^ type.hash
+        end
+      end
+
+      class InstanceVariable < Base
+        include Var
+
+        def to_json(state = _ = nil)
+          {
+            member: :instance_variable,
+            name: name,
+            type: type,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class ClassInstanceVariable < Base
+        include Var
+
+        def to_json(state = _ = nil)
+          {
+            member: :class_instance_variable,
+            name: name,
+            type: type,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class ClassVariable < Base
+        include Var
+
+        def to_json(state = _ = nil)
+          {
+            member: :class_variable,
+            name: name,
+            type: type,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      module Mixin
+        attr_reader :name
+        attr_reader :args
+        attr_reader :annotations
+        attr_reader :location
+        attr_reader :comment
+
+        def initialize(name:, args:, annotations:, location:, comment:)
+          @name = name
+          @args = args
+          @annotations = annotations
+          @location = location
+          @comment = comment
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && other.name == name && other.args == args
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          name.hash ^ args.hash
+        end
+      end
+
+      class Include < Base
+        include Mixin
+
+        def to_json(state = _ = nil)
+          {
+            member: :include,
+            name: name,
+            args: args,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class Extend < Base
+        include Mixin
+
+        def to_json(state = _ = nil)
+          {
+            member: :extend,
+            name: name,
+            args: args,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class Prepend < Base
+        include Mixin
+
+        def to_json(state = _ = nil)
+          {
+            member: :prepend,
+            name: name,
+            args: args,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      module Attribute
+        attr_reader :name
+        attr_reader :type
+        attr_reader :kind
+        attr_reader :ivar_name
+        attr_reader :annotations
+        attr_reader :location
+        attr_reader :comment
+        attr_reader :visibility
+
+        def initialize(name:, type:, ivar_name:, kind:, annotations:, location:, comment:, visibility: nil)
+          @name = name
+          @type = type
+          @ivar_name = ivar_name
+          @annotations = annotations
+          @location = location
+          @comment = comment
+          @kind = kind
+          @visibility = visibility
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.name == name &&
+            other.type == type &&
+            other.ivar_name == ivar_name &&
+            other.kind == kind &&
+            other.visibility == visibility
+        end
+
+        alias eql? ==
+
+        def hash
+          name.hash ^ type.hash ^ ivar_name.hash ^ kind.hash ^ visibility.hash
+        end
+
+        def update(name: self.name, type: self.type, ivar_name: self.ivar_name, kind: self.kind, annotations: self.annotations, location: self.location, comment: self.comment, visibility: self.visibility)
+          klass = _ = self.class
+          klass.new(
+            name: name,
+            type: type,
+            ivar_name: ivar_name,
+            kind: kind,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            visibility: visibility
+          )
+        end
+      end
+
+      class AttrReader < Base
+        include Attribute
+
+        def to_json(state = _ = nil)
+          {
+            member: :attr_reader,
+            name: name,
+            type: type,
+            ivar_name: ivar_name,
+            kind: kind,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            visibility: visibility
+          }.to_json(state)
+        end
+      end
+
+      class AttrAccessor < Base
+        include Attribute
+
+        def to_json(state = _ = nil)
+          {
+            member: :attr_accessor,
+            name: name,
+            type: type,
+            ivar_name: ivar_name,
+            kind: kind,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            visibility: visibility
+          }.to_json(state)
+        end
+      end
+
+      class AttrWriter < Base
+        include Attribute
+
+        def to_json(state = _ = nil)
+          {
+            member: :attr_writer,
+            name: name,
+            type: type,
+            ivar_name: ivar_name,
+            kind: kind,
+            annotations: annotations,
+            location: location,
+            comment: comment,
+            visibility: visibility
+          }.to_json(state)
+        end
+      end
+
+      module LocationOnly
+        attr_reader :location
+
+        def initialize(location:)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(self.class)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+      end
+
+      class Public < Base
+        include LocationOnly
+
+        def to_json(state = _ = nil)
+          { member: :public, location: location }.to_json(state)
+        end
+      end
+
+      class Private < Base
+        include LocationOnly
+
+        def to_json(state = _ = nil)
+          { member: :private, location: location }.to_json(state)
+        end
+      end
+
+      class Alias < Base
+        attr_reader :new_name
+        attr_reader :old_name
+        attr_reader :kind
+        attr_reader :annotations
+        attr_reader :location
+        attr_reader :comment
+
+        def initialize(new_name:, old_name:, kind:, annotations:, location:, comment:)
+          @new_name = new_name
+          @old_name = old_name
+          @kind = kind
+          @annotations = annotations
+          @location = location
+          @comment = comment
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.new_name == new_name &&
+            other.old_name == old_name &&
+            other.kind == kind
+        end
+
+        alias eql? ==
+
+        def hash
+          new_name.hash ^ old_name.hash ^ kind.hash
+        end
+
+        def to_json(state = _ = nil)
+          {
+            member: :alias,
+            new_name: new_name,
+            old_name: old_name,
+            kind: kind,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+
+        def instance?
+          kind == :instance
+        end
+
+        def singleton?
+          kind == :singleton
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/type_param.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    class TypeParam
+      attr_reader :name, :variance, :location, :upper_bound_type, :default_type
+
+      def initialize(name:, variance:, upper_bound:, location:, default_type: nil, unchecked: false)
+        @name = name
+        @variance = variance
+        @upper_bound_type = upper_bound
+        @location = location
+        @default_type = default_type
+        @unchecked = unchecked
+      end
+
+      def upper_bound
+        case upper_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          upper_bound_type
+        end
+      end
+
+      def unchecked!(value = true)
+        @unchecked = value ? true : false
+        self
+      end
+
+      def unchecked?
+        @unchecked
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.variance == variance &&
+          other.upper_bound_type == upper_bound_type &&
+          other.default_type == default_type &&
+          other.unchecked? == unchecked?
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ unchecked?.hash ^ default_type.hash
+      end
+
+      def to_json(state = JSON::State.new)
+        {
+          name: name,
+          variance: variance,
+          unchecked: unchecked?,
+          location: location,
+          upper_bound: upper_bound_type,
+          default_type: default_type
+        }.to_json(state)
+      end
+
+      def rename(name)
+        TypeParam.new(
+          name: name,
+          variance: variance,
+          upper_bound: upper_bound_type,
+          location: location,
+          default_type: default_type
+        ).unchecked!(unchecked?)
+      end
+
+      def map_type(&block)
+        if b = upper_bound_type
+          _upper_bound_type = yield(b)
+        end
+
+        if dt = default_type
+          _default_type = yield(dt)
+        end
+
+        TypeParam.new(
+          name: name,
+          variance: variance,
+          upper_bound: _upper_bound_type,
+          location: location,
+          default_type: _default_type
+        ).unchecked!(unchecked?)
+      end
+
+      def self.resolve_variables(params)
+        return if params.empty?
+
+        vars = Set.new(params.map(&:name))
+
+        params.map! do |param|
+          param.map_type {|bound| _ = subst_var(vars, bound) }
+        end
+      end
+
+      def self.subst_var(vars, type)
+        case type
+        when Types::ClassInstance
+          namespace = type.name.namespace
+          if namespace.relative? && namespace.empty? && vars.member?(type.name.name)
+            return Types::Variable.new(name: type.name.name, location: type.location)
+          end
+        end
+
+        type.map_type {|t| subst_var(vars, t) }
+      end
+
+      def self.rename(params, new_names:)
+        raise unless params.size == new_names.size
+
+        subst = Substitution.build(new_names, Types::Variable.build(new_names))
+
+        params.map.with_index do |param, index|
+          new_name = new_names[index]
+
+          TypeParam.new(
+            name: new_name,
+            variance: param.variance,
+            upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            location: param.location,
+            default_type: param.default_type&.map_type {|type| type.sub(subst) }
+          ).unchecked!(param.unchecked?)
+        end
+      end
+
+      def to_s
+        s = +""
+
+        if unchecked?
+          s << "unchecked "
+        end
+
+        case variance
+        when :invariant
+          # nop
+        when :covariant
+          s << "out "
+        when :contravariant
+          s << "in "
+        end
+
+        s << name.to_s
+
+        if type = upper_bound_type
+          s << " < #{type}"
+        end
+
+        if dt = default_type
+          s << " = #{dt}"
+        end
+
+        s
+      end
+
+      def self.application(params, args)
+        if params.empty?
+          return nil
+        end
+
+        optional_params, required_params = params.partition {|param| param.default_type }
+
+        param_subst = Substitution.new()
+        app_subst = Substitution.new()
+
+        required_params.zip(args.take(required_params.size)).each do |param, arg|
+          arg ||= Types::Bases::Any.new(location: nil)
+          param_subst.add(from: param.name, to: arg)
+          app_subst.add(from: param.name, to: arg)
+        end
+
+        optional_params.each do |param|
+          param_subst.add(from: param.name, to: Types::Bases::Any.new(location: nil))
+        end
+
+        optional_params.zip(args.drop(required_params.size)).each do |param, arg|
+          if arg
+            app_subst.add(from: param.name, to: arg)
+          else
+            param.default_type or raise
+            app_subst.add(from: param.name, to: param.default_type.sub(param_subst))
+          end
+        end
+
+        app_subst
+      end
+
+      def self.normalize_args(params, args)
+        app = application(params, args) or return []
+
+        min_count = params.count { _1.default_type.nil? }
+        unless min_count <= args.size && args.size <= params.size
+          return args
+        end
+
+        params.zip(args).filter_map do |param, arg|
+          if arg
+            arg
+          else
+            if param.default_type
+              param.default_type.sub(app)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+        end
+      end
+
+      def self.validate(type_params)
+        optionals = type_params.filter {|param| param.default_type }
+
+        optional_param_names = optionals.map(&:name).sort
+
+        optionals.filter! do |param|
+          default_type = param.default_type or raise
+          optional_param_names.any? { default_type.free_variables.include?(_1) }
+        end
+
+        unless optionals.empty?
+          optionals
+        end
+      end
+    end
+  end
+end