steep-relaxed 1.9.3.3

data/lib/steep/interface/substitution.rb

@@ -0,0 +1,159 @@
+module Steep
+  module Interface
+    class Substitution
+      class InvalidSubstitutionError < StandardError
+        attr_reader :vars_size
+        attr_reader :types_size
+
+        def initialize(vars_size:, types_size:)
+          @vars_size = vars_size
+          @types_size = types_size
+
+          super "Invalid substitution: vars.size=#{vars_size}, types.size=#{types_size}"
+        end
+      end
+
+      attr_reader :dictionary
+      attr_reader :instance_type
+      attr_reader :module_type
+      attr_reader :self_type
+
+      def initialize(dictionary:, instance_type:, module_type:, self_type:)
+        @dictionary = dictionary
+        @instance_type = instance_type
+        @module_type = module_type
+        @self_type = self_type
+      end
+
+      def self.empty
+        new(dictionary: {},
+            instance_type: AST::Types::Instance.instance,
+            module_type: AST::Types::Class.instance,
+            self_type: AST::Types::Self.instance)
+      end
+
+      def empty?
+        dictionary.empty? &&
+          instance_type.is_a?(AST::Types::Instance) &&
+          module_type.is_a?(AST::Types::Class) &&
+          self_type.is_a?(AST::Types::Self)
+      end
+
+      def domain
+        set = Set.new
+
+        set.merge(dictionary.keys)
+        set << AST::Types::Self.instance if self_type
+        set << AST::Types::Class.instance if module_type
+        set << AST::Types::Instance.instance if instance_type
+
+        set
+      end
+
+      def to_s
+        a = [] #: Array[String]
+
+        dictionary.each do |x, ty|
+          a << "#{x} -> #{ty}"
+        end
+
+        a << "[instance_type] -> #{instance_type}"
+        a << "[module_type] -> #{module_type}"
+        a << "[self_type] -> #{self_type}"
+
+        "{ #{a.join(", ")} }"
+      end
+
+      def [](key)
+        dictionary[key] or raise "Unknown variable: #{key}"
+      end
+
+      def key?(var)
+        dictionary.key?(var)
+      end
+
+      def apply?(type)
+        case type
+        when AST::Types::Var
+          key?(type.name)
+        when AST::Types::Self
+          !self_type.is_a?(AST::Types::Self)
+        when AST::Types::Instance
+          !instance_type.is_a?(AST::Types::Instance)
+        when AST::Types::Class
+          !module_type.is_a?(AST::Types::Class)
+        when AST::Types::Name::Applying
+          type.args.any? {|ty| apply?(ty) }
+        else
+          type.each_child.any? {|t| apply?(t) }
+        end
+      end
+
+      def self.build(vars, types = nil, instance_type: nil, module_type: nil, self_type: nil)
+        types ||= vars.map {|var| AST::Types::Var.fresh(var) }
+
+        raise InvalidSubstitutionError.new(vars_size: vars.size, types_size: types.size) unless vars.size == types.size
+
+        dic = vars.zip(types).each.with_object({}) do |(var, type), d| #$ Hash[Symbol, AST::Types::t]
+          type or raise
+          d[var] = type
+        end
+
+        new(dictionary: dic, instance_type: instance_type, module_type: module_type, self_type: self_type)
+      end
+
+      def except(vars)
+        self.class.new(
+          dictionary: dictionary.dup,
+          instance_type: instance_type,
+          module_type: module_type,
+          self_type: self_type
+        ).except!(vars)
+      end
+
+      def except!(vars)
+        vars.each do |var|
+          dictionary.delete(var)
+        end
+
+        self
+      end
+
+      def merge!(s, overwrite: false)
+        dictionary.transform_values! {|ty| ty.subst(s) }
+        dictionary.merge!(s.dictionary) do |key, a, b|
+          if a == b
+            a
+          else
+            if overwrite
+              b
+            else
+              raise "Duplicated key on merge!: #{key}, #{a}, #{b} (#{self})"
+            end
+          end
+        end
+
+        @instance_type = instance_type.subst(s) if instance_type
+        @module_type = module_type.subst(s) if module_type
+        @self_type = self_type.subst(s) if self_type
+
+        self
+      end
+
+      def update(self_type: self_type(), instance_type: instance_type(), module_type: module_type())
+        Substitution.new(dictionary: dictionary.dup, instance_type: instance_type, self_type: self_type, module_type: module_type)
+      end
+
+      def merge(s)
+        Substitution.new(dictionary: dictionary.dup,
+                         instance_type: instance_type,
+                         module_type: module_type,
+                         self_type: self_type).merge!(s)
+      end
+
+      def add!(v, ty)
+        merge!(Substitution.new(dictionary: { v => ty }, instance_type: instance_type, module_type: module_type, self_type: self_type))
+      end
+    end
+  end
+end

