steep 1.6.0 → 1.7.1

data/sig/shims/parser/source/map.rbs

@@ -1,146 +0,0 @@
-module Parser
-  module Source
-    #
-    # {Map} relates AST nodes to the source code they were parsed from.
-    # More specifically, a {Map} or its subclass contains a set of ranges:
-    #
-    #  * `expression`: smallest range which includes all source corresponding
-    #    to the node and all `expression` ranges of its children.
-    #  * other ranges (`begin`, `end`, `operator`, ...): node-specific ranges
-    #    pointing to various interesting tokens corresponding to the node.
-    #
-    # Note that the {Map::Heredoc} map is the only one whose `expression` does
-    # not include other ranges. It only covers the heredoc marker (`<<HERE`),
-    # not the here document itself.
-    #
-    # All ranges except `expression` are defined by {Map} subclasses.
-    #
-    # Ranges (except `expression`) can be `nil` if the corresponding token is
-    # not present in source. For example, a hash may not have opening/closing
-    # braces, and so would its source map.
-    #
-    #     p Parser::CurrentRuby.parse('[1 => 2]').children[0].loc
-    #     # => <Parser::Source::Map::Collection:0x007f5492b547d8
-    #     #  @end=nil, @begin=nil,
-    #     #  @expression=#<Source::Range (string) 1...7>>
-    #
-    # The {file:doc/AST_FORMAT.md} document describes how ranges associated to source
-    # code tokens. For example, the entry
-    #
-    #     (array (int 1) (int 2))
-    #
-    #     "[1, 2]"
-    #      ^ begin
-    #           ^ end
-    #      ~~~~~~ expression
-    #
-    # means that if `node` is an {Parser::AST::Node} `(array (int 1) (int 2))`,
-    # then `node.loc` responds to `begin`, `end` and `expression`, and
-    # `node.loc.begin` returns a range pointing at the opening bracket, and so on.
-    #
-    # If you want to write code polymorphic by the source map (i.e. accepting
-    # several subclasses of {Map}), use `respond_to?` instead of `is_a?` to
-    # check whether the map features the range you need. Concrete {Map}
-    # subclasses may not be preserved between versions, but their interfaces
-    # will be kept compatible.
-    #
-    # You can visualize the source maps with `ruby-parse -E` command-line tool.
-    #
-    # @example
-    #  require 'parser/current'
-    #
-    #  p Parser::CurrentRuby.parse('[1, 2]').loc
-    #  # => #<Parser::Source::Map::Collection:0x007f14b80eccd8
-    #  #  @end=#<Source::Range (string) 5...6>,
-    #  #  @begin=#<Source::Range (string) 0...1>,
-    #  #  @expression=#<Source::Range (string) 0...6>>
-    #
-    # @!attribute [r] node
-    #  The node that is described by this map. Nodes and maps have 1:1 correspondence.
-    #  @return [Parser::AST::Node]
-    #
-    # @!attribute [r] expression
-    #  @return [Range]
-    #
-    # @api public
-    #
-    class Map
-      attr_reader node: AST::Node
-
-      attr_reader expression: Range
-
-      #
-      # @param [Range] expression
-      def initialize: (untyped expression) -> void
-
-      #
-      # @api private
-      def initialize_copy: (untyped other) -> untyped
-
-      #
-      # @api private
-      def node=: (untyped node) -> untyped
-
-      #
-      # A shortcut for `self.expression.line`.
-      # @return [Integer]
-      #
-      def line: () -> Integer
-
-      alias first_line line
-
-      #
-      # A shortcut for `self.expression.column`.
-      # @return [Integer]
-      #
-      def column: () -> Integer
-
-      #
-      # A shortcut for `self.expression.last_line`.
-      # @return [Integer]
-      #
-      def last_line: () -> Integer
-
-      #
-      # A shortcut for `self.expression.last_column`.
-      # @return [Integer]
-      #
-      def last_column: () -> Integer
-
-      #
-      # @api private
-      #
-      def with_expression: (untyped expression_l) -> untyped
-
-      #
-      # Compares source maps.
-      # @return [Boolean]
-      #
-      def ==: (untyped other) -> bool
-
-      #
-      # Converts this source map to a hash with keys corresponding to
-      # ranges. For example, if called on an instance of {Collection},
-      # which adds the `begin` and `end` ranges, the resulting hash
-      # will contain keys `:expression`, `:begin` and `:end`.
-      #
-      # @example
-      #  require 'parser/current'
-      #
-      #  p Parser::CurrentRuby.parse('[1, 2]').loc.to_hash
-      #  # => {
-      #  #   :begin => #<Source::Range (string) 0...1>,
-      #  #   :end => #<Source::Range (string) 5...6>,
-      #  #   :expression => #<Source::Range (string) 0...6>
-      #  # }
-      #
-      # @return [Hash<Symbol, Parser::Source::Range>]
-      #
-      def to_hash: () -> Hash[Symbol, Range]
-
-      def with: () ?{ () -> untyped } -> untyped
-
-      def update_expression: (untyped expression_l) -> untyped
-    end
-  end
-end

