steep 1.6.0 → 1.7.0.dev.1

data/lib/steep/type_inference/case_when.rb

@@ -0,0 +1,301 @@
+module Steep
+  module TypeInference
+    class CaseWhen
+      class WhenPatterns
+        include NodeHelper
+
+        attr_reader :logic, :initial_constr, :unreachable_clause, :pattern_results
+
+        def initialize(logic, initial_constr, unreachable_clause, assignment_node)
+          @logic = logic
+          @initial_constr = initial_constr
+          @unreachable_clause = unreachable_clause
+          @assignment_node = assignment_node
+
+          @pattern_results = []
+        end
+
+        def add_pattern(pat)
+          test_node = pat.updated(:send, [pat, :===, assignment_node])
+
+          latest_constr, unreachable_pattern = latest_result
+
+          type, constr = yield(test_node, latest_constr, unreachable_pattern)
+          truthy_result, falsy_result = logic.eval(env: latest_constr.context.type_env, node: test_node)
+
+          pattern_results << [pat, truthy_result, falsy_result]
+        end
+
+        def latest_result
+          if (_, truthy, falsy = pattern_results.last)
+            [
+              initial_constr.update_type_env { falsy.env },
+              falsy.unreachable
+            ]
+          else
+            [initial_constr, unreachable_clause]
+          end
+        end
+
+        def body_result
+          raise if pattern_results.empty?
+
+          type_envs = pattern_results.map {|_, truthy, _| truthy.env }
+          env = initial_constr.context.type_env.join(*type_envs)
+
+          env = yield(env) || env
+
+          [
+            initial_constr.update_type_env { env },
+            unreachable_clause || pattern_results.all? {|_, truthy, _| truthy.unreachable }
+          ]
+        end
+
+        def falsy_result
+          (_, _, falsy = pattern_results.last) or raise
+
+          [
+            initial_constr.update_type_env { falsy.env },
+            unreachable_clause || falsy.unreachable
+          ]
+        end
+
+        def assignment_node()
+          clone_node(@assignment_node)
+        end
+      end
+
+      include NodeHelper
+      extend NodeHelper
+
+      def self.type_check(constr, node, logic, hint:, condition:)
+        case_when = new(node, logic) do |condition_node|
+          constr.synthesize(condition_node)
+        end
+
+        case_when.when_clauses() do |when_pats, patterns, body_node, loc|
+          patterns.each do |pat|
+            when_pats.add_pattern(pat) {|test, constr| constr.synthesize(test) }
+          end
+
+          body_constr, body_unreachable = when_pats.body_result() do |env|
+            case_when.propagate_value_node_type(env)
+          end
+
+          if body_node
+            body_constr = body_constr.for_branch(body_node)
+            type, body_constr = body_constr.synthesize(body_node, hint: hint, condition: condition)
+          else
+            type = AST::Builtin.nil_type
+          end
+
+          body_result = LogicTypeInterpreter::Result.new(
+            type: type,
+            env: body_constr.context.type_env,
+            unreachable: body_unreachable
+          )
+
+          falsy_constr, falsy_unreachable = when_pats.falsy_result
+          next_result = LogicTypeInterpreter::Result.new(
+            type: AST::Builtin.any_type,    # Unused for falsy pattern
+            env: falsy_constr.context.type_env,
+            unreachable: falsy_unreachable
+          )
+
+          [body_result, next_result]
+        end
+
+        case_when.else_clause do |else_node, constr|
+          constr.synthesize(else_node, hint: hint, condition: condition)
+        end
+
+        case_when.result()
+      end
+
+      attr_reader :location, :node, :condition_node, :when_nodes, :else_node
+      attr_reader :initial_constr, :logic, :clause_results, :else_result
+      attr_reader :assignment_node, :value_node, :var_name
+
+      def initialize(node, logic)
+        @node = node
+
+        condition_node, when_nodes, else_node, location = deconstruct_case_node!(node)
+        condition_node or raise "CaseWhen works for case-when syntax with condition node"
+
+        @condition_node = condition_node
+        @when_nodes = when_nodes
+        @else_node = else_node
+        @location = location
+        @logic = logic
+        @clause_results = []
+
+        type, constr = yield(condition_node)
+
+        @var_name = "__case_when:#{SecureRandom.alphanumeric(5)}__".to_sym
+        @value_node, @assignment_node = rewrite_condition_node(var_name, condition_node)
+
+        @initial_constr = constr.update_type_env do |env|
+          env.merge(local_variable_types: { var_name => [type, nil] })
+        end
+      end
+
+      def when_clauses()
+        when_nodes.each do |when_node|
+          clause_constr, unreachable = latest_result
+
+          patterns, body, loc = deconstruct_when_node!(when_node)
+
+          when_pats = WhenPatterns.new(
+            logic,
+            clause_constr,
+            unreachable,
+            assignment_node
+          )
+
+          body_result, next_result = yield(
+            when_pats,
+            patterns,
+            body,
+            loc
+          )
+
+          if body_result.unreachable
+            if body_result.type.is_a?(AST::Types::Any) || initial_constr.no_subtyping?(sub_type: body_result.type, super_type: AST::Builtin.bottom_type)
+              typing.add_error(
+                Diagnostic::Ruby::UnreachableValueBranch.new(
+                  node: when_node,
+                  type: body_result.type,
+                  location: loc.keyword
+                )
+              )
+            end
+          end
+
+          clause_results << [body_result, next_result]
+        end
+      end
+
+      def else_clause()
+        unless else_loc = has_else_clause?
+          return
+        end
+
+        constr, unreachable = latest_result
+
+        constr = constr.update_type_env do |env|
+          propagate_value_node_type(env) || env
+        end
+
+        @else_result =
+          if else_node
+            yield(else_node, constr)
+          else
+            TypeConstruction::Pair.new(type: AST::Builtin.nil_type, constr: constr)
+          end
+
+        else_result or raise
+
+        if unreachable
+          if else_result.type.is_a?(AST::Types::Any) || initial_constr.no_subtyping?(sub_type: else_result.type, super_type: AST::Builtin.bottom_type)
+            typing.add_error(
+              Diagnostic::Ruby::UnreachableValueBranch.new(
+                node: else_node || node,
+                type: else_result.type,
+                location: else_loc
+              )
+            )
+          end
+        end
+      end
+
+      def latest_result
+        if (_, falsy_result = clause_results.last)
+          [
+            initial_constr.update_type_env { falsy_result.env },
+            falsy_result.unreachable
+          ]
+        else
+          [initial_constr, false]
+        end
+      end
+
+      def result
+        results = clause_results.filter_map do |body, _|
+          unless body.unreachable
+            body
+          end
+        end
+        next_constr, next_clause_unreachable = latest_result
+
+        unless next_clause_unreachable
+          if else_result
+            results << LogicTypeInterpreter::Result.new(
+              type: else_result.type,
+              env: else_result.context.type_env,
+              unreachable: false    # Unused
+            )
+          else
+            results << LogicTypeInterpreter::Result.new(
+              type: AST::Builtin.nil_type,
+              env: next_constr.context.type_env,
+              unreachable: false
+            )
+          end
+        end
+
+        types = results.map {|result| result.type }
+        envs = results.map {|result| result.env }
+
+        [
+          types,
+          envs
+        ]
+      end
+
+      def has_else_clause?
+        location.else
+      end
+
+      def typing
+        logic.typing
+      end
+
+      def rewrite_condition_node(var_name, node)
+        case node.type
+        when :lvasgn
+          name, rhs = node.children
+          value, rhs = rewrite_condition_node(var_name, rhs)
+          [value, node.updated(nil, [name, rhs])]
+        when :lvar
+          name, = node.children
+          [
+            nil,
+            node.updated(:lvasgn, [name, node.updated(:lvar, [var_name])])
+          ]
+        when :begin
+          *children, last = node.children
+          value_node, last = rewrite_condition_node(var_name, last)
+          [
+            value_node,
+            node.updated(nil, children.push(last))
+          ]
+        else
+          [
+            node,
+            node.updated(:lvar, [var_name])
+          ]
+        end
+      end
+
+      def propagate_value_node_type(env)
+        if value_node
+          if (call = initial_constr.typing.method_calls[value_node]).is_a?(MethodCall::Typed)
+            if env[value_node]
+              env.merge(pure_method_calls: { value_node => [call, env[var_name]] })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.6.0"
+  VERSION = "1.7.0.dev.1"
 end

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby32"
+require "parser/ruby33"
 require "active_support"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
