steep 1.1.1 → 1.2.0.pre.1

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

@@ -8,6 +8,10 @@ module Steep
           @location = location
         end
 
+        def self.instance
+          @instance ||= new()
+        end
+
         def ==(other)
           other.is_a?(Instance)
         end

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

@@ -38,7 +38,7 @@ module Steep
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location)
+          _ = self.class.new(value: value, location: new_location)
         end
 
         def back_type

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

@@ -4,20 +4,22 @@ module Steep
       class Proc
         attr_reader :location
         attr_reader :type
+        attr_reader :self_type
         attr_reader :block
 
-        def initialize(type:, block:, location: type.location)
+        def initialize(type:, block:, self_type:, location: type.location)
           @type = type
           @block = block
+          @self_type = self_type
           @location = location
         end
 
         def ==(other)
-          other.is_a?(self.class) && other.type == type && other.block == block
+          other.is_a?(self.class) && other.type == type && other.block == block && other.self_type == self_type
         end
 
         def hash
-          self.class.hash ^ type.hash ^ block.hash
+          self.class.hash ^ type.hash ^ block.hash ^ self_type.hash
         end
 
         alias eql? ==
@@ -26,15 +28,21 @@ module Steep
           self.class.new(
             type: type.subst(s),
             block: block&.subst(s),
+            self_type: self_type&.subst(s),
             location: location
           )
         end
 
         def to_s
+          s =
+            if self_type
+              "[self: #{self_type}] "
+            end
+
           if block
-            "^#{type.params} #{block} -> #{type.return_type}"
+            "^#{type.params} #{s}#{block} -> #{type.return_type}"
           else
-            "^#{type.params} -> #{type.return_type}"
+            "^#{type.params} #{s}-> #{type.return_type}"
           end
         end
 
@@ -42,6 +50,7 @@ module Steep
           @fvs ||= Set[].tap do |fvs|
             fvs.merge(type.free_variables)
             fvs.merge(block.free_variables) if block
+            fvs.merge(self_type.free_variables) if self_type
           end
         end
 
@@ -53,21 +62,25 @@ module Steep
             children.push(*block.type.params.each_type.to_a)
             children.push(block.type.return_type)
           end
+          if self_type
+            children.push(self_type)
+          end
           [0] + level_of_children(children)
         end
 
         def closed?
-          type.closed? && (block.nil? || block.closed?)
+          type.closed? && (block.nil? || block.closed?) &&  (self_type ? self_type.closed? : false)
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location, block: block, type: type)
+          self.class.new(location: new_location, block: block, type: type, self_type: self_type)
         end
 
         def map_type(&block)
           self.class.new(
             type: type.map_type(&block),
             block: self.block&.map_type(&block),
+            self_type: self_type ? yield(self_type) : nil,
             location: location
           )
         end
@@ -94,9 +107,10 @@ module Steep
         end
 
         def each_child(&block)
-          if block_given?
+          if block
             type.each_child(&block)
             self.block&.type&.each_child(&block)
+            self_type.each_child(&block) if self_type
           else
             enum_for :each_child
           end

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

@@ -8,6 +8,10 @@ module Steep
           @location = location
         end
 
+        def self.instance
+          @instance ||= new()
+        end
+
         def ==(other)
           other.is_a?(Self)
         end

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

@@ -49,7 +49,7 @@ module Steep
         end
 
         def hash
-          @hash ||= self.class.hash ^ types.sort_by(&:to_s).hash
+          @hash ||= types.inject(self.class.hash) {|c, type| type.hash ^ c }
         end
 
         alias eql? ==

data/lib/steep/cli.rb

@@ -18,7 +18,7 @@ module Steep
     end
 
     def self.available_commands
-      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats, :binstub]
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats, :binstub, :checkfile]
     end
 
     def process_global_options
@@ -123,6 +123,29 @@ module Steep
       end.run
     end
 
