steep 0.9.0 → 0.10.0

data/lib/steep/drivers/watch.rb

@@ -0,0 +1,188 @@
+module Steep
+  module Drivers
+    class Watch
+      class Options
+        attr_accessor :fallback_any_is_error
+        attr_accessor :allow_missing_definitions
+
+        def initialize
+          self.fallback_any_is_error = false
+          self.allow_missing_definitions = true
+        end
+      end
+
+      attr_reader :source_dirs
+      attr_reader :signature_dirs
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :options
+      attr_reader :queue
+
+      include Utils::EachSignature
+
+      def initialize(source_dirs:, signature_dirs:, stdout:, stderr:)
+        @source_dirs = source_dirs
+        @signature_dirs = signature_dirs
+        @stdout = stdout
+        @stderr = stderr
+        @options = Options.new
+        @queue = Thread::Queue.new
+      end
+
+      def project_options
+        Project::Options.new.tap do |opt|
+          opt.fallback_any_is_error = options.fallback_any_is_error
+          opt.allow_missing_definitions = options.allow_missing_definitions
+        end
+      end
+
+      def source_listener
+        @source_listener ||= yield_self do
+          Listen.to(*source_dirs.map(&:to_s), only: /\.rb$/) do |modified, added, removed|
+            queue << [:source, modified, added, removed]
+          end
+        end
+      end
+
+      def signature_listener
+        @signature_listener ||= yield_self do
+          Listen.to(*signature_dirs.map(&:to_s), only: /\.rbi$/) do |modified, added, removed|
+            queue << [:signature, modified, added, removed]
+          end
+        end
+      end
+
+      def type_check_thread(project)
+        Thread.new do
+          until queue.closed?
+            begin
+              events = []
+              events << queue.deq
+              until queue.empty?
+                events << queue.deq(nonblock: true)
+              end
+
+              events.compact.each do |name, modified, added, removed|
+                case name
+                when :source
+                  (modified + added).each do |name|
+                    path = Pathname(name).relative_path_from(Pathname.pwd)
+                    file = project.source_files[path] || Project::SourceFile.new(path: path, options: project_options)
+                    file.content = path.read
+                    project.source_files[path] = file
+                  end
+
+                  removed.each do |name|
+                    path = Pathname(name).relative_path_from(Pathname.pwd)
+                    project.source_files.delete(path)
+                  end
+
+                when :signature
+                  (modified + added).each do |name|
+                    path = Pathname(name).relative_path_from(Pathname.pwd)
+                    file = project.signature_files[path] || Project::SignatureFile.new(path: path)
+                    file.content = path.read
+                    project.signature_files[path] = file
+                  end
+
+                  removed.each do |name|
+                    path = Pathname(name).relative_path_from(Pathname.pwd)
+                    project.signature_files.delete(path)
+                  end
+                end
+              end
+
+              begin
+                project.type_check
+              rescue Racc::ParseError => exn
+                stderr.puts exn.message
+                project.clear
+              end
+            end
+          end
+        rescue ClosedQueueError
+          # nop
+        end
+      end
+
+      class WatchListener < Project::NullListener
+        attr_reader :stdout
+        attr_reader :stderr
+
+        def initialize(stdout:, stderr:, verbose:)
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        def check(project:)
+          yield.tap do
+            if project.success?
+              if project.has_type_error?
+                stdout.puts "Detected #{project.errors.size} errors... 🔥"
+              else
+                stdout.puts "No error detected. 🎉"
+              end
+            else
+              stdout.puts "Type checking failed... 🔥"
+            end
+          end
+        end
+
+        def type_check_source(project:, file:)
+          yield.tap do
+            case
+            when file.source.is_a?(Source) && file.errors
+              file.errors.each do |error|
+                error.print_to stdout
+              end
+            end
+          end
+        end
+
+        def load_signature(project:)
+          # @type var project: Project
+          yield.tap do
+            case sig = project.signature
+            when Project::SignatureHasError
+            when Project::SignatureHasSyntaxError
+              sig.errors.each do |path, exn|
+                stdout.puts "#{path} has a syntax error: #{exn.inspect}"
+              end
+            end
+          end
+        end
+      end
+
+      def run(block: true)
+        project = Project.new(WatchListener.new(stdout: stdout, stderr: stderr, verbose: false))
+
+        source_dirs.each do |path|
+          each_file_in_path(".rb", path) do |file_path|
+            file = Project::SourceFile.new(path: file_path, options: options)
+            file.content = file_path.read
+            project.source_files[file_path] = file
+          end
+        end
+
+        signature_dirs.each do |path|
+          each_file_in_path(".rbi", path) do |file_path|
+            file = Project::SignatureFile.new(path: file_path)
+            file.content = file_path.read
+            project.signature_files[file_path] = file
+          end
+        end
+
+        project.type_check
+
+        source_listener.start
+        signature_listener.start
+        t = type_check_thread(project)
+
+        binding.pry(quiet: true) if block
+
+        queue.close
+        t.join
+      end
+    end
+  end
+end

