steep 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3a5b5a55253f50083410cd7d58bf7cda545301d9a7d5b72a5a8fd3865a76e93
-  data.tar.gz: fcf1273fc81c720266d4cdf2456d996b8f406137b204bb22fe1ad25852850a0a
+  metadata.gz: 0e95857ced793435c07c948b2a51ac914c52816811ae8e5d18337bcf946eb33d
+  data.tar.gz: 9038e63999222be3e0b7172aa423056ef7792b905e1d277271fa795b6ca06889
 SHA512:
-  metadata.gz: a6e6dc76cf7aaf2cdf97965733d6762a1fb75d314d0dd8f859cc617296a433a002a512c829828a927bc43718e2f44776332f1c739d894460d8828195853a24c9
-  data.tar.gz: c3daca75b0a4846302665a9d165f13de175e1e5436d3605fa5c53948bc5548b1a36a19a43e4200d4f3b37ce257e8369ec645602ccb15b419b5fae0f1c34e39b1
+  metadata.gz: 2747b3e5f3303ae48a91e76b2256cd1e402e7022caa714083267da0820f1bce2d81188586e551a10158d4c6716ab7a8db8562aa84b31c98731872b08d05048c9
+  data.tar.gz: 9d5bd44685d8228ee304bdaf94ae52e5eef2a2871580e7190ef941ea510406eab28bdb3aa6849fd9234649da10cd9344e2c38ba309a11a73cca70c6ed7e946e3

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.13.0 (2020-02-16)
+
+* Improve LSP _hover_ support. ([#117](https://github.com/soutaro/steep/pull/117))
+
 ## 0.12.0 (2020-02-11)
 
 * Add `Steepfile` for configuration

data/README.md

@@ -204,6 +204,14 @@ Generally, these are by our design.
 
 You can find examples in `smoke` directory.
 
+## IDEs
+
+Steep implements some of the Language Server Protocol features. You can use Steep with VSCode and its plugin.
+
+- https://github.com/soutaro/steep-vscode
+
+Other LSP supporting tools may work with Steep where it starts the server as `steep langserver`.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/steep.rb

@@ -60,6 +60,7 @@ require "steep/annotation_parser"
 require "steep/typing"
 require "steep/errors"
 require "steep/type_construction"
+require "steep/type_inference/context"
 require "steep/type_inference/send_args"
 require "steep/type_inference/block_params"
 require "steep/type_inference/constant_env"
@@ -72,6 +73,7 @@ require "steep/project/options"
 require "steep/project/target"
 require "steep/project/dsl"
 require "steep/project/file_loader"
+require "steep/project/hover_content"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/validate"

data/lib/steep/drivers/langserver.rb

@@ -187,6 +187,8 @@ module Steep
                                   [diagnostics_raw(source.status.error.message, source.status.location)]
                                 when Project::SourceFile::ParseErrorStatus
                                   []
+                                when Project::SourceFile::TypeCheckErrorStatus
+                                  []
                                 end
 
                   report_diagnostics source.path, diagnostics
@@ -264,22 +266,71 @@ module Steep
       def response_to_hover(path:, line:, column:)
         Steep.logger.info { "path=#{path}, line=#{line}, column=#{column}" }
 
-        # line in LSP is zero-origin
-        project.type_of_node(path: path, line: line + 1, column: column) do |type, node|
-          Steep.logger.warn { "node = #{node.type}, type = #{type.to_s}" }
-
-          start_position = { line: node.location.line - 1, character: node.location.column }
-          end_position = { line: node.location.last_line - 1, character: node.location.last_column }
-          range = { start: start_position, end: end_position }
-
-          Steep.logger.warn { "range = #{range.inspect}" }
+        hover = Project::HoverContent.new(project: project)
+        content = hover.content_for(path: path, line: line+1, column: column+1)
+        if content
+          range = content.location.yield_self do |location|
+            start_position = { line: location.line - 1, character: location.column }
+            end_position = { line: location.last_line - 1, character: location.last_column }
+            { start: start_position, end: end_position }
+          end
 
           LanguageServer::Protocol::Interface::Hover.new(
-            contents: { kind: "markdown", value: "`#{type}`" },
+            contents: { kind: "markdown", value: format_hover(content) },
             range: range
           )
         end
       end
+
+      def format_hover(content)
+        case content
+        when Project::HoverContent::VariableContent
+          "`#{content.name}`: `#{content.type.to_s}`"
+        when Project::HoverContent::MethodCallContent
+          method_name = case content.method_name
+                        when Project::HoverContent::InstanceMethodName
+                          "#{content.method_name.class_name}##{content.method_name.method_name}"
+                        when Project::HoverContent::SingletonMethodName
+                          "#{content.method_name.class_name}.#{content.method_name.method_name}"
+                        else
+                          nil
+                        end
+
+          if method_name
+            string = <<HOVER
+```
+#{method_name} ~> #{content.type}
+```
+HOVER
+            if content.definition
+              if content.definition.comment
+                string << "\n----\n\n#{content.definition.comment.string}"
+              end
+
+              string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
+            end
+          else
+            "`#{content.type}`"
+          end
+        when Project::HoverContent::DefinitionContent
+          string = <<HOVER
+```
+def #{content.method_name}: #{content.method_type}
+```
+HOVER
+          if (comment = content.definition.comment)
+            string << "\n----\n\n#{comment.string}\n"
+          end
+
+          if content.definition.method_types.size > 1
+            string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
+          end
+
+          string
+        when Project::HoverContent::TypeContent
+          "`#{content.type}`"
+        end
+      end
     end
   end
 end

data/lib/steep/interface/substitution.rb

@@ -1,6 +1,18 @@
 module Steep
   module Interface
     class Substitution
+      class InvalidSubstitutionError < StandardError
+        attr_reader :vars_size
+        attr_reader :types_size
+
+        def initialize(vars_size:, types_size:)
+          @var_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
@@ -42,7 +54,7 @@ module Steep
       def self.build(vars, types = nil, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
         types ||= vars.map {|var| AST::Types::Var.fresh(var) }
 
-        raise "Invalid substitution: vars.size=#{vars.size}, types.size=#{types.size}" unless vars.size == types.size
+        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|
           d[var] = type

data/lib/steep/project.rb

@@ -24,6 +24,7 @@ module Steep
       source_file = targets.map {|target| target.source_files[path] }.compact[0]
 
       if source_file
+
         case (status = source_file.status)
         when SourceFile::TypeCheckStatus
           node = status.source.find_node(line: line, column: column)

data/lib/steep/project/file.rb

@@ -11,6 +11,7 @@ module Steep
       ParseErrorStatus = Struct.new(:error, keyword_init: true)
       AnnotationSyntaxErrorStatus = Struct.new(:error, :location, keyword_init: true)
       TypeCheckStatus = Struct.new(:typing, :source, :timestamp, keyword_init: true)
+      TypeCheckErrorStatus = Struct.new(:error, keyword_init: true)
 
       def initialize(path:)
         @path = path
@@ -62,20 +63,22 @@ module Steep
               checker: subtyping,
               annotations: annotations,
               source: source,
-              self_type: AST::Builtin::Object.instance_type,
-              block_context: nil,
-              module_context: TypeConstruction::ModuleContext.new(
-                instance_type: nil,
-                module_type: nil,
-                implement_name: nil,
-                current_namespace: AST::Namespace.root,
-                const_env: const_env,
-                class_name: nil
+              context: TypeInference::Context.new(
+                block_context: nil,
+                module_context: TypeInference::Context::ModuleContext.new(
+                  instance_type: nil,
+                  module_type: nil,
+                  implement_name: nil,
+                  current_namespace: AST::Namespace.root,
+                  const_env: const_env,
+                  class_name: nil
+                ),
+                method_context: nil,
+                break_context: nil,
+                self_type: AST::Builtin::Object.instance_type,
+                type_env: type_env
               ),
-              method_context: nil,
-              typing: typing,
-              break_context: nil,
-              type_env: type_env
+              typing: typing
             )
 
             construction.synthesize(source.node)
@@ -86,6 +89,8 @@ module Steep
             source: source,
             timestamp: Time.now
           )
+        rescue => exn
+          @status = TypeCheckErrorStatus.new(error: exn)
         end
 
         true

data/lib/steep/project/hover_content.rb

@@ -0,0 +1,128 @@
+module Steep
+  class Project
+    class HoverContent
+      TypeContent = Struct.new(:node, :type, :location, keyword_init: true)
+      VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
+      MethodCallContent = Struct.new(:node, :method_name, :type, :definition, :location, keyword_init: true)
+      DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+
+      InstanceMethodName = Struct.new(:class_name, :method_name)
+      SingletonMethodName = Struct.new(:class_name, :method_name)
+
+      attr_reader :project
+
+      def initialize(project:)
+        @project = project
+      end
+
+      def method_definition_for(factory, module_name, singleton_method: nil, instance_method: nil)
+        type_name = factory.type_name_1(module_name)
+
+        case
+        when instance_method
+          factory.definition_builder.build_instance(type_name).methods[instance_method]
+        when singleton_method
+          methods = factory.definition_builder.build_singleton(type_name).methods
+
+          if singleton_method == :new
+            methods[:new] || methods[:initialize]
+          else
+            methods[singleton_method]
+          end
+        end
+      end
+
+      def content_for(path:, line:, column:)
+        source_file = project.targets.map {|target| target.source_files[path] }.compact[0]
+
+        if source_file
+          case (status = source_file.status)
+          when SourceFile::TypeCheckStatus
+            node, *parents = status.source.find_nodes(line: line, column: column)
+
+            if node
+              case node.type
+              when :lvar, :lvasgn
+                var_name = node.children[0]
+                context = status.typing.context_of(node: node)
+                var_type = context.type_env.get(lvar: var_name.name)
+
+                VariableContent.new(node: node, name: var_name.name, type: var_type, location: node.location.name)
+              when :send
+                receiver, method_name, *_ = node.children
+
+
+                result_node = if parents[0]&.type == :block
+                                parents[0]
+                              else
+                                node
+                              end
+
+                context = status.typing.context_of(node: result_node)
+
+                receiver_type = if receiver
+                                  status.typing.type_of(node: receiver)
+                                else
+                                  context.self_type
+                                end
+
+                factory = context.type_env.subtyping.factory
+                method_name, definition = case receiver_type
+                                          when AST::Types::Name::Instance
+                                            method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
+                                            if method_definition&.defined_in
+                                              owner_name = factory.type_name(method_definition.defined_in.name.absolute!)
+                                              [
+                                                InstanceMethodName.new(owner_name, method_name),
+                                                method_definition
+                                              ]
+                                            end
+                                          when AST::Types::Name::Class
+                                            method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
+                                            if method_definition&.defined_in
+                                              owner_name = factory.type_name(method_definition.defined_in.name.absolute!)
+                                              [
+                                                SingletonMethodName.new(owner_name, method_name),
+                                                method_definition
+                                              ]
+                                            end
+                                          else
+                                            nil
+                                          end
+
+                MethodCallContent.new(
+                  node: node,
+                  method_name: method_name,
+                  type: status.typing.type_of(node: result_node),
+                  definition: definition,
+                  location: result_node.location.expression
+                )
+              when :def, :defs
+                context = status.typing.context_of(node: node)
+                method_context = context.method_context
+
+                if method_context
+                  DefinitionContent.new(
+                    node: node,
+                    method_name: method_context.name,
+                    method_type: method_context.method_type,
+                    definition: method_context.method,
+                    location: node.loc.expression
+                  )
+                end
+              else
+                type = status.typing.type_of(node: node)
+
+                TypeContent.new(
+                  node: node,
+                  type: type,
+                  location: node.location.expression
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/source.rb

@@ -294,8 +294,7 @@ module Steep
       end
     end
 
-    # @type method find_node: (line: Integer, column: Integer, ?node: any, ?position: Integer?) -> any
-    def find_node(line:, column:, node: self.node, position: nil)
+    def find_nodes(line:, column:, node: self.node, position: nil, parents: [])
       position ||= (line-1).times.sum do |i|
         node.location.expression.source_buffer.source_line(i+1).size + 1
       end + column
@@ -306,14 +305,13 @@ module Steep
 
       if range
         if range === position
+          parents.unshift node
+
           Source.each_child_node(node) do |child|
-            n = find_node(line: line, column: column, node: child, position: position)
-            if n
-              return n
-            end
+            ns = find_nodes(line: line, column: column, node: child, position: position, parents: parents) and return ns
           end
 
-          node
+          parents
         end
       end
     end

data/lib/steep/type_construction.rb

@@ -1,97 +1,43 @@
 module Steep
   class TypeConstruction
-    class MethodContext
-      attr_reader :name
-      attr_reader :method
-      attr_reader :method_type
-      attr_reader :return_type
-      attr_reader :constructor
-      attr_reader :super_method
-
-      def initialize(name:, method:, method_type:, return_type:, constructor:, super_method:)
-        @name = name
-        @method = method
-        @return_type = return_type
-        @method_type = method_type
-        @constructor = constructor
-        @super_method = super_method
-      end
-
-      def block_type
-        method_type&.block
-      end
-    end
+    attr_reader :checker
+    attr_reader :source
+    attr_reader :annotations
+    attr_reader :typing
+    attr_reader :type_env
 
-    class BlockContext
-      attr_reader :body_type
+    attr_reader :context
 
-      def initialize(body_type:)
-        @body_type = body_type
-      end
+    def module_context
+      context.module_context
     end
 
-    class BreakContext
-      attr_reader :break_type
-      attr_reader :next_type
+    def method_context
+      context.method_context
+    end
 
-      def initialize(break_type:, next_type:)
-        @break_type = break_type
-        @next_type = next_type
-      end
+    def block_context
+      context.block_context
     end
 
-    class ModuleContext
-      attr_reader :instance_type
-      attr_reader :module_type
-      attr_reader :defined_instance_methods
-      attr_reader :defined_module_methods
-      attr_reader :const_env
-      attr_reader :implement_name
-      attr_reader :current_namespace
-      attr_reader :class_name
-      attr_reader :instance_definition
-      attr_reader :module_definition
-
-      def initialize(instance_type:, module_type:, implement_name:, current_namespace:, const_env:, class_name:, instance_definition: nil, module_definition: nil)
-        @instance_type = instance_type
-        @module_type = module_type
-        @defined_instance_methods = Set.new
-        @defined_module_methods = Set.new
-        @implement_name = implement_name
-        @current_namespace = current_namespace
-        @const_env = const_env
-        @class_name = class_name
-        @instance_definition = instance_definition
-        @module_definition = module_definition
-      end
+    def break_context
+      context.break_context
+    end
 
-      def const_context
-        const_env.context
-      end
+    def self_type
+      context.self_type
     end
 
-    attr_reader :checker
-    attr_reader :source
-    attr_reader :annotations
-    attr_reader :typing
-    attr_reader :method_context
-    attr_reader :block_context
-    attr_reader :module_context
-    attr_reader :self_type
-    attr_reader :break_context
-    attr_reader :type_env
+    def type_env
+      context.type_env
+    end
 
-    def initialize(checker:, source:, annotations:, type_env:, typing:, self_type:, method_context:, block_context:, module_context:, break_context:)
+    def initialize(checker:, source:, annotations:, typing:, context:)
       @checker = checker
       @source = source
       @annotations = annotations
       @typing = typing
-      @self_type = self_type
-      @block_context = block_context
-      @method_context = method_context
-      @module_context = module_context
-      @break_context = break_context
-      @type_env = type_env
+      @context = context
     end
 
     def with_new_typing(typing)
@@ -99,13 +45,8 @@ module Steep
         checker: checker,
         source: source,
         annotations: annotations,
-        type_env: type_env,
         typing: typing,
-        self_type: self_type,
-        method_context: method_context,
-        block_context: block_context,
-        module_context: module_context,
-        break_context: break_context
+        context: context
       )
     end
 
@@ -173,7 +114,7 @@ module Steep
                        end
                      end
 
-      method_context = MethodContext.new(
+      method_context = TypeInference::Context::MethodContext.new(
         name: method_name,
         method: definition && definition.methods[method_name],
         method_type: method_type,
@@ -205,13 +146,15 @@ module Steep
         checker: checker,
         source: source,
         annotations: annots,
-        type_env: type_env,
-        block_context: nil,
-        self_type: annots.self_type || self_type,
-        method_context: method_context,
+        context: TypeInference::Context.new(
+          method_context: method_context,
+          module_context: module_context,
+          block_context: nil,
+          break_context: nil,
+          self_type: annots.self_type || self_type,
+          type_env: type_env
+        ),
         typing: typing,
-        module_context: module_context,
-        break_context: nil
       )
     end
 
@@ -283,7 +226,7 @@ module Steep
                       end
       module_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
-      module_context_ = ModuleContext.new(
+      module_context_ = TypeInference::Context::ModuleContext.new(
         instance_type: instance_type,
         module_type: annots.self_type || module_type,
         implement_name: implement_module_name,
@@ -303,13 +246,15 @@ module Steep
         checker: checker,
         source: source,
         annotations: annots,
-        type_env: module_type_env,
         typing: typing,
-        method_context: nil,
-        block_context: nil,
-        module_context: module_context_,
-        self_type: module_context_.module_type,
-        break_context: nil
+        context: TypeInference::Context.new(
+          method_context: nil,
+          block_context: nil,
+          break_context: nil,
+          module_context: module_context_,
+          self_type: module_context_.module_type,
+          type_env: module_type_env
+        )
       )
     end
 
@@ -380,7 +325,7 @@ module Steep
                       end
       class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
-      module_context = ModuleContext.new(
+      module_context = TypeInference::Context::ModuleContext.new(
         instance_type: annots.instance_type || instance_type,
         module_type: annots.self_type || annots.module_type || module_type,
         implement_name: implement_module_name,
@@ -401,21 +346,21 @@ module Steep
         checker: checker,
         source: source,
         annotations: annots,
-        type_env: class_type_env,
         typing: typing,
-        method_context: nil,
-        block_context: nil,
-        module_context: module_context,
-        self_type: module_context.module_type,
-        break_context: nil
+        context: TypeInference::Context.new(
+          method_context: nil,
+          block_context: nil,
+          module_context: module_context,
+          break_context: nil,
+          self_type: module_context.module_type,
+          type_env: class_type_env
+        )
       )
     end
 
-    def for_branch(node, truthy_vars: Set.new, type_case_override: nil)
+    def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
-      type_env = self.type_env
-
       lvar_types = self.type_env.lvar_types.each.with_object({}) do |(var, type), env|
         if truthy_vars.member?(var)
           env[var] = unwrap(type)
@@ -423,7 +368,8 @@ module Steep
           env[var] = type
         end
       end
-      type_env = type_env.with_annotations(lvar_types: lvar_types, self_type: self_type) do |var, relation, result|
+
+      type_env = self.type_env.with_annotations(lvar_types: lvar_types, self_type: self_type) do |var, relation, result|
         raise "Unexpected annotate failure: #{relation}"
       end
 
@@ -453,23 +399,18 @@ module Steep
         )
       end
 
-      with(type_env: type_env)
+      with(context: context.with(type_env: type_env, break_context: break_context))
     end
 
     NOTHING = ::Object.new
 
-    def with(annotations: NOTHING, type_env: NOTHING, method_context: NOTHING, block_context: NOTHING, module_context: NOTHING, self_type: NOTHING, break_context: NOTHING)
+    def with(annotations: NOTHING, context: NOTHING)
       self.class.new(
         checker: checker,
         source: source,
         annotations: annotations.equal?(NOTHING) ? self.annotations : annotations,
-        type_env: type_env.equal?(NOTHING) ? self.type_env : type_env,
         typing: typing,
-        method_context: method_context.equal?(NOTHING) ? self.method_context : method_context,
-        block_context: block_context.equal?(NOTHING) ? self.block_context : block_context,
-        module_context: module_context.equal?(NOTHING) ? self.module_context : module_context,
-        self_type: self_type.equal?(NOTHING) ? self.self_type : self_type,
-        break_context: break_context.equal?(NOTHING) ? self.break_context : break_context
+        context: context.equal?(NOTHING) ? self.context : context
       )
     end
 
@@ -489,7 +430,7 @@ module Steep
               type = AST::Builtin.nil_type
             end
 
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :lvasgn
@@ -500,9 +441,9 @@ module Steep
             case var.name
             when :_, :__any__
               synthesize(rhs, hint: AST::Builtin.any_type)
-              typing.add_typing(node, AST::Builtin.any_type)
+              typing.add_typing(node, AST::Builtin.any_type, context)
             when :__skip__
-              typing.add_typing(node, AST::Builtin.any_type)
+              typing.add_typing(node, AST::Builtin.any_type, context)
             else
               type_assignment(var, rhs, node, hint: hint)
             end
@@ -515,7 +456,7 @@ module Steep
               fallback_to_any node
             end
 
-            typing.add_typing node, type
+            typing.add_typing node, type, context
           end
 
         when :ivasgn
@@ -530,7 +471,7 @@ module Steep
             type = type_env.get(ivar: name) do
               fallback_to_any node
             end
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :send
@@ -543,7 +484,7 @@ module Steep
                        module_type
                      end
 
-              typing.add_typing(node, type)
+              typing.add_typing(node, type, context)
             else
               type_send(node, send_node: node, block_params: nil, block_body: nil)
             end
@@ -558,7 +499,7 @@ module Steep
                             else
                               module_type
                             end
-                     typing.add_typing(node, type)
+                     typing.add_typing(node, type, context)
                    else
                      type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true)
                    end
@@ -570,7 +511,7 @@ module Steep
           each_child_node(node) do |child|
             synthesize(child)
           end
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :op_asgn
           yield_self do
@@ -594,7 +535,7 @@ module Steep
 
             case
             when lhs_type == AST::Builtin.any_type
-              typing.add_typing(node, lhs_type)
+              typing.add_typing(node, lhs_type, context)
             when !lhs_type
               fallback_to_any(node)
             else
@@ -627,7 +568,7 @@ module Steep
                 typing.add_error Errors::NoMethod.new(node: node, method: op, type: expand_self(lhs_type))
               end
 
-              typing.add_typing(node, lhs_type)
+              typing.add_typing(node, lhs_type, context)
             end
           end
 
@@ -656,7 +597,7 @@ module Steep
                                                   block_body: nil,
                                                   topdown_hint: true)
 
-                typing.add_typing node, return_type
+                typing.add_typing node, return_type, context
               else
                 fallback_to_any node do
                   Errors::UnexpectedSuper.new(node: node, method: method_context.name)
@@ -717,7 +658,7 @@ module Steep
             module_context.defined_instance_methods << node.children[0]
           end
 
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, new.context)
 
         when :defs
           synthesize(node.children[0]).tap do |self_type|
@@ -762,7 +703,7 @@ module Steep
             end
           end
 
-          typing.add_typing(node, AST::Builtin::Symbol.instance_type)
+          typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
 
         when :return
           yield_self do
@@ -791,7 +732,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, AST::Builtin.any_type)
+            typing.add_typing(node, AST::Builtin.any_type, context)
           end
 
         when :break
