steep 0.37.0 → 0.42.0

data/lib/steep/services/stats_calculator.rb

@@ -0,0 +1,69 @@
+module Steep
+  module Services
+    class StatsCalculator
+      SuccessStats = Struct.new(:target, :path, :typed_calls_count, :untyped_calls_count, :error_calls_count, keyword_init: true) do
+        def as_json
+          {
+            type: "success",
+            target: target.name.to_s,
+            path: path.to_s,
+            typed_calls: typed_calls_count,
+            untyped_calls: untyped_calls_count,
+            error_calls: error_calls_count,
+            total_calls: typed_calls_count + untyped_calls_count + error_calls_count
+          }
+        end
+      end
+      ErrorStats = Struct.new(:target, :path, keyword_init: true) do
+        def as_json
+          {
+            type: "error",
+            target: target.name.to_s,
+            path: path.to_s
+          }
+        end
+      end
+
+      attr_reader :service
+
+      def initialize(service:)
+        @service = service
+      end
+
+      def project
+        service.project
+      end
+
+      def calc_stats(target, file:)
+        if typing = file.typing
+          typed = 0
+          untyped = 0
+          errors = 0
+          total = 0
+          typing.method_calls.each_value do |call|
+            case call
+            when TypeInference::MethodCall::Typed
+              typed += 1
+            when TypeInference::MethodCall::Untyped
+              untyped += 1
+            when TypeInference::MethodCall::Error, TypeInference::MethodCall::NoMethodError
+              errors += 1
+            else
+              raise
+            end
+          end
+
+          SuccessStats.new(
+            target: target,
+            path: file.path,
+            typed_calls_count: typed,
+            untyped_calls_count: untyped,
+            error_calls_count: errors
+          )
+        else
+          ErrorStats.new(target: target, path: file.path)
+        end
+      end
+    end
+  end
+end

data/lib/steep/services/type_check_service.rb

