steep 0.14.0 → 0.15.0

data/lib/steep/type_inference/constant_env.rb

@@ -12,7 +12,7 @@ module Steep
         @cache = {}
         @factory = factory
         @context = context
-        @table = Ruby::Signature::ConstantTable.new(builder: factory.definition_builder)
+        @table = RBS::ConstantTable.new(builder: factory.definition_builder)
       end
 
       def namespace

data/lib/steep/type_inference/context.rb

@@ -77,14 +77,16 @@ module Steep
       attr_reader :module_context
       attr_reader :self_type
       attr_reader :type_env
+      attr_reader :lvar_env
 
-      def initialize(method_context:, block_context:, break_context:, module_context:, self_type:, type_env:)
+      def initialize(method_context:, block_context:, break_context:, module_context:, self_type:, type_env:, lvar_env:)
         @method_context = method_context
         @block_context = block_context
         @break_context = break_context
         @module_context = module_context
         @self_type = self_type
         @type_env = type_env
+        @lvar_env = lvar_env
       end
 
       def with(method_context: self.method_context,
@@ -92,14 +94,16 @@ module Steep
                break_context: self.break_context,
                module_context: self.module_context,
                self_type: self.self_type,
-               type_env: self.type_env)
+               type_env: self.type_env,
+               lvar_env: self.lvar_env)
         self.class.new(
           method_context: method_context,
           block_context: block_context,
           break_context: break_context,
           module_context: module_context,
           self_type: self_type,
-          type_env: type_env
+          type_env: type_env,
+          lvar_env: lvar_env
         )
       end
     end

data/lib/steep/type_inference/context_array.rb

@@ -0,0 +1,111 @@
+module Steep
+  module TypeInference
+    class ContextArray
+      class Entry
+        attr_reader :range, :context, :sub_entries
+
+        def initialize(range:, context:)
+          @range = range
+          @context = context
+          @sub_entries = Set[].compare_by_identity
+        end
+      end
+
+      attr_reader :buffer
+      attr_reader :root
+
+      def initialize(buffer:, context:, range: 0..buffer.content.size)
+        @buffer = buffer
+        @root = Entry.new(range: range, context: context)
+      end
+
+      def range
+        root.range
+      end
+
+      def self.from_source(source:, range: nil, context: nil)
+        content = if source.node
+                    source.node.location.expression.source_buffer.source
+                  else
+                    ""
+                  end
+        buffer = AST::Buffer.new(name: source.path, content: content)
+        new(buffer: buffer, context: context, range: range || 0..buffer.content.size)
+      end
+
+      def insert_context(range, context:, entry: self.root)
+        entry.sub_entries.each do |sub|
+          next if sub.range.begin < range.begin && range.end <= sub.range.end
+          next if range.begin < sub.range.begin && sub.range.end <= range.end
+          next if range.end <= sub.range.begin
+          next if sub.range.end <= range.begin
+
+          raise "Range crossing: sub range=#{sub.range}, new range=#{range}"
+        end
+
+        sup = entry.sub_entries.find do |sub|
+          sub.range.begin < range.begin && range.end <= sub.range.end
+        end
+
+        if sup
+          insert_context(range, context: context, entry: sup)
+        else
+          subs = entry.sub_entries.select do |sub|
+            range.begin < sub.range.begin && sub.range.end <= range.end
+          end
+
+          new_entry = Entry.new(range: range, context: context)
+          entry.sub_entries.subtract(subs)
+          new_entry.sub_entries.merge(subs)
+          entry.sub_entries << new_entry
+        end
+      end
+
+      def each_entry
+        if block_given?
+          es = [root]
+
+          until es.empty?
+            e = es.pop
+            es.push(*e.sub_entries.to_a)
+
+            yield e
+          end
+        else
+          enum_for :each_entry
+        end
+      end
+
+      def context_at(index, entry: self.root)
+        return nil if index < entry.range.begin || entry.range.end < index
+
+        sub = entry.sub_entries.find do |sub|
+          sub.range.begin <= index && index <= sub.range.end
+        end
+
+        if sub
+          context_at(index, entry: sub)
+        else
+          entry.context
+        end
+      end
+
+      def [](index)
+        context_at(index)
+      end
+
+      def at(line:, column:)
+        pos = buffer.loc_to_pos([line, column])
+        self[pos]
+      end
+
+      def merge(subtree)
+        subtree.each_entry do |entry|
+          if entry.context
+            insert_context entry.range, context: entry.context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/local_variable_type_env.rb

@@ -0,0 +1,226 @@
+module Steep
+  module TypeInference
+    class LocalVariableTypeEnv
+      attr_reader :subtyping
+      attr_reader :self_type
+
+      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 :declared_types
+      attr_reader :assigned_types
+
+      def self.empty(subtyping:, self_type:)
+        new(subtyping: subtyping, declared_types: {}, assigned_types: {}, self_type: self_type)
+      end
+
+      def initialize(subtyping:, declared_types:, assigned_types:, self_type:)
+        @subtyping = subtyping
+        @self_type = self_type
+
+        @declared_types = declared_types
+        @assigned_types = assigned_types
+
+        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)
+        self.class.new(
+          subtyping: subtyping,
+          declared_types: declared_types,
+          assigned_types: assigned_types,
+          self_type: self_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).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).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).else do |result|
+              yield var, outer_type, inner_type, result
+            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 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
+            )
+          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

@@ -0,0 +1,130 @@
+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].name
+            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 :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