@@ -817,7 +758,7 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :next
           value = node.children[0]
@@ -842,13 +783,13 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :retry
           unless break_context
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :arg, :kwarg, :procarg0
           yield_self do
@@ -856,7 +797,7 @@ module Steep
             type = type_env.get(lvar: var.name) do
               fallback_to_any node
             end
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :optarg, :kwoptarg
@@ -874,7 +815,7 @@ module Steep
               AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
 
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :kwrestarg
@@ -885,23 +826,23 @@ module Steep
               AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
 
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :float
-          typing.add_typing(node, AST::Builtin::Float.instance_type)
+          typing.add_typing(node, AST::Builtin::Float.instance_type, context)
 
         when :nil
-          typing.add_typing(node, AST::Builtin.nil_type)
+          typing.add_typing(node, AST::Builtin.nil_type, context)
 
         when :int
           yield_self do
             literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
-              typing.add_typing(node, literal_type)
+              typing.add_typing(node, literal_type, context)
             else
-              typing.add_typing(node, AST::Builtin::Integer.instance_type)
+              typing.add_typing(node, AST::Builtin::Integer.instance_type, context)
             end
           end
 
@@ -910,9 +851,9 @@ module Steep
             literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
-              typing.add_typing(node, literal_type)
+              typing.add_typing(node, literal_type, context)
             else
