steep 0.23.0 → 0.29.0

data/lib/steep/interface/substitution.rb

@@ -26,7 +26,32 @@ module Steep
       end
 
       def self.empty
-        new(dictionary: {}, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
+        new(dictionary: {},
+            instance_type: INSTANCE_TYPE,
+            module_type: CLASS_TYPE,
+            self_type: SELF_TYPE)
+      end
+
+      def empty?
+        dictionary.empty? &&
+          instance_type.is_a?(AST::Types::Instance) &&
+          module_type.is_a?(AST::Types::Class) &&
+          self_type.is_a?(AST::Types::Self)
+      end
+
+      INSTANCE_TYPE = AST::Types::Instance.new
+      CLASS_TYPE = AST::Types::Class.new
+      SELF_TYPE = AST::Types::Self.new
+
+      def domain
+        set = Set.new
+
+        set.merge(dictionary.keys)
+        set << INSTANCE_TYPE unless instance_type.is_a?(AST::Types::Instance)
+        set << CLASS_TYPE unless instance_type.is_a?(AST::Types::Class)
+        set << SELF_TYPE unless instance_type.is_a?(AST::Types::Self)
+
+        set
       end
 
       def to_s
@@ -65,22 +90,39 @@ module Steep
 
       def except(vars)
         self.class.new(
-          dictionary: dictionary.reject {|k, _| vars.include?(k) },
+          dictionary: dictionary,
           instance_type: instance_type,
           module_type: module_type,
           self_type: self_type
-        )
+        ).except!(vars)
       end
 
-      def merge!(s)
+      def except!(vars)
+        vars.each do |var|
+          dictionary.delete(var)
+        end
+
+        self
+      end
+
+      def merge!(s, overwrite: false)
         dictionary.transform_values! {|ty| ty.subst(s) }
         dictionary.merge!(s.dictionary) do |key, a, b|
           if a == b
             a
           else
-            raise "Duplicated key on merge!: #{key}, #{a}, #{b}"
+            if overwrite
+              b
+            else
+              raise "Duplicated key on merge!: #{key}, #{a}, #{b} (#{self})"
+            end
           end
         end
+
+        @instance_type = instance_type.subst(s)
+        @module_type = module_type.subst(s)
+        @self_type = self_type.subst(s)
+
         self
       end
 
@@ -92,7 +134,7 @@ module Steep
       end
 
       def add!(v, ty)
-        merge!(Substitution.new(dictionary: { v => ty }, instance_type: nil, module_type: nil, self_type: nil))
+        merge!(Substitution.new(dictionary: { v => ty }, instance_type: instance_type, module_type: module_type, self_type: self_type))
       end
     end
   end

data/lib/steep/module_helper.rb

@@ -0,0 +1,25 @@
+module Steep
+  module ModuleHelper
+    def module_name_from_node(node)
+      case node.type
+      when :const, :casgn
+        namespace = namespace_from_node(node.children[0]) or return
+        name = node.children[1]
+        RBS::TypeName.new(name: name, namespace: namespace)
+      end
+    end
+
+    def namespace_from_node(node)
+      case node&.type
+      when nil
+        RBS::Namespace.empty
+      when :cbase
+        RBS::Namespace.root
+      when :const
+        namespace_from_node(node.children[0])&.yield_self do |parent|
+          parent.append(node.children[1])
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/completion_provider.rb

@@ -10,13 +10,9 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
-      MethodNameItem = Struct.new(:identifier, :range, :definition, :def_type, :inherited_method, keyword_init: true) do
-        def method_type
-          def_type.type
-        end
-
+      MethodNameItem = Struct.new(:identifier, :range, :method_def, :method_type, :inherited_method, keyword_init: true) do
         def comment
-          def_type.comment
+          method_def&.comment
         end
       end
 
@@ -90,7 +86,9 @@ module Steep
       end
 
       def at_end?(pos, of:)
-        of.last_line == pos.line && of.last_column == pos.column
+        if of
+          of.last_line == pos.line && of.last_column == pos.column
+        end
       end
 
       def range_for(position, prefix: "")
@@ -194,21 +192,25 @@ module Steep
         return [] unless node
 
         if at_end?(shift_pos, of: node.loc)
