steep 1.8.2 → 1.9.0.dev.1

data/lib/steep/index/signature_symbol_provider.rb

@@ -11,7 +11,7 @@ module Steep
       attr_reader :assignment
 
       def initialize(project:, assignment:)
-        @indexes = []
+        @indexes = {}
         @project = project
         @assignment = assignment
       end
@@ -39,20 +39,20 @@ module Steep
         end
       end
 
-      def assigned?(path)
+      def assigned?(target, path)
         if path.relative?
           if project.targets.any? {|target| target.possible_signature_file?(path) }
             path = project.absolute_path(path)
           end
         end
 
-        assignment =~ path
+        assignment =~ [target, path]
       end
 
       def query_symbol(query)
         symbols = [] #: Array[SymbolInformation]
 
-        indexes.each do |index|
+        indexes.each do |target, index|
           index.each_entry do |entry|
             case entry
             when RBSIndex::TypeEntry
@@ -63,7 +63,7 @@ module Steep
 
               entry.declarations.each do |decl|
                 location = decl.location or next
-                next unless assigned?(Pathname(location.buffer.name))
+                next unless assigned?(target, Pathname(location.buffer.name))
 
                 case decl
                 when RBS::AST::Declarations::Class
@@ -111,7 +111,7 @@ module Steep
 
               entry.declarations.each do |decl|
                 location = decl.location or next
-                next unless assigned?(Pathname(location.buffer.name))
+                next unless assigned?(target, Pathname(location.buffer.name))
 
                 case decl
                 when RBS::AST::Members::MethodDefinition
@@ -151,7 +151,7 @@ module Steep
 
               entry.declarations.each do |decl|
                 next unless decl.location
-                next unless assigned?(Pathname(decl.location.buffer.name))
+                next unless assigned?(target, Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: entry.const_name.name.to_s,
@@ -165,7 +165,7 @@ module Steep
 
               entry.declarations.each do |decl|
                 next unless decl.location
-                next unless assigned?(Pathname(decl.location.buffer.name))
+                next unless assigned?(target, Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: decl.name.to_s,

data/lib/steep/interface/builder.rb

@@ -282,6 +282,7 @@ module Steep
                 method_type = factory.method_type(type_def.type)
                 method_type = replace_primitive_method(method_name, type_def, method_type)
                 method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Builtin::Class.instance_type }
+                method_type = add_implicitly_returns_nil(type_def.annotations, method_type)
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 
@@ -315,6 +316,7 @@ module Steep
                 if type_name.class?
                   method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Types::Name::Singleton.new(name: type_name) }
                 end
+                method_type = add_implicitly_returns_nil(type_def.annotations, method_type)
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 
@@ -586,7 +588,7 @@ module Steep
 
       def record_shape(record)
         all_key_type = AST::Types::Union.build(
-          types: record.elements.each_key.map {|value| AST::Types::Literal.new(value: value) }
+          types: record.elements.each_key.map {|value| AST::Types::Literal.new(value: value).back_type }
         )
         all_value_type = AST::Types::Union.build(types: record.elements.values)
         hash_type = AST::Builtin::Hash.instance_type(all_key_type, all_value_type)
@@ -822,6 +824,17 @@ module Steep
 
         method_type
       end
+
+      def add_implicitly_returns_nil(annotations, method_type)
+        if annotations.find { _1.string == "implicitly-returns-nil" }
+          return_type = method_type.type.return_type
+          method_type = method_type.with(
+            type: method_type.type.with(return_type: AST::Types::Union.build(types: [return_type, AST::Builtin.nil_type]))
+          )
+        else
+          method_type
+        end
+      end
     end
   end
 end

data/lib/steep/interface/function.rb

@@ -926,10 +926,10 @@ module Steep
         def to_s
           required = self.required.map {|ty| ty.to_s }
           optional = self.optional.map {|ty| "?#{ty}" }