data/lib/steep/interface/type_param.rb

@@ -0,0 +1,115 @@
+module Steep
+  module Interface
+    class TypeParam
+      attr_reader :name
+      attr_reader :upper_bound
+      attr_reader :variance
+      attr_reader :unchecked
+      attr_reader :location
+      attr_reader :default_type
+
+      def initialize(name:, upper_bound:, variance:, unchecked:, location: nil, default_type:)
+        @name = name
+        @upper_bound = upper_bound
+        @variance = variance
+        @unchecked = unchecked
+        @location = location
+        @default_type = default_type
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.upper_bound == upper_bound &&
+          other.variance == variance &&
+          other.unchecked == unchecked &&
+          other.default_type == default_type
+      end
+
+      alias eql? ==
+
+      def hash
+        name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash ^ default_type.hash
+      end
+
+      def self.rename(params, conflicting_names = params.map(&:name), new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) })
+        unless conflicting_names.empty?
+          hash = conflicting_names.zip(new_names).to_h
+          new_types = new_names.map {|n| AST::Types::Var.new(name: n) }
+
+          subst = Substitution.build(conflicting_names, new_types)
+
+          [
+            params.map do |param|
+              if hash.key?(param.name) || param.upper_bound
+                TypeParam.new(
+                  name: hash[param.name] || param.name,
+                  upper_bound: param.upper_bound&.subst(subst),
+                  variance: param.variance,
+                  unchecked: param.unchecked,
+                  location: param.location,
+                  default_type: param.default_type&.subst(subst)
+                )
+              else
+                param
+              end
+            end,
+            subst
+          ]
+        else
+          [params, Substitution.empty]
+        end
+      end
+
+      def to_s
+        buf = +""
+
+        if unchecked
+          buf << "unchecked "
+        end
+
+        case variance
+        when :covariant
+          buf << "out "
+        when :contravariant
+          buf << "in "
+        end
+
+        buf << name.to_s
+
+        if upper_bound
+          buf << " < #{upper_bound}"
+        end
+
+        buf
+      end
+
+      def update(name: self.name, upper_bound: self.upper_bound, variance: self.variance, unchecked: self.unchecked, location: self.location, default_type: self.default_type)
+        TypeParam.new(
+          name: name,
+          upper_bound: upper_bound,
+          variance: variance,
+          unchecked: unchecked,
+          location: location,
+          default_type: default_type
+        )
+      end
+
+      def subst(s)
+        if u = upper_bound
+          ub = u.subst(s)
+        end
+
+        if d = default_type
+          dt = d.subst(s)
+        end
+
+        if ub || dt
+          update(upper_bound: ub, default_type: dt)
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/steep/located_value.rb

@@ -0,0 +1,20 @@
+module Steep
+  class LocatedValue
+    attr_reader :value, :location
+
+    def initialize(value:, location:)
+      @value = value
+      @location = location
+    end
+
+    def ==(other)
+      other.is_a?(LocatedValue) && other.value == value
+    end
+
+    alias eql? ==
+
+    def hash
+      value.hash # steep:ignore NoMethod
+    end
+  end
+end

data/lib/steep/method_name.rb