+    def process_checkfile
+      Drivers::Checkfile.new(stdout: stdout, stderr: stderr).tap do |check|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep checkfile [options] [files]"
+
+          opts.on("--steepfile=PATH") {|path| check.steepfile = Pathname(path) }
+          opts.on("--all-rbs", "Type check all RBS files") { check.all_rbs = true }
+          opts.on("--all-ruby", "Type check all Ruby files") { check.all_ruby = true }
+          opts.on("--stdin", "Read files to type check from stdin") do
+            while line = stdin.gets()
+              object = JSON.parse(line, symbolize_names: true)
+              Steep.logger.info { "Loading content of `#{object[:path]}` from stdin: #{object[:content].lines[0].chomp}" }
+              check.stdin_input[Pathname(object[:path])] = object[:content]
+            end
+          end
+          handle_jobs_option check, opts
+          handle_logging_options opts
+        end.parse!(argv)
+
+        check.command_line_args.push *argv
+      end.run
+    end
+
     def process_stats
       Drivers::Stats.new(stdout: stdout, stderr: stderr).tap do |check|
         OptionParser.new do |opts|

data/lib/steep/diagnostic/ruby.rb

@@ -87,13 +87,11 @@ module Steep
 
       class UnexpectedPositionalArgument < Base
         attr_reader :node
-        attr_reader :method_type
-        attr_reader :method_name
+        attr_reader :params
 
-        def initialize(node:, method_name:, method_type:)
+        def initialize(node:, params:)
           super(node: node)
-          @method_name = method_name
-          @method_type = method_type
+          @params = params
         end
 
         def header_line
@@ -103,10 +101,9 @@ module Steep
 
       class InsufficientPositionalArguments < Base
         attr_reader :node
-        attr_reader :method_name
-        attr_reader :method_type
+        attr_reader :params
 
-        def initialize(node:, method_name:, method_type:)
+        def initialize(node:, params:)
           send = case node.type
                  when :send, :csend
                    node
@@ -121,8 +118,7 @@ module Steep
                 end
 
           super(node: node, location: loc)
-          @method_name = method_name
-          @method_type = method_type
+          @params = params
         end
 
         def header_line
@@ -132,10 +128,9 @@ module Steep
 
       class UnexpectedKeywordArgument < Base
         attr_reader :node
-        attr_reader :method_name
-        attr_reader :method_type
+        attr_reader :params
 
-        def initialize(node:, method_name:, method_type:)
+        def initialize(node:, params:)
           loc = case node.type
                 when :pair
                   node.children[0].location.expression
@@ -145,8 +140,7 @@ module Steep
                   raise
                 end
           super(node: node, location: loc)
-          @method_name = method_name
-          @method_type = method_type
+          @params = params
         end
 
         def header_line
@@ -160,7 +154,7 @@ module Steep
         attr_reader :method_type
         attr_reader :missing_keywords
 
-        def initialize(node:, method_name:, method_type:, missing_keywords:)
+        def initialize(node:, params:, missing_keywords:)
           send = case node.type
                  when :send, :csend
                    node
@@ -176,8 +170,7 @@ module Steep
 
           super(node: node, location: loc)
 
-          @method_name = method_name
-          @method_type = method_type
+          @params = params
           @missing_keywords = missing_keywords
         end
 
@@ -220,14 +213,12 @@ module Steep
         attr_reader :node
         attr_reader :expected
         attr_reader :actual
-        attr_reader :receiver_type
         attr_reader :result
 
         include ResultPrinter
 
-        def initialize(node:, receiver_type:, expected:, actual:, result:)
+        def initialize(node:, expected:, actual:, result:)
           super(node: node)
-          @receiver_type = receiver_type
           @expected = expected
           @actual = actual
           @result = result
@@ -512,7 +503,11 @@ module Steep
         end
 
         def header_line
