steep 0.11.1 → 0.12.0

data/lib/steep/project/file_loader.rb

@@ -0,0 +1,63 @@
+module Steep
+  class Project
+    class FileLoader
+      attr_reader :project
+
+      def initialize(project:)
+        @project = project
+      end
+
+      def each_path_in_patterns(patterns, ext)
+        patterns.each do |path|
+          absolute_path = project.base_dir + path
+
+          if absolute_path.file?
+            yield project.relative_path(absolute_path)
+          else
+            files = if absolute_path.directory?
+                      Pathname.glob("#{absolute_path}/**/*#{ext}")
+                    else
+                      Pathname.glob(absolute_path)
+                    end
+
+            files.each do |source_path|
+              yield project.relative_path(source_path)
+            end
+          end
+        end
+      end
+
+      def load_sources(command_line_patterns)
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
+            target_patterns = command_line_patterns.empty? ? target.source_patterns : command_line_patterns
+
+            each_path_in_patterns target_patterns, ".rb" do |path|
+              if target.possible_source_file?(path)
+                unless target.source_file?(path)
+                  Steep.logger.info { "Adding source file: #{path}" }
+                  target.add_source path, project.absolute_path(path).read
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def load_signatures()
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
+            each_path_in_patterns target.signature_patterns, ".rbs" do |path|
+              if target.possible_signature_file?(path)
+                unless target.signature_file?(path)
+                  Steep.logger.info { "Adding signature file: #{path}" }
+                  target.add_signature path, project.absolute_path(path).read
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/options.rb

@@ -3,10 +3,17 @@ module Steep
     class Options
       attr_accessor :fallback_any_is_error
       attr_accessor :allow_missing_definitions
+      attr_accessor :vendored_stdlib_path
+      attr_accessor :vendored_gems_path
+      attr_reader :libraries
 
       def initialize
         self.fallback_any_is_error = false
         self.allow_missing_definitions = true
+        self.vendored_gems_path = nil
+        self.vendored_stdlib_path = nil
+
+        @libraries = []
       end
     end
   end

data/lib/steep/project/target.rb

@@ -0,0 +1,190 @@
+module Steep
+  class Project
+    class Target
+      attr_reader :name
+      attr_reader :options
+
+      attr_reader :source_patterns
+      attr_reader :ignore_patterns
+      attr_reader :signature_patterns
+
+      attr_reader :source_files
+      attr_reader :signature_files
+
+      attr_reader :status
+
+      SignatureSyntaxErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
+      SignatureValidationErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
+      TypeCheckStatus = Struct.new(:environment, :subtyping, :type_check_sources, :timestamp, keyword_init: true)
+
+      def initialize(name:, options:, source_patterns:, ignore_patterns:, signature_patterns:)
+        @name = name
+        @options = options
+        @source_patterns = source_patterns
+        @ignore_patterns = ignore_patterns
+        @signature_patterns = signature_patterns
+
+        @source_files = {}
+        @signature_files = {}
+      end
+
+      def add_source(path, content)
+        file = SourceFile.new(path: path)
+        file.content = content
+        source_files[path] = file
+      end
+
+      def remove_source(path)
+        source_files.delete(path)
+      end
+
+      def update_source(path, content)
+        file = source_files[path]
+        file.content = content
+      end
+
+      def add_signature(path, content)
+        file = SignatureFile.new(path: path)
+        file.content = content
+        signature_files[path] = file
+      end
+
+      def remove_signature(path)
+        signature_files.delete(path)
+      end
+
+      def update_signature(path, content)
+        file = signature_files[path]
+        file.content = content
+      end
+
+      def source_file?(path)
+        source_files.key?(path)
+      end
+
+      def signature_file?(path)
+        signature_files.key?(path)
+      end
+
+      def possible_source_file?(path)
+        self.class.test_pattern(source_patterns, path) &&
+          !self.class.test_pattern(ignore_patterns, path)
+      end
+
+      def possible_signature_file?(path)
+        self.class.test_pattern(signature_patterns, path)
+      end
+
+      def self.test_pattern(patterns, path)
+        patterns.any? do |pattern|
+          p = pattern.end_with?(File::Separator) ? pattern : pattern + File::Separator
+          path.to_s.start_with?(p) || File.fnmatch(pattern, path.to_s)
+        end
+      end
+
+      def type_check
+        load_signatures do |env, check, timestamp|
+          run_type_check(env, check, timestamp)
+        end
+      end
+
+      def environment
+        @environment ||= Ruby::Signature::Environment.new().tap do |env|
+          stdlib_root = options.vendored_stdlib_path || Ruby::Signature::EnvironmentLoader::STDLIB_ROOT
+          gem_vendor_path = options.vendored_gems_path
+          loader = Ruby::Signature::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
+          options.libraries.each do |lib|
+            loader.add(library: lib)
+          end
+          loader.load(env: env)
+        end
+      end
+
+      def load_signatures
+        timestamp = case status
+                    when TypeCheckStatus
+                      status.timestamp
+                    end
+
+        updated_files = []
+
+        signature_files.each_value do |file|
+          if !timestamp || file.content_updated_at >= timestamp
+            updated_files << file
+            file.load!()
+          end
+        end
+
+        if signature_files.each_value.all? {|file| file.status.is_a?(SignatureFile::DeclarationsStatus) }
+          if status.is_a?(TypeCheckStatus) && updated_files.empty?
+            yield status.environment, status.subtyping, status.timestamp
+          else
+            env = environment.dup
+
+            signature_files.each_value do |file|
+              if file.status.is_a?(SignatureFile::DeclarationsStatus)
+                file.status.declarations.each do |decl|
+                  env << decl
+                end
+              end
+            end
+
+            definition_builder = Ruby::Signature::DefinitionBuilder.new(env: env)
+            factory = AST::Types::Factory.new(builder: definition_builder)
+            check = Subtyping::Check.new(factory: factory)
+
+            validator = Signature::Validator.new(checker: check)
+            validator.validate()
+
+            if validator.no_error?
+              yield env, check, Time.now
+            else
+              @status = SignatureValidationErrorStatus.new(
+                errors: validator.each_error.to_a,
+                timestamp: Time.now
+              )
+            end
+          end
+
+        else
+          errors = signature_files.each_value.with_object([]) do |file, errors|
+            if file.status.is_a?(SignatureFile::ParseErrorStatus)
+              errors << file.status.error
+            end
+          end
+
+          @status = SignatureSyntaxErrorStatus.new(
+            errors: errors,
+            timestamp: Time.now
+          )
+        end
+      end
+
+      def run_type_check(env, check, timestamp)
+        type_check_sources = []
+
+        source_files.each_value do |file|
+          if file.type_check(check, timestamp)
+            type_check_sources << file
+          end
+        end
+
+        @status = TypeCheckStatus.new(
+          environment: env,
+          subtyping: check,
+          type_check_sources: type_check_sources,
+          timestamp: timestamp
+        )
+      end
+
+      def errors
+        case status
+        when TypeCheckStatus
+          source_files.each_value.flat_map(&:errors)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/steep/signature/errors.rb