@@ -0,0 +1,42 @@
+module Steep
+  InstanceMethodName = _ = Struct.new(:type_name, :method_name, keyword_init: true) do
+    # @implements InstanceMethodName
+    def to_s
+      "#{type_name}##{method_name}"
+    end
+
+    def relative
+      InstanceMethodName.new(type_name: type_name.relative!, method_name: method_name)
+    end
+  end
+
+  SingletonMethodName = _ = Struct.new(:type_name, :method_name, keyword_init: true) do
+    # @implements SingletonMethodName
+    def to_s
+      "#{type_name}.#{method_name}"
+    end
+
+    def relative
+      SingletonMethodName.new(type_name: type_name.relative!, method_name: method_name)
+    end
+  end
+
+  class ::Object
+    def MethodName(string)
+      case string
+      when /#/
+        type_name, method_name = string.split(/#/, 2)
+        type_name or raise
+        method_name or raise
+        InstanceMethodName.new(type_name: RBS::TypeName.parse(type_name), method_name: method_name.to_sym)
+      when /\./
+        type_name, method_name = string.split(/\./, 2)
+        type_name or raise
+        method_name or raise
+        SingletonMethodName.new(type_name: RBS::TypeName.parse(type_name), method_name: method_name.to_sym)
+      else
+        raise "Unexpected method name: #{string}"
+      end
+    end
+  end
+end

data/lib/steep/module_helper.rb

@@ -0,0 +1,24 @@
+module Steep
+  module ModuleHelper
+    def module_name_from_node(parent_node, constant_name)
+      if namespace = namespace_from_node(parent_node)
+        RBS::TypeName.new(name: constant_name, namespace: namespace)
+      end
+    end
+
+    def namespace_from_node(node)
+      if node
+        case node.type
+        when :cbase
+          RBS::Namespace.root
+        when :const
+          if parent = namespace_from_node(node.children[0])
+            parent.append(node.children[1])
+          end
+        end
+      else
+        RBS::Namespace.empty
+      end
+    end
+  end
+end

data/lib/steep/node_helper.rb

@@ -0,0 +1,273 @@
+module Steep
+  module NodeHelper
+    def each_child_node(node, &block)
+      if block
+        node.children.each do |child|
+          if child.is_a?(Parser::AST::Node)
+            yield child
+          end
+        end
+      else
+        enum_for :each_child_node, node
+      end
+    end
+
+    def each_descendant_node(node, &block)
+      if block
+        each_child_node(node) do |child|
+          yield child
+          each_descendant_node(child, &block)
+        end
+      else
+        enum_for :each_descendant_node, node
+      end
+    end
+
+    def value_node?(node)
+      case node.type
+      when :self
+        true
+      when :true, :false, :str, :sym, :int, :float, :nil
+        true
+      when :lvar
+        true
+      when :const
+        each_child_node(node).all? {|child| child.type == :cbase || value_node?(child) }
+      when :array
+        each_child_node(node).all? {|child| value_node?(child) }
+      when :hash
+        each_child_node(node).all? do |pair|
+          each_child_node(pair).all? {|child| value_node?(child) }
+        end
+      when :dstr
+        each_child_node(node).all? {|child| value_node?(child)}
+      when :begin
+        each_child_node(node).all? {|child| value_node?(child) }
+      else
+        false
+      end
+    end
+
+    def deconstruct_if_node(node)
+      if node.type == :if
+        [
+          node.children[0],
+          node.children[1],
+          node.children[2],
+          _ = node.location
+        ]
+      end
+    end
+
+    def deconstruct_if_node!(node)
+      deconstruct_if_node(node) or raise
+    end
+
+    def test_if_node(node)
+      if (a, b, c, d = deconstruct_if_node(node))
+        yield(a, b, c, d)
+      else
+        false
+      end
+    end
+
+    def deconstruct_whileish_node(node)
+      case node.type
+      when :while, :until, :while_post, :until_post
+        [
+          node.children[0],
+          node.children[1],
+          _ = node.location
+        ]
+      end
+    end
+
+    def deconstruct_whileish_node!(node)
+      deconstruct_whileish_node(node) or raise
+    end
+
+    def test_whileish_node(node)
+      if (a, b, c = deconstruct_whileish_node(node))
+        yield(a, b, c)
+      else
+        false
+      end
+    end
+
+    def deconstruct_case_node(node)
+      case node.type
+      when :case
+        cond, *whens, else_ = node.children
+        [
+          cond,
+          whens,
+          else_,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_case_node!(node)
+      deconstruct_case_node(node) or raise
+    end
+
+    def test_case_node(node)
+      if (a, b, c, d = deconstruct_case_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_when_node(node)
+      case node.type
+      when :when
+        *conds, body = node.children
+        [
+          conds,
+          body,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_when_node!(node)
+      deconstruct_when_node(node) or raise
+    end
+
+    def test_when_node(node)
+      if (a, b, c = deconstruct_when_node(node))
+        yield a, b, c
+      else
+        false
+      end
+    end
+
+    def deconstruct_rescue_node(node)
+      case node.type
+      when :rescue
+        body, *resbodies, else_ = node.children
+
+        [
+          body,
+          resbodies,
+          else_,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_rescue_node!(node)
+      deconstruct_rescue_node(node) or raise
+    end
+
+    def test_rescue_node(node)
+      if (a, b, c, d = deconstruct_rescue_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_resbody_node(node)
+      case node.type
+      when :resbody
+        [
+          node.children[0],
+          node.children[1],
+          node.children[2],
+          _  = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_resbody_node!(node)
+      deconstruct_resbody_node(node) or raise
+    end
+
+    def test_resbody_node(node)
+      if (a, b, c, d = deconstruct_resbody_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_send_node(node)
+      case node.type
+      when :send, :csend
+        receiver, selector, *args = node.children
+        [
+          receiver,
+          selector,
+          args,
+          _  = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_send_node!(node)
+      deconstruct_send_node(node) or raise(node.inspect)
+    end
+
+    def test_send_node(node)
+      if (a, b, c, d = deconstruct_send_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def private_send?(node)
+      case node.type
+      when :block, :numblock
+        private_send?(node.children[0])
+      when :send, :csend
+        receiver, = deconstruct_send_node!(node)
+
+        if receiver && receiver.type != :self
+          return false
+        end
+
+        true
+      else
+        raise "Unexpected node is given: #{node.inspect}"
+      end
+    end
+
+    def deconstruct_sendish_and_block_nodes(*nodes)
+      send_node, block_node = nodes.take(2)
+
+      if send_node
+        case send_node.type
+        when :send, :csend, :super
+          if block_node
+            case block_node.type
+            when :block, :numblock
+              if send_node.equal?(block_node.children[0])
+                return [send_node, block_node]
+              end
+            end
+          end
+
+          [send_node, nil]
+        when :zsuper
+          # zsuper doesn't receive block
+          [send_node, nil]
+        end
+      end
+    end
+
+    def clone_node(node)
+      children = node.children.map do |child|
+        if child.is_a?(Parser::AST::Node)
+          clone_node(child)
+        else
+          child.dup
+        end
+      end
+
+      node.updated(nil, children)
+    end
+  end
+end

data/lib/steep/path_helper.rb

@@ -0,0 +1,30 @@
+module Steep
+  module PathHelper
+    module_function
+
+    URIParser = URI::RFC2396_Parser.new()
+
+    def to_pathname(uri, dosish: Gem.win_platform?)
+      uri = URI.parse(uri)
+      if uri.scheme == "file"
+        path = uri.path or raise
+        path.sub!(%r{^/([a-zA-Z])(:|%3A)//?}i, '\1:/') if dosish
+        path = URIParser.unescape(path)
+        Pathname(path)
+      end
+    end
+
+    def to_pathname!(uri, dosish: Gem.win_platform?)
+      to_pathname(uri, dosish: dosish) or raise "Cannot translate a URI to pathname: #{uri}"
+    end
+
+    def to_uri(path, dosish: Gem.win_platform?)
+      str_path = path.to_s
+      if dosish
+        str_path.insert(0, "/") if str_path[0] != "/"
+      end
+      str_path = URIParser.escape(str_path)
+      URI::File.build(path: str_path)
+    end
+  end
+end