steep 0.44.0 → 0.47.0

data/lib/steep/diagnostic/ruby.rb

@@ -71,46 +71,104 @@ module Steep
         end
       end
 
-      class IncompatibleArguments < Base
+      class UnexpectedPositionalArgument < Base
         attr_reader :node
+        attr_reader :method_type
         attr_reader :method_name
-        attr_reader :receiver_type
-        attr_reader :method_types
 
-        def initialize(node:, method_name:, receiver_type:, method_types:)
-          location = case node.type
-                     when :send
-                       node.loc.selector
-                     when :block
-                       node.children[0].yield_self do |node|
-                         node.loc.selector
-                       end
-                     when :super
-                       node.loc.expression
-                     else
-                       Steep.logger.error { "Unexpected node given: #{node.type} (IncompatibleArguments#initialize)"}
-                       node.loc.expression
-                     end
-          super(node: node, location: location)
-          @receiver_type = receiver_type
-          @method_types = method_types
+        def initialize(node:, method_name:, method_type:)
+          super(node: node)
           @method_name = method_name
+          @method_type = method_type
         end
 
         def header_line
-          "Cannot find method `#{method_name}` of type `#{receiver_type}` with compatible arity"
+          "Unexpected positional argument"
         end
+      end
 
-        def detail_lines
-          StringIO.new.tap do |io|
-            io.puts "Method types:"
-            first_type, *rest_types = method_types
-            defn = "  def #{method_name}"
-            io.puts "#{defn}: #{first_type}"
-            rest_types.each do |method_type|
-              io.puts "#{" " * defn.size}| #{method_type}"
-            end
-          end.string.chomp
+      class InsufficientPositionalArguments < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+
+        def initialize(node:, method_name:, method_type:)
+          send = case node.type
+                 when :send, :csend
+                   node
+                 when :block, :numblock
+                   node.children[0]
+                 end
+
+          loc = if send
+                  send.loc.selector.with(end_pos: send.loc.expression.end_pos)
+                else
+                  node.loc.expression
+                end
+
+          super(node: node, location: loc)
+          @method_name = method_name
+          @method_type = method_type
+        end
+
+        def header_line
+          "More positional arguments are required"
+        end
+      end
+
+      class UnexpectedKeywordArgument < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+
+        def initialize(node:, method_name:, method_type:)
+          loc = case node.type
+                when :pair
+                  node.children[0].location.expression
+                when :kwsplat
+                  node.location.expression
+                else
+                  raise
+                end
+          super(node: node, location: loc)
+          @method_name = method_name
+          @method_type = method_type
+        end
+
+        def header_line
+          "Unexpected keyword argument"
+        end
+      end
+
+      class InsufficientKeywordArguments < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+        attr_reader :missing_keywords
+
+        def initialize(node:, method_name:, method_type:, missing_keywords:)
+          send = case node.type
+                 when :send, :csend
+                   node
+                 when :block, :numblock
+                   node.children[0]
+                 end
+
+          loc = if send
+                  send.loc.selector.with(end_pos: send.loc.expression.end_pos)
+                else
+                  node.loc.expression
+                end
+
+          super(node: node, location: loc)
+
+          @method_name = method_name
+          @method_type = method_type
+          @missing_keywords = missing_keywords
+        end
+
+        def header_line
+          "More keyword arguments are required: #{missing_keywords.join(", ")}"
         end
       end
 
@@ -292,6 +350,23 @@ module Steep
         end
       end
 
+      class ImplicitBreakValueMismatch < Base
+        attr_reader :jump_type
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, jump_type:, result:)
+          super(node: node)
+          @jump_type = jump_type
+          @result = result
+        end
+
+        def header_line
+          "Breaking without a value may result an error because a value of type `#{jump_type}` is expected"
+        end
+      end
+
       class UnexpectedJump < Base
         def header_line
           "Cannot jump from here"
@@ -323,6 +398,36 @@ module Steep
         end
       end
 
+      class MethodParameterMismatch < Base
+        attr_reader :method_param
+        attr_reader :method_type
+
+        def initialize(method_param:, method_type:)
+          super(node: method_param.node)
+          @method_param = method_param
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method parameter is incompatible with the declaration `#{method_type}`"
+        end
+      end
+
+      class DifferentMethodParameterKind < Base
+        attr_reader :method_param
+        attr_reader :method_type
+
+        def initialize(method_param:, method_type:)
+          super(node: method_param.node)
+          @method_param = method_param
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method parameter has different kind from the declaration `#{method_type}`"
+        end
+      end
+
       class IncompatibleMethodTypeAnnotation < Base
         attr_reader :interface_method
         attr_reader :annotation_method