@@ -52,6 +52,7 @@ require "steep/ast/node/type_assertion"
 require "steep/ast/node/type_application"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
+require "steep/ast/ignore"
 
 require "steep/range_extension"
 
@@ -76,6 +77,7 @@ require "steep/diagnostic/signature"
 require "steep/diagnostic/lsp_formatter"
 require "steep/signature/validator"
 require "steep/source"
+require "steep/source/ignore_ranges"
 require "steep/annotation_parser"
 require "steep/typing"
 require "steep/module_helper"
@@ -91,6 +93,7 @@ require "steep/type_inference/type_env_builder"
 require "steep/type_inference/logic_type_interpreter"
 require "steep/type_inference/multiple_assignment"
 require "steep/type_inference/method_call"
+require "steep/type_inference/case_when"
 
 require "steep/index/rbs_index"
 require "steep/index/signature_symbol_provider"
@@ -152,6 +155,10 @@ module Steep
     @logger || raise
   end
 
+  def self.ui_logger
+    @ui_logger || raise
+  end
+
   def self.new_logger(output, prev_level)
     ActiveSupport::TaggedLogging.new(Logger.new(output)).tap do |logger|
       logger.push_tags "Steep #{VERSION}"
@@ -165,12 +172,18 @@ module Steep
 
   def self.log_output=(output)
     @log_output = output