-          rest = self.rest ? ["*#{self.rest}"] : []
+          rest = self.rest ? ["*#{self.rest}"] : [] #: Array[String]
           required_keywords = keyword_params.requireds.map {|name, type| "#{name}: #{type}" }
           optional_keywords = keyword_params.optionals.map {|name, type| "?#{name}: #{type}"}
-          rest_keywords = keyword_params.rest ? ["**#{keyword_params.rest}"] : []
+          rest_keywords = keyword_params.rest ? ["**#{keyword_params.rest}"] : [] #: Array[String]
           "(#{(required + optional + rest + required_keywords + optional_keywords + rest_keywords).join(", ")})"
         end
 

data/lib/steep/path_helper.rb

@@ -2,12 +2,14 @@ module Steep
   module PathHelper
     module_function
 
+    URIParser = URI::RFC2396_Parser.new()
+
     def to_pathname(uri, dosish: Gem.win_platform?)
       uri = URI.parse(uri)
       if uri.scheme == "file"
         path = uri.path or raise
         path.sub!(%r{^/([a-zA-Z])(:|%3A)//?}i, '\1:/') if dosish
-        path = URI::DEFAULT_PARSER.unescape(path)
+        path = URIParser.unescape(path)
         Pathname(path)
       end
     end
@@ -21,7 +23,7 @@ module Steep
       if dosish
         str_path.insert(0, "/") if str_path[0] != "/"
       end
-      str_path = URI::DEFAULT_PARSER.escape(str_path)
+      str_path = URIParser.escape(str_path)
       URI::File.build(path: str_path)
     end
   end

data/lib/steep/project/dsl.rb

@@ -1,137 +1,154 @@
 module Steep
   class Project
     class DSL
-      class TargetDSL
-        attr_reader :name
-        attr_reader :sources
-        attr_reader :libraries
-        attr_reader :signatures
-        attr_reader :ignored_sources
+      module LibraryOptions
         attr_reader :stdlib_root
         attr_reader :core_root
-        attr_reader :repo_paths
-        attr_reader :code_diagnostics_config
-        attr_reader :project
         attr_reader :collection_config_path
 
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: nil)
-          @name = name
-          @sources = sources
-          @libraries = libraries
-          @signatures = signatures
-          @ignored_sources = ignored_sources
-          @core_root = nil
-          @stdlib_root = nil
-          @repo_paths = []
-          @code_diagnostics_config = code_diagnostics_config
-          @project = project
-          @collection_config_path = collection_config_path
+        def stdlib_path(core_root:, stdlib_root:)
+          @core_root = Pathname(core_root)
+          @stdlib_root = Pathname(stdlib_root)
         end
 
-        def initialize_copy(other)
-          @name = other.name
-          @sources = other.sources.dup
-          @libraries = other.libraries.dup
-          @signatures = other.signatures.dup
-          @ignored_sources = other.ignored_sources.dup
-          @repo_paths = other.repo_paths.dup
-          @core_root = other.core_root
-          @stdlib_root = other.stdlib_root
-          @code_diagnostics_config = other.code_diagnostics_config.dup
-          @project = other.project
-          @collection_config_path = other.collection_config_path
+        def repo_path(*paths)
+          @library_configured = true
+          repo_paths.push(*paths.map {|s| Pathname(s) })
         end
 
-        def check(*args)
-          sources.push(*args)
+        def collection_config(path)
+          @library_configured = true
+          @collection_config_path = project.absolute_path(path)
         end
 
-        def ignore(*args)
-          ignored_sources.push(*args)
+        def disable_collection
+          @library_configured = true
+          @collection_config_path = false
         end
 
         def library(*args)
+          @library_configured = true
           libraries.push(*args)
         end
 
-        def typing_options(level = nil, **hash)
-          Steep.logger.error "#typing_options is deprecated and has no effect as of version 0.46.0. Update your Steepfile as follows for (almost) equivalent setting:"
+        def repo_paths
+          @repo_paths ||= []
+        end
 
-          messages = [] #: Array[String]
+        def libraries
+          @libraries ||= []
+        end
 
-          messages << "# D = Steep::Diagnostic                          # Define a constant to shorten namespace"
+        def library_configured?
+          @library_configured
+        end
 
-          case level
-          when :strict
-            messages << "configure_code_diagnostics(D::Ruby.strict)       # :strict"
-          when :default
-            messages << "configure_code_diagnostics(D::Ruby.default)      # :default"
-          when :lenient
-            messages << "configure_code_diagnostics(D::Ruby.lenient)      # :lenient"
-          end
+        def to_library_options
+          config_path =
+            case collection_config_path
+            when Pathname
+              collection_config_path
+            when nil
+              default = project.absolute_path(RBS::Collection::Config::PATH)
+              if default.file?
+                default
+              end
+            when false
+              nil
+            end
 
-          messages.each do |msg|
-            Steep.logger.error "  #{msg}"
+          Options.new.tap do |options|
+            options.libraries.push(*libraries)
+            options.paths = Options::PathOptions.new(
+              core_root: core_root,
+              stdlib_root: stdlib_root,
+              repo_paths: repo_paths
+            )
+            options.collection_config_path = config_path
           end
+        end
+      end
 
-          config = [] #: Array[String]
+      module WithPattern
+        def check(*args)
+          sources.concat(args)
+        end
 
-          if hash[:allow_missing_definitions]
-            config << "hash[D::Ruby::MethodDefinitionMissing] = nil   # allow_missing_definitions"
-          end
+        def ignore(*args)
+          ignored_sources.concat(args)
+        end
 
-          if hash[:allow_fallback_any]
-            config << "hash[D::Ruby::FallbackAny] = nil               # allow_fallback_any"
-          end
+        def signature(*args)
+          signatures.concat(args)
+        end
 
-          if hash[:allow_unknown_constant_assignment]
-            config << "hash[D::Ruby::UnknownConstantAssigned] = nil   # allow_unknown_constant_assignment"
-          end
+        def ignore_signature(*args)
+          ignored_signatures.concat(args)
+        end
 
-          if hash[:allow_unknown_method_calls]
-            config << "hash[D::Ruby::NoMethod] = nil                  # allow_unknown_method_calls"
-          end
+        def sources
+          @sources ||= []
+        end
 
-          unless config.empty?
-            Steep.logger.error "  configure_code_diagnostics do |hash|"
-            config.each do |c|
-              Steep.logger.error "    #{c}"
-            end
-            Steep.logger.error "  end"
-          end
+        def ignored_sources
+          @ignored_sources ||= []
+        end
 
+        def signatures
+          @signatures ||= []
         end
 
-        def signature(*args)
-          signatures.push(*args)
+        def ignored_signatures
+          @ignored_signatures ||= []
         end
 
-        def update(name: self.name, sources: self.sources, libraries: self.libraries, ignored_sources: self.ignored_sources, signatures: self.signatures, project: self.project)
-          self.class.new(
-            name,
-            sources: sources,
-            libraries: libraries,
-            signatures: signatures,
-            ignored_sources: ignored_sources,
-            project: project,
-          )
+        def source_pattern
+          Pattern.new(patterns: sources, ignores: ignored_sources, ext: ".rb")
         end
 
-        def no_builtin!(value = true)
-          Steep.logger.error "`#no_builtin!` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
+        def signature_pattern
+          Pattern.new(patterns: signatures, ignores: ignored_signatures, ext: ".rbs")
         end
+      end
+
+      class TargetDSL
+        include LibraryOptions
+        include WithPattern
+
+        attr_reader :name
+        attr_reader :project
+        attr_reader :unreferenced
+        attr_reader :groups
 
-        def vendor(dir = "vendor/sigs", stdlib: nil, gems: nil)
-          Steep.logger.error "`#vendor` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
+        def initialize(name, project:)
+          @name = name
+          @core_root = nil
+          @stdlib_root = nil
+          @project = project
+          @collection_config_path = collection_config_path
+          @unreferenced = false
+          @groups = []
         end
 
-        def stdlib_path(core_root:, stdlib_root:)
-          @core_root = Pathname(core_root)
-          @stdlib_root = Pathname(stdlib_root)
+        def initialize_copy(other)
+          @name = other.name
+          @libraries = other.libraries.dup
+          @sources = other.sources.dup
+          @signatures = other.signatures.dup
+          @ignored_sources = other.ignored_sources.dup
+          @ignored_signatures = other.ignored_signatures.dup
+          @repo_paths = other.repo_paths.dup
+          @core_root = other.core_root
+          @stdlib_root = other.stdlib_root
+          @code_diagnostics_config = other.code_diagnostics_config.dup
+          @project = other.project
+          @collection_config_path = other.collection_config_path
+          @unreferenced = other.unreferenced
+          @groups = other.groups.dup
         end
 
-        def repo_path(*paths)
-          @repo_paths.push(*paths.map {|s| Pathname(s) })
+        def unreferenced!(value = true)
+          @unreferenced = value
         end
 
         def configure_code_diagnostics(hash = nil)
@@ -142,91 +159,99 @@ module Steep
           yield code_diagnostics_config if block_given?
         end
 
-        def project!
-          project or raise "TargetDSL doesn't have project (#{name})"
+        def code_diagnostics_config
+          @code_diagnostics_config ||= Diagnostic::Ruby.default.dup
         end
 
-        def collection_config(path)
-          @collection_config_path = project!.absolute_path(path)
-        end
+        def group(name, &block)
+          group = GroupDSL.new(name, self)
 
-        def disable_collection
-          @collection_config_path = false
+          Steep.logger.tagged "group=#{name}" do
+            group.instance_exec(&block) if block
+          end
+
+          groups << group
         end
       end
 
-      attr_reader :project
+      class GroupDSL
+        include WithPattern
+
+        attr_reader :name
+
+        attr_reader :target
+
+        attr_reader :code_diagnostics_config
 
-      @@templates = {
-        gemfile: TargetDSL.new(:gemfile).tap do |target|
-          target.check "Gemfile"
-          target.library "gemfile"
+        def initialize(name, target)
+          @name = name
+          @target = target
         end
-      }
 
-      def self.templates
-        @@templates
+        def configure_code_diagnostics(config = nil)
+          if block_given?
+            if code_diagnostics_config
+              if config
+                code_diagnostics_config.merge!(config)
+              end
+            else
+              @code_diagnostics_config = (config || target.code_diagnostics_config).dup
+            end
+
+            yield (code_diagnostics_config || raise)
+          else
+            @code_diagnostics_config = config&.dup
+          end
+        end
       end
 
+      include LibraryOptions
+
+      attr_reader :project
+
       def initialize(project:)
         @project = project
       end
 
-      def self.register_template(name, target)
-        templates[name] = target
-      end
-
       def self.parse(project, code, filename: "Steepfile")
         Steep.logger.tagged filename do
-          self.new(project: project).instance_eval(code, filename)
+          dsl = self.new(project: project)
+          dsl.instance_eval(code, filename)
+          project.global_options = dsl.to_library_options
         end
       end
 
-      def target(name, template: nil, &block)
-        target = if template
-                   self.class.templates[template]&.dup&.update(name: name, project: project) or
-                     raise "Unknown template: #{template}, available templates: #{@@templates.keys.join(", ")}"
-                 else
-                   TargetDSL.new(name, code_diagnostics_config: Diagnostic::Ruby.default.dup, project: project)
-                 end
-
-        Steep.logger.tagged "target=#{name}" do
-          target.instance_eval(&block) if block
+      def self.eval(project, &block)
+        Steep.logger.tagged "DSL.eval" do
+          dsl = self.new(project: project)
+          dsl.instance_exec(&block)
+          project.global_options = dsl.to_library_options
         end
+      end
 
-        source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
-        signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
+      def target(name, &block)
+        dsl = TargetDSL.new(name, project: project)
 
-        config_path =
-          case target.collection_config_path
-          when Pathname
-            target.collection_config_path
-          when nil
-            default = project.absolute_path(RBS::Collection::Config::PATH)
-            if default.file?
-              default
-            end
-          when false
-            nil
-          end
+        Steep.logger.tagged "target=#{name}" do
+          dsl.instance_eval(&block) if block
+        end
 
-        Project::Target.new(
-          name: target.name,
-          source_pattern: source_pattern,
-          signature_pattern: signature_pattern,
-          options: Options.new.tap do |options|
-            options.libraries.push(*target.libraries)
-            options.paths = Options::PathOptions.new(
-              core_root: target.core_root,
-              stdlib_root: target.stdlib_root,
-              repo_paths: target.repo_paths
-            )
-            options.collection_config_path = config_path
-          end,
-          code_diagnostics_config: target.code_diagnostics_config
-        ).tap do |target|
-          project.targets << target
+        target = Project::Target.new(
+          name: dsl.name,
+          source_pattern: dsl.source_pattern,
+          signature_pattern: dsl.signature_pattern,
+          options: dsl.library_configured? ? dsl.to_library_options : nil,
+          code_diagnostics_config: dsl.code_diagnostics_config,
+          project: project,
+          unreferenced: dsl.unreferenced
+        )
+
+        dsl.groups.each do
+          group = Group.new(target, _1.name, _1.source_pattern, _1.signature_pattern, _1.code_diagnostics_config || target.code_diagnostics_config)
+          target.groups << group
         end
+
+        project.targets << target
       end
     end
   end

data/lib/steep/project/group.rb

@@ -0,0 +1,31 @@
+module Steep
+  class Project
+    class Group
+      attr_reader :name
+      attr_reader :source_pattern
+      attr_reader :signature_pattern
+      attr_reader :target
+      attr_reader :code_diagnostics_config
+
+      def initialize(target, name, source_pattern, signature_pattern, code_diagnostics_config)
+        @target = target
+        @name = name
+        @source_pattern = source_pattern
+        @signature_pattern = signature_pattern
+        @code_diagnostics_config = code_diagnostics_config
+      end
+
+      def project
+        target.project
+      end
+
+      def possible_source_file?(path)
+        source_pattern =~ path
+      end
+
+      def possible_signature_file?(path)
+        signature_pattern =~ path
+      end
+    end
+  end
+end

data/lib/steep/project/target.rb

@@ -2,29 +2,55 @@ module Steep
   class Project
     class Target
       attr_reader :name
-      attr_reader :options
+      attr_reader :target_options
 
       attr_reader :source_pattern
       attr_reader :signature_pattern
       attr_reader :code_diagnostics_config
+      attr_reader :project
+      attr_reader :unreferenced
+      attr_reader :groups
 
-      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:)
+      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:, project:, unreferenced:)
         @name = name
-        @options = options
+        @target_options = options
         @source_pattern = source_pattern
         @signature_pattern = signature_pattern
         @code_diagnostics_config = code_diagnostics_config
+        @project = project
+        @unreferenced = unreferenced
+        @groups = []
+      end
+
+      def options
+        target_options || project.global_options
       end
 
       def possible_source_file?(path)
-        source_pattern =~ path
+        if target = groups.find { _1.possible_source_file?(path) }
+          return target
+        end
+
+        if source_pattern =~ path
+          return self
+        end
+
+        nil
       end
 
       def possible_signature_file?(path)
-        signature_pattern =~ path
+        if target = groups.find { _1.possible_signature_file?(path) }
+          return target
+        end
+
+        if signature_pattern =~ path
+          return self
+        end
+
+        nil
       end
 
-      def new_env_loader(project:)
+      def new_env_loader()
         Target.construct_env_loader(options: options, project: project)
       end