@@ -366,7 +471,7 @@ module Steep
         include ResultPrinter
 
         def initialize(node:, expected:, actual:, result:)
-          super(node: node)
+          super(node: node, location: node.loc.name)
           @expected = expected
           @actual = actual
           @result = result
@@ -552,34 +657,6 @@ module Steep
         end
       end
 
-      class UnexpectedKeyword < Base
-        attr_reader :unexpected_keywords
-
-        def initialize(node:, unexpected_keywords:)
-          super(node: node)
-          @unexpected_keywords = unexpected_keywords
-        end
-
-        def header_line
-          keywords = unexpected_keywords.sort.map {|x| "`#{x}`" }
-          "Cannot specify unexpected keyword arguments: #{keywords.join(", ")}"
-        end
-      end
-
-      class MissingKeyword < Base
-        attr_reader :missing_keywords
-
-        def initialize(node:, missing_keywords:)
-          super(node: node)
-          @missing_keywords = missing_keywords
-        end
-
-        def header_line
-          keywords = missing_keywords.sort.map {|x| "`#{x}`" }
-          "Cannot omit required keywords: #{keywords.join(", ")}"
-        end
-      end
-
       class UnsupportedSyntax < Base
         attr_reader :message
 
@@ -623,6 +700,57 @@ module Steep
           "SyntaxError: #{message}"
         end
       end
+
+      ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
+        if klass < Base
+          array << klass
+        end
+      end
+
+      def self.all_error
+        @all_error ||= ALL.each.with_object({}) do |klass, hash|
+          hash[klass] = LSPFormatter::ERROR
+        end.freeze
+      end
+
+      def self.default
+        @default ||= all_error.merge(
+          {
+            ImplicitBreakValueMismatch => :warning,
+            FallbackAny => :information,
+            ElseOnExhaustiveCase => :warning,
+            UnknownConstantAssigned => :warning,
+            MethodDefinitionMissing => :information
+          }
+        ).freeze
+      end
+
+      def self.strict
+        @strict ||= all_error.merge(
+          {
+            NoMethod => nil,
+            ImplicitBreakValueMismatch => nil,
+            FallbackAny => nil,
+            ElseOnExhaustiveCase => nil,
+            UnknownConstantAssigned => nil,
+            MethodDefinitionMissing => nil
+          }
+        ).freeze
+      end
+
+      def self.lenient
+        @lenient ||= all_error.merge(
+          {
+            NoMethod => nil,
+            ImplicitBreakValueMismatch => nil,
+            FallbackAny => nil,
+            ElseOnExhaustiveCase => nil,
+            UnknownConstantAssigned => nil,
+            MethodDefinitionMissing => nil,
+            UnexpectedJump => nil
+          }
+        ).freeze
+      end
     end
   end
 end

data/lib/steep/diagnostic/signature.rb

@@ -38,25 +38,16 @@ module Steep
         end
 
         def self.parser_syntax_error_message(exception)
-          value = if exception.error_value.is_a?(RBS::Parser::LocatedValue)
-                    exception.error_value.value
-                  else
-                    exception.error_value
-                  end
-          string = value.to_s
+          string = exception.location.source.to_s
           unless string.empty?
             string = " (#{string})"
           end
 
-          "Syntax error caused by token `#{exception.token_str}`#{string}"
+          "Syntax error caused by token `#{exception.token_type}`#{string}"
         end
 
         def header_line
-          if exception.is_a?(RBS::Parser::SyntaxError)
-            SyntaxError.parser_syntax_error_message(exception)
-          else
-            exception.message
-          end
+          exception.message
         end
       end
 
@@ -275,6 +266,34 @@ module Steep
         end
       end
 
+      class MixinClassError < Base
+        attr_reader :member
+        attr_reader :type_name
+
+        def initialize(location:, member:, type_name:)
+          super(location: location)
+          @member = member
+          @type_name = type_name
+        end
+
+        def header_line
+          "Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+        end
+
+        private
+
+        def mixin_name
+          case member
+          when RBS::AST::Members::Prepend
+            "prepend"
+          when RBS::AST::Members::Include
+            "include"
+          when RBS::AST::Members::Extend
+            "extend"
+          end
+        end
+      end
+
       class UnexpectedError < Base
         attr_reader :message
 