data/sig/shims/parser/source/range.rbs

@@ -1,237 +0,0 @@
-module Parser
-  module Source
-    #
-    # A range of characters in a particular source buffer.
-    #
-    # The range is always exclusive, i.e. a range with `begin_pos` of 3 and
-    # `end_pos` of 5 will contain the following characters:
-    #
-    #     example
-    #        ^^
-    #
-    # @!attribute [r] source_buffer
-    #  @return [Parser::Source::Buffer]
-    #
-    # @!attribute [r] begin_pos
-    #  @return [Integer] index of the first character in the range
-    #
-    # @!attribute [r] end_pos
-    #  @return [Integer] index of the character after the last character in the range
-    #
-    # @api public
-    #
-    class Range
-      include Comparable
-
-      attr_reader source_buffer: untyped
-
-      attr_reader begin_pos: Integer
-
-      attr_reader end_pos: Integer
-
-      #
-      # @param [Buffer]  source_buffer
-      # @param [Integer] begin_pos
-      # @param [Integer] end_pos
-      #
-      def initialize: (untyped source_buffer, untyped begin_pos, untyped end_pos) -> void
-
-      #
-      # @return [Range] a zero-length range located just before the beginning
-      #   of this range.
-      #
-      def begin: () -> Range
-
-      #
-      # @return [Range] a zero-length range located just after the end
-      #   of this range.
-      #
-      def end: () -> Range
-
-      #
-      # @return [Integer] amount of characters included in this range.
-      #
-      def size: () -> Integer
-
-      alias length size
-
-      #
-      # Line number of the beginning of this range. By default, the first line
-      # of a buffer is 1; as such, line numbers are most commonly one-based.
-      #
-      # @see Buffer
-      # @return [Integer] line number of the beginning of this range.
-      #
-      def line: () -> Integer
-
-      alias first_line line
-
-      #
-      # @return [Integer] zero-based column number of the beginning of this range.
-      #
-      def column: () -> Integer
-
-      #
-      # @return [Integer] line number of the end of this range.
-      #
-      def last_line: () -> Integer
-
-      #
-      # @return [Integer] zero-based column number of the end of this range.
-      #
-      def last_column: () -> Integer
-
-      #
-      # @return [::Range] a range of columns spanned by this range.
-      # @raise RangeError
-      #
-      def column_range: () -> ::Range[Integer]
-
-      #
-      # @return [String] a line of source code containing the beginning of this range.
-      #
-      def source_line: () -> String
-
-      #
-      # @return [String] all source code covered by this range.
-      #
-      def source: () -> String
-
-      #
-      # `is?` provides a concise way to compare the source corresponding to this range.
-      # For example, `r.source == '(' || r.source == 'begin'` is equivalent to
-      # `r.is?('(', 'begin')`.
-      #
-      def is?: (*untyped what) -> untyped
-
-      #
-      # @return [Array<Integer>] a set of character indexes contained in this range.
-      #
-      def to_a: () -> Array[Integer]
-
-      #
-      # @return [Range] a Ruby range with the same `begin_pos` and `end_pos`
-      #
-      def to_range: () -> ::Range[Integer]
-
-      #
-      # Composes a GNU/Clang-style string representation of the beginning of this
-      # range.
-      #
-      # For example, for the following range in file `foo.rb`,
-      #
-      #     def foo
-      #         ^^^
-      #
-      # `to_s` will return `foo.rb:1:5`.
-      # Note that the column index is one-based.
-      #
-      # @return [String]
-      #
-      def to_s: () -> String
-
-      #
-      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
-      # @return [Range] the same range as this range but with the given end point(s) changed
-      # to the given value(s).
-      #
-      def with: (?begin_pos: untyped, ?end_pos: untyped) -> untyped
-
-      #
-      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
-      # @return [Range] the same range as this range but with the given end point(s) adjusted
-      # by the given amount(s)
-      #
-      def adjust: (?begin_pos: ::Integer, ?end_pos: ::Integer) -> untyped
-
-      #
-      # @param [Integer] new_size
-      # @return [Range] a range beginning at the same point as this range and length `new_size`.
-      #
-      def resize: (untyped new_size) -> untyped
-
-      #
-      # @param [Range] other
-      # @return [Range] smallest possible range spanning both this range and `other`.
-      #
-      def join: (untyped other) -> untyped
-
-      #
-      # @param [Range] other
-      # @return [Range] overlapping region of this range and `other`, or `nil`
-      #   if they do not overlap
-      #
-      def intersect: (untyped other) -> (untyped | nil)
-
-      #
-      # Return `true` iff this range and `other` are disjoint.
-      #
-      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
-      #
-      # @param [Range] other
-      # @return [Boolean]
-      #
-      def disjoint?: (untyped other) -> untyped
-
-      #
-      # Return `true` iff this range is not disjoint from `other`.
-      #
-      # @param [Range] other
-      # @return [Boolean] `true` if this range and `other` overlap
-      #
-      def overlaps?: (untyped other) -> untyped
-
-      #
-      # Returns true iff this range contains (strictly) `other`.
-      #
-      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
-      #
-      # @param [Range] other
-      # @return [Boolean]
-      #
-      def contains?: (untyped other) -> untyped
-
-      #
-      # Return `other.contains?(self)`
-      #
-      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
-      #
-      # @param [Range] other
-      # @return [Boolean]
-      #
-      def contained?: (untyped other) -> untyped
-
-      #
-      # Returns true iff both ranges intersect and also have different elements from one another.
-      #
-      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
-      #
-      # @param [Range] other
-      # @return [Boolean]
-      #
-      def crossing?: (untyped other) -> (false | untyped)
-
-      #
-      # Checks if a range is empty; if it contains no characters
-      # @return [Boolean]
-      def empty?: () -> untyped
-
-      #
-      # Compare ranges, first by begin_pos, then by end_pos.
-      #
-      def <=>: (untyped other) -> (nil | untyped)
-
-      alias eql? ==
-
-      #
-      # Support for Ranges be used in as Hash indices and in Sets.
-      #
-      def hash: () -> untyped
-
-      #
-      # @return [String] a human-readable representation of this range.
-      #
-      def inspect: () -> ::String
-    end
-  end
-end

