steep 0.13.0 → 0.16.2

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
 

data/lib/steep/typing.rb

@@ -1,5 +1,17 @@
 module Steep
   class Typing
+    class UnknownNodeError < StandardError
+      attr_reader :op
+      attr_reader :node
+
+      def initialize(op, node:)
+        @op = op
+        @node = node
+        super "Unknown node for #{op}: #{node.inspect}"
+      end
+    end
+
+    attr_reader :source
     attr_reader :errors
     attr_reader :typing
     attr_reader :parent
@@ -7,8 +19,11 @@ module Steep
     attr_reader :last_update
     attr_reader :should_update
     attr_reader :contexts
+    attr_reader :root_context
+
+    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil)
+      @source = source
 
-    def initialize(parent: nil, parent_last_update: parent&.last_update)
       @parent = parent
       @parent_last_update = parent_last_update
       @last_update = parent&.last_update || 0
@@ -16,25 +31,26 @@ module Steep
 
       @errors = []
       @typing = {}.compare_by_identity
-      @contexts = {}.compare_by_identity
+      @root_context = root_context
+      @contexts = contexts || TypeInference::ContextArray.from_source(source: source)
     end
 
     def add_error(error)
       errors << error
     end
 
-    def add_typing(node, type, context)
+    def add_typing(node, type, _context)
       typing[node] = type
-      contexts[node] = context
-
-      if should_update
-        @last_update += 1
-        @should_update = false
-      end
+      @last_update += 1
 
       type
     end
 
+    def add_context(range, context:)
+      contexts.insert_context(range, context: context)
+      @last_update += 1
+    end
+
     def has_type?(node)
       typing.key?(node)
     end
@@ -48,25 +64,72 @@ module Steep
         if parent
           parent.type_of(node: node)
         else
-          raise "Unknown node for typing: #{node.inspect}"
+          raise UnknownNodeError.new(:type, node: node)
         end
       end
     end
 
-    def context_of(node:)
-      ctx = contexts[node]
+    def add_context_for_node(node, context:)
+      begin_pos = node.loc.expression.begin_pos
+      end_pos = node.loc.expression.end_pos
+
+      add_context(begin_pos..end_pos, context: context)
+    end
+
+    def add_context_for_body(node, context:)
+      case node.type
+      when :class
+        name_node, super_node, _ = node.children
+        begin_pos = if super_node
+                      super_node.loc.expression.end_pos
+                    else
+                      name_node.loc.expression.end_pos
+                    end
+        end_pos = node.loc.end.begin_pos
+
+        add_context(begin_pos..end_pos, context: context)
+
+      when :module
+        name_node = node.children[0]
+        begin_pos = name_node.loc.expression.end_pos
+        end_pos = node.loc.end.begin_pos
+        add_context(begin_pos..end_pos, context: context)
+
+      when :def, :defs
+        args_node = case node.type
+                    when :def
+                      node.children[1]
+                    when :defs
+                      node.children[2]
+                    end
+        body_begin_pos = if args_node.loc.expression
+                           args_node.loc.expression.end_pos
+                         else
+                           node.loc.name.end_pos
+                         end
+        body_end_pos = node.loc.end.begin_pos
+        add_context(body_begin_pos..body_end_pos, context: context)
+
+      when :block
+        send_node, args_node, _ = node.children
+        begin_pos = if send_node.type != :lambda && args_node.loc.expression
+                      args_node.loc.expression.end_pos
+                    else
+                      node.loc.begin.end_pos
+                    end
+        end_pos = node.loc.end.begin_pos
+        add_context(begin_pos..end_pos, context: context)
 
-      if ctx
-        ctx
       else
-        if parent
-          parent.context_of(node: node)
-        else
-          raise "Unknown node for context: #{node.inspect}"
-        end
+        raise "Unexpected node for insert_context: #{node.type}"
       end
     end
 
+    def context_at(line:, column:)
+      contexts.at(line: line, column: column) ||
+        (parent ? parent.context_at(line: line, column: column) : root_context)
+    end
+
     def dump(io)
       io.puts "Typing: "
       nodes.each_value do |node|
@@ -87,8 +150,11 @@ module Steep
       "#{line}:#{col}:#{src}"
     end
 
-    def new_child
-      child = self.class.new(parent: self)
+    def new_child(range)
+      child = self.class.new(source: source,
+                             parent: self,
+                             root_context: root_context,
+                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil))
       @should_update = true
 
       if block_given?
@@ -104,12 +170,14 @@ module Steep
 
     def save!
       raise "Unexpected save!" unless parent
-      raise "Parent modified since new_child" unless parent.last_update == parent_last_update
+      raise "Parent modified since #new_child: parent.last_update=#{parent.last_update}, parent_last_update=#{parent_last_update}" unless parent.last_update == parent_last_update
 
       each_typing do |node, type|
-        parent.add_typing(node, type, contexts[node])
+        parent.add_typing(node, type, nil)
       end
 
+      parent.contexts.merge(contexts)
+
       errors.each do |error|
         parent.add_error error
       end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.13.0"
+  VERSION = "0.16.2"
 end

data/smoke/alias/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/alias/a.rb

@@ -1,7 +1,7 @@
 # @type var x: foo
 x = ""
 
-# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::String, actual=::Integer
+# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::string, actual=::Integer
 x + 123
 
 # @type var y: bar

data/smoke/and/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/array/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/array/b.rb

@@ -1,9 +1,7 @@
 x = ""
 y = 1
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = y
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 y = x
 
 # @type var a: Array[Integer]

data/smoke/block/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/case/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/class/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/const/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/dstr/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/ensure/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/enumerator/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/extension/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/extension/c.rb

@@ -5,5 +5,6 @@ class Foo
     # @type var string: String
     # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Object
     string = super()
+    string
   end
 end

data/smoke/hash/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/hello/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end

data/smoke/if/Steepfile

@@ -1,4 +1,5 @@
 target :test do
+  typing_options :strict
   check "*.rb"
   signature "*.rbs"
 end