@@ -2,102 +2,50 @@ module Steep
   module Signature
     module Errors
       class Base
-        # @implements Steep__Signature__Error
+        attr_reader :location
 
-        # @dynamic signature
-        attr_reader :signature
-
-        def initialize(signature:)
-          @signature = signature
-        end
-      end
-
-      class UnknownTypeName < Base
-        # @implements Steep__Signature__Errors__UnknownTypeName
-
-        # @dynamic type
-        attr_reader :type
-
-        def initialize(signature:, type:)
-          super(signature: signature)
-          @type = type
-        end
-
-        def puts(io)
-          io.puts "UnknownTypeName: signature=#{signature.name}, type=#{type}"
-        end
-      end
-
-      class IncompatibleOverride < Base
-        # @implements Steep__Signature__Errors__IncompatibleOverride
-
-        # @dynamic method_name
-        attr_reader :method_name
-        # @dynamic this_method
-        attr_reader :this_method
-        # @dynamic super_method
-        attr_reader :super_method
-
-        def initialize(signature:, method_name:, this_method:, super_method:)
-          super(signature: signature)
-          @method_name = method_name
-          @this_method = this_method
-          @super_method = super_method
+        def loc_to_s
+          Ruby::Signature::Location.to_string location
         end
 
-        def puts(io)
-          io.puts "IncompatibleOverride: signature=#{signature.name}, method=#{method_name}"
+        def to_s
+          StringIO.new.tap do |io|
+            puts io
+          end.string
         end
-      end
-
-      class InvalidTypeApplication < Base
-        attr_reader :type_name
-        attr_reader :type_args
 
-        def initialize(signature:, type_name:, type_args:)
-          super(signature: signature)
-          @type_name = type_name
-          @type_args = type_args
-        end
-
-        def puts(io)
-          io.puts "InvalidTypeApplication: signature=#{signature.name}, type_name=#{type_name}, type_args=#{type_args}"
+        def path
+          location.buffer.name
         end
       end
 
-      class InvalidSelfType < Base
-        attr_reader :member
+      class UnknownTypeNameError < Base
+        attr_reader :name
 
-        def initialize(signature:, member:)
-          super(signature: signature)
-          @member = member
+        def initialize(name:, location:)
+          @name = name
+          @location = location
         end
 