data/sig/shims/parser.rbs

@@ -1,59 +0,0 @@
-module Parser
-  module AST
-    class Node
-      attr_reader type: Symbol
-
-      attr_reader children: Array[untyped]
-
-      def initialize: (Symbol `type`, ?Array[untyped] children, ?Hash[Symbol, untyped] properties) -> void
-
-      def updated: (?Symbol?, ?Array[untyped]?, ?Hash[Symbol, untyped]? properties) -> Node
-
-      attr_reader location: Source::Map
-
-      alias loc location
-    end
-  end
-
-  class Ruby31
-    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
-
-  class Ruby32
-    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
-    end
-  end
-
-  module Builders
-    class Default
-      attr_accessor self.emit_lambda: bool
-      attr_accessor self.emit_procarg0: bool
-      attr_accessor self.emit_kwargs: bool
-      attr_accessor self.emit_forward_arg: bool
-
-      def string_value: (untyped) -> untyped
-
-      def value: (untyped) -> untyped
-    end
-  end
-
-  class SyntaxError < StandardError
-  end
-end

data/sig/shims/string.rbs

@@ -1,4 +0,0 @@
-class String
-  def start_with?: (Regexp) -> bool
-                 | ...
-end

data/sig/shims/tagged_logging.rbs

@@ -1,6 +0,0 @@
-module ActiveSupport::TaggedLogging
-  def tagged: [A] (*String) { () -> A } -> A
-            | ...
-
-  def formatter: () -> Formatter
-end

