steep 1.8.3 → 1.9.0.dev.2

data/lib/steep/drivers/print_project.rb

@@ -1,68 +1,111 @@
+require "active_support/core_ext/hash/keys"
+
 module Steep
   module Drivers
     class PrintProject
       attr_reader :stdout
       attr_reader :stderr
 
+      attr_accessor :print_files
+      attr_reader :files
+
       include Utils::DriverHelper
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
+        @print_files = false
       end
 
-      def run
-        project = load_config()
-
-        loader = Services::FileLoader.new(base_dir: project.base_dir)
-
-        project.targets.each do |target|
-          source_changes = loader.load_changes(target.source_pattern, changes: {})
-          signature_changes = loader.load_changes(target.signature_pattern, changes: {})
-
-          stdout.puts "Target:"
-          stdout.puts "  #{target.name}:"
-          stdout.puts "    sources:"
-          stdout.puts "      patterns:"
-          target.source_pattern.patterns.each do |pattern|
-            stdout.puts "        - #{pattern}"
-          end
-          stdout.puts "      ignores:"
-          target.source_pattern.ignores.each do |pattern|
-            stdout.puts "        - #{pattern}"
-          end
-          stdout.puts "      files:"
-          source_changes.each_key do |path|
-            stdout.puts "        - #{path}"
+      def as_json(project)
+        {
+          steepfile: project.steepfile_path.to_s,
+          targets: project.targets.map do |target|
+            target_as_json(target)
           end
-          stdout.puts "    signatures:"
-          stdout.puts "      patterns:"
-          target.signature_pattern.patterns.each do |pattern|
-            stdout.puts "        - #{pattern}"
-          end
-          stdout.puts "      files:"
-          signature_changes.each_key do |path|
-            stdout.puts "        - #{path}"
-          end
-          stdout.puts "    libraries:"
-          target.options.libraries.each do |lib|
-            stdout.puts "      - #{lib}"
-          end
-          stdout.puts "    library dirs:"
-          target.new_env_loader(project: project).tap do |loader|
+        }.stringify_keys
+      end
+
+      def target_as_json(target)
+        json = {
+          "name" => target.name.to_s,
+          "source_pattern" => pattern_as_json(target.source_pattern),
+          "signature_pattern" => pattern_as_json(target.signature_pattern),
+          "groups" => target.groups.map do |group|
+            group_as_json(group)
+          end,
+          "libraries" => target.new_env_loader().yield_self do |loader|
+            libs = [] #: Array[library_json]
             loader.each_dir do |lib, path|
               case lib
               when :core
-                stdout.puts "      - core: #{path}"
+                libs << { "name" => "__core__", "path" => path.to_s }
               when Pathname
                 raise "Unexpected pathname from loader: path=#{path}"
               else
-                stdout.puts "      - #{lib.name}(#{lib.version}): #{path}"
+                libs << { "name" => lib.name, "version" => lib.version, "path" => path.to_s }
               end
             end
+            libs
+          end,
+          "unreferenced" => target.unreferenced
+        } #: target_json
+
+        if files
+          files.each_group_signature_path(target, true) do |path|
+            (json["signature_paths"] ||= []) << path.to_s
+          end
+          files.each_group_source_path(target, true) do |path|
+            (json["source_paths"] ||= []) << path.to_s
           end
         end
 
+        json
+      end
+
+      def group_as_json(group)
+        json = {
+          "name" => group.name.to_s,
+          "source_pattern" => pattern_as_json(group.source_pattern),
+          "signature_pattern" => pattern_as_json(group.signature_pattern)
+        } #: group_json
+
+        if files
+          files.each_group_signature_path(group, true) do |path|
+            (json["signature_paths"] ||= []) << path.to_s
+
+          end
+          files.each_group_source_path(group, true) do |path|
+            (json["source_paths"] ||= []) << path.to_s
+          end
+        end
+
+        json
+      end
+
+      def pattern_as_json(pattern)
+        {
+          "pattern" => pattern.patterns,
+          "ignore" => pattern.ignores
+        }
+      end
+
+      def run
+        project = load_config()
+        if print_files
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+          @files = files = Server::TargetGroupFiles.new(project)
+          project.targets.each do |target|
+            loader.each_path_in_target(target) do |path|
+              files.add_path(path)
+            end
+          end
+        else
+          @files = nil
+        end
+
+        stdout.puts YAML.dump(as_json(project))
+
         0
       end
     end

