steep 1.0.2 → 1.1.0.pre.1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0.pre.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-19 00:00:00.000000000 Z
+date: 2022-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -156,6 +156,8 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- Gemfile.steep
+- Gemfile.steep.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -164,6 +166,7 @@ files:
 - bin/output_rebaseline.rb
 - bin/output_test.rb
 - bin/setup
+- bin/steep
 - bin/steep-prof
 - exe/steep
 - lib/steep.rb
@@ -225,6 +228,7 @@ files:
 - lib/steep/interface/type_param.rb
 - lib/steep/method_name.rb
 - lib/steep/module_helper.rb
+- lib/steep/node_helper.rb
 - lib/steep/path_helper.rb
 - lib/steep/project.rb
 - lib/steep/project/dsl.rb
@@ -251,6 +255,7 @@ files:
 - lib/steep/services/stats_calculator.rb
 - lib/steep/services/type_check_service.rb
 - lib/steep/shims/filter_map.rb
+- lib/steep/shims/symbol_start_with.rb
 - lib/steep/signature/validator.rb
 - lib/steep/source.rb
 - lib/steep/subtyping/cache.rb
@@ -264,21 +269,100 @@ files:
 - lib/steep/type_inference/constant_env.rb
 - lib/steep/type_inference/context.rb
 - lib/steep/type_inference/context_array.rb
-- lib/steep/type_inference/local_variable_type_env.rb
-- lib/steep/type_inference/logic.rb
 - lib/steep/type_inference/logic_type_interpreter.rb
 - lib/steep/type_inference/method_call.rb
 - lib/steep/type_inference/method_params.rb
+- lib/steep/type_inference/multiple_assignment.rb
 - lib/steep/type_inference/send_args.rb
 - lib/steep/type_inference/type_env.rb
+- lib/steep/type_inference/type_env_builder.rb
 - lib/steep/typing.rb
 - lib/steep/version.rb
 - manual/annotations.md
+- rbs_collection.steep.lock.yaml
+- rbs_collection.steep.yaml
 - sample/Steepfile
 - sample/lib/conference.rb
 - sample/lib/length.rb
 - sample/sig/conference.rbs
 - sample/sig/length.rbs
+- sig/shims/parser.rbs
+- sig/shims/parser/source/map.rbs
+- sig/shims/parser/source/range.rbs
+- sig/steep.rbs
+- sig/steep/ast/annotation.rbs
+- sig/steep/ast/annotation/collection.rbs
+- sig/steep/ast/builtin.rbs
+- sig/steep/ast/type_params.rbs
+- sig/steep/ast/types.rbs
+- sig/steep/ast/types/any.rbs
+- sig/steep/ast/types/boolean.rbs
+- sig/steep/ast/types/bot.rbs
+- sig/steep/ast/types/class.rbs
+- sig/steep/ast/types/factory.rbs
+- sig/steep/ast/types/helper.rbs
+- sig/steep/ast/types/instance.rbs
+- sig/steep/ast/types/intersection.rbs
+- sig/steep/ast/types/literal.rbs
+- sig/steep/ast/types/logic.rbs
+- sig/steep/ast/types/name.rbs
+- sig/steep/ast/types/nil.rbs
+- sig/steep/ast/types/proc.rbs
+- sig/steep/ast/types/record.rbs
+- sig/steep/ast/types/self.rbs
+- sig/steep/ast/types/top.rbs
+- sig/steep/ast/types/tuple.rbs
+- sig/steep/ast/types/union.rbs
+- sig/steep/ast/types/var.rbs
+- sig/steep/ast/types/void.rbs
+- sig/steep/diagnostic/deprecated/unknown_constant_assigned.rbs
+- sig/steep/diagnostic/helper.rbs
+- sig/steep/diagnostic/lsp_formatter.rbs
+- sig/steep/diagnostic/ruby.rbs
+- sig/steep/diagnostic/signature.rbs
+- sig/steep/interface/block.rbs
+- sig/steep/interface/function.rbs
+- sig/steep/interface/interface.rbs
+- sig/steep/interface/method_type.rbs
+- sig/steep/interface/substitution.rbs
+- sig/steep/interface/type_param.rbs
+- sig/steep/method_name.rbs
+- sig/steep/module_helper.rbs
+- sig/steep/node_helper.rbs
+- sig/steep/project.rbs
+- sig/steep/project/dsl.rbs
+- sig/steep/project/options.rbs
+- sig/steep/project/pattern.rbs
+- sig/steep/project/target.rbs
+- sig/steep/services/completion_provider.rbs
+- sig/steep/services/content_change.rbs
+- sig/steep/services/file_loader.rbs
+- sig/steep/services/goto_service.rbs
+- sig/steep/services/hover_provider/rbs.rbs
+- sig/steep/services/hover_provider/ruby.rbs
+- sig/steep/services/hover_provider/singleton_methods.rbs
+- sig/steep/services/path_assignment.rbs
+- sig/steep/services/signature_service.rbs
+- sig/steep/services/stats_calculator.rbs
+- sig/steep/services/type_check_service.rbs
+- sig/steep/source.rbs
+- sig/steep/subtyping/cache.rbs
+- sig/steep/subtyping/check.rbs
+- sig/steep/subtyping/constraints.rbs
+- sig/steep/subtyping/relation.rbs
+- sig/steep/subtyping/result.rbs
+- sig/steep/subtyping/variable_variance.rbs
+- sig/steep/type_construction.rbs
+- sig/steep/type_inference/block_params.rbs
+- sig/steep/type_inference/constant_env.rbs
+- sig/steep/type_inference/context.rbs
+- sig/steep/type_inference/logic_type_interpreter.rbs
+- sig/steep/type_inference/method_call.rbs
+- sig/steep/type_inference/method_params.rbs
+- sig/steep/type_inference/multiple_assignment.rbs
+- sig/steep/type_inference/type_env.rbs
+- sig/steep/type_inference/type_env_builder.rbs
+- sig/steep/typing.rbs
 - smoke/alias/Steepfile
 - smoke/alias/a.rb
 - smoke/alias/a.rbs
