steep 0.13.0 → 0.16.2

data/lib/steep/project/dsl.rb

@@ -9,6 +9,7 @@ module Steep
         attr_reader :ignored_sources
         attr_reader :no_builtin
         attr_reader :vendor_dir
+        attr_reader :strictness_level
 
         def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
           @name = name
@@ -17,6 +18,7 @@ module Steep
           @signatures = signatures
           @ignored_sources = ignored_sources
           @vendor_dir = nil
+          @strictness_level = :default
         end
 
         def initialize_copy(other)
@@ -26,6 +28,7 @@ module Steep
           @signatures = other.signatures.dup
           @ignored_sources = other.ignored_sources.dup
           @vendor_dir = other.vendor_dir
+          @strictness_level = other.strictness_level
         end
 
         def check(*args)
@@ -40,6 +43,10 @@ module Steep
           libraries.push(*args)
         end
 
+        def typing_options(level)
+          @strictness_level = level
+        end
+
         def signature(*args)
           signatures.push(*args)
         end
@@ -114,6 +121,13 @@ module Steep
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
 
+            case target.strictness_level
+            when :strict
+              options.apply_strict_typing_options!
+            when :lenient
+              options.apply_lenient_typing_options!
+            end
+
             case target.vendor_dir
             when Array
               options.vendored_stdlib_path = target.vendor_dir[0]

data/lib/steep/project/file.rb

@@ -31,65 +31,72 @@ module Steep
         case status
         when TypeCheckStatus
           status.typing.errors
-          # 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
         else
           []
         end
       end
 
+      def self.parse(source_code, path:, factory:)
+        Source.parse(source_code, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
+      end
+
+      def self.type_check(source, subtyping:)
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [AST::Namespace.root])
+        type_env = TypeInference::TypeEnv.build(annotations: annotations,
+                                                subtyping: subtyping,
+                                                const_env: const_env,
+                                                signatures: subtyping.factory.env)
+        lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+          subtyping: subtyping,
+          self_type: AST::Builtin::Object.instance_type
+        ).annotate(annotations)
+
+        context = TypeInference::Context.new(
+          block_context: nil,
+          module_context: TypeInference::Context::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,
+          break_context: nil,
+          self_type: AST::Builtin::Object.instance_type,
+          type_env: type_env,
+          lvar_env: lvar_env
+        )
+
+        typing = Typing.new(source: source, root_context: context)
+
+        construction = TypeConstruction.new(
+          checker: subtyping,
+          annotations: annotations,
+          source: source,
+          context: context,
+          typing: typing
+        )
+
+        construction.synthesize(source.node) if source.node
+
+        typing
+      end
+
       def type_check(subtyping, env_updated_at)
         # skip type check
         return false if status.is_a?(TypeCheckStatus) && env_updated_at <= status.timestamp
 
         parse(subtyping.factory) do |source|
-          typing = Typing.new
-
-          if source
-            annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-            const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
-            type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                    subtyping: subtyping,
-                                                    const_env: const_env,
-                                                    signatures: subtyping.factory.env)
-
-            construction = TypeConstruction.new(
-              checker: subtyping,
-              annotations: annotations,
-              source: source,
-              context: TypeInference::Context.new(
-                block_context: nil,
-                module_context: TypeInference::Context::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,
-                break_context: nil,
-                self_type: AST::Builtin::Object.instance_type,
-                type_env: type_env
-              ),
-              typing: typing
-            )
-
-            construction.synthesize(source.node)
-          end
-
+          typing = self.class.type_check(source, subtyping: subtyping)
           @status = TypeCheckStatus.new(
             typing: typing,
             source: source,
             timestamp: Time.now
           )
         rescue => exn
+          Steep.log_error(exn)
           @status = TypeCheckErrorStatus.new(error: exn)
         end
 
@@ -100,7 +107,7 @@ module Steep
         if status.is_a?(TypeCheckStatus)
           yield status.source
         else
-          yield Source.parse(content, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
+          yield self.class.parse(content, path: path, factory: factory)
         end
       rescue AnnotationParser::SyntaxError => exn
         Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }
