steep 1.0.0 → 1.1.0.pre.1

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

@@ -0,0 +1,237 @@
+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

@@ -0,0 +1,17 @@
+module Parser
+  module AST
+    class Node
+      attr_reader type: Symbol
+
+      attr_reader children: Array[untyped]
+
+      def initialize: (Symbol `type`, Array[untyped] children) -> void
+
+      def updated: (?Symbol?, ?Array[untyped]?) -> Node
+
+      attr_reader location: Source::Map
+
+      alias loc location
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Steep
+  module AST
+    module Annotation
+      class Collection
+        attr_reader annotations: untyped
+
+        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: untyped
+
+        attr_reader block_type_annotation: untyped
+
+        attr_reader return_type_annotation: untyped
+
+        attr_reader self_type_annotation: untyped
+
+        attr_reader instance_type_annotation: untyped
+
+        attr_reader module_type_annotation: untyped
+
+        attr_reader implement_module_annotation: untyped
+
+        attr_reader dynamic_annotations: untyped
+
+        attr_reader break_type_annotation: untyped
+
+        def initialize: (annotations: untyped, factory: untyped, context: untyped) -> void
+
+        def absolute_type: (untyped `type`) -> (untyped | nil)
+
+        def var_type: (?lvar: untyped?, ?ivar: untyped?, ?const: untyped?) -> untyped
+
+        def method_type: (untyped name) -> (untyped | nil)
+
+        def block_type: () -> untyped
+
+        def return_type: () -> untyped
+
+        def self_type: () -> untyped
+
+        def instance_type: () -> untyped
+
+        def module_type: () -> untyped
+
+        def break_type: () -> untyped
+
+        def lvar_types: () -> untyped
+
+        def ivar_types: () -> untyped
+
+        def const_types: () -> untyped
+
+        def instance_dynamics: () -> untyped
+
+        def module_dynamics: () -> untyped
+
+        def merge_block_annotations: (untyped annotations) -> untyped
+
+        def any?: () { () -> untyped } -> untyped
+
+        def size: () -> untyped
+
+        def include?: (untyped obj) -> untyped
+      end
+    end
+  end
+end

data/sig/steep/ast/annotation.rbs

@@ -0,0 +1,126 @@
+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]
+
+      class Named
+        attr_reader name: Symbol
+
+        attr_reader type: Types::t
+
+        attr_reader location: loc?
+
+        def initialize: (name: Symbol, type: Types::t, ?location: loc?) -> void
+
+        def ==: (untyped other) -> bool
+      end
+
+      class Typed
+        attr_reader type: Types::t
+
+        attr_reader annotation: untyped
+
+        attr_reader location: loc?
+
+        def initialize: (type: Types::t, ?location: loc?) -> void
+
+        def ==: (untyped other) -> bool
+      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
+      end
+
+      class VarType < Named
+      end
+
+      class ConstType < Named
+        attr_reader name: RBS::TypeName
+
+        attr_reader type: Types::t
+
+        attr_reader location: loc?
+
+        def initialize: (name: RBS::TypeName, type: untyped, ?location: loc?) -> void
+
+        def ==: (untyped other) -> bool
+      end
+
+      class IvarType < Named
+      end
+
+      class Implements
+        class Module
+          attr_reader name: RBS::TypeName
+
+          attr_reader args: Array[Types::t]
+
+          def initialize: (name: RBS::TypeName, args: Array[Types::t]) -> void
+
+          def ==: (untyped other) -> bool
+
+          alias eql? ==
+
+          def hash: () -> Integer
+        end
+
+        attr_reader location: loc?
+
+        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
+
+        attr_reader location: loc?
+
+        attr_reader names: Array[Name]
+
+        def initialize: (names: Array[Name], ?location: loc?) -> void
+
+        def ==: (untyped other) -> bool
+      end
+    end
+  end
+end

data/sig/steep/ast/builtin.rbs