-              typing.add_typing(node, AST::Builtin::Symbol.instance_type)
+              typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
             end
           end
 
@@ -921,14 +862,14 @@ module Steep
             literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
-              typing.add_typing(node, literal_type)
+              typing.add_typing(node, literal_type, context)
             else
-              typing.add_typing(node, AST::Builtin::String.instance_type)
+              typing.add_typing(node, AST::Builtin::String.instance_type, context)
             end
           end
 
         when :true, :false
-          typing.add_typing(node, AST::Types::Boolean.new)
+          typing.add_typing(node, AST::Types::Boolean.new, context)
 
         when :hash
           yield_self do
@@ -975,7 +916,7 @@ module Steep
               typing.add_error Errors::FallbackAny.new(node: node)
             end
 
-            typing.add_typing(node, AST::Builtin::Hash.instance_type(key_type, value_type))
+            typing.add_typing(node, AST::Builtin::Hash.instance_type(key_type, value_type), context)
           end
 
         when :dstr, :xstr
@@ -983,14 +924,14 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::String.instance_type)
+          typing.add_typing(node, AST::Builtin::String.instance_type, context)
 
         when :dsym
           each_child_node(node) do |child|
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::Symbol.instance_type)
+          typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
 
         when :class
           yield_self do
@@ -1002,7 +943,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, AST::Builtin.nil_type)
+            typing.add_typing(node, AST::Builtin.nil_type, context)
           end
 
         when :module