@@ -0,0 +1,342 @@
+module Steep
+  module Services
+    class TypeCheckService
+      attr_reader :project
+      attr_reader :assignment
+      attr_reader :signature_validation_diagnostics
+      attr_reader :source_files
+      attr_reader :signature_services
+
+      class SourceFile
+        attr_reader :path
+        attr_reader :target
+        attr_reader :content
+        attr_reader :node
+        attr_reader :typing
+        attr_reader :errors
+
+        def initialize(path:, node:, content:, typing:, errors:)
+          @path = path
+          @node = node
+          @content = content
+          @typing = typing
+          @errors = errors
+        end
+
+        def self.with_syntax_error(path:, content:, error:)
+          new(path: path, node: false, content: content, errors: [error], typing: nil)
+        end
+
+        def self.with_typing(path:, content:, typing:, node:)
+          new(path: path, node: node, content: content, errors: nil, typing: typing)
+        end
+
+        def self.no_data(path:, content:)
+          new(path: path, content: content, node: false, errors: nil, typing: nil)
+        end
+
+        def update_content(content)
+          self.class.new(
+            path: path,
+            content: content,
+            node: node,
+            errors: errors,
+            typing: typing
+          )
+        end
+
+        def diagnostics
+          errors || typing&.errors || []
+        end
+      end
+
+      def initialize(project:, assignment:)
+        @project = project
+        @assignment = assignment
+
+        @signature_validation_diagnostics = {}
+        @source_files = {}
+        @signature_services = project.targets.each.with_object({}) do |target, hash|
+          loader = Project::Target.construct_env_loader(options: target.options)
+          hash[target.name] = SignatureService.load_from(loader)
+        end
+
+        @no_type_checking = false
+      end
+
+      def no_type_checking!
+        @no_type_checking = true
+        self
+      end
+
+      def no_type_checking?
+        @no_type_checking
+      end
+
+      def signature_diagnostics
+        signature_diagnostics = {}
+
+        project.targets.each do |target|
+          service = signature_services[target.name]
+
+          service.each_rbs_path do |path|
+            if assignment =~ path
+              signature_diagnostics[path] ||= []
+            end
+          end
+
+          case service.status
+          when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
+            service.status.diagnostics.group_by {|diag| Pathname(diag.location.buffer.name) }.each do |path, diagnostics|
+              if assignment =~ path
+                signature_diagnostics[path].push(*diagnostics)
+              end
+            end
+          when SignatureService::LoadedStatus
+            validation_diagnostics = signature_validation_diagnostics[target.name] || {}
+            validation_diagnostics.each do |path, diagnostics|
+              if assignment =~ path
+                signature_diagnostics[path].push(*diagnostics)
+              end
+            end
+          end
+        end
+
+        signature_diagnostics
+      end
+
+      def has_diagnostics?
+        each_diagnostics.count > 0
+      end
+
+      def diagnostics
+        each_diagnostics.to_h
+      end
+
+      def each_diagnostics(&block)
+        if block
+          signature_diagnostics.each do |path, diagnostics|
+            yield [path, diagnostics]
+          end
+
+          source_files.each_value do |file|
+            yield [file.path, file.diagnostics]
+          end
+        else
+          enum_for :each_diagnostics
+        end
+      end
+
+      def update(changes:, &block)
+        updated_targets = Steep.measure "#update_signature" do
+          update_signature(changes: changes, &block)
+        end
+        Steep.measure2 "Type check target" do |sampler|
+          project.targets.each do |target|
+            sampler.sample target.name.to_s do
+              update_target(target: target, changes: changes, updated: updated_targets.include?(target), &block)
+            end
+          end
+        end
+      end
+
+      def update_signature(changes:, &block)
+        Steep.logger.tagged "#update_signature" do
+          updated_targets = []
+
+          Steep.measure2 "Update signatures" do |sampler|
+            project.targets.each do |target|
+              sampler.sample target.name.to_s do
+                signature_service = signature_services[target.name]
+                signature_changes = changes.filter {|path, _| target.possible_signature_file?(path) }
+
+                unless signature_changes.empty?
+                  updated_targets << target
+                  signature_service.update(signature_changes)
+                end
+              end
+            end
+          end
+
+          Steep.measure "signature validations" do
+            accumulated_diagnostics = {}
+
+            updated_targets.each do |target|
+              service = signature_services[target.name]
+
+              next if no_type_checking?
+
+              case service.status
+              when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
+                service.status.diagnostics.group_by {|diag| Pathname(diag.location.buffer.name) }.each do |path, diagnostics|
+                  if assignment =~ path
+                    array = accumulated_diagnostics[path] ||= []
+                    array.push(*diagnostics)
+                    yield [path, array]
+                  end
+                end
+              when SignatureService::LoadedStatus
+                validator = Signature::Validator.new(checker: service.current_subtyping)
+                paths = service.each_rbs_path.select {|path| assignment =~ path }.to_set
+                type_names = service.type_names(paths: paths, env: service.latest_env).to_set
+
+                Steep.measure2 "Validating #{type_names.size} types from #{paths.size} files" do |sampler|
+                  type_names.each do |type_name|
+                    sampler.sample type_name.to_s do
+                      case
+                      when type_name.class?
+                        validator.validate_one_class(type_name)
+                      when type_name.interface?
+                        validator.validate_one_interface(type_name)
+                      when type_name.alias?
+                        validator.validate_one_alias(type_name)
+                      end
+                    end
+                  end
+                end
+
+                Steep.measure "Validating const and globals" do
+                  validator.validate_const()
+                  validator.validate_global()
+                end
+
+                target_diagnostics = validator.each_error.group_by {|error| Pathname(error.location.buffer.name) }
+                signature_validation_diagnostics[target.name] = target_diagnostics
+
+                paths.each do |path|
+                  array = (accumulated_diagnostics[path] ||= [])
+                  if ds = target_diagnostics[path]
+                    array.push(*ds)
+                  end
+                  yield [path, array]
+                end
+              end
+            end
+          end
+
+          updated_targets
+        end
+      end
+
+      def update_target(changes:, target:, updated:, &block)
+        Steep.logger.tagged "#update_target" do
+          contents = {}
+
+          if updated
+            source_files.each do |path, file|
+              if target.possible_source_file?(path)
+                contents[path] = file.content
+              end
+            end
+
+            changes.each do |path, changes|
+              if target.possible_source_file?(path)
+                text = contents[path] || ""
+                contents[path] = changes.inject(text) {|text, change| change.apply_to(text) }
+              end
+            end
+          else
+            changes.each do |path, changes|
+              if target.possible_source_file?(path)
+                text = source_files[path]&.content || ""
+                contents[path] = changes.inject(text) {|text, change| change.apply_to(text) }
+              end
+            end
+          end
+
+          signature_service = signature_services[target.name]
+          subtyping = signature_service.current_subtyping
+
+          Steep.measure2 "Type check sources" do |sampler|
+            contents.each do |path, text|
+              if assignment =~ path
+                if subtyping
+                  file = sampler.sample(path.to_s) do
+                    type_check_file(target: target, subtyping: subtyping, path: path, text: text)
+                  end
+                  yield [file.path, file.diagnostics]
+                else
+                  if source_files.key?(path)
+                    file = source_files[path]&.update_content(text)
+                  else
+                    file = SourceFile.no_data(path: path, content: text)
+                    yield [file.path, []]
+                  end
+                end
+
+                source_files[path] = file
+              end
+            end
+          end
+        end
+      end
+
+      def type_check_file(target:, subtyping:, path:, text:)
+        Steep.logger.tagged "#type_check_file(#{path}@#{target.name})" do
+          if no_type_checking?
+            SourceFile.no_data(path: path, content: text)
+          else
+            source = Source.parse(text, path: path, factory: subtyping.factory)
+            typing = TypeCheckService.type_check(source: source, subtyping: subtyping)
+            SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing)
+          end
+        end
+      rescue AnnotationParser::SyntaxError => exn
+        SourceFile.no_data(path: path, content: text)
+        # SourceFile.with_syntax_error(path: path, content: text, error: exn)
+      rescue ::Parser::SyntaxError, EncodingError => exn
+        SourceFile.no_data(path: path, content: text)
+        # SourceFile.with_syntax_error(path: path, content: text, error: exn)
+      end
+
+      def self.type_check(source:, subtyping:)
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: RBS::Namespace.root)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [RBS::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,
+          instance_type: AST::Builtin::Object.instance_type,
+          class_type: AST::Builtin::Object.module_type
+        ).annotate(annotations)
+
+        context = TypeInference::Context.new(
+          block_context: nil,
+          module_context: TypeInference::Context::ModuleContext.new(
+            instance_type: AST::Builtin::Object.instance_type,
+            module_type: AST::Builtin::Object.module_type,
+            implement_name: nil,
+            current_namespace: RBS::Namespace.root,
+            const_env: const_env,
+            class_name: AST::Builtin::Object.module_name,
+            instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
+            module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
+          ),
+          method_context: nil,
+          break_context: nil,
+          self_type: AST::Builtin::Object.instance_type,
+          type_env: type_env,
+          lvar_env: lvar_env,
+          call_context: TypeInference::MethodCall::TopLevelContext.new
+        )
+
+        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
+    end
+  end
+end