@@ -133,10 +140,10 @@ module Steep
       end
 
       def load!
-        buffer = Ruby::Signature::Buffer.new(name: path, content: content)
-        decls = Ruby::Signature::Parser.parse_signature(buffer)
+        buffer = RBS::Buffer.new(name: path, content: content)
+        decls = RBS::Parser.parse_signature(buffer)
         @status = DeclarationsStatus.new(declarations: decls)
-      rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
         @status = ParseErrorStatus.new(error: exn)
       end
     end

data/lib/steep/project/hover_content.rb

@@ -33,21 +33,30 @@ module Steep
       end
 
       def content_for(path:, line:, column:)
-        source_file = project.targets.map {|target| target.source_files[path] }.compact[0]
+        target = project.targets.find {|target| target.source_file?(path) }
+
+        if target
+          source_file = target.source_files[path]
+          target.type_check(target_sources: [source_file], validate_signatures: false)
 
-        if source_file
           case (status = source_file.status)
           when SourceFile::TypeCheckStatus
             node, *parents = status.source.find_nodes(line: line, column: column)
 
             if node
               case node.type
-              when :lvar, :lvasgn
+              when :lvar
                 var_name = node.children[0]
-                context = status.typing.context_of(node: node)
-                var_type = context.type_env.get(lvar: var_name.name)
+                context = status.typing.context_at(line: line, column: column)
+                var_type = context.lvar_env[var_name.name] || AST::Types::Any.new(location: nil)
 
                 VariableContent.new(node: node, name: var_name.name, type: var_type, location: node.location.name)
+              when :lvasgn
+                var_name, rhs = node.children
+                context = status.typing.context_at(line: line, column: column)
+                type = context.lvar_env[var_name.name] || status.typing.type_of(node: rhs)
+
+                VariableContent.new(node: node, name: var_name.name, type: type, location: node.location.name)
               when :send
                 receiver, method_name, *_ = node.children
 
@@ -58,7 +67,7 @@ module Steep
                                 node
                               end
 
-                context = status.typing.context_of(node: result_node)
+                context = status.typing.context_at(line: line, column: column)
 
                 receiver_type = if receiver
                                   status.typing.type_of(node: receiver)
@@ -98,10 +107,10 @@ module Steep
                   location: result_node.location.expression
                 )
               when :def, :defs
-                context = status.typing.context_of(node: node)
+                context = status.typing.context_at(line: line, column: column)
                 method_context = context.method_context
 
-                if method_context
+                if method_context && method_context.method
                   DefinitionContent.new(
                     node: node,
                     method_name: method_context.name,

data/lib/steep/project/options.rb

@@ -1,20 +1,42 @@
 module Steep
   class Project
     class Options
-      attr_accessor :fallback_any_is_error
+      attr_accessor :allow_fallback_any
       attr_accessor :allow_missing_definitions
+      attr_accessor :allow_unknown_constant_assignment
+      attr_accessor :allow_unknown_method_calls
       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
+        apply_default_typing_options!
         self.vendored_gems_path = nil
         self.vendored_stdlib_path = nil
 
         @libraries = []
       end
+
+      def apply_default_typing_options!
+        self.allow_fallback_any = true
+        self.allow_missing_definitions = true
+        self.allow_unknown_constant_assignment = false
+        self.allow_unknown_method_calls = false
+      end
+
+      def apply_strict_typing_options!
+        self.allow_fallback_any = false
+        self.allow_missing_definitions = false
+        self.allow_unknown_constant_assignment = false
+        self.allow_unknown_method_calls = false
+      end
+
+      def apply_lenient_typing_options!
+        self.allow_fallback_any = true
+        self.allow_missing_definitions = true
+        self.allow_unknown_constant_assignment = true
+        self.allow_unknown_method_calls = true
+      end
     end
   end
 end

data/lib/steep/project/target.rb

@@ -67,32 +67,38 @@ module Steep
       end
 
       def possible_source_file?(path)
-        self.class.test_pattern(source_patterns, path) &&
-          !self.class.test_pattern(ignore_patterns, path)
+        self.class.test_pattern(source_patterns, path, ext: ".rb") &&
+          !self.class.test_pattern(ignore_patterns, path, ext: ".rb")
       end
 
       def possible_signature_file?(path)
-        self.class.test_pattern(signature_patterns, path)
+        self.class.test_pattern(signature_patterns, path, ext: ".rbs")
       end
 
-      def self.test_pattern(patterns, path)
+      def self.test_pattern(patterns, path, ext:)
         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)