@@ -1015,11 +956,11 @@ module Steep
               end
             end
 
-            typing.add_typing(node, AST::Builtin.nil_type)
+            typing.add_typing(node, AST::Builtin.nil_type, context)
           end
 
         when :self
-          typing.add_typing node, AST::Types::Self.new
+          typing.add_typing node, AST::Types::Self.new, context
 
         when :const
           const_name = Names::Module.from_node(node)
@@ -1027,7 +968,7 @@ module Steep
             type = type_env.get(const: const_name) do
               fallback_to_any node
             end
-            typing.add_typing node, type
+            typing.add_typing node, type, context
           else
             fallback_to_any node
           end
@@ -1050,7 +991,7 @@ module Steep
                 end
               end
 
-              typing.add_typing(node, type)
+              typing.add_typing(node, type, context)
             else
               synthesize(node.children.last)
               fallback_to_any(node)
@@ -1072,7 +1013,7 @@ module Steep
                 end
               end
 
-              typing.add_typing(node, block_type.type.return_type)
+              typing.add_typing(node, block_type.type.return_type, context)
             else
               typing.add_error(Errors::UnexpectedYield.new(node: node))
               fallback_to_any node
@@ -1095,7 +1036,7 @@ module Steep
                     raise "Unexpected method_type: #{method_type.inspect}"
                   end
                 }