data/sig/steep/annotation_parser.rbs

@@ -1,60 +0,0 @@
-module Steep
-  class AnnotationParser
-    VAR_NAME: Regexp
-
-    METHOD_NAME: Regexp
-
-    CONST_NAME: Regexp
-
-    DYNAMIC_NAME: Regexp
-
-    IVAR_NAME: Regexp
-
-    attr_reader factory: AST::Types::Factory
-
-    def initialize: (factory: AST::Types::Factory) -> void
-
-    class SyntaxError < StandardError
-      attr_reader source: String
-
-      attr_reader location: RBS::Location[untyped, untyped]
-
-      def initialize: (source: String, location: RBS::Location[untyped, untyped], exn: Exception) -> void
-                    | (source: String, location: RBS::Location[untyped, untyped], message: String) -> void
-    end
-
-    TYPE: Regexp
-
-    COLON: Regexp
-
-    PARAM: Regexp
-
-    TYPE_PARAMS: Regexp
-
-    def parse_type: (MatchData, ?Symbol, location: RBS::Location[untyped, untyped]) -> AST::Types::t
-
-    # ```
-    # @type ${keyword} ${name}: ${type}
-    # ```
-    #
-    # Example:
-    #
-    # - `@type const Foo::Bar: String`
-    # - `@type var xyzzy: Array[String]`
-    #
-    def keyword_subject_type: (String keyword, Regexp name) -> Regexp
-
-    # ```
-    # @type ${keyword}: ${type}
-    # ```
-    #
-    # Example:
-    #
-    # - `@type break: String`
-    # - `@type self: Foo`
-    #
-    def keyword_and_type: (String keyword) -> ::Regexp
-
-    def parse: (String src, location: RBS::Location[untyped, untyped]) -> AST::Annotation::t?
-  end
-end

data/sig/steep/ast/annotation/collection.rbs

@@ -1,78 +0,0 @@
-module Steep
-  module AST
-    module Annotation
-      class Collection
-        attr_reader annotations: Array[Annotation::t]
-
-        attr_reader factory: Types::Factory
-
-        attr_reader context: RBS::Resolver::context
-
-        attr_reader var_type_annotations: Hash[Symbol, VarType]
-
-        attr_reader const_type_annotations: Hash[RBS::TypeName, ConstType]
-
-        attr_reader ivar_type_annotations: Hash[Symbol, IvarType]
-
-        attr_reader method_type_annotations: Hash[Symbol, MethodType?]
-
-        attr_reader block_type_annotation: BlockType?
-
-        attr_reader return_type_annotation: ReturnType?
-
-        attr_reader self_type_annotation: SelfType?
-
-        attr_reader instance_type_annotation: InstanceType?
-
-        attr_reader module_type_annotation: ModuleType?
-
-        attr_reader implement_module_annotation: Implements?
-
-        attr_reader dynamic_annotations: Array[Dynamic]
-
-        attr_reader break_type_annotation: BreakType?
-
-        def initialize: (annotations: Array[Annotation::t], factory: Types::Factory, context: RBS::Resolver::context) -> void
-
-        def absolute_type: (Types::t) -> Types::t
-                         | (Types::t?) -> Types::t?
-
-        def var_type: (lvar: Symbol) -> Types::t?
-                    | (ivar: Symbol) -> Types::t?
-                    | (const: RBS::TypeName) -> Types::t?
-
-        def method_type: (Symbol name) -> Interface::MethodType?
-
-        %a{pure} def block_type: () -> Types::t?
-
-        %a{pure} def return_type: () -> Types::t?
-
-        %a{pure} def self_type: () -> Types::t?
-
-        %a{pure} def instance_type: () -> Types::t?
-
-        %a{pure} def module_type: () -> Types::t?
-
-        %a{pure} def break_type: () -> Types::t?
-
-        def lvar_types: () -> Hash[Symbol, Types::t]
-
-        def ivar_types: () -> Hash[Symbol, Types::t]
-
-        def const_types: () -> Hash[RBS::TypeName, Types::t]
-
-        def instance_dynamics: () -> Array[Symbol]
-
-        def module_dynamics: () -> Array[Symbol]
-
-        def merge_block_annotations: (Collection annotations) -> Collection
-
-        def any?: () { (Annotation::t) -> boolish } -> bool
-
-        def size: () -> Integer
-
-        def include?: (Annotation::t obj) -> bool
-      end
-    end
-  end
-end

