steep 1.6.0 → 1.7.0.dev.1

data/sig/steep/services/completion_provider.rbs

@@ -178,6 +178,18 @@ module Steep
         def comments: () -> Array[RBS::AST::Comment]
       end
 
+      class TextItem
+        attr_reader label: String
+
+        attr_reader text: String
+
+        attr_reader help_text: String?
+
+        attr_reader range: Range
+
+        def initialize: (text: String, help_text: String?, range: Range, label: String) -> void
+      end
+
       type item = InstanceVariableItem
                 | KeywordArgumentItem
                 | LocalVariableItem
@@ -186,6 +198,7 @@ module Steep
                 | ComplexMethodNameItem
                 | GeneratedMethodNameItem
                 | TypeNameItem
+                | TextItem
 
       attr_reader source_text: String
 
@@ -209,7 +222,7 @@ module Steep
 
       def range_from_loc: (Parser::Source::Range loc) -> Range
 
-      def at_comment?: (Position pos) -> bool
+      def at_comment?: (Position pos) -> Parser::Source::Comment?
 
       def at_end?: (Position pos, of: Parser::Source::Map | Parser::Source::Range | nil) -> boolish
 

data/sig/steep/services/type_check_service.rbs

@@ -20,6 +20,8 @@ module Steep
 
         attr_reader typing: Typing?
 
+        attr_reader ignores: Source::IgnoreRanges?
+
         attr_reader errors: Array[Diagnostic::Ruby::Base]?
 
         def initialize: (
@@ -27,17 +29,20 @@ module Steep
           node: Parser::AST::Node | nil | false,
           content: String,
           typing: Typing?,
+          ignores: Source::IgnoreRanges?,
           errors: Array[Diagnostic::Ruby::Base]?
         ) -> void
 
         def self.with_syntax_error: (path: Pathname, content: String, error: Diagnostic::Ruby::SyntaxError) -> SourceFile
 
-        def self.with_typing: (path: Pathname, content: String, typing: Typing, node: Parser::AST::Node?) -> SourceFile
+        def self.with_typing: (path: Pathname, content: String, typing: Typing, ignores: Source::IgnoreRanges, node: Parser::AST::Node?) -> SourceFile
 
         def self.no_data: (path: Pathname, content: String) -> SourceFile
 
         def update_content: (String content) -> SourceFile
 
+        # Diagnostics filgered by `ignores`
+        # 
         def diagnostics: () -> Array[Diagnostic::Ruby::Base]
       end
 

data/sig/steep/source/ignore_ranges.rbs

@@ -0,0 +1,38 @@
+use Steep::AST::Ignore, RBS::Location
+
+module Steep
+  class Source
+    class IgnoreRanges
+      attr_reader all_ignores: Array[Ignore::t]
+
+      attr_reader error_ignores: Array[Ignore::t]
+
+      attr_reader ignored_ranges: Array[Range[Integer]]
+
+      attr_reader ignored_lines: Hash[Integer, Ignore::IgnoreLine]
+
+      def initialize: (ignores: Array[Ignore::t]) -> void
+
+      # If given diagnostic code at the location is ignored or not
+      #
+      # Ignore ranges work for location that is completely inside the range.
+      # Both the starting point and ending point should be in one range.
+      # Only diagnostic (1) is ignored in the following example.
+      #
+      # ```ruby
+      #                         + <2
+      # # steep:ignore:start    |
+      #                   1> +  +
+      #                      +    +
+      # # steep:ignore:end        |
+      #                           + <3
+      # ```
+      #
+      # Ignore lines work for location that has starting line or ending line.
+      #
+      def ignore?: (Integer start_line, Integer end_line, String code) -> bool
+
+      def ignore_code?: (Ignore::IgnoreLine, String code) -> bool
+    end
+  end
+end

data/sig/steep/source.rbs

@@ -12,19 +12,22 @@ module Steep
 
     attr_reader comments: Array[Parser::Source::Comment]
 
+    attr_reader ignores: Array[AST::Ignore::t]
+
     def initialize: (
       buffer: RBS::Buffer,
       path: Pathname,
       node: Parser::AST::Node?,
       mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]],
-      comments: Array[Parser::Source::Comment]
+      comments: Array[Parser::Source::Comment],
+      ignores: Array[AST::Ignore::t]
     ) -> void
 
     class Builder < ::Parser::Builders::Default
       def string_value: (untyped token) -> untyped
     end
 