-                typing.add_typing(node, union_type(*types))
+                typing.add_typing(node, union_type(*types), context)
               else
                 typing.add_error(Errors::UnexpectedSuper.new(node: node, method: method_context.name))
                 fallback_to_any node
@@ -1117,7 +1058,7 @@ module Steep
                              end
                            end
 
-              typing.add_typing(node, array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type))
+              typing.add_typing(node, array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type), context)
             else
               is_tuple = nil
 
@@ -1170,7 +1111,7 @@ module Steep
                 array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
               end
 
-              typing.add_typing(node, array_type)
+              typing.add_typing(node, array_type, context)
             end
           end
 
@@ -1189,9 +1130,9 @@ module Steep
                                                                   const_env: nil)])
 
             if left_type.is_a?(AST::Types::Boolean)
-              typing.add_typing(node, union_type(left_type, right_type))
+              typing.add_typing(node, union_type(left_type, right_type), context)
             else
-              typing.add_typing(node, union_type(right_type, AST::Builtin.nil_type))
+              typing.add_typing(node, union_type(right_type, AST::Builtin.nil_type), context)
             end
           end
 
@@ -1201,7 +1142,7 @@ module Steep
             t1 = synthesize(c1, hint: hint)
             t2 = synthesize(c2, hint: unwrap(t1))
             type = union_type(unwrap(t1), t2)
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :if
@@ -1224,7 +1165,7 @@ module Steep
           end
 
           type_env.join!([true_env, false_env].compact)