data/lib/steep/errors.rb

@@ -518,7 +518,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedKeyword: #{unexpected_keywords.join(", ")}"
+        "#{location_to_str}: UnexpectedKeyword: #{unexpected_keywords.to_a.join(", ")}"
       end
     end
 
@@ -531,7 +531,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MissingKeyword: #{missing_keywords.join(", ")}"
+        "#{location_to_str}: MissingKeyword: #{missing_keywords.to_a.join(", ")}"
       end
     end
   end

data/lib/steep/project/file.rb

@@ -0,0 +1,119 @@
+module Steep
+  class Project
+    class SourceFile
+      attr_reader :options
+      attr_reader :path
+      attr_reader :content
+      attr_reader :content_updated_at
+
+      attr_reader :source
+      attr_reader :typing
+      attr_reader :last_type_checked_at
+
+      def initialize(path:, options:)
+        @path = path
+        @options = options
+        self.content = ""
+      end
+
+      def content=(content)
+        @content_updated_at = Time.now
+        @content = content
+      end
+
+      def requires_type_check?
+        if last = last_type_checked_at
+          last < content_updated_at
+        else
+          true
+        end
+      end
+
+      def invalidate
+        @source = nil
+        @typing = nil
+        @last_type_checked_at = nil
+      end
+
+      def parse
+        _ = @source =
+          begin
+            Source.parse(content, path: path.to_s, labeling: ASTUtils::Labeling.new)
+          rescue ::Parser::SyntaxError => exn
+            Steep.logger.warn { "Syntax error on #{path}: #{exn.inspect}" }
+            exn
+          end
+      end
+
+      def errors
+        typing&.errors&.reject do |error|
+          case
+          when error.is_a?(Errors::FallbackAny)
+            !options.fallback_any_is_error
+          when error.is_a?(Errors::MethodDefinitionMissing)
+            options.allow_missing_definitions
+          end
+        end
+      end
+
+      def type_check(check)
+        case source = self.source
+        when Source
+          @typing = Typing.new
+
+          annotations = source.annotations(block: source.node, builder: check.builder, current_module: AST::Namespace.root)
+
+          const_env = TypeInference::ConstantEnv.new(builder: check.builder, context: nil)
+          type_env = TypeInference::TypeEnv.build(annotations: annotations,
+                                                  subtyping: check,
+                                                  const_env: const_env,
+                                                  signatures: check.builder.signatures)
+
+          construction = TypeConstruction.new(
+            checker: check,
+            annotations: annotations,
+            source: source,
+            self_type: AST::Builtin::Object.instance_type,
+            block_context: nil,
+            module_context: TypeConstruction::ModuleContext.new(
+              instance_type: nil,
+              module_type: nil,
+              implement_name: nil,
+              current_namespace: AST::Namespace.root,
+              const_env: const_env,
+              class_name: nil
+            ),
+            method_context: nil,
+            typing: typing,
+            break_context: nil,
+            type_env: type_env
+          )
+
+          construction.synthesize(source.node)
+
+          @last_type_checked_at = Time.now
+        end
+      end
+    end
+
+    class SignatureFile
+      attr_reader :path
+      attr_reader :content
+      attr_reader :content_updated_at
+
+      def initialize(path:)
+        @path = path
+        self.content = ""
+      end
+
+      def parse
+        Parser.parse_signature(content, name: path)
+      end
+
+      def content=(content)
+        @content_updated_at = Time.now
+        @content = content
+      end
+    end
+  end
+end

