steep 0.24.0 → 0.30.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.rb

@@ -24,6 +24,31 @@ module Steep
       (base_dir + path).cleanpath
     end
 
+    def target_for_source_path(path)
+      targets.find do |target|
+        target.possible_source_file?(path)
+      end
+    end
+
+    def targets_for_path(path)
+      if target = target_for_source_path(path)
+        [target, []]
+      else
+        [
+          nil,
+          targets.select do |target|
+            target.possible_signature_file?(path)
+          end
+        ]
+      end
+    end
+
+    def all_source_files
+      targets.each.with_object(Set[]) do |target, paths|
+        paths.merge(target.source_files.keys)
+      end
+    end
+
     def type_of_node(path:, line:, column:)
       source_file = targets.map {|target| target.source_files[path] }.compact[0]
 

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_loader.rb

@@ -28,15 +28,20 @@ module Steep
       end
 
       def load_sources(command_line_patterns)
+        loaded_paths = Set[]
+
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
             target_patterns = command_line_patterns.empty? ? target.source_patterns : command_line_patterns
 
-            each_path_in_patterns target_patterns, ".rb" do |path|
+            each_path_in_patterns(target_patterns, ".rb") do |path|
               if target.possible_source_file?(path)
-                unless target.source_file?(path)
+                if loaded_paths.include?(path)
+                  Steep.logger.warn { "Skipping #{target} while loading #{path}... (Already loaded to another target.)" }
+                else
                   Steep.logger.info { "Adding source file: #{path}" }
                   target.add_source path, project.absolute_path(path).read
+                  loaded_paths << path
                 end
               end
             end

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/signature_file.rb

@@ -0,0 +1,33 @@
+module Steep
+  class Project
+    class SignatureFile
+      attr_reader :path
+      attr_reader :content
+      attr_reader :content_updated_at
+
+      attr_reader :status
+
+      ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
+      DeclarationsStatus = Struct.new(:declarations, :timestamp, keyword_init: true)
+
+      def initialize(path:)
+        @path = path
+        self.content = ""
+      end
+
+      def content=(content)
+        @content_updated_at = Time.now
+        @content = content
+        @status = nil
+      end
+
+      def load!
+        buffer = RBS::Buffer.new(name: path, content: content)
+        decls = RBS::Parser.parse_signature(buffer)
+        @status = DeclarationsStatus.new(declarations: decls, timestamp: Time.now)
+      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
+        @status = ParseErrorStatus.new(error: exn, timestamp: Time.now)
+      end
+    end
+  end
+end

data/lib/steep/project/{file.rb → source_file.rb}

@@ -8,10 +8,10 @@ module Steep
 
       attr_accessor :status
 
-      ParseErrorStatus = Struct.new(:error, keyword_init: true)
-      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, keyword_init: true)
+      ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
+      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, :timestamp, keyword_init: true)
       TypeCheckStatus = Struct.new(:typing, :source, :timestamp, keyword_init: true)
-      TypeCheckErrorStatus = Struct.new(:error, keyword_init: true)
+      TypeCheckErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
 
       def initialize(path:)
         @path = path
@@ -20,11 +20,9 @@ module Steep
       end
 
       def content=(content)
-        if @content != content
-          @content_updated_at = Time.now
-          @content = content
-          @status = nil
-        end
+        @content_updated_at = Time.now
+        @content = content
+        @status = nil
       end
 
       def errors
@@ -41,8 +39,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,
@@ -55,12 +53,14 @@ module Steep
         context = TypeInference::Context.new(
           block_context: nil,
           module_context: TypeInference::Context::ModuleContext.new(
-            instance_type: nil,
-            module_type: nil,
+            instance_type: AST::Builtin::Object.instance_type,
+            module_type: AST::Builtin::Object.module_type,
             implement_name: nil,
-            current_namespace: AST::Namespace.root,
+            current_namespace: RBS::Namespace.root,
             const_env: const_env,
-            class_name: nil
+            class_name: AST::Builtin::Object.module_name,
+            instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
+            module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
           ),
           method_context: nil,
           break_context: nil,
@@ -86,31 +86,31 @@ module Steep
 
       def type_check(subtyping, env_updated_at)
         # skip type check
-        return false if status.is_a?(TypeCheckStatus) && env_updated_at <= status.timestamp
+        return false if status && env_updated_at <= status.timestamp
+
+        now = Time.now
 
         parse(subtyping.factory) do |source|
           typing = self.class.type_check(source, subtyping: subtyping)
-          @status = TypeCheckStatus.new(
-            typing: typing,
-            source: source,
-            timestamp: Time.now
-          )
+          @status = TypeCheckStatus.new(typing: typing, source: source, timestamp: now)
         rescue RBS::NoTypeFoundError,
           RBS::NoMixinFoundError,
           RBS::NoSuperclassFoundError,
           RBS::DuplicatedMethodDefinitionError,
           RBS::InvalidTypeApplicationError => exn
           # Skip logging known signature errors (they are handled with load_signatures(validate: true))
-          @status = TypeCheckErrorStatus.new(error: exn)
+          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
         rescue => exn
           Steep.log_error(exn)
-          @status = TypeCheckErrorStatus.new(error: exn)
+          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
         end
 
         true
       end
 
       def parse(factory)
+        now = Time.now
+
         if status.is_a?(TypeCheckStatus)
           yield status.source
         else
@@ -118,40 +118,10 @@ module Steep
         end
       rescue AnnotationParser::SyntaxError => exn
         Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }
-        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location)
+        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location, timestamp: now)
       rescue ::Parser::SyntaxError, EncodingError => exn
         Steep.logger.warn { "Source parsing error on #{path}: #{exn.inspect}" }
-        @status = ParseErrorStatus.new(error: exn)
-      end
-    end
-
-    class SignatureFile
-      attr_reader :path
-      attr_reader :content
-      attr_reader :content_updated_at
-
-      attr_reader :status
-
-      ParseErrorStatus = Struct.new(:error, keyword_init: true)
-      DeclarationsStatus = Struct.new(:declarations, keyword_init: true)
-
-      def initialize(path:)
-        @path = path
-        self.content = ""
-      end
-
-      def content=(content)
-        @content_updated_at = Time.now
-        @content = content
-        @status = nil
-      end
-
-      def load!
-        buffer = RBS::Buffer.new(name: path, content: content)
-        decls = RBS::Parser.parse_signature(buffer)
-        @status = DeclarationsStatus.new(declarations: decls)
-      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
-        @status = ParseErrorStatus.new(error: exn)
+        @status = ParseErrorStatus.new(error: exn, timestamp: now)
       end
     end
   end