-          context = typing.context_at(line: position.line, column: position.column)
-          receiver_type = case (type = typing.type_of(node: node))
-                          when AST::Types::Self
-                            context.self_type
-                          else
-                            type
-                          end
-
-          items = []
-          method_items_for_receiver_type(receiver_type,
-                                         include_private: false,
-                                         prefix: "",
-                                         position: position,
-                                         items: items)
-          items
+          begin
+            context = typing.context_at(line: position.line, column: position.column)
+            receiver_type = case (type = typing.type_of(node: node))
+                            when AST::Types::Self
+                              context.self_type
+                            else
+                              type
+                            end
+
+            items = []
+            method_items_for_receiver_type(receiver_type,
+                                           include_private: false,
+                                           prefix: "",
+                                           position: position,
+                                           items: items)
+            items
+          rescue Typing::UnknownNodeError
+            []
+          end
         else
           []
         end
@@ -230,37 +232,27 @@ module Steep
 
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
-        definition = case type
-                     when AST::Types::Name::Instance
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_instance(type_name)
-                     when AST::Types::Name::Class, AST::Types::Name::Module
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_singleton(type_name)
-                     when AST::Types::Name::Interface
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_interface(type_name)
-                     end
-
-        if definition
-          definition.methods.each do |name, method|
-            next if disallowed_method?(name)
-
-            if include_private || method.public?
-              if name.to_s.start_with?(prefix)
-                if word_name?(name.to_s)
-                  method.defs.each do |def_type|
-                    items << MethodNameItem.new(identifier: name,
-                                                range: range,
-                                                definition: method,
-                                                def_type: def_type,
-                                                inherited_method: inherited_method?(method, definition))
-                  end
-                end
+        interface = subtyping.factory.interface(type, self_type: type, private: include_private)
+
+        interface.methods.each do |name, method_entry|
+          next if disallowed_method?(name)
+
+          if name.to_s.start_with?(prefix)
+            if word_name?(name.to_s)
+              method_entry.method_types.each do |method_type|
+                items << MethodNameItem.new(
+                  identifier: name,
+                  range: range,
+                  method_def: method_type.method_def,
+                  method_type: method_type.method_def&.type || subtyping.factory.method_type_1(method_type, self_type: type),
+                  inherited_method: inherited_method?(method_type.method_def, type)
+                )
               end
             end
           end
         end
+      rescue
+        # nop
       end
 
       def word_name?(name)
@@ -304,8 +296,13 @@ module Steep
         index
       end
 
-      def inherited_method?(method, definition)
-        method.implemented_in != definition.type_name
+      def inherited_method?(method_def, type)
+        case type
+        when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
+          method_def.implemented_in != type.name
+        else
+          false
+        end
       end
 
       def disallowed_method?(name)

data/lib/steep/project/file.rb

@@ -41,8 +41,8 @@ module Steep
       end
 
       def self.type_check(source, subtyping:)
-        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [AST::Namespace.root])
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: RBS::Namespace.root)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [RBS::Namespace.root])
         type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                 subtyping: subtyping,
                                                 const_env: const_env,
@@ -58,7 +58,7 @@ module Steep
             instance_type: nil,
             module_type: nil,
             implement_name: nil,
-            current_namespace: AST::Namespace.root,
+            current_namespace: RBS::Namespace.root,
             const_env: const_env,
             class_name: nil
           ),

data/lib/steep/project/hover_content.rb

@@ -21,9 +21,7 @@ module Steep
         @project = project
       end
 
-      def method_definition_for(factory, module_name, singleton_method: nil, instance_method: nil)
-        type_name = factory.type_name_1(module_name)
-
+      def method_definition_for(factory, type_name, singleton_method: nil, instance_method: nil)
         case
         when instance_method
           factory.definition_builder.build_instance(type_name).methods[instance_method]
@@ -86,16 +84,16 @@ module Steep
                                           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)
+                                              owner_name = method_definition.defined_in
                                               [
                                                 InstanceMethodName.new(owner_name, method_name),
                                                 method_definition
                                               ]
                                             end
-                                          when AST::Types::Name::Class
+                                          when AST::Types::Name::Singleton
                                             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)