+
     prev_level = @logger&.level
     @logger = new_logger(output, prev_level)
+
+    prev_level = @ui_logger&.level
+    @ui_logger = new_logger(output, prev_level)
+
     output
   end
 
   @logger = nil
+  @ui_logger = nil
   self.log_output = STDERR
 
   def self.measure(message, level: :warn)

data/rbs_collection.steep.lock.yaml

@@ -1,10 +1,4 @@
 ---
-sources:
-- type: git
-  name: ruby/gem_rbs_collection
-  revision: c42c09528dd99252db98f0744181a6de54ec2f55
-  remote: https://github.com/ruby/gem_rbs_collection.git
-  repo_dir: gems
 path: ".gem_rbs_collection"
 gems:
 - name: activesupport
@@ -15,6 +9,14 @@ gems:
     revision: c42c09528dd99252db98f0744181a6de54ec2f55
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
+- name: base64
+  version: '0'
+  source:
+    type: stdlib
+- name: bigdecimal
+  version: '0'
+  source:
+    type: stdlib
 - name: concurrent-ruby
   version: '1.1'
   source:

data/sig/shims/parser.rbs

@@ -35,6 +35,16 @@ module Parser
     attr_reader diagnostics: untyped
   end
 
+  class Ruby33
+    def initialize: (untyped builder) -> void
+
+    def parse: (Source::Buffer) -> AST
+
+    def parse_with_comments: (Source::Buffer) -> [AST::Node, Array[Source::Comment]]
+
+    attr_reader diagnostics: untyped
+  end
+
   module Source
     class Buffer
       def initialize: (String file, Integer lineno, source: String) -> void

data/sig/shims/yaml.rbs

@@ -0,0 +1,4 @@
+module Psych
+  class SyntaxError < StandardError
+  end
+end

data/sig/steep/ast/ignore.rbs