-          "No superclass method `#{method}` defined"
+          if method
+            "No superclass method `#{method}` defined"
+          else
+            "`super` is not allowed from outside of method"
+          end
         end
       end
 

data/lib/steep/drivers/checkfile.rb

@@ -0,0 +1,205 @@
+module Steep
+  module Drivers
+    class Checkfile
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_args
+      attr_accessor :all_ruby, :all_rbs
+      attr_reader :stdin_input
+
+      include Utils::DriverHelper
+      include Utils::JobsCount
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_args = []
+
+        @all_rbs = false
+        @all_ruby = false
+        @stdin_input = {}
+      end
+
+      def run
+        return 0 if command_line_args.empty? && !all_rbs && !all_ruby && stdin_input.empty?
+
+        project = load_config()
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
+
+        # @type var target_paths: Set[Pathname]
+        target_paths = Set[]
+        # @type var signature_paths: Set[Pathname]
+        signature_paths = Set[]
+
+        loader = Services::FileLoader.new(base_dir: project.base_dir)
+        project.targets.each do |target|
+          ruby_patterns =
+            case
+            when all_ruby
+              []
+            when command_line_args.empty?
+              nil
+            else
+              command_line_args
+            end
+
+          if ruby_patterns
+            loader.each_path_in_patterns(target.source_pattern, ruby_patterns) do |path|
+              target_paths << path
+            end
+          end
+
+          rbs_patterns =
+            case
+            when all_rbs
+              []
+            when command_line_args.empty?
+              nil
+            else
+              command_line_args
+            end
+
+          if rbs_patterns
+            loader.each_path_in_patterns(target.signature_pattern, rbs_patterns) do |path|
+              signature_paths << path
+            end
+          end
+        end
+
+        stdin_input.each_key do |path|
+          case ts = project.targets_for_path(path)
+          when Array
+            signature_paths << path
+          when Project::Target
+            target_paths << path
+          end
+        end
+
+        files = target_paths + signature_paths
+
+        count =
+          if files.size >= jobs_count
+            jobs_count
+          else
+            files.size + 2
+          end
+
+        Steep.logger.info { "Starting #{count} workers for #{files.size} files..." }
+
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+          steepfile: project.steepfile_path,
+          args: [],
+          delay_shutdown: true,
+          steep_command: steep_command,
+          count: count
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = false
+
+        main_thread = Thread.start do
+          master.start()
+        end
+        main_thread.abort_on_exception = true
+
+        Steep.logger.info { "Initializing server" }
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: {} })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        stdin_input.each do |path, content|
+          uri = PathHelper.to_uri(project.absolute_path(path))
+
+          master.broadcast_notification(
+            {
+              method: "textDocument/didChange",
+              params: {
+              textDocument: { uri: uri, version: 0 },
+              contentChanges: [{ text: content }]
+              }
+            }
+          )
+          master.broadcast_notification(
+            {
+              method: "textDocument/didSave",
+              params: {
+                textDocument: { uri: uri }
+              }
+            }
+          )
+        end
+
+        ping_guid = master.fresh_request_id()
+        client_writer.write({ method: "$/ping", id: ping_guid, params: {} })
+        wait_for_response_id(reader: client_reader, id: ping_guid)
+
+        request_guid = master.fresh_request_id()
+        request = Server::Master::TypeCheckRequest.new(guid: request_guid)
+
+        target_paths.each do |path|
+          request.code_paths << project.absolute_path(path)
+        end
+        signature_paths.each do |path|
+          request.signature_paths << project.absolute_path(path)
+        end
+
+        master.start_type_check(request, last_request: nil, start_progress: true)
+
+        Steep.logger.info { "Starting type checking: #{request_guid}" }
+
+        diagnostic_notifications = []
+        error_messages = []
+        client_reader.read do |response|
+          case
+          when response[:method] == "textDocument/publishDiagnostics"
+            params = response[:params]
+
+            if path = PathHelper.to_pathname(params[:uri])
+              stdout.puts(
+                {
+                  path: project.relative_path(path).to_s,
+                  diagnostics: params[:diagnostics]
+                }.to_json
+              )
+            end
+          when response[:method] == "window/showMessage"
+            # Assuming ERROR message means unrecoverable error.
+            message = response[:params]
+            if message[:type] == LSP::Constant::MessageType::ERROR
+              error_messages << message[:message]
+            end
+          when response[:method] == "$/progress"
+            if response[:params][:token] == request_guid
+              if response[:params][:value][:kind] == "end"
+                break
+              end
+            end
+          end
+        end
+
+        Steep.logger.info { "Shutting down..." }
+
+        shutdown_exit(reader: client_reader, writer: client_writer)
+        main_thread.join()
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/validate.rb