@@ -290,10 +309,8 @@ module Steep
 
       def self.from_rbs_error(error, factory:)
         case error
-        when RBS::Parser::SemanticsError, RBS::Parser::LexerError
+        when RBS::ParsingError
           Diagnostic::Signature::SyntaxError.new(error, location: error.location)
-        when RBS::Parser::SyntaxError
-          Diagnostic::Signature::SyntaxError.new(error, location: error.error_value.location)
         when RBS::DuplicatedDeclarationError
           Diagnostic::Signature::DuplicatedDeclaration.new(
             type_name: error.name,
@@ -365,6 +382,12 @@ module Steep
             param: error.param,
             location: error.location
           )
+        when RBS::MixinClassError
+          Diagnostic::Signature::MixinClassError.new(
+            location: error.location,
+            type_name: error.type_name,
+            member: error.member,
+          )
         else
           raise error
         end

data/lib/steep/drivers/check.rb

@@ -8,6 +8,7 @@ module Steep
       attr_reader :command_line_patterns
       attr_accessor :with_expectations_path
       attr_accessor :save_expectations_path
+      attr_accessor :severity_level
 
       include Utils::DriverHelper
       include Utils::JobsCount
@@ -16,6 +17,7 @@ module Steep
         @stdout = stdout
         @stderr = stderr
         @command_line_patterns = []
+        @severity_level = :warning
       end
 
       def run
@@ -70,6 +72,7 @@ module Steep
           case
           when response[:method] == "textDocument/publishDiagnostics"
             ds = response[:params][:diagnostics]
+            ds.select! {|d| keep_diagnostic?(d) }
             if ds.empty?
               stdout.print "."
             else

data/lib/steep/drivers/init.rb

@@ -8,6 +8,8 @@ module Steep
       include Utils::DriverHelper
 
       TEMPLATE = <<~EOF
+      # D = Steep::Diagnostic
+      #
       # target :lib do
       #   signature "sig"
       #
@@ -18,15 +20,20 @@ module Steep
       #
       #   # library "pathname", "set"       # Standard libraries
       #   # library "strong_json"           # Gems
+      #   
+      #   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+      #   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+      #   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+      #   #   hash[D::Ruby::NoMethod] = :information
+      #   # end
       # end
 
-      # target :spec do
+      # target :test do
       #   signature "sig", "sig-private"
       #
-      #   check "spec"
+      #   check "test"
       #
       #   # library "pathname", "set"       # Standard libraries
-      #   # library "rspec"
       # end
       EOF
 

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

@@ -55,6 +55,21 @@ module Steep
             end
           end
         end
+
+        def keep_diagnostic?(diagnostic)
+          severity = diagnostic[:severity]
+
+          case self.severity_level
+          when nil, :hint
+            true
+          when :error
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR
+          when :warning
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING
+          when :information
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION
+          end
+        end
       end
     end
   end

data/lib/steep/drivers/validate.rb

@@ -36,7 +36,7 @@ module Steep
 
           any_error ||= !errors.empty?
 
-          formatter = Diagnostic::LSPFormatter.new
+          formatter = Diagnostic::LSPFormatter.new({})
           diagnostics = errors.group_by {|e| e.location.buffer }.transform_values do |errors|
             errors.map {|error| formatter.format(error) }
           end

data/lib/steep/drivers/watch.rb

@@ -5,6 +5,7 @@ module Steep
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :queue
+      attr_accessor :severity_level
 
       include Utils::DriverHelper
       include Utils::JobsCount
@@ -16,6 +17,7 @@ module Steep
         @stdout = stdout
         @stderr = stderr
         @queue = Thread::Queue.new
+        @severity_level = :warning
       end
 
       def watching?(changed_path, files:, dirs:)
@@ -126,6 +128,7 @@ module Steep
               printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
 
               diagnostics = response[:params][:diagnostics]
+              diagnostics.filter! {|d| keep_diagnostic?(d) }
 
               unless diagnostics.empty?
                 diagnostics.each do |diagnostic|

data/lib/steep/equatable.rb

@@ -0,0 +1,21 @@
+module Steep
+  module Equatable
+    def ==(other)
+      if other.class == self.class
+        instance_variables.all? do |name|
+          other.instance_variable_get(name) == instance_variable_get(name)
+        end
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      instance_variables.inject(self.class.hash) do |hash, name|
+        hash ^ instance_variable_get(name).hash
+      end
+    end
+  end
+end