-
         def puts(io)
-          io.puts "InvalidSelfType: signature=#{signature.name}, module=#{member.name}"
+          io.puts "#{loc_to_s}\tUnknownTypeNameError: name=#{name}"
         end
       end
 
-      class UnexpectedTypeNameKind < Base
-        attr_reader :type
-        attr_reader :expected_kind
-
-        def initialize(signature:, type:, expected_kind:)
-          super(signature: signature)
-          @type = type
-          @expected_kind = expected_kind
-        end
-
+      class InvalidTypeApplicationError < Base
+        attr_reader :name
+        attr_reader :args
+        attr_reader :params
 
-        def puts(io)
-          io.puts "UnexpectedTypeNameKind: signature=#{signature.name}, type=#{type}, kind=#{expected_kind}"
+        def initialize(name:, args:, params:, location:)
+          @name = name
+          @args = args
+          @params = params
+          @location = location
         end
-      end
 
-      class ConstructorNoCheck < Base
         def puts(io)
-          io.puts "ConstructorNoCheck: signature=#{signature.name}"
+          io.puts "#{loc_to_s}\tInvalidTypeApplicationError: name=#{name}, expected=[#{params.join(", ")}], actual=[#{args.join(", ")}]"
         end
       end
     end

data/lib/steep/signature/validator.rb

@@ -0,0 +1,122 @@
+module Steep
+  module Signature
+    class Validator
+      Location = Ruby::Signature::Location
+      Declarations = Ruby::Signature::AST::Declarations
+
+      attr_reader :checker
+
+      def initialize(checker:)
+        @checker = checker
+        @errors = []
+      end
+
+      def has_error?
+        !no_error?
+      end
+
+      def no_error?
+        @errors.empty?
+      end
+
+      def each_error(&block)
+        if block_given?
+          @errors.each(&block)
+        else
+          enum_for :each_error
+        end
+      end
+
+      def env
+        checker.factory.env
+      end
+
+      def builder
+        checker.factory.definition_builder
+      end
+
+      def factory
+        checker.factory
+      end
+
+      def validate
+        @errors = []
+
+        validate_decl
+        validate_const
+        validate_global
+      end
+
+      def validate_one_decl(name, decl)
+        case decl
+        when Declarations::Class
+          rescue_validation_errors do
+            Steep.logger.info "#{Location.to_string decl.location}:\tValidating class definition `#{name}`..."
+            builder.build_instance(decl.name.absolute!).each_type do |type|
+              env.validate type, namespace: Ruby::Signature::Namespace.root
+            end
+            builder.build_singleton(decl.name.absolute!).each_type do |type|
+              env.validate type, namespace: Ruby::Signature::Namespace.root
+            end
+          end
+        when Declarations::Interface
+          rescue_validation_errors do
+            Steep.logger.info "#{Location.to_string decl.location}:\tValidating interface `#{name}`..."
+            builder.build_interface(decl.name.absolute!, decl).each_type do |type|
+              env.validate type, namespace: Ruby::Signature::Namespace.root
+            end
+          end
+        end
+      end
+
+      def validate_decl
+        env.each_decl do |name, decl|
+          validate_one_decl name, decl
+        end
+      end
+
+      def validate_const
+        env.each_constant do |name, decl|
+          rescue_validation_errors do
+            Steep.logger.info "#{Location.to_string decl.location}:\tValidating constant `#{name}`..."
+            env.validate(decl.type, namespace: name.namespace)
+          end
+        end
+      end
+
+      def validate_global
+        env.each_global do |name, decl|
+          rescue_validation_errors do
+            Steep.logger.info "#{Location.to_string decl.location}:\tValidating global `#{name}`..."
+            env.validate(decl.type, namespace: Ruby::Signature::Namespace.root)
+          end
+        end
+      end
+
+      def validate_alias
+        env.each_alias do |name, decl|
+          rescue_validation_errors do
+            Steep.logger.info "#{Location.to_string decl.location}:\tValidating alias `#{name}`..."
+            env.validate(decl.type, namespace: name.namespace)
+          end
+        end
+      end
+
+      def rescue_validation_errors
+        yield
+      rescue Ruby::Signature::InvalidTypeApplicationError => exn
+        @errors << Errors::InvalidTypeApplicationError.new(
+          name: factory.type_name(exn.type_name),
+          args: exn.args.map {|ty| factory.type(ty) },
+          params: exn.params.each.map(&:name),
+          location: exn.location
+        )
+      rescue Ruby::Signature::NoTypeFoundError => exn
+        @errors << Errors::UnknownTypeNameError.new(
+          name: factory.type_name(exn.type_name),
+          location: exn.location
+        )
+      end
+    end
+  end
+end