-          typing.add_typing(node, union_type(true_type, false_type))
+          typing.add_typing(node, union_type(true_type, false_type), context)
 
         when :case
           yield_self do
@@ -1306,7 +1247,7 @@ module Steep
             end
 
             type_env.join!(envs.compact)
-            typing.add_typing(node, union_type(*types))
+            typing.add_typing(node, union_type(*types), context)
           end
 
         when :rescue
@@ -1373,7 +1314,7 @@ module Steep
             type_env.join!([*resbody_envs, else_env].compact)
 
             types = [body_type, *resbody_types, else_type].compact
-            typing.add_typing(node, union_type(*types))
+            typing.add_typing(node, union_type(*types), context)
           end
 
         when :resbody
@@ -1382,7 +1323,7 @@ module Steep
             synthesize(klasses) if klasses
             synthesize(asgn) if asgn
             body_type = synthesize(body) if body
-            typing.add_typing(node, body_type)
+            typing.add_typing(node, body_type, context)
           end
 
         when :ensure
@@ -1390,7 +1331,7 @@ module Steep
             body, ensure_body = node.children
             body_type = synthesize(body) if body
             synthesize(ensure_body) if ensure_body
-            typing.add_typing(node, union_type(body_type))
+            typing.add_typing(node, union_type(body_type), context)
           end
 
         when :masgn