@@ -545,9 +629,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/steep/type_inference/local_variable_type_env.rb

@@ -1,249 +0,0 @@
-module Steep
-  module TypeInference
-    class LocalVariableTypeEnv
-      class Entry
-        attr_reader :type
-        attr_reader :annotations
-        attr_reader :nodes
-
-        def initialize(type:, annotations: [], nodes: [])
-          @type = type
-          @annotations = Set.new(annotations)
-          @nodes = Set[].compare_by_identity.merge(nodes)
-        end
-
-        def update(type: self.type, annotations: self.annotations, nodes: self.nodes)
-          Entry.new(type: type, annotations: annotations, nodes: nodes)
-        end
-
-        def ==(other)
-          other.is_a?(Entry) &&
-            other.type == type &&
-            other.annotations == annotations &&
-            other.nodes == nodes
-        end
-
-        def +(other)
-          self.class.new(type: AST::Types::Union.build(types: [type, other.type]),
-                         annotations: annotations + other.annotations,
-                         nodes: nodes + other.nodes)
-        end
-
-        def optional
-          self.class.new(type: AST::Types::Union.build(types: [type, AST::Builtin.nil_type]),
-                         annotations: annotations,
-                         nodes: nodes)
-        end
-      end
-
-      attr_reader :subtyping
-      attr_reader :self_type
-      attr_reader :instance_type
-      attr_reader :class_type
-      attr_reader :declared_types
-      attr_reader :assigned_types
-
-      def self.empty(subtyping:, self_type:, instance_type:, class_type:)
-        new(
-          subtyping: subtyping,
-          declared_types: {},
-          assigned_types: {},
-          self_type: self_type,
-          instance_type: instance_type,
-          class_type: class_type
-        )
-      end
-
-      def initialize(subtyping:, declared_types:, assigned_types:, self_type:, instance_type:, class_type:)
-        @subtyping = subtyping
-        @self_type = self_type
-
-        @declared_types = declared_types
-        @assigned_types = assigned_types
-        @class_type = class_type
-        @instance_type = instance_type
-
-        unless (intersection = Set.new(declared_types.keys) & Set.new(assigned_types.keys)).empty?
-          raise "Declared types and assigned types should be disjoint: #{intersection}"
-        end
-      end
-
-      def update(declared_types: self.declared_types, assigned_types: self.assigned_types, self_type: self.self_type, instance_type: self.instance_type, class_type: self.class_type)
-        self.class.new(
-          subtyping: subtyping,
-          declared_types: declared_types,
-          assigned_types: assigned_types,
-          self_type: self_type,
-          instance_type: instance_type,
-          class_type: class_type
-        )
-      end
-
-      def assign!(var, node:, type:)
-        declared_type = declared_types[var]&.type
-
-        if declared_type
-          relation = Subtyping::Relation.new(sub_type: type, super_type: declared_type)
-          constraints = Subtyping::Constraints.new(unknowns: Set.new)
-          subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
-            yield declared_type, type, result
-          end
-        end
-
-        assignments = { var => Entry.new(type: type, nodes: [node]) }
-        update(assigned_types: assigned_types.merge(assignments),
-               declared_types: declared_types.reject {|k, _| k == var })
-      end
-
-      def assign(var, node:, type:)
-        declared_type = declared_types[var]&.type
-
-        if declared_type
-          relation = Subtyping::Relation.new(sub_type: type, super_type: declared_type)
-          constraints = Subtyping::Constraints.new(unknowns: Set.new)
-          subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
-            yield declared_type, type, result
-          end
-
-          self
-        else
-          assignments = { var => Entry.new(type: type, nodes: [node]) }
-          update(assigned_types: assigned_types.merge(assignments))
-        end
-      end
-
-      def annotate(collection)
-        decls = collection.var_type_annotations.each.with_object({}) do |(var, annotation), hash|
-          type = collection.var_type(lvar: var)
-          hash[var] = Entry.new(type: type, annotations: [annotation])
-        end
-
-        decls.each do |var, annot|
-          inner_type = annot.type
-          outer_type = self[var]
-
-          if outer_type
-            relation = Subtyping::Relation.new(sub_type: inner_type, super_type: outer_type)
-            constraints = Subtyping::Constraints.new(unknowns: Set.new)
-            subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
-              if block_given?
-                yield var, outer_type, inner_type, result
-              end
-            end
-          end
-        end
-
-        new_decls = declared_types.merge(decls)
-        new_assigns = assigned_types.reject {|var, _| new_decls.key?(var) }
-
-        update(declared_types: new_decls, assigned_types: new_assigns)
-      end
-
-      def [](var)
-        entry(var)&.type
-      end
-
-      def entry(var)
-        declared_types[var] || assigned_types[var]
-      end
-
-      def pin_assignments
-        update(
-          declared_types: assigned_types.merge(declared_types),
-          assigned_types: {}
-        )
-      end
-
-      def except(variables)
-        update(
-          declared_types: declared_types.reject {|var, _| variables.include?(var) },
-          assigned_types: assigned_types.reject {|var, _| variables.include?(var) }
-        )
-      end
-
-      def subst(s)
-        update(
-          declared_types: declared_types.transform_values {|e| e.update(type: e.type.subst(s)) },
-          assigned_types: assigned_types.transform_values {|e| e.update(type: e.type.subst(s)) }
-        )
-      end
-
-      def each
-        if block_given?
-          vars.each do |var|
-            yield var, self[var]
-          end
-        else
-          enum_for :each
-        end
-      end
-
-      def vars
-        @vars ||= Set.new(declared_types.keys + assigned_types.keys)
-      end
-
-      def join(*envs)
-        if envs.empty?
-          self
-        else
-          env = envs.inject do |env1, env2|
-            assigned_types = {}
-            declared_types = {}
-
-            (env1.vars + env2.vars).each do |var|
-              e1 = env1.entry(var)
-              e2 = env2.entry(var)
-              je = join_entry(e1, e2)
-
-              if env1.declared_types.key?(var) || env2.declared_types.key?(var)
-                declared_types[var] = je
-              else
-                assigned_types[var] = je
-              end
-            end
-
-            LocalVariableTypeEnv.new(
-              subtyping: subtyping,
-              self_type: self_type,
-              declared_types: declared_types,
-              assigned_types: assigned_types,
-              instance_type: instance_type,
-              class_type: class_type
-            )
-          end
-
-          decls = env.declared_types.merge(declared_types)
-          assignments = env.assigned_types.reject {|var, _| decls.key?(var) }
-
-          update(
-            declared_types: decls,
-            assigned_types: assignments,
-          )
-        end
-      end
-
-      def join_entry(e1, e2)
-        case
-        when e1 && e2
-          e1 + e2
-        when e1
-          e1.optional
-        when e2
-          e2.optional
-        else
-          raise
-        end
-      end
-
-      def to_s
-        ss = []
-
-        vars.each do |var|
-          ss << "#{var}: #{self[var].to_s}"
-        end
-
-        "{#{ss.join(", ")}}"
-      end
-    end
-  end
-end