@@ -29,7 +29,9 @@ module Steep
               when Services::SignatureService::SyntaxErrorStatus, Services::SignatureService::AncestorErrorStatus
                 controller.status.diagnostics
               when Services::SignatureService::LoadedStatus
-                check = Subtyping::Check.new(factory: AST::Types::Factory.new(builder: controller.latest_builder))
+                factory = AST::Types::Factory.new(builder: controller.latest_builder)
+                builder = Interface::Builder.new(factory)
+                check = Subtyping::Check.new(builder: builder)
                 Signature::Validator.new(checker: check).tap {|v| v.validate() }.each_error.to_a
               end
             end

data/lib/steep/equatable.rb

@@ -5,6 +5,8 @@ module Steep
         instance_variables.all? do |name|
           other.instance_variable_get(name) == instance_variable_get(name)
         end
+      else
+        false
       end
     end
 

data/lib/steep/interface/block.rb

@@ -3,10 +3,12 @@ module Steep
     class Block
       attr_reader :type
       attr_reader :optional
+      attr_reader :self_type
 
-      def initialize(type:, optional:)
+      def initialize(type:, optional:, self_type:)
         @type = type
         @optional = optional
+        @self_type = self_type
       end
 
       def optional?
@@ -20,18 +22,19 @@ module Steep
       def to_optional
         self.class.new(
           type: type,
+          self_type: self_type,
           optional: true
         )
       end
 
       def ==(other)
-        other.is_a?(self.class) && other.type == type && other.optional == optional
+        other.is_a?(self.class) && other.type == type && other.optional == optional && other.self_type == self_type
       end
 
       alias eql? ==
 
       def hash
-        type.hash ^ optional.hash
+        type.hash ^ optional.hash ^ self_type.hash
       end
 
       def closed?
@@ -40,27 +43,28 @@ module Steep
 
       def subst(s)
         ty = type.subst(s)
-        if ty == type
+        st = self_type.subst(s) if self_type
+
+        if ty == type && st == self_type
           self
         else
-          self.class.new(
-            type: ty,
-            optional: optional
-          )
+          self.class.new(type: ty, self_type: st, optional: optional)
         end
       end
 
       def free_variables()
-        @fvs ||= type.free_variables
+        @fvs ||= type.free_variables + (self_type&.free_variables || Set[])
       end
 
       def to_s
-        "#{optional? ? "?" : ""}{ #{type.params} -> #{type.return_type} }"
+        self_binding = self_type ? "[self: #{self_type}] " : ""
+        "#{optional? ? "?" : ""}{ #{type.params} #{self_binding}-> #{type.return_type} }"
       end
 
       def map_type(&block)
         self.class.new(
           type: type.map_type(&block),
+          self_type: self_type&.map_type(&block),
           optional: optional
         )
       end
@@ -73,9 +77,15 @@ module Steep
           location: nil
         )
 
+        self_types = [self.self_type, other.self_type].compact
+
         self.class.new(
           type: type,
-          optional: optional
+          optional: optional,
+          self_type:
+            unless self_types.empty?
+              AST::Types::Union.build(types: self_types)
+            end
         )
       end
     end