data/lib/steep/project/listener.rb

@@ -0,0 +1,53 @@
+module Steep
+  class Project
+    class NullListener
+      def parse_signature(project:, file:)
+        yield
+      end
+
+      def parse_source(project:, file:)
+        yield
+      end
+
+      def check(project:)
+        yield
+      end
+
+      def validate_signature(project:)
+        yield
+      end
+
+      def type_check_source(project:, file:)
+        yield
+      end
+
+      def clear_project(project:)
+        yield
+      end
+
+      def load_signature(project:)
+        yield
+      end
+    end
+
+    class SyntaxErrorRaisingListener < NullListener
+      def load_signature(project:)
+        yield.tap do
+          case signature = project.signature
+          when SignatureHasSyntaxError
+            raise signature.errors.values[0]
+          end
+        end
+      end
+
+      def parse_source(project:, file:)
+        yield.tap do
+          case source = file.source
+          when ::Parser::SyntaxError
+            raise source
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/options.rb

@@ -0,0 +1,13 @@
+module Steep
+  class Project
+    class Options
+      attr_accessor :fallback_any_is_error
+      attr_accessor :allow_missing_definitions
+
+      def initialize
+        self.fallback_any_is_error = false
+        self.allow_missing_definitions = true
+      end
+    end
+  end
+end

data/lib/steep/project.rb