@@ -1404,38 +1345,43 @@ module Steep
             truthy_vars = node.type == :while ? TypeConstruction.truthy_variables(cond) : Set.new
 
             if body
-              for_loop = for_branch(body, truthy_vars: truthy_vars).with(break_context: BreakContext.new(break_type: nil, next_type: nil))
+              for_loop = for_branch(body,
+                                    truthy_vars: truthy_vars,
+                                    break_context: TypeInference::Context::BreakContext.new(
+                                      break_type: nil,
+                                      next_type: nil
+                                    ))
               for_loop.synthesize(body)
               type_env.join!([for_loop.type_env])
             end
 
-            typing.add_typing(node, AST::Builtin.any_type)
+            typing.add_typing(node, AST::Builtin.any_type, context)
           end
 
         when :irange, :erange
           types = node.children.map {|n| synthesize(n)}
           type = AST::Builtin::Range.instance_type(union_type(*types))
-          typing.add_typing(node, type)
+          typing.add_typing(node, type, context)
 
         when :regexp
           each_child_node(node) do |child|
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::Regexp.instance_type)
+          typing.add_typing(node, AST::Builtin::Regexp.instance_type, context)
 
         when :regopt
           # ignore
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :nth_ref, :back_ref
-          typing.add_typing(node, AST::Builtin::String.instance_type)
+          typing.add_typing(node, AST::Builtin::String.instance_type, context)
 
         when :or_asgn, :and_asgn
           yield_self do
             _, rhs = node.children
             rhs_type = synthesize(rhs)
-            typing.add_typing(node, rhs_type)
+            typing.add_typing(node, rhs_type, context)
           end
 
         when :defined?
@@ -1443,7 +1389,7 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type)
+          typing.add_typing(node, AST::Builtin.any_type, context)
 
         when :gvasgn
           yield_self do
@@ -1469,7 +1415,7 @@ module Steep
               typing.add_error Errors::FallbackAny.new(node: node)
             end
 
-            typing.add_typing(node, type)
+            typing.add_typing(node, type, context)
           end
 
         when :block_pass
@@ -1499,7 +1445,7 @@ module Steep
 
             type ||= synthesize(node.children[0], hint: hint)
 
-            typing.add_typing node, type
+            typing.add_typing node, type, context
           end
 
         when :blockarg
@@ -1508,7 +1454,7 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, AST::Builtin.any_type
+            typing.add_typing node, AST::Builtin.any_type, context
           end
 
         when :splat, :sclass, :alias
@@ -1519,7 +1465,7 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, AST::Builtin.any_type
+            typing.add_typing node, AST::Builtin.any_type, context
           end
 
         else
@@ -1541,14 +1487,14 @@ module Steep
       if rhs
         expand_alias(synthesize(rhs, hint: type_env.lvar_types[var.name] || hint)) do |rhs_type|
           node_type = assign_type_to_variable(var, rhs_type, node)
-          typing.add_typing(node, node_type)
+          typing.add_typing(node, node_type, context)
         end
       else
         raise
         lhs_type = variable_type(var)
 
         if lhs_type
-          typing.add_typing(node, lhs_type)
+          typing.add_typing(node, lhs_type, context)
         else
           fallback_to_any node
         end
@@ -1580,7 +1526,7 @@ module Steep
           fallback_to_any node
         end
       end
-      typing.add_typing(node, ivar_type)
+      typing.add_typing(node, ivar_type, context)
     end
 
     def type_masgn(node)
@@ -1600,7 +1546,7 @@ module Steep
           end
         end
 
-        typing.add_typing(node, rhs_type)
+        typing.add_typing(node, rhs_type, context)
 
       when rhs_type.is_a?(AST::Types::Tuple) && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn}
         lhs.children.each.with_index do |asgn, index|
@@ -1628,7 +1574,7 @@ module Steep
           end
         end
 
-        typing.add_typing(node, rhs_type)
+        typing.add_typing(node, rhs_type, context)
 
       when rhs_type.is_a?(AST::Types::Any)
         fallback_to_any(node)
@@ -1658,7 +1604,7 @@ module Steep
           end
         end
 
-        typing.add_typing node, rhs_type
+        typing.add_typing node, rhs_type, context
 
       when rhs_type.is_a?(AST::Types::Union) &&
         rhs_type.types.all? {|type| AST::Builtin::Array.instance_type?(type)}
@@ -1691,7 +1637,7 @@ module Steep
           end
         end
 
-        typing.add_typing node, rhs_type
+        typing.add_typing node, rhs_type, context
 
       else
         Steep.logger.error("Unsupported masgn: #{rhs.type} (#{rhs_type})")
@@ -1717,7 +1663,7 @@ module Steep
                               block_annotations: block_annotations,
                               topdown_hint: true)
 
-      typing.add_typing node, block_type
+      typing.add_typing node, block_type, context
     end
 
     def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
@@ -1732,7 +1678,7 @@ module Steep
 
       return_type = case receiver_type
                     when AST::Types::Any
-                      typing.add_typing node, AST::Builtin.any_type
+                      typing.add_typing node, AST::Builtin.any_type, context
 
                     when nil
                       fallback_to_any node