data/lib/steep/type_inference/logic.rb

@@ -1,161 +0,0 @@
-module Steep
-  module TypeInference
-    class Logic
-      class Result
-        attr_reader :nodes
-
-        def initialize(nodes = [])
-          @nodes = Set[].compare_by_identity.merge(nodes)
-        end
-
-        def +(other)
-          Result.new(nodes + other.nodes)
-        end
-
-        def merge(nodes)
-          Result.new(self.nodes + nodes)
-        end
-
-        def vars
-          vars = Set[]
-
-          nodes.each do |node|
-            case node.type
-            when :lvar, :lvasgn
-              vars << node.children[0]
-            end
-          end
-
-          vars
-        end
-      end
-
-      attr_reader :subtyping
-
-      def initialize(subtyping:)
-        @subtyping = subtyping
-      end
-
-      def nodes(node:)
-        case node.type
-        when :lvasgn
-          rhs = node.children[1]
-          t, f = nodes(node: rhs)
-
-          [
-            t.merge([node]),
-            f.merge([node])
-          ]
-
-        when :masgn
-          lhs, rhs = node.children
-
-          lt, lf = nodes(node: lhs)
-          rt, rf = nodes(node: rhs)
-
-          [
-            (lt + rt).merge([node]),
-            (lf + rf).merge([node])
-          ]
-
-        when :mlhs
-          nodes = [node]
-
-          node.children.each do |child|
-            case child.type
-            when :lvasgn
-              nodes << child
-            when :splat
-              if node.children[0].type == :lvasgn
-                nodes << child
-                nodes << child.children[0]
-              end
-            end
-          end
-
-          [
-            Result.new(nodes),
-            Result.new(nodes)
-          ]
-
-        when :and
-          lhs, rhs = node.children
-
-          lt, _ = nodes(node: lhs)
-          rt, _ = nodes(node: rhs)
-
-          [
-            Result.new([node]) + lt + rt,
-            Result.new([node])
-          ]
-
-        when :or
-          lhs, rhs = node.children
-
-          _, lf = nodes(node: lhs)
-          _, rf = nodes(node: rhs)
-
-          [
-            Result.new([node]),
-            Result.new([node]) + lf + rf
-          ]
-
-        when :begin
-          nodes(node: node.children.last)
-
-        else
-          [
-            Result.new([node]),
-            Result.new([node])
-          ]
-        end
-      end
-
-      def environments(truthy_vars:, falsey_vars:, lvar_env:)
-        truthy_hash = lvar_env.assigned_types.dup
-        falsey_hash = lvar_env.assigned_types.dup
-
-        (truthy_vars + falsey_vars).each do |var|
-          type = lvar_env[var]
-          truthy_type, falsey_type = partition_union(type)
-
-          if truthy_vars.include?(var)
-            truthy_hash[var] = LocalVariableTypeEnv::Entry.new(type: truthy_type)
-          end
-
-          if falsey_vars.include?(var)
-            falsey_hash[var] = LocalVariableTypeEnv::Entry.new(type: falsey_type)
-          end
-        end
-
-        [
-          lvar_env.except(truthy_vars).update(assigned_types: truthy_hash),
-          lvar_env.except(falsey_vars).update(assigned_types: falsey_hash)
-        ]
-      end
-
-      def partition_union(type)
-        case type
-        when AST::Types::Union
-          falsey_types, truthy_types = type.types.partition do |type|
-            case type
-            when AST::Types::Nil
-              true
-            when AST::Types::Literal
-              type.value == false
-            end
-          end
-
-          [
-            truthy_types.empty? ? AST::Types::Bot.new : AST::Types::Union.build(types: truthy_types),
-            falsey_types.empty? ? AST::Types::Bot.new : AST::Types::Union.build(types: falsey_types)
-          ]
-        when AST::Types::Any, AST::Types::Top, AST::Types::Boolean, AST::Types::Void
-          [type, type]
-        else
-          [type, AST::Types::Bot.new]
-        end
-      end
-    end
-  end
-end