steep 1.6.0 → 1.7.1

data/lib/steep/ast/ignore.rb

@@ -0,0 +1,148 @@
+module Steep
+  module AST
+    module Ignore
+      class BufferScanner
+        attr_reader :scanner, :location
+
+        def initialize(location)
+          @location = location
+
+          @scanner = StringScanner.new(location.source)
+        end
+
+        def offset
+          @location.start_pos
+        end
+
+        def charpos
+          scanner.charpos + offset
+        end
+
+        def scan(regexp)
+          if matched = scanner.scan(regexp)
+            end_pos = charpos()
+            begin_pos = end_pos - matched.size
+            RBS::Location.new(location.buffer, begin_pos, end_pos)
+          end
+        end
+
+        def skip(regexp)
+          scanner.skip(regexp)
+        end
+
+        def eos?
+          scanner.eos?
+        end
+      end
+
+      class IgnoreStart
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreEnd
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreLine
+        attr_reader :comment, :location, :raw_diagnostics
+
+        def initialize(comment, diagnostics, location)
+          @comment = comment
+          @raw_diagnostics = diagnostics
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+
+        def ignored_diagnostics
+          if raw_diagnostics.empty?
+            return :all
+          end
+
+          if raw_diagnostics.size == 1 && raw_diagnostics[0].source == "all"
+            return :all
+          end
+
+          raw_diagnostics.map do |diagnostic|
+            name = diagnostic[:name].source
+            name.gsub(/\ARuby::/, "")
+          end
+        end
+      end
+
+      def self.parse(comment, buffer)
+        return unless comment.inline?
+
+        comment_location = RBS::Location.new(buffer, comment.loc.expression.begin_pos, comment.loc.expression.end_pos)
+        scanner = BufferScanner.new(comment_location)
+
+        scanner.scan(/#/)
+        scanner.skip(/\s*/)
+
+        begin_pos = comment.location.expression.begin_pos
+        end_pos = comment.location.expression.end_pos
+
+        case
+        when loc = scanner.scan(/steep:ignore:start\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreStart.new(comment, loc)
+        when loc = scanner.scan(/steep:ignore:end\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreEnd.new(comment, loc)
+        when keyword_loc = scanner.scan(/steep:ignore\b/)
+          # @type var diagnostics: IgnoreLine::diagnostics
+          diagnostics = []
+
+          scanner.skip(/\s*/)
+
+          while true
+            name = scanner.scan(/[A-Z]\w*/) or break
+            scanner.skip(/\s*/)
+            comma = scanner.scan(/,/)
+            scanner.skip(/\s*/)
+
+            diagnostic = RBS::Location.new(buffer, name.start_pos, comma&.end_pos || name.end_pos) #: IgnoreLine::diagnostic
+            diagnostic.add_required_child(:name, name.range)
+            diagnostic.add_optional_child(:following_comma, comma&.range)
+            diagnostics << diagnostic
+
+            break unless comma
+          end
+
+          return unless scanner.eos?
+
+          loc = RBS::Location.new(
+            buffer,
+            keyword_loc.start_pos,
+            diagnostics.last&.end_pos || keyword_loc.end_pos
+          )
+          IgnoreLine.new(comment, diagnostics, loc)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/factory.rb

@@ -212,27 +212,36 @@ module Steep
           params = func.params
           return_type = func.return_type
 
-          RBS::Types::Function.new(
-            required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            trailing_positionals: [],
-            required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            return_type: type_1(return_type)
-          )
+          if params
+            RBS::Types::Function.new(
+              required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              trailing_positionals: [],
+              required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              return_type: type_1(return_type)
+            )
+          else
+            RBS::Types::UntypedFunction.new(return_type: type_1(return_type))
+          end
         end
 
         def params(type)
-          Interface::Function::Params.build(
-            required: type.required_positionals.map {|param| type(param.type) },
-            optional: type.optional_positionals.map {|param| type(param.type) },
-            rest: type.rest_positionals&.yield_self {|param| type(param.type) },
-            required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
-            optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
-            rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
-          )
+          case type
+          when RBS::Types::Function
+            Interface::Function::Params.build(
+              required: type.required_positionals.map {|param| type(param.type) },
+              optional: type.optional_positionals.map {|param| type(param.type) },
+              rest: type.rest_positionals&.yield_self {|param| type(param.type) },
+              required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
+              optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
+              rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
+            )
+          when RBS::Types::UntypedFunction
+            nil
+          end
         end
 
         def type_param(type_param)

data/lib/steep/ast/types/helper.rb

@@ -29,6 +29,10 @@ module Steep
               enum_for :each_child
             end
           end
+
+          def map_type
+            self
+          end
         end
       end
     end

data/lib/steep/ast/types/intersection.rb

@@ -80,6 +80,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          self.class.build(
+            types: each_child.map(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(types)
         end

data/lib/steep/ast/types/proc.rb

@@ -57,9 +57,11 @@ module Steep
         include Helper::ChildrenLevel
 
         def level
-          children = type.params.each_type.to_a + [type.return_type]
+          children = type.params&.each_type.to_a + [type.return_type]
           if block
-            children.push(*block.type.params.each_type.to_a)
+            if block.type.params
+              children.push(*block.type.params.each_type.to_a)
+            end
             children.push(block.type.return_type)
           end
           if self_type
@@ -83,13 +85,16 @@ module Steep
 
         def one_arg?
           params = type.params
-
-          params.required.size == 1 &&
-            params.optional.empty? &&
-            !params.rest &&
-            params.required_keywords.empty? &&
-            params.optional_keywords.empty? &&
-            !params.rest_keywords
+          if params
+            params.required.size == 1 &&
+              params.optional.empty? &&
+              !params.rest &&
+              params.required_keywords.empty? &&
+              params.optional_keywords.empty? &&
+              !params.rest_keywords
+          else
+            true
+          end
         end
 
         def back_type

data/lib/steep/ast/types/record.rb

@@ -50,6 +50,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          self.class.new(
+            elements: elements.transform_values(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(elements.values)
         end

data/lib/steep/ast/types/tuple.rb

@@ -46,6 +46,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          Tuple.new(
+            types: types.map(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(types)
         end

data/lib/steep/ast/types/union.rb

@@ -80,6 +80,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          Union.build(
+            types: types.map(&block),
+            location: location
+          )
+        end
+
         include Helper::ChildrenLevel
 
         def level

data/lib/steep/cli.rb

@@ -63,6 +63,7 @@ module Steep
     def handle_logging_options(opts)
       opts.on("--log-level=LEVEL", "Specify log level: debug, info, warn, error, fatal") do |level|
         Steep.logger.level = level
+        Steep.ui_logger.level = level
       end
 
       opts.on("--log-output=PATH", "Print logs to given path") do |file|
@@ -71,6 +72,7 @@ module Steep
 
       opts.on("--verbose", "Set log level to debug") do
         Steep.logger.level = Logger::DEBUG
+        Steep.ui_logger.level = Logger::DEBUG
       end
     end
 
@@ -129,7 +131,7 @@ module Steep
         end.parse!(argv)
 
         setup_jobs_for_ci(command.jobs_option)
-        
+
         command.command_line_patterns.push *argv
       end.run
     end
@@ -349,6 +351,9 @@ TEMPLATE
           opts.on("--index=INDEX") {|index| command.index = Integer(index) }
         end.parse!(argv)
 
+        # Disable any `ui_logger` output in workers
+        Steep.ui_logger.level = :fatal
+
         command.commandline_args.push(*argv)
       end.run
     end

data/lib/steep/diagnostic/ruby.rb

@@ -997,6 +997,19 @@ module Steep
         end
       end
 
+      class InvalidIgnoreComment < Base
+        attr_reader :comment
+
+        def initialize(comment:)
+          @comment = comment
+          super(node: nil, location: comment.location.expression)
+        end
+
+        def header_line
+          "Invalid ignore comment"
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass
@@ -1028,6 +1041,7 @@ module Steep
             InsufficientKeywordArguments => :error,
             InsufficientPositionalArguments => :error,
             InsufficientTypeArgument => :hint,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :error,
             MethodBodyTypeMismatch => :error,
             MethodDefinitionMissing => nil,
@@ -1086,6 +1100,7 @@ module Steep
             InsufficientKeywordArguments => :error,
             InsufficientPositionalArguments => :error,
             InsufficientTypeArgument => :error,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :error,
             MethodBodyTypeMismatch => :error,
             MethodDefinitionMissing => :hint,
@@ -1144,6 +1159,7 @@ module Steep
             InsufficientKeywordArguments => :information,
             InsufficientPositionalArguments => :information,
             InsufficientTypeArgument => nil,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :information,
             MethodBodyTypeMismatch => :warning,
             MethodDefinitionMissing => nil,

data/lib/steep/drivers/stats.rb

@@ -83,7 +83,7 @@ module Steep
             end
           end
 
-          table = Terminal::Table.new(
+          table = Terminal::Table.new( # steep:ignore UnknownConstant
             headings: ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"],
             rows: rows
           )
@@ -166,7 +166,7 @@ module Steep
           {
             id: stats_id,
             method: "workspace/executeCommand",
-            params: { command: "steep/stats", arguments: [] }
+            params: { command: "steep/stats", arguments: _ = [] }
           })
 
         stats_response = wait_for_response_id(reader: client_reader, id: stats_id)

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

@@ -5,18 +5,29 @@ module Steep
         attr_accessor :steepfile
 
         def load_config(path: steepfile || Pathname("Steepfile"))
-          raise "Cannot find a configuration at #{path}: `steep init` to scaffold" unless path.file?
-
-          steep_file_path = path.absolute? ? path : Pathname.pwd + path
-          Project.new(steepfile_path: steep_file_path).tap do |project|
-            Project::DSL.parse(project, path.read, filename: path.to_s)
-
+          if path.file?
+            steep_file_path = path.absolute? ? path : Pathname.pwd + path
+            Project.new(steepfile_path: steep_file_path).tap do |project|
+              Project::DSL.parse(project, path.read, filename: path.to_s)
+            end
+          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 '.'
+              end
+            end
+          end.tap do |project|
             project.targets.each do |target|
-              if collection_lock = target.options.collection_lock
-                begin
-                  collection_lock.check_rbs_availability!
-                rescue RBS::Collection::Config::CollectionNotAvailable
-                  raise "Run `rbs collection install` to install type definitions"
+              case result = target.options.load_collection_lock
+              when nil, RBS::Collection::Config::Lockfile
+                # ok
+              else
+                if result == target.options.collection_config_path
+                  Steep.ui_logger.error { "rbs-collection setup is broken: `#{result}` is missing" }
+                else
+                  Steep.ui_logger.error { "Run `rbs collection install` to install type definitions" }
                 end
               end
             end

data/lib/steep/drivers/validate.rb

@@ -49,8 +49,10 @@ module Steep
             if buffer
               printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
               ds.each do |d|
-                printer.print(d)
-                stdout.puts
+                if d
+                  printer.print(_ = d)
+                  stdout.puts
+                end
               end
             end
           end

data/lib/steep/expectations.rb

@@ -23,7 +23,7 @@ module Steep
             :information
           when "HINT"
             :hint
-          end #: Diagnostic::LSPFormatter::severity
+          end #: Steep::Diagnostic::LSPFormatter::severity
 
         Diagnostic.new(
           start_position: start_position,
@@ -56,7 +56,7 @@ module Steep
             :hint
           else
             :error
-          end #: Diagnostic::LSPFormatter::severity
+          end #: Steep::Diagnostic::LSPFormatter::severity
 
         Diagnostic.new(
           start_position: start_position,

data/lib/steep/interface/block.rb

@@ -82,7 +82,7 @@ module Steep
       def +(other)
         optional = self.optional? || other.optional?
         type = Function.new(
-          params: self.type.params + other.type.params,
+          params: self.type.params && other.type.params ? self.type.params + other.type.params : nil,
           return_type: AST::Types::Union.build(types: [self.type.return_type, other.type.return_type]),
           location: nil
         )