@@ -1768,7 +1714,7 @@ module Steep
                                                               receiver_type: receiver_type,
                                                               topdown_hint: true)
 
-                            typing.add_typing node, return_type
+                            typing.add_typing node, return_type, context
                           else
                             fallback_to_any node do
                               Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
@@ -1793,7 +1739,7 @@ module Steep
           unless typing.has_type?(arg)
             if arg.type == :splat
               type = synthesize(arg.children[0])
-              typing.add_typing(arg, AST::Builtin::Array.instance_type(type))
+              typing.add_typing(arg, AST::Builtin::Array.instance_type(type), context)
             else
               synthesize(arg)
             end
@@ -1843,10 +1789,10 @@ module Steep
                     end
       Steep.logger.debug("return_type = #{return_type}")
 
-      block_context = BlockContext.new(body_type: block_annotations.block_type)
+      block_context = TypeInference::Context::BlockContext.new(body_type: block_annotations.block_type)
       Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
 
-      break_context = BreakContext.new(
+      break_context = TypeInference::Context::BreakContext.new(
         break_type: block_annotations.break_type || method_return_type,
         next_type: block_annotations.block_type
       )
@@ -1856,13 +1802,15 @@ module Steep
         checker: checker,
         source: source,
         annotations: annotations.merge_block_annotations(block_annotations),
-        type_env: block_type_env,
-        block_context: block_context,
         typing: typing,
-        method_context: method_context,
-        module_context: module_context,
-        self_type: block_annotations.self_type || self_type,
-        break_context: break_context
+        context: TypeInference::Context.new(
+          block_context: block_context,
+          method_context: method_context,
+          module_context: module_context,
+          break_context: break_context,
+          self_type: block_annotations.self_type || self_type,
+          type_env: block_type_env
+        )
       ), return_type]
     end
 
@@ -1979,7 +1927,7 @@ module Steep
                     this.synthesize(block_body)
                   end
 
-                  child_typing.add_typing node, AST::Builtin.any_type
+                  child_typing.add_typing node, AST::Builtin.any_type, context
 
                   [[AST::Builtin.any_type, child_typing, :any]]
                 end
@@ -2029,7 +1977,7 @@ module Steep
       when :hash
         keyword_hash_type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type,
                                                              AST::Builtin.any_type)
-        typing.add_typing node, keyword_hash_type
+        typing.add_typing node, keyword_hash_type, context
 
         given_keys = Set.new()
 
@@ -2053,7 +2001,7 @@ module Steep
                                params.rest_keywords
                              end
 
-              typing.add_typing key_node, AST::Builtin::Symbol.instance_type
+              typing.add_typing key_node, AST::Builtin::Symbol.instance_type, context
 
               given_keys << key_symbol
 
@@ -2159,13 +2107,8 @@ module Steep
         checker: checker,
         source: source,
         annotations: annotations,
-        type_env: type_env,
         typing: child_typing,
-        self_type: self_type,
-        method_context: method_context,
-        block_context: block_context,
-        module_context: module_context,
-        break_context: break_context
+        context: context
       )
 
       method_type.instantiate(instantiation).yield_self do |method_type|
@@ -2182,7 +2125,7 @@ module Steep
 
             arg_type = if arg_node.type == :splat
                          type = construction.synthesize(arg_node.children[0])
-                         child_typing.add_typing(arg_node, type)
+                         child_typing.add_typing(arg_node, type, context)
                        else
                          construction.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
                        end
@@ -2364,10 +2307,10 @@ module Steep
                    end
       Steep.logger.debug("return_type = #{break_type}")
 
-      block_context = BlockContext.new(body_type: block_annotations.block_type)
+      block_context = TypeInference::Context::BlockContext.new(body_type: block_annotations.block_type)
       Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
 
-      break_context = BreakContext.new(
+      break_context = TypeInference::Context::BreakContext.new(
         break_type: break_type,
         next_type: block_context.body_type
       )
@@ -2377,13 +2320,15 @@ module Steep
         checker: checker,
         source: source,
         annotations: annotations.merge_block_annotations(block_annotations),
-        type_env: block_type_env,
-        block_context: block_context,
         typing: typing,
-        method_context: method_context,
-        module_context: module_context,
-        self_type: block_annotations.self_type || self_type,
-        break_context: break_context
+        context: TypeInference::Context.new(
+          block_context: block_context,
+          method_context: method_context,
+          module_context: module_context,
+          break_context: break_context,
+          self_type: block_annotations.self_type || self_type,
+          type_env: block_type_env
+        )
       )
 
       if block_body
@@ -2600,7 +2545,7 @@ module Steep
         typing.add_error Errors::FallbackAny.new(node: node)
       end
 
-      typing.add_typing node, AST::Builtin.any_type
+      typing.add_typing node, AST::Builtin.any_type, context
     end
 
     def self_class?(node)
@@ -2774,7 +2719,7 @@ module Steep
           child_typing.save!
 
           hash = AST::Types::Record.new(elements: elements)
-          typing.add_typing(node, hash)
+          typing.add_typing(node, hash, context)
         end
       when AST::Types::Union
         hint.types.find do |type|