-    def self.new_parser: () -> Parser::Ruby32
+    def self.new_parser: () -> Parser::Ruby33
 
     def self.parse: (String source_code, path: Pathname, factory: AST::Types::Factory) -> Source
 

data/sig/steep/subtyping/check.rbs

@@ -21,7 +21,7 @@ module Steep
 
       def factory: () -> AST::Types::Factory
 
-      def with_context: [A] (self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t, constraints: Constraints) { () -> A } -> A
+      def with_context: [A] (self_type: AST::Types::t?, instance_type: AST::Types::t?, class_type: AST::Types::t?, constraints: Constraints?) { () -> A } -> A
 
       def self_type: () -> AST::Types::t
 
@@ -50,7 +50,7 @@ module Steep
 
       def singleton_super_types: (RBS::TypeName type_name) -> Array[super_type]
 
-      def check: (Relation[AST::Types::t] relation, constraints: Constraints, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Result::t
+      def check: (Relation[AST::Types::t] relation, constraints: Constraints, self_type: AST::Types::t?, instance_type: AST::Types::t?, class_type: AST::Types::t?) -> Result::t
 
       def check_type: (Relation[AST::Types::t] relation) -> Result::t
 

data/sig/steep/type_construction.rbs

@@ -400,7 +400,7 @@ module Steep
     #
     def namespace_module?: (Parser::AST::Node node) -> bool
 
-    def type_any_rec: (Parser::AST::Node node) -> Pair
+    def type_any_rec: (Parser::AST::Node node, ?only_children: bool) -> Pair
 
     def unwrap: (AST::Types::t `type`) -> AST::Types::t
 
@@ -533,35 +533,10 @@ module Steep
     #
     def pure_send?: (TypeInference::MethodCall::Typed call, Parser::AST::Node? receiver, Array[Parser::AST::Node] arguments) -> bool
 
-    # Transform given `node` to a node that has a local variable instead of the outer most call/non-value node
-    #
-    # Returns a pair of transformed node and the outer most call/non-value node if present.
-    #
-    # ```rb
-    # x = y = foo()   # Call `#transform_condition_node` with the node and var_name `:__foo__`
-    #                 # => Returns [x = y = __foo__, foo()]
-    #
-    # x               # Call `#transform_condition_node` with the node and var_name `:__foo__`
-    #                 # => Returns [__foo__, x]
-    # ```
-    #
-    # This is typically used for transforming assginment node for case condition.
-    #
-    def transform_condition_node: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node]
-
     def type_name: (AST::Types::t) -> RBS::TypeName?
 
     def singleton_type: (AST::Types::t) -> AST::Types::t?
 
     def instance_type: (AST::Types::t) -> AST::Types::t?
-
-    # Propagate an entry of `source` in TypeEnv to `dest`
-    #
-    # `source` is name of a local variable.
-    #
-    # If `dest` is a `lvar` node, it updates local variable entry of TypeEnv.
-    # Otherwise, it updates *pure* call of `dest` if it already exists.
-    #
-    def propagate_type_env: (Symbol source, Parser::AST::Node dest, TypeInference::TypeEnv) -> TypeInference::TypeEnv
   end
 end

data/sig/steep/type_inference/branch.rbs

@@ -0,0 +1,15 @@
+use Steep::TypeConstruction::Pair, Steep::TypeInference::LogicTypeInterpreter::Result
+
+module Steep
+  module TypeInference
+    class Branch
+      attr_reader start_env: TypeEnv
+
+      def initialize: (TypeEnv start_env) -> void
+
+      def add_branch: () { (TypeEnv) -> [Result, Pair] } -> void
+
+      
+    end
+  end
+end

data/sig/steep/type_inference/case_when.rbs