data/lib/steep/signature/validator.rb

@@ -61,22 +61,176 @@ module Steep
         validator.validate_type type, context: [RBS::Namespace.root]
       end
 
+      def ancestor_to_type(ancestor)
+        case ancestor
+        when RBS::Definition::Ancestor::Instance
+          args = ancestor.args.map {|type| checker.factory.type(type) }
+
+          case
+          when ancestor.name.interface?
+            AST::Types::Name::Interface.new(name: ancestor.name, args: args, location: nil)
+          when ancestor.name.class?
+            AST::Types::Name::Instance.new(name: ancestor.name, args: args, location: nil)
+          else
+            raise "#{ancestor.name}"
+          end
+        else
+          raise "Unexpected ancestor: #{ancestor.inspect}"
+        end
+      end
+
+      def mixin_constraints(definition, mixin_ancestors, immediate_self_types:)
+        relations = []
+
+        self_type = checker.factory.type(definition.self_type)
+        if immediate_self_types && !immediate_self_types.empty?
+          self_type = AST::Types::Intersection.build(
+            types: immediate_self_types.map {|st| ancestor_to_type(st) }.push(self_type),
+            location: nil
+          )
+        end
+
+        mixin_ancestors.each do |ancestor|
+          args = ancestor.args.map {|type| checker.factory.type(type) }
+          ancestor_ancestors = builder.ancestor_builder.one_instance_ancestors(ancestor.name)
+          self_constraints = ancestor_ancestors.self_types.map do |self_ancestor|
+            s = Interface::Substitution.build(ancestor_ancestors.params, args)
+            ancestor_to_type(self_ancestor).subst(s)
+          end
+
+          self_constraints.each do |constraint|
+            relations << [
+              Subtyping::Relation.new(sub_type: self_type, super_type: constraint),
+              ancestor
+            ]
+          end
+        end
+
+        relations
+      end
+
       def validate_one_class(name)
-        rescue_validation_errors do
-          Steep.logger.debug "Validating class definition `#{name}`..."
+        rescue_validation_errors(name) do
+          Steep.logger.debug { "Validating class definition `#{name}`..." }
+
           Steep.logger.tagged "#{name}" do