@@ -0,0 +1,66 @@
+use Parser::Source::Comment, RBS::Buffer, RBS::Location
+
+module Steep
+  module AST
+    module Ignore
+      class BufferScanner
+        attr_reader scanner: StringScanner
+
+        attr_reader location: Location[untyped, untyped]
+
+        def initialize: (Location[untyped, untyped]) -> void
+
+        def offset: () -> Integer
+
+        def charpos: () -> Integer
+
+        def scan: (Regexp) -> Location[bot, bot]?
+
+        def skip: (Regexp) -> void
+
+        def eos?: () -> bool
+      end
+
+      type t = IgnoreStart | IgnoreEnd | IgnoreLine
+
+      def self.parse: (Comment, Buffer) -> t?
+
+      class IgnoreStart
+        attr_reader comment: Comment
+
+        attr_reader location: Location[bot, bot]
+
+        def initialize: (Comment, Location[bot, bot]) -> void
+
+        def line: () -> Integer
+      end
+
+      class IgnoreEnd
+        attr_reader comment: Comment
+
+        attr_reader location: Location[bot, bot]
+
+        def initialize: (Comment, Location[bot, bot]) -> void
+
+        def line: () -> Integer
+      end
+
+      class IgnoreLine
+        type diagnostic = Location[:name, :following_comma]
+        type diagnostics = Array[diagnostic]
+
+        attr_reader comment: Comment
+
+        attr_reader location: Location[:keyword, bot]
+
+        attr_reader raw_diagnostics: diagnostics
+
+        def initialize: (Comment, diagnostics, Location[:keyword, bot]) -> void
+
+        def line: () -> Integer
+
+        def ignored_diagnostics: () -> (:all | Array[String])
+      end
+    end
+  end
+end

data/sig/steep/diagnostic/ruby.rbs

@@ -628,6 +628,14 @@ module Steep
         def initialize: (error: Signature::Base, node: Parser::AST::Node, location: location) -> void
       end
 
+      # steep:ignore comment is invalid
+      #
+      class InvalidIgnoreComment < Base
+        attr_reader comment: Parser::Source::Comment
+
+        def initialize: (comment: Parser::Source::Comment) -> void
+      end
+
       # Argument forwarding `...` cannot be done safely, because of
       #
       # 1. The arguments are incompatible, or

data/sig/steep/node_helper.rbs

@@ -74,5 +74,7 @@ module Steep
     # If the next node is a `block` or `numblock` that is associated to the *sendish node*, it is the block node.
     #
     def deconstruct_sendish_and_block_nodes: (*Parser::AST::Node) -> [Parser::AST::Node, Parser::AST::Node?]?
+
+    def clone_node: (Node) -> Node
   end
 end

data/sig/steep/project/dsl.rbs

@@ -24,9 +24,13 @@ module Steep
 
         attr_reader project: Project?
 
-        attr_reader collection_config_path: Pathname?
-
-        NONE: untyped
+        # Attribute to keep track of collection configuration
+        #
+        # * `Pathname` means loading the configuration from the path
+        # * `nil` means no configuration is given
+        # * `false` means rbs-collection is disabled
+        #
+        attr_reader collection_config_path: Pathname | nil | false
 
         def project!: () -> Project
 
@@ -86,7 +90,7 @@ module Steep
         def disable_collection: () -> void
       end
 
-      attr_reader project: untyped
+      attr_reader project: Project
 
       @@templates: Hash[Symbol, TargetDSL]
 

data/sig/steep/project/options.rbs

@@ -19,9 +19,29 @@ module Steep
 
       attr_accessor paths: PathOptions
 
-      attr_accessor collection_lock: RBS::Collection::Config::Lockfile?
+      attr_accessor collection_config_path: Pathname?
 
       def initialize: () -> void