@@ -0,0 +1,130 @@
+use Parser::AST::Node
+use Steep::TypeConstruction::Pair, Steep::TypeInference::LogicTypeInterpreter::Result
+use Steep::NodeHelper::condition_loc, Steep::NodeHelper::keyword_loc
+
+module Steep
+  module TypeInference
+    class CaseWhen
+      class WhenPatterns
+        include NodeHelper
+
+        attr_reader logic: LogicTypeInterpreter
+
+        attr_reader initial_constr: TypeConstruction
+
+        # True if the `when` clause is unreachable
+        attr_reader unreachable_clause: bool
+
+        @assignment_node: Node
+
+        attr_reader pattern_results: Array[[Node, Result, Result]]
+
+        def initialize: (LogicTypeInterpreter logic, TypeConstruction initial_constr, bool unreachable, Node assignment_node) -> void
+
+        def add_pattern: (Node pattern) { (Node, TypeConstruction, bool) -> Pair } -> void
+
+        # The result for body of the when-clause
+        #
+        # Raises an error when no patern is registered.
+        #
+        def body_result: () { (TypeEnv) -> TypeEnv? } -> [TypeConstruction, bool]
+
+        # The result for next when-clause
+        #
+        # Raises an error when no patern is registered.
+        #
+        def falsy_result: () -> [TypeConstruction, bool]
+
+        # The result for incoming pattern
+        def latest_result: () -> [TypeConstruction, bool]
+
+        # Returns new object equivalent to @assignment_node
+        def assignment_node: () -> Node
+      end
+
+      type when_result = [
+        Result,   # Type of the body of the when-clause
+        Result    # Result for the case the when-clause doesn't match
+      ]
+
+      include NodeHelper
+      extend NodeHelper
+
+      # The location of `#node`
+      attr_reader location: condition_loc
+
+      # `case` node
+      attr_reader node: Node
+
+      attr_reader condition_node: Node
+
+      attr_reader when_nodes: Array[Node]
+
+      attr_reader else_node: Node?
+
+      attr_reader logic: LogicTypeInterpreter
+
+      attr_reader clause_results: Array[when_result]
+
+      attr_reader else_result: Pair?
+
+      # Fresh local variable name that contains the value of `#condition_node`
+      attr_reader var_name: Symbol
+
+      # `lvasgn` node that propagates the value of `#condition_node` to local variables
+      attr_reader assignment_node: Node
+
+      # A node that points to the value of `#condition_node`
+      #
+      # `nil` if it is an local variable.
+      #
+      attr_reader value_node: Node?
+
+      # The result of the type checking of `#condition_node`
+      #
+      attr_reader initial_constr: TypeConstruction
+
+      # The public API
+      #
+      # It type checks given `case` node with condition node, and records types and errors of sub nodes.
+      #
+      def self.type_check: (TypeConstruction, Node, LogicTypeInterpreter, hint: AST::Types::t?, condition: bool) -> [Array[AST::Types::t], Array[TypeEnv]]
+
+      def initialize: (Node, LogicTypeInterpreter) { (Node) -> Pair } -> void
+
+      def when_clauses: () { (WhenPatterns, Array[Node], Node?, keyword_loc) -> when_result } -> void
+
+      def else_clause: () { (Node, TypeConstruction) -> Pair } -> void
+
+      def result: () -> [Array[AST::Types::t], Array[TypeEnv]]
+
+      # Assign type of `value_node`
+      def propagate_value_node_type: (TypeEnv) -> TypeEnv?
+
+      # Returns `true` is `else` keyword is given
+      #
+      # `else_node` may be `nil` because body expression might be omitted.
+      #
+      # ```ruby
+      # case x
+      # when 1
+      # else
+      #   # The body expression is omitted, but the branch is given.
+      # end
+      # ```
+      #
+      def has_else_clause?: () -> Parser::Source::Range?
+
+      # def typing: () -> Typing
+
+      # Extract assignments
+      #
+      # Returns a pair of the node that represents the value and assignment.
+      #
+      def rewrite_condition_node: (Symbol, Node) ->[Node?, Node]
+
+      # TypeConstruction for incoming clause
+      def latest_result: () -> [TypeConstruction, bool]
+    end
+  end
+end

data/sig/steep.rbs

@@ -1,6 +1,13 @@
 module Steep
   VERSION: String
 
+  # `ui_logger` is a logger for user interaction messages
+  #
+  # The *main* process has the logger.
+  # The *worker* processes disables the logging through this.
+  #
+  def self.ui_logger: () -> (Logger & ActiveSupport::TaggedLogging)
+
   def self.logger: () -> (Logger & ActiveSupport::TaggedLogging)
 
   def self.new_logger: (IO output, Integer? prev_level) -> (Logger & ActiveSupport::TaggedLogging)
@@ -13,6 +20,8 @@ module Steep
 
   self.@logger: (Logger & ActiveSupport::TaggedLogging)?
 
+  self.@ui_logger: (Logger & ActiveSupport::TaggedLogging)?
+
   class Sampler
     type sample = [String, Float]
     @samples: Array[sample]

data/steep.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"] = "https://github.com/soutaro/steep/blob/master/CHANGELOG.md"
 
   spec.files         = `git ls-files -z`.split("\x0").reject {|f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(test|spec|features|smoke)/})
   }
 
   spec.bindir        = "exe"