-            builder.build_instance(name).each_type do |type|
-              validate_type type
+            builder.build_instance(name).tap do |definition|
+              definition.instance_variables.each do |name, var|
+                if parent = var.parent_variable
+                  var_type = checker.factory.type(var.type)
+                  parent_type = checker.factory.type(parent.type)
+
+                  relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
+                  result1 = checker.check(
+                    relation,
+                    self_type: AST::Types::Self.new,
+                    instance_type: AST::Types::Instance.new,
+                    class_type: AST::Types::Class.new,
+                    constraints: Subtyping::Constraints.empty
+                  )
+                  result2 = checker.check(
+                    relation.flip,
+                    self_type: AST::Types::Self.new,
+                    instance_type: AST::Types::Instance.new,
+                    class_type: AST::Types::Class.new,
+                    constraints: Subtyping::Constraints.empty
+                  )
+
+                  unless result1.success? and result2.success?
+                    @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                      name: name,
+                      location: var.type.location,
+                      var_type: var_type,
+                      parent_type: parent_type
+                    )
+                  end
+                end
+              end
+
+              ancestors = builder.ancestor_builder.one_instance_ancestors(name)
+              mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                checker.check(
+                  relation,
+                  self_type: AST::Types::Self.new,
+                  instance_type: AST::Types::Instance.new,
+                  class_type: AST::Types::Class.new,
+                  constraints: Subtyping::Constraints.empty
+                ).else do
+                  @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
+                    name: name,
+                    location: ancestor.source&.location || raise,
+                    ancestor: ancestor,
+                    relation: relation
+                  )
+                end
+              end
+
+              definition.each_type do |type|
+                validate_type type
+              end
             end
-            builder.build_singleton(name).each_type do |type|
-              validate_type type
+
+            builder.build_singleton(name).tap do |definition|
+              definition.instance_variables.each do |name, var|
+                if parent = var.parent_variable
+                  var_type = checker.factory.type(var.type)
+                  parent_type = checker.factory.type(parent.type)
+
+                  relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
+                  result1 = checker.check(
+                    relation,
+                    self_type: AST::Types::Self.new,
+                    instance_type: AST::Types::Instance.new,
+                    class_type: AST::Types::Class.new,
+                    constraints: Subtyping::Constraints.empty
+                  )
+                  result2 = checker.check(
+                    relation.flip,
+                    self_type: AST::Types::Self.new,
+                    instance_type: AST::Types::Instance.new,
+                    class_type: AST::Types::Class.new,
+                    constraints: Subtyping::Constraints.empty
+                  )
+
+                  unless result1.success? and result2.success?
+                    @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                      name: name,
+                      location: var.type.location,
+                      var_type: var_type,
+                      parent_type: parent_type
+                    )
+                  end
+                end
+              end
+
+              ancestors = builder.ancestor_builder.one_singleton_ancestors(name)
+              mixin_constraints(definition, ancestors.extended_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                checker.check(
+                  relation,
+                  self_type: AST::Types::Self.new,
+                  instance_type: AST::Types::Instance.new,
+                  class_type: AST::Types::Class.new,
+                  constraints: Subtyping::Constraints.empty
+                ).else do
+                  @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
+                    name: name,
+                    location: ancestor.source&.location || raise,
+                    ancestor: ancestor,
+                    relation: relation
+                  )
+                end
+              end
+
+              definition.each_type do |type|
+                validate_type type
+              end
             end
           end
         end
       end
 
       def validate_one_interface(name)
-        rescue_validation_errors do
+        rescue_validation_errors(name) do
           Steep.logger.debug "Validating interface `#{name}`..."
           Steep.logger.tagged "#{name}" do
             builder.build_interface(name).each_type do |type|
@@ -115,37 +269,25 @@ module Steep
         end
       end
 
+      def validate_one_alias(name)
+        rescue_validation_errors(name) do
+          Steep.logger.debug "Validating alias `#{name}`..."
+          builder.expand_alias(name).tap do |type|
+            validate_type(type)
+          end
+        end
+      end
+
       def validate_alias
         env.alias_decls.each do |name, entry|
-          rescue_validation_errors do
-            Steep.logger.debug "Validating alias `#{name}`..."
-            builder.expand_alias(name).tap do |type|
-              validate_type(type)
-            end
-          end
+          validate_one_alias(name)
         end
       end
 
-      def rescue_validation_errors
+      def rescue_validation_errors(type_name = nil)
         yield
-      rescue RBS::InvalidTypeApplicationError => exn
-        @errors << Errors::InvalidTypeApplicationError.new(
-          name: exn.type_name,
-          args: exn.args.map {|ty| factory.type(ty) },
-          params: exn.params,
-          location: exn.location
-        )
-      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
-        @errors << Errors::UnknownTypeNameError.new(
-          name: exn.type_name,
-          location: exn.location
-        )
-      rescue RBS::InvalidOverloadMethodError => exn
-        @errors << Errors::InvalidMethodOverloadError.new(
-          class_name: exn.type_name,
-          method_name: exn.method_name,
-          location: exn.members[0].location
-        )
+      rescue RBS::ErrorBase => exn
+        @errors << Diagnostic::Signature.from_rbs_error(exn, factory: factory)
       end
     end
   end