+
+      # Returns path of lockfile
+      %a{pure} def collection_lock_path: () -> Pathname?
+
+      # Returns `Lockfile` instance if it can be loaded
+      #
+      %a{pure} def collection_lock: () -> RBS::Collection::Config::Lockfile?
+
+      @collection_lock: RBS::Collection::Config::Lockfile | Pathname | YAML::SyntaxError | RBS::Collection::Config::CollectionNotAvailable | nil
+
+      # Load collection configuration
+      #
+      # * Returns `Lockfile` instance if successfully loaded
+      # * Returns `nil` if collection is disabled
+      # * Returns `Pathname` if a file is missing
+      # * Returns `YAML::SyntaxError` or `CollectionNotAvailable` if an error is raised
+      #
+      # It keeps the last result unless `force: true` is specified.
+      #
+      def load_collection_lock: (?force: bool) -> (RBS::Collection::Config::Lockfile | Pathname | YAML::SyntaxError | RBS::Collection::Config::CollectionNotAvailable | nil)
     end
   end
 end

data/sig/steep/project.rbs

@@ -2,11 +2,11 @@ module Steep
   class Project
     attr_reader targets: Array[Target]
 
-    attr_reader steepfile_path: Pathname
+    attr_reader steepfile_path: Pathname?
 
-    def initialize: (steepfile_path: Pathname) -> void
+    attr_reader base_dir: Pathname
 
-    def base_dir: () -> Pathname
+    def initialize: (steepfile_path: Pathname?, ?base_dir: Pathname?) -> void
 
     def relative_path: (Pathname path) -> Pathname
 

data/sig/steep/server/change_buffer.rbs

@@ -1,13 +1,15 @@
 module Steep
   module Server
-    module ChangeBuffer : _WithProject
+    module ChangeBuffer : _WithProject, _WithMutex
       interface _WithProject
         def project: () -> Project
       end
 
-      type changes = Hash[Pathname, Array[Services::ContentChange]]
+      interface _WithMutex
+        def mutex: () -> Mutex
+      end
 
-      attr_reader mutex: Thread::Mutex
+      type changes = Hash[Pathname, Array[Services::ContentChange]]
 
       attr_reader buffered_changes: changes
 
@@ -29,7 +31,7 @@ module Steep
       def collect_changes: (untyped request) -> void
 
       # Reset the content of `uri` to `text`
-      # 
+      #
       def reset_change: (uri: String, text: String) -> void
     end
   end

data/sig/steep/server/interaction_worker.rbs

@@ -58,10 +58,20 @@ module Steep
 
       attr_reader service: Services::TypeCheckService
 
+      attr_reader mutex: Mutex
+
       def initialize: (project: Project, reader: Reader, writer: Writer, ?queue: Queue) -> void
 
       def handle_job: (job) -> void
 
+      @last_job_mutex: Mutex
+
+      @last_job: job?
+
+      def process_latest_job: [T] (job) { () -> T } -> T?
+
+      def queue_job: (job) -> void
+
       type lsp_request = { id: String, method: String, params: untyped }
 
       def handle_request: (lsp_request) -> void

data/sig/steep/server/worker_process.rbs

@@ -49,7 +49,7 @@ module Steep
       def self.start_worker: (
         worker_type `type`,
         name: String,
-        steepfile: Pathname,
+        steepfile: Pathname?,
         steep_command: String?,
         ?patterns: Array[String],
         ?delay_shutdown: bool,
@@ -59,7 +59,7 @@ module Steep
       def self.fork_worker: (
         worker_type `type`,
         name: String,
-        steepfile: Pathname,
+        steepfile: Pathname?,
         patterns: Array[String],
         delay_shutdown: bool,
         index: [Integer, Integer]?
@@ -68,7 +68,7 @@ module Steep
       def self.spawn_worker: (
         worker_type `type`,
         name: String,
-        steepfile: Pathname,
+        steepfile: Pathname?,
         steep_command: ::String,
         patterns: Array[String],
         delay_shutdown: bool,
@@ -76,7 +76,7 @@ module Steep
       ) -> WorkerProcess
 
       def self.start_typecheck_workers: (
-        steepfile: Pathname,
+        steepfile: Pathname?,
         args: Array[String],
         steep_command: ::String?,
         ?count: Integer,