data/lib/steep/type_inference/type_env.rb

@@ -2,7 +2,6 @@ module Steep
   module TypeInference
     class TypeEnv
       attr_reader :subtyping
-      attr_reader :lvar_types
       attr_reader :const_types
       attr_reader :gvar_types
       attr_reader :ivar_types
@@ -10,7 +9,6 @@ module Steep
 
       def initialize(subtyping:, const_env:)
         @subtyping = subtyping
-        @lvar_types = {}
         @const_types = {}
         @gvar_types = {}
         @ivar_types = {}
@@ -19,7 +17,6 @@ module Steep
 
       def initialize_copy(other)
         @subtyping = other.subtyping
-        @lvar_types = other.lvar_types.dup
         @const_types = other.const_types.dup
         @gvar_types = other.gvar_types.dup
         @ivar_types = other.ivar_types.dup
@@ -28,9 +25,6 @@ module Steep
 
       def self.build(annotations:, signatures:, subtyping:, const_env:)
         new(subtyping: subtyping, const_env: const_env).tap do |env|
-          annotations.lvar_types.each do |name, type|
-            env.set(lvar: name, type: type)
-          end
           annotations.ivar_types.each do |name, type|
             env.set(ivar: name, type: type)
           end
@@ -38,15 +32,14 @@ module Steep
             env.set(const: name, type: type)
           end
           signatures.name_to_global.each do |name, global|
-            type = signatures.absolute_type(global.type, namespace: Ruby::Signature::Namespace.root) {|ty| ty.name.absolute! }
+            type = signatures.absolute_type(global.type, namespace: RBS::Namespace.root) {|ty| ty.name.absolute! }
             env.set(gvar: name, type: subtyping.factory.type(type))
           end
         end
       end
 
-      def with_annotations(lvar_types: {}, ivar_types: {}, const_types: {}, gvar_types: {}, self_type:, &block)
+      def with_annotations(ivar_types: {}, const_types: {}, gvar_types: {}, self_type:, &block)
         dup.tap do |env|
-          merge!(original_env: env.lvar_types, override_env: lvar_types, self_type: self_type, &block)
           merge!(original_env: env.ivar_types, override_env: ivar_types, self_type: self_type, &block)
           merge!(original_env: env.gvar_types, override_env: gvar_types, self_type: self_type, &block)
 
@@ -64,44 +57,11 @@ module Steep
         end
       end
 
-      def join!(envs)
-        lvars = {}
-
-        common_vars = envs.map {|env| Set.new(env.lvar_types.keys) }.inject {|a, b| a & b }
-
-        envs.each do |env|
-          env.lvar_types.each do |name, type|
-            unless lvar_types.key?(name)
-              lvars[name] = [] unless lvars[name]
-              lvars[name] << type
-            end
-          end
-        end
-
-        lvars.each do |name, types|
-          if lvar_types.key?(name) || common_vars.member?(name)
-            set(lvar: name, type: AST::Types::Union.build(types: types))
-          else
-            set(lvar: name, type: AST::Types::Union.build(types: types + [AST::Types::Nil.new]))
-          end
-        end
-      end
-
       # @type method assert: (const: Names::Module) { () -> void } -> AST::Type
       #                    | (gvar: Symbol) { () -> void } -> AST::Type
       #                    | (ivar: Symbol) { () -> void } -> AST::Type
-      #                    | (lvar: Symbol) { () -> AST::Type | nil } -> AST::Type
-      def get(lvar: nil, const: nil, gvar: nil, ivar: nil)
+      def get(const: nil, gvar: nil, ivar: nil)
         case
-        when lvar
-          lvar_name(lvar).yield_self do |name|
-            if lvar_types.key?(name)
-              lvar_types[name]
-            else
-              ty = yield
-              lvar_types[name] = ty || AST::Types::Any.new
-            end
-          end
         when const
           if const_types.key?(const)
             const_types[const]
@@ -127,12 +87,8 @@ module Steep
         end
       end
 
-      def set(lvar: nil, const: nil, gvar: nil, ivar: nil, type:)
+      def set(const: nil, gvar: nil, ivar: nil, type:)
         case
-        when lvar
-          lvar_name(lvar).yield_self do |name|
-            lvar_types[name] = type
-          end
         when const
           const_types[const] = type
         else
@@ -145,19 +101,8 @@ module Steep
       # @type method assign: (const: Names::Module, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (gvar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (ivar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
-      #                    | (lvar: Symbol | LabeledName, type: AST::Type) { (Subtyping::Result::Failure) -> void } -> AST::Type
-      def assign(lvar: nil, const: nil, gvar: nil, ivar: nil, type:, self_type:, &block)
+      def assign(const: nil, gvar: nil, ivar: nil, type:, self_type:, &block)
         case
-        when lvar
-          yield_self do
-            name = lvar_name(lvar)
-            var_type = lvar_types[name]
-            if var_type
-              assert_assign(var_type: var_type, lhs_type: type, self_type: self_type, &block)
-            else
-              lvar_types[name] = type
-            end
-          end
         when const
           yield_self do
             const_type = const_types[const] || const_env.lookup(const)
@@ -189,15 +134,6 @@ module Steep
         end
       end
 
-      def lvar_name(lvar)
-        case lvar
-        when Symbol
-          lvar
-        when ASTUtils::Labeling::LabeledName
-          lvar.name
-        end
-      end
-
       def assert_assign(var_type:, lhs_type:, self_type:)
         return var_type if var_type == lhs_type