data/lib/steep/drivers/utils/driver_helper.rb

@@ -3,6 +3,7 @@ module Steep
     module Utils
       module DriverHelper
         attr_accessor :steepfile
+        attr_accessor :disable_install_collection
 
         def load_config(path: steepfile || Pathname("Steepfile"))
           if path.file?
@@ -13,9 +14,11 @@ module Steep
           else
             Steep.ui_logger.error { "Cannot find a configuration at #{path}: `steep init` to scaffold. Using current directory..." }
             Project.new(steepfile_path: nil, base_dir: Pathname.pwd).tap do |project|
-              Project::DSL.new(project: project).target :'.' do
-                check '.'
-                signature '.'
+              Project::DSL.eval(project) do
+                target :'.' do
+                  check '.'
+                  signature '.'
+                end
               end
             end
           end.tap do |project|
@@ -23,17 +26,47 @@ module Steep
               case result = target.options.load_collection_lock
               when nil, RBS::Collection::Config::Lockfile
                 # ok
-              else
+              when Pathname
+                # File is missing
                 if result == target.options.collection_config_path
-                  Steep.ui_logger.error { "rbs-collection setup is broken: `#{result}` is missing" }
+                  # Config file is missing
+                  Steep.ui_logger.error { "rbs-collection configuration is missing: `#{result}`" }
+                else
+                  # Lockfile is missing
+                  Steep.ui_logger.error { "Run `rbs collection install` to generate missing lockfile: `#{result}`" }
+                end
+              when YAML::SyntaxError
+                # File is broken
+                Steep.ui_logger.error { "rbs-collection setup is broken:\nsyntax error #{result.inspect}" }
+              when RBS::Collection::Config::CollectionNotAvailable
+                unless disable_install_collection
+                  install_collection(target, target.options.collection_config_path || raise)
                 else
-                  Steep.ui_logger.error { "Run `rbs collection install` to install type definitions" }
+                  Steep.ui_logger.error { "Run `rbs collection install` to set up RBS files for gems" }
                 end
               end
             end
           end
         end
 
+        def install_collection(target, config_path)
+          Steep.ui_logger.info { "Installing RBS files for collection: #{config_path}" }
+          lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
+          io = StringIO.new
+          begin
+            RBS::Collection::Installer.new(lockfile_path: lockfile_path, stdout: io).install_from_lockfile()
+            target.options.load_collection_lock(force: true)
+            Steep.ui_logger.debug { "Finished setting up RBS collection: " + io.string }
+
+            result = target.options.load_collection_lock(force: true)
+            unless result.is_a?(RBS::Collection::Config::Lockfile)
+              raise "Failed to set up RBS collection: #{result.inspect}"
+            end
+          rescue => exn
+            Steep.ui_logger.error { "Failed to set up RBS collection: #{exn.inspect}" }
+          end
+        end
+
         def request_id
           SecureRandom.alphanumeric(10)
         end

data/lib/steep/drivers/watch.rb

@@ -112,7 +112,19 @@ module Steep
             end
           end
 
-          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
+          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+
+          (modified + added).each do |path|
+            path = Pathname(path)
+            if target = project.target_for_source_path(path)
+              params[:code_paths] << [target.name.to_s, path.to_s]
+            end
+            if target = project.target_for_signature_path(path)
+              params[:signature_paths] << [target.name.to_s, path.to_s]
+            end
+          end
+
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, params))
 
           stdout.puts Rainbow("done!").bold
         end.tap(&:start)
@@ -120,7 +132,17 @@ module Steep
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
 
-          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
+          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+          file_loader = Services::FileLoader.new(base_dir: project.base_dir)
+          project.targets.each do |target|
+            file_loader.each_path_in_patterns(target.source_pattern, dirs.map(&:to_s)) do |path|
+              params[:code_paths] << [target.name.to_s, project.absolute_path(path).to_s]
+            end
+            file_loader.each_path_in_patterns(target.signature_pattern, dirs.map(&:to_s)) do |path|
+              params[:signature_paths] << [target.name.to_s, project.absolute_path(path).to_s]
+            end
+          end
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, params))
 
           client_reader.read do |response|
             case response[:method]

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