@@ -0,0 +1,231 @@
+module Steep
+  class Project
+    class SignatureLoaded
+      attr_reader :check
+      attr_reader :loaded_at
+      attr_reader :file_paths
+
+      def initialize(check:, loaded_at:, file_paths:)
+        @check = check
+        @loaded_at = loaded_at
+        @file_paths = file_paths
+      end
+    end
+
+    class SignatureHasSyntaxError
+      attr_reader :errors
+
+      def initialize(errors:)
+        @errors = errors
+      end
+    end
+
+    class SignatureHasError
+      attr_reader :errors
+
+      def initialize(errors:)
+        @errors = errors
+      end
+    end
+
+    attr_reader :source_files
+    attr_reader :signature_files
+    attr_reader :listener
+
+    attr_reader :signature
+
+    def initialize(listener = nil)
+      @listener = listener || NullListener.new
+      @source_files = {}
+      @signature_files = {}
+    end
+
+    def clear
+      listener.clear_project project: self do
+        @signature = nil
+        source_files.each_value do |file|
+          file.invalidate
+        end
+      end
+    end
+
+    def type_check(force_signatures: false, force_sources: false)
+      listener.check(project: self) do
+        should_reload_signature = force_signatures || signature_updated?
+        reload_signature if should_reload_signature
+
+        case sig = signature
+        when SignatureLoaded
+          each_updated_source(force: force_sources || should_reload_signature) do |file|
+            file.invalidate
+
+            listener.parse_source(project: self, file: file) do
+              file.parse()
+            end
+
+            listener.type_check_source(project: self, file: file) do
+              file.type_check(sig.check)
+            end
+          end
+        end
+      end
+    end
+
+    def success?
+      signature.is_a?(SignatureLoaded) &&
+        source_files.all? {|_, file| file.source.is_a?(Source) && file.typing }
+    end
+
+    def has_type_error?
+      source_files.any? do |_, file|
+        file.errors&.any?
+      end
+    end
+
+    def errors
+      source_files.flat_map do |_, file|
+        file.errors || []
+      end
+    end
+
+    # @type method each_updated_source: (?force: bool) ?{ (SourceFile) -> any } -> any
+    def each_updated_source(force: false)
+      if block_given?
+        source_files.each_value do |file|
+          if force || file.requires_type_check?
+            yield file
+          end
+        end
+      else
+        enum_for :each_updated_source, force: force
+      end
+    end
+
+    def signature_updated?
+      case sig = signature
+      when SignatureLoaded
+        signature_files.keys != sig.file_paths ||
+          signature_files.any? {|_, file| file.content_updated_at >= sig.loaded_at }
+      else
+        true
+      end
+    end
+
+    def reload_signature
+      @signature = nil
+
+      env = AST::Signature::Env.new
+      builder = Interface::Builder.new(signatures: env)
+      check = Subtyping::Check.new(builder: builder)
+
+      # @type var syntax_errors: Hash<Pathname, any>
+      syntax_errors = {}
+
+      listener.load_signature(project: self) do
+        signature_files.each_value do |file|
+          sigs = listener.parse_signature(project: self, file: file) do
+            file.parse
+          end
+
+          sigs.each do |sig|
+            env.add sig
+          end
+        rescue Racc::ParseError => exn
+          Steep.logger.warn { "Syntax error on #{file.path}: #{exn.inspect}" }
+          syntax_errors[file.path] = exn
+        end
+
+        if syntax_errors.empty?
+          listener.validate_signature(project: self) do
+            errors = validate_signature(check)
+            @signature = if errors.empty?
+                           SignatureLoaded.new(check: check, loaded_at: Time.now, file_paths: signature_files.keys)
+                         else
+                           SignatureHasError.new(errors: errors)
+                         end
+          end
+        else
+          @signature = SignatureHasSyntaxError.new(errors: syntax_errors)
+        end
+      end
+    end
+
+    def validate_signature(check)
+      errors = []
+
+      builder = check.builder
+
+      check.builder.signatures.each do |sig|
+        Steep.logger.debug { "Validating signature: #{sig.inspect}" }
+
+        case sig
+        when AST::Signature::Interface
+          yield_self do
+            instance_interface = builder.build_interface(sig.name)
+
+            args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+            instance_type = AST::Types::Name::Interface.new(name: sig.name, args: args)
+
+            instance_interface.instantiate(type: instance_type,
+                                           args: args,
+                                           instance_type: instance_type,
+                                           module_type: nil).validate(check)
+          end
+
+        when AST::Signature::Module
+          yield_self do
+            instance_interface = builder.build_instance(sig.name)
+            instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+            module_interface = builder.build_module(sig.name)
+            module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+            instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
+            module_type = AST::Types::Name::Module.new(name: sig.name)
+
+            Steep.logger.debug { "Validating instance methods..." }
+            instance_interface.instantiate(type: instance_type,
+                                           args: instance_args,
+                                           instance_type: instance_type,
+                                           module_type: module_type).validate(check)
+
+            Steep.logger.debug { "Validating class methods..." }
+            module_interface.instantiate(type: module_type,
+                                         args: module_args,
+                                         instance_type: instance_type,
+                                         module_type: module_type).validate(check)
+          end
+
+        when AST::Signature::Class
+          yield_self do
+            instance_interface = builder.build_instance(sig.name)
+            instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+            module_interface = builder.build_class(sig.name, constructor: true)
+            module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+            instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
+            module_type = AST::Types::Name::Class.new(name: sig.name, constructor: true)
+
+            Steep.logger.debug { "Validating instance methods..." }
+            instance_interface.instantiate(type: instance_type,
+                                           args: instance_args,
+                                           instance_type: instance_type,
+                                           module_type: module_type).validate(check)
+
+            Steep.logger.debug { "Validating class methods..." }
+            module_interface.instantiate(type: module_type,
+                                         args: module_args,
+                                         instance_type: instance_type,
+                                         module_type: module_type).validate(check)
+          end
+        end
+
+      rescue => exn
+        errors << exn
+      end
+
+      errors
+    end
+  end
+end