steep 0.14.0 → 0.16.3

data/lib/steep/type_inference/constant_env.rb

@@ -12,29 +12,21 @@ module Steep
         @cache = {}
         @factory = factory
         @context = context
-        @table = Ruby::Signature::ConstantTable.new(builder: factory.definition_builder)
-      end
-
-      def namespace
-        @namespace ||= if context
-                         context.namespace.append(context.name)
-                       else
-                         AST::Namespace.root
-                       end
+        @table = RBS::ConstantTable.new(builder: factory.definition_builder)
       end
 
       def lookup(name)
         cache[name] ||= begin
           constant = table.resolve_constant_reference(
             factory.type_name_1(name),
-            context: factory.namespace_1(namespace)
+            context: context.map {|namespace| factory.namespace_1(namespace) }
           )
 
           if constant
             factory.type(constant.type)
           end
         rescue => exn
-          Steep.logger.error "Looking up a constant failed: name=#{name}, context=#{context}, error=#{exn.inspect}"
+          Steep.logger.error "Looking up a constant failed: name=#{name}, context=[#{context.join(", ")}], error=#{exn.inspect}"
           nil
         end
       end

data/lib/steep/type_inference/context.rb

@@ -48,6 +48,7 @@ module Steep
         attr_reader :defined_module_methods
         attr_reader :const_env
         attr_reader :implement_name
+        attr_reader :namespaces
         attr_reader :current_namespace
         attr_reader :class_name
         attr_reader :instance_definition
@@ -77,14 +78,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 +95,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