steep 0.39.0 → 0.40.0

data/lib/steep/drivers/signature_error_printer.rb

@@ -1,25 +0,0 @@
-module Steep
-  module Drivers
-    class SignatureErrorPrinter
-      attr_reader :stdout
-      attr_reader :stderr
-
-      def initialize(stdout:, stderr:)
-        @stdout = stdout
-        @stderr = stderr
-      end
-
-      def print_syntax_errors(errors)
-        errors.each do |error|
-          stderr.puts error.message
-        end
-      end
-
-      def print_semantic_errors(errors)
-        errors.each do |error|
-          error.puts stderr
-        end
-      end
-    end
-  end
-end

data/lib/steep/errors.rb

@@ -1,594 +0,0 @@
-module Steep
-  module Errors
-    class Base
-      attr_reader :node
-
-      def initialize(node:)
-        @node = node
-      end
-
-      def location_to_str
-        file = Rainbow(node.loc.expression.source_buffer.name).cyan
-        line = Rainbow(node.loc.first_line).bright
-        column = Rainbow(node.loc.column).bright
-        "#{file}:#{line}:#{column}"
-      end
-
-      def format_message(message, class_name: self.class.name.split("::").last)
-        if message.empty?
-          "#{location_to_str}: #{Rainbow(class_name).red}"
-        else
-          "#{location_to_str}: #{Rainbow(class_name).red}: #{message}"
-        end
-      end
-
-      def print_to(io)
-        source = node.loc.expression.source
-        io.puts "#{to_s} (#{Rainbow(source.split(/\n/).first).blue})"
-      end
-    end
-
-    module ResultPrinter
-      def print_result_to(io, level: 2)
-        printer = Drivers::TracePrinter.new(io)
-        printer.print result.trace, level: level
-        io.puts "==> #{result.error.message}"
-      end
-
-      def print_to(io)
-        super
-        print_result_to io
-      end
-    end
-
-    class IncompatibleAssignment < Base
-      attr_reader :lhs_type
-      attr_reader :rhs_type
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, lhs_type:, rhs_type:, result:)
-        super(node: node)
-        @lhs_type = lhs_type
-        @rhs_type = rhs_type
-        @result = result
-      end
-
-      def to_s
-        format_message "lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
-      end
-    end
-
-    class IncompatibleArguments < Base
-      attr_reader :node
-      attr_reader :receiver_type
-      attr_reader :method_type
-
-      def initialize(node:, receiver_type:, method_type:)
-        super(node: node)
-        @receiver_type = receiver_type
-        @method_type = method_type
-      end
-
-      def to_s
-        format_message "receiver=#{receiver_type}, method_type=#{method_type}"
-      end
-    end
-
-    class UnresolvedOverloading < Base
-      attr_reader :node
-      attr_reader :receiver_type
-      attr_reader :method_name
-      attr_reader :method_types
-
-      def initialize(node:, receiver_type:, method_name:, method_types:)
-        super node: node
-        @receiver_type = receiver_type
-        @method_name = method_name
-        @method_types = method_types
-      end
-
-      def to_s
-        format_message "receiver=#{receiver_type}, method_name=#{method_name}, method_types=#{method_types.join(" | ")}"
-      end
-    end
-
-    class ArgumentTypeMismatch < Base
-      attr_reader :node
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :receiver_type
-
-      def initialize(node:, receiver_type:, expected:, actual:)
-        super(node: node)
-        @receiver_type = receiver_type
-        @expected = expected
-        @actual = actual
-      end
-
-      def to_s
-        format_message "receiver=#{receiver_type}, expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class BlockParameterTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-
-      def initialize(node:, expected:, actual:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-      end
-
-      def to_s
-        format_message "expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class NoMethod < Base
-      attr_reader :type
-      attr_reader :method
-
-      def initialize(node:, type:, method:)
-        super(node: node)
-        @type = type
-        @method = method
-      end
-
-      def to_s
-        format_message "type=#{type}, method=#{method}", class_name: "NoMethodError"
-      end
-    end
-
-    class ReturnTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, expected:, actual:, result:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-        @result = result
-      end
-
-      def to_s
-        format_message "expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class UnexpectedBlockGiven < Base
-      attr_reader :method_type
-
-      def initialize(node:, method_type:)
-        super(node: node)
-        @method_type = method_type
-      end
-
-      def to_s
-        format_message "method_type=#{method_type}"
-      end
-    end
-
-    class RequiredBlockMissing < Base
-      attr_reader :method_type
-
-      def initialize(node:, method_type:)
-        super(node: node)
-        @method_type = method_type
-      end
-
-      def to_s
-        format_message "method_type=#{method_type}"
-      end
-    end
-
-    class BlockTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, expected:, actual:, result:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-        @result = result
-      end
-
-      def to_s
-        format_message "expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class BlockBodyTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, expected:, actual:, result:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-        @result = result
-      end
-
-      def to_s
-        format_message "expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class BreakTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, expected:, actual:, result:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-        @result = result
-      end
-
-      def to_s
-        format_message "expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class UnexpectedJump < Base
-      def to_s
-        format_message ""
-      end
-    end
-
-    class UnexpectedJumpValue < Base
-      def to_s
-        format_message ""
-      end
-    end
-
-    class MethodArityMismatch < Base
-      def to_s
-        format_message "method=#{node.children[0]}"
-      end
-    end
-
-    class IncompatibleMethodTypeAnnotation < Base
-      attr_reader :interface_method
-      attr_reader :annotation_method
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, interface_method:, annotation_method:, result:)
-        super(node: node)
-        @interface_method = interface_method
-        @annotation_method = annotation_method
-        @result = result
-      end
-
-      def to_s
-        format_message "interface_method=#{interface_method.type_name}.#{interface_method.name}, annotation_method=#{annotation_method.name}"
-      end
-    end
-
-    class MethodDefinitionWithOverloading < Base
-      attr_reader :method
-
-      def initialize(node:, method:)
-        super(node: node)
-        @method = method
-      end
-
-      def to_s
-        format_message "method=#{method.name}, types=#{method.types.join(" | ")}"
-      end
-    end
-
-    class MethodReturnTypeAnnotationMismatch < Base
-      attr_reader :method_type
-      attr_reader :annotation_type
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, method_type:, annotation_type:, result:)
-        super(node: node)
-        @method_type = method_type
-        @annotation_type = annotation_type
-        @result = result
-      end
-
-      def to_s
-        format_message "method_type=#{method_type.return_type}, annotation_type=#{annotation_type}"
-      end
-    end
-
-    class MethodBodyTypeMismatch < Base
-      attr_reader :expected
-      attr_reader :actual
-      attr_reader :result
-
-      include ResultPrinter
-
-      def initialize(node:, expected:, actual:, result:)
-        super(node: node)
-        @expected = expected
-        @actual = actual
-        @result = result
-      end
-
-      def to_s
-        method = case node.type
-                 when :def
-                   node.children[0]
-                 when :defs
-                   prefix = node.children[0].type == :self ? "self" : "*"
-                   "#{prefix}.#{node.children[1]}"
-                 end
-        format_message "method=#{method}, expected=#{expected}, actual=#{actual}"
-      end
-    end
-
-    class UnexpectedYield < Base
-      def to_s
-        format_message ""
-      end
-    end
-
-    class UnexpectedSuper < Base
-      attr_reader :method
-
-      def initialize(node:, method:)
-        super(node: node)
-        @method = method
-      end
-
-      def to_s
-        format_message "method=#{method}"
-      end
-    end
-
-    class IncompatibleZuper < Base
-      attr_reader :method
-
-      def initialize(node:, method:)
-        super(node: node)
-        @method = method
-      end
-
-      def to_s
-        format_message "method=#{method}"
-      end
-    end
-
-    class MethodDefinitionMissing < Base
-      attr_reader :module_name
-      attr_reader :kind
-      attr_reader :missing_method
-
-      def initialize(node:, module_name:, kind:, missing_method:)
-        super(node: node)
-        @module_name = module_name
-        @kind = kind
-        @missing_method = missing_method
-      end
-
-      def to_s
-        method = case kind
-                 when :instance
-                   "#{missing_method}"
-                 when :module
-                   "self.#{missing_method}"
-                 end
-        format_message "module=#{module_name}, method=#{method}"
-      end
-    end
-
-    class UnexpectedDynamicMethod < Base
-      attr_reader :module_name
-      attr_reader :method_name
-
-      def initialize(node:, module_name:, method_name:)
-        @node = node
-        @module_name = module_name
-        @method_name = method_name
-      end
-
-      def to_s
-        format_message "module=#{module_name}, method=#{method_name}"
-      end
-    end
-
-    class UnknownConstantAssigned < Base
-      attr_reader :type
-
-      def initialize(node:, type:)
-        super(node: node)
-        @type = type
-      end
-
-      def to_s
-        format_message "type=#{type}"
-      end
-    end
-
-    class FallbackAny < Base
-      def initialize(node:)
-        @node = node
-      end
-
-      def to_s
-        format_message ""
-      end
-    end
-
-    class UnsatisfiableConstraint < Base
-      attr_reader :method_type
-      attr_reader :var
-      attr_reader :sub_type
-      attr_reader :super_type
-      attr_reader :result
-
-      def initialize(node:, method_type:, var:, sub_type:, super_type:, result:)
-        super(node: node)
-        @method_type = method_type
-        @var = var
-        @sub_type = sub_type
-        @super_type = super_type
-        @result = result
-      end
-
-      include ResultPrinter
-
-      def to_s
-        format_message "method_type=#{method_type}, constraint=#{sub_type} <: '#{var} <: #{super_type}"
-      end
-    end
-
-    class IncompatibleAnnotation < Base
-      attr_reader :var_name
-      attr_reader :result
-      attr_reader :relation
-
-      def initialize(node:, var_name:, result:, relation:)
-        super(node: node)
-        @var_name = var_name
-        @result = result
-        @relation = relation
-      end
-
-      include ResultPrinter
-
-      def to_s
-        format_message "var_name=#{var_name}, #{relation}"
-      end
-    end
-
-    class IncompatibleTypeCase < Base
-      attr_reader :var_name
-      attr_reader :result
-      attr_reader :relation
-
-      def initialize(node:, var_name:, result:, relation:)
-        super(node: node)
-        @var_name = var_name
-        @result = result
-        @relation = relation
-      end
-
-      include ResultPrinter
-
-      def to_s
-        format_message "var_name=#{var_name}, #{relation}"
-      end
-    end
-
-    class ElseOnExhaustiveCase < Base
-      attr_reader :type
-
-      def initialize(node:, type:)
-        super(node: node)
-        @type = type
-      end
-
-      def to_s
-        format_message "type=#{type}"
-      end
-    end
-
-    class UnexpectedSplat < Base
-      attr_reader :type
-
-      def initialize(node:, type:)
-        super(node: node)
-        @type = type
-      end
-
-      def to_s
-        format_message "type=#{type}"
-      end
-    end
-
-    class IncompatibleTuple < Base
-      attr_reader :expected_tuple
-      include ResultPrinter
-
-      def initialize(node:, expected_tuple:, result:)
-        super(node: node)
-        @result = result
-        @expected_tuple = expected_tuple
-      end
-
-      def to_s
-        format_message "expected_tuple=#{expected_tuple}"
-      end
-    end
-
-    class UnexpectedKeyword < Base
-      attr_reader :unexpected_keywords
-
-      def initialize(node:, unexpected_keywords:)
-        super(node: node)
-        @unexpected_keywords = unexpected_keywords
-      end
-
-      def to_s
-        format_message unexpected_keywords.to_a.join(", ")
-      end
-    end
-
-    class MissingKeyword < Base
-      attr_reader :missing_keywords
-
-      def initialize(node:, missing_keywords:)
-        super(node: node)
-        @missing_keywords = missing_keywords
-      end
-
-      def to_s
-        format_message missing_keywords.to_a.join(", ")
-      end
-    end
-
-    class UnsupportedSyntax < Base
-      attr_reader :message
-
-      def initialize(node:, message: nil)
-        super(node: node)
-        @message = message
-      end
-
-      def to_s
-        format_message(message || "#{node.type} is not supported")
-      end
-    end
-
-    class UnexpectedError < Base
-      attr_reader :message
-      attr_reader :error
-
-      def initialize(node:, error:)
-        super(node: node)
-        @error = error
-        @message = error.message
-      end
-
-      def to_s
-        format_message <<-MESSAGE
-#{error.class}
->> #{message}
-        MESSAGE
-      end
-    end
-  end
-end