@@ -0,0 +1,69 @@
+module Steep
+  module AST
+    module Builtin
+      class Type
+        attr_reader module_name: RBS::TypeName
+
+        attr_reader arity: Integer
+
+        def initialize: (String module_name, ?arity: ::Integer) -> void
+
+        def instance_type: (*Types::t args, ?fill_untyped: bool) -> Types::Name::Instance
+
+        def module_type: () -> Types::Name::Singleton
+
+        def instance_type?: (Types::t `type`, ?args: Array[Types::t]?) -> bool
+
+        def module_type?: (Types::t `type`) -> bool
+      end
+
+      Object: Type
+
+      BasicObject: Type
+
+      Array: Type
+
+      Range: Type
+
+      Hash: Type
+
+      Module: Type
+
+      Class: Type
+
+      Integer: Type
+
+      Float: Type
+
+      String: Type
+
+      Symbol: Type
+
+      TrueClass: Type
+
+      FalseClass: Type
+
+      Regexp: Type
+
+      NilClass: Type
+
+      Proc: Type
+
+      def self.nil_type: () -> Types::Nil
+
+      def self.any_type: () -> Types::Any
+
+      def self.bool_type: () -> Types::Boolean
+
+      def self.bottom_type: () -> Types::Bot
+
+      def self.top_type: () -> Types::Top
+
+      def self.optional: (Types::t `type`) -> Types::Union
+
+      def self.true_type: () -> Types::Literal
+
+      def self.false_type: () -> Types::Literal
+    end
+  end
+end

data/sig/steep/ast/type_params.rbs

@@ -0,0 +1,11 @@
+# module Steep
+#   module AST
+#     class TypeParams
+#       attr_reader location: untyped
+
+#       attr_reader variables: untyped
+
+#       def initialize: (variables: untyped, ?location: untyped?) -> void
+#     end
+#   end
+# end

data/sig/steep/ast/types/any.rbs

@@ -0,0 +1,29 @@
+module Steep
+  module AST
+    module Types
+      class Any
+        attr_reader location: untyped
+
+        def initialize: (?location: untyped?) -> void
+
+        def ==: (untyped other) -> untyped
+
+        def hash: () -> untyped
+
+        alias eql? ==
+
+        def subst: (untyped s) -> self
+
+        def to_s: () -> "untyped"
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level: () -> ::Array[1]
+
+        def with_location: (untyped new_location) -> untyped
+      end
+    end
+  end
+end

data/sig/steep/ast/types/boolean.rbs

@@ -0,0 +1,31 @@
+module Steep
+  module AST
+    module Types
+      class Boolean
+        attr_reader location: untyped
+
+        def initialize: (?location: untyped?) -> void
+
+        def ==: (untyped other) -> untyped
+
+        def hash: () -> untyped
+
+        alias eql? ==
+
+        def subst: (untyped s) -> self
+
+        def to_s: () -> "bool"
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level: () -> ::Array[0]
+
+        def with_location: (untyped new_location) -> untyped
+
+        def back_type: () -> untyped
+      end
+    end
+  end
+end

data/sig/steep/ast/types/bot.rbs

@@ -0,0 +1,29 @@
+module Steep
+  module AST
+    module Types
+      class Bot
+        attr_reader location: untyped
+
+        def initialize: (?location: untyped?) -> void
+
+        def ==: (untyped other) -> untyped
+
+        def hash: () -> untyped
+
+        alias eql? ==
+
+        def subst: (untyped s) -> self
+
+        def to_s: () -> "bot"
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level: () -> ::Array[2]
+
+        def with_location: (untyped new_location) -> untyped
+      end
+    end
+  end
+end

data/sig/steep/ast/types/class.rbs

@@ -0,0 +1,29 @@
+module Steep
+  module AST
+    module Types
+      class Class
+        attr_reader location: untyped
+
+        def initialize: (?location: untyped?) -> void
+
+        def to_s: () -> "class"
+
+        def ==: (untyped other) -> untyped
+
+        def hash: () -> untyped
+
+        alias eql? ==
+
+        def subst: (untyped s) -> untyped
+
+        def free_variables: () -> untyped
+
+        include Helper::NoChild
+
+        def level: () -> ::Array[0]
+
+        def with_location: (untyped new_location) -> untyped
+      end
+    end
+  end
+end