data/sig/steep/ast/annotation.rbs

@@ -1,121 +0,0 @@
-module Steep
-  module AST
-    module Annotation
-      type t = ReturnType | BlockType | SelfType | InstanceType | ModuleType | BreakType
-             | MethodType | VarType | ConstType | IvarType
-             | Implements | Dynamic
-
-      type loc = RBS::Location[untyped, untyped]
-
-      module Located
-        attr_reader location: loc?
-
-        %a{pure} def line: () -> Integer?
-      end
-
-      class Named[T, N]
-        attr_reader name: N
-
-        attr_reader type: T
-
-        include Located
-
-        def initialize: (name: N, type: T, ?location: loc?) -> void
-
-        def ==: (untyped other) -> bool
-      end
-
-      class Typed
-        attr_reader type: Types::t
-
-        def initialize: (type: Types::t, ?location: loc?) -> void
-
-        def ==: (untyped other) -> bool
-
-        include Located
-      end
-
-      class ReturnType < Typed
-      end
-
-      class BlockType < Typed
-      end
-
-      class SelfType < Typed
-      end
-
-      class InstanceType < Typed
-      end
-
-      class ModuleType < Typed
-      end
-
-      class BreakType < Typed
-      end
-
-      class MethodType < Named[Interface::MethodType, Symbol]
-      end
-
-      class VarType < Named[Types::t, Symbol]
-      end
-
-      class ConstType < Named[Types::t, RBS::TypeName]
-      end
-
-      class IvarType < Named[Types::t, Symbol]
-      end
-
-      class Implements
-        class Module
-          attr_reader name: RBS::TypeName
-
-          attr_reader args: Array[Symbol]
-
-          def initialize: (name: RBS::TypeName, args: Array[Symbol]) -> void
-
-          def ==: (untyped other) -> bool
-
-          alias eql? ==
-
-          def hash: () -> Integer
-        end
-
-        include Located
-
-        attr_reader name: Module
-
-        def initialize: (name: Module, ?location: loc?) -> void
-
-        def ==: (untyped other) -> bool
-      end
-
-      class Dynamic
-        class Name
-          type kind = :instance | :module_instance | :module
-
-          attr_reader kind: kind
-
-          attr_reader name: Symbol
-
-          attr_reader location: loc?
-
-          def initialize: (name: Symbol, kind: kind, ?location: loc?) -> void
-
-          def instance_method?: () -> bool
-
-          def module_method?: () -> bool
-
-          def ==: (untyped other) -> bool
-        end
-
-        include Located
-
-        attr_reader names: Array[Name]
-
-        def initialize: (names: Array[Name], ?location: loc?) -> void
-
-        def ==: (untyped other) -> bool
-      end
-    end
-  end
-end