+                                              owner_name = method_definition.defined_in
                                               [
                                                 SingletonMethodName.new(owner_name, method_name),
                                                 method_definition

data/lib/steep/project/target.rb

@@ -172,6 +172,7 @@ module Steep
                 timestamp: Time.now
               )
             rescue => exn
+              Steep.log_error exn
               @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
             end
           end
@@ -194,8 +195,10 @@ module Steep
         type_check_sources = []
 
         target_sources.each do |file|
-          if file.type_check(check, timestamp)
-            type_check_sources << file
+          Steep.logger.tagged("path=#{file.path}") do
+            if file.type_check(check, timestamp)
+              type_check_sources << file
+            end
           end
         end
 

data/lib/steep/server/base_worker.rb

@@ -12,6 +12,7 @@ module Steep
         @project = project
         @reader = reader
         @writer = writer
+        @shutdown = false
       end
 
       def handle_request(request)
@@ -28,7 +29,7 @@ module Steep
           Steep.logger.formatter.push_tags(*tags)
           Steep.logger.tagged "background" do
             while job = queue.pop
-              handle_job(job)
+              handle_job(job) unless @shutdown
             end
           end
         end
@@ -38,11 +39,12 @@ module Steep
             reader.read do |request|
               case request[:method]
               when "shutdown"
-                # nop
+                @shutdown = true
+                writer.write(id: request[:id], result: nil)
               when "exit"
                 break
               else
-                handle_request(request)
+                handle_request(request) unless @shutdown
               end
             end
           ensure

data/lib/steep/server/code_worker.rb

@@ -139,6 +139,8 @@ module Steep
       end
 
       def handle_job(job)
+        sleep 0.1
+
         path, version, target = job
         if !version || target_files[path] == version
           typecheck_file(path, target)

data/lib/steep/server/master.rb

@@ -23,6 +23,7 @@ module Steep
         @signature_worker = signature_worker
         @code_workers = code_workers
         @worker_to_paths = {}
+        @shutdown_request_id = nil
       end
 
       def start
@@ -59,7 +60,14 @@ module Steep
         end
 
         while job = queue.pop
-          writer.write(job)
+          if @shutdown_request_id
+            if job[:id] == @shutdown_request_id
+              writer.write(job)
+              break
+            end
+          else
+            writer.write(job)
+          end
         end
 
         writer.io.close
@@ -154,6 +162,7 @@ module Steep
 
         when "shutdown"
           queue << { id: id, result: nil }
+          @shutdown_request_id = id
 
         when "exit"
           queue << nil

data/lib/steep/signature/validator.rb

@@ -130,19 +130,19 @@ module Steep
         yield
       rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           args: exn.args.map {|ty| factory.type(ty) },
           params: exn.params,
           location: exn.location
         )
       rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           location: exn.location
         )
       rescue RBS::InvalidOverloadMethodError => exn
         @errors << Errors::InvalidMethodOverloadError.new(
-          class_name: factory.type_name(exn.type_name),
+          class_name: exn.type_name,
           method_name: exn.method_name,
           location: exn.members[0].location
         )

data/lib/steep/source.rb

@@ -38,7 +38,7 @@ module Steep
     end
 
     def self.parser
-      ::Parser::Ruby25.new(Builder.new).tap do |parser|
+      ::Parser::Ruby27.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -60,7 +60,7 @@ module Steep
       _, comments, _ = yield_self do
         buffer = ::Parser::Source::Buffer.new(path.to_s)
         buffer.source = source_code
-        parser = ::Parser::Ruby25.new
+        parser = ::Parser::Ruby27.new
 
         parser.tokenize(buffer)
       end
@@ -79,6 +79,7 @@ module Steep
       end
 
       mapping = {}
+
       construct_mapping(node: node, annotations: annotations, mapping: mapping)
 
       annotations.each do |annot|
@@ -185,7 +186,7 @@ module Steep
           construct_mapping(node: node.children[0], annotations: annotations, mapping: mapping, line_range: nil)
         end
 
-        if node.loc.else
+        if node.children.last
           else_node = node.children.last
           else_start = node.loc.else.last_line
           else_end = node.loc.end.line