+          (path.to_s.start_with?(p) && path.extname == ext) || File.fnmatch(pattern, path.to_s)
         end
       end
 
-      def type_check
-        load_signatures do |env, check, timestamp|
-          run_type_check(env, check, timestamp)
+      def type_check(target_sources: source_files.values, validate_signatures: true)
+        Steep.logger.tagged "target#type_check(target_sources: [#{target_sources.map(&:path).join(", ")}], validate_signatures: #{validate_signatures})" do
+          Steep.measure "load signature and type check" do
+            load_signatures(validate: validate_signatures) do |env, check, timestamp|
+              Steep.measure "type checking #{target_sources.size} files" do
+                run_type_check(env, check, timestamp, target_sources: target_sources)
+              end
+            end
+          end
         end
       end
 
       def environment
-        @environment ||= Ruby::Signature::Environment.new().tap do |env|
-          stdlib_root = options.vendored_stdlib_path || Ruby::Signature::EnvironmentLoader::STDLIB_ROOT
+        @environment ||= RBS::Environment.new().tap do |env|
+          stdlib_root = options.vendored_stdlib_path || RBS::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)
+          loader = RBS::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
           options.libraries.each do |lib|
             loader.add(library: lib)
           end
@@ -100,7 +106,7 @@ module Steep
         end
       end
 
-      def load_signatures
+      def load_signatures(validate:)
         timestamp = case status
                     when TypeCheckStatus
                       status.timestamp
@@ -129,20 +135,24 @@ module Steep
               end
             end
 
-            definition_builder = Ruby::Signature::DefinitionBuilder.new(env: env)
+            definition_builder = RBS::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
+            if validate
+              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
             else
-              @status = SignatureValidationErrorStatus.new(
-                errors: validator.each_error.to_a,
-                timestamp: Time.now
-              )
+              yield env, check, Time.now
             end
           end
 
@@ -160,10 +170,10 @@ module Steep
         end
       end
 
-      def run_type_check(env, check, timestamp)
+      def run_type_check(env, check, timestamp, target_sources: source_files.values)
         type_check_sources = []
 
-        source_files.each_value do |file|
+        target_sources.each do |file|
           if file.type_check(check, timestamp)
             type_check_sources << file
           end
@@ -177,6 +187,12 @@ module Steep
         )
       end
 
+      def no_error?
+        source_files.all? do |_, file|
+          file.status.is_a?(Project::SourceFile::TypeCheckStatus)
+        end
+      end
+
       def errors
         case status
         when TypeCheckStatus

data/lib/steep/server/base_worker.rb

@@ -0,0 +1,56 @@
+module Steep
+  module Server
+    class BaseWorker
+      LSP = LanguageServer::Protocol
+
+      include Utils
+
+      attr_reader :project
+      attr_reader :reader, :writer
+
+      def initialize(project:, reader:, writer:)
+        @project = project
+        @reader = reader
+        @writer = writer
+      end
+
+      def handle_request(request)
+        # process request
+      end
+
+      def handle_job(job)
+        # process async job
+      end
+
+      def run
+        tags = Steep.logger.formatter.current_tags.dup
+        thread = Thread.new do
+          Steep.logger.formatter.push_tags(*tags)
+          Steep.logger.tagged "background" do
+            while job = queue.pop
+              handle_job(job)
+            end
+          end
+        end
+
+        Steep.logger.tagged "frontend" do
+          begin
+            reader.read do |request|
+              case request[:method]
+              when "shutdown"
+                # nop
+              when "exit"
+                break
+              else
+                handle_request(request)
+              end
+            end
+          ensure
+            queue << nil
+            thread.join
+          end
+        end
+      end
+    end
+  end
+end