steep 1.7.0.dev.3 → 1.7.0

data/sig/shims/yaml.rbs

@@ -1,4 +0,0 @@
-module Psych
-  class SyntaxError < StandardError
-  end
-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

data/sig/steep/ast/builtin.rbs

@@ -1,69 +0,0 @@
-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]?) -> Types::Name::Instance?
-
-        def module_type?: (Types::t `type`) -> Types::Name::Singleton?
-      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) -> Types::t
-
-      def self.true_type: () -> Types::Literal
-
-      def self.false_type: () -> Types::Literal
-    end
-  end
-end

data/sig/steep/ast/ignore.rbs

@@ -1,66 +0,0 @@
-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/ast/node/type_application.rbs

@@ -1,31 +0,0 @@
-module Steep
-  module AST
-    module Node
-      class TypeApplication
-        attr_reader location: RBS::Location[untyped, untyped]
-
-        attr_reader node: Parser::AST::Node
-
-        def line: () -> Integer
-
-        def source: () -> String
-
-        def initialize: (RBS::Location[untyped, untyped]) -> void
-
-        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | Enumerator[Diagnostic::Signature::Base, void] | nil)
-
-        def types?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Array[Types::t]?
-
-        @type_str: String?
-        def type_str: () -> String
-
-        def type_location: () -> RBS::Location[untyped, untyped]
-
-        # Set the back reference to the `:tapp` node
-        def set_node: (Parser::AST::Node) -> void
-
-        def self.parse: (RBS::Location[untyped, untyped]) -> TypeApplication?
-      end
-    end
-  end
-end

data/sig/steep/ast/node/type_assertion.rbs

@@ -1,32 +0,0 @@
-module Steep
-  module AST
-    module Node
-      class TypeAssertion
-        attr_reader location: RBS::Location[untyped, untyped]
-
-        def source: () -> String
-
-        def line: () -> Integer
-
-        def initialize: (RBS::Location[untyped, untyped]) -> void
-
-        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | Array[Diagnostic::Signature::Base] | nil)
-
-        def type?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Types::t?
-
-        @type_str: String?
-        def type_str: () -> String
-
-        def type_location: () -> RBS::Location[untyped, untyped]
-
-        # Returns true if given comment body has a valid type syntax
-        #
-        # This method is used to reject RDoc directives beforehand.
-        #
-        def type_syntax?: () -> bool
-
-        def self.parse: (RBS::Location[untyped, untyped]) -> TypeAssertion?
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

@@ -1,33 +0,0 @@
-module Steep
-  module AST
-    module Types
-      class Class
-        attr_reader location: untyped
-
-        def initialize: (?location: untyped?) -> void
-
-        def to_s: () -> String
-
-        def ==: (untyped other) -> bool
-
-        def hash: () -> Integer
-
-        alias eql? ==
-
-        def subst: (Interface::Substitution s) -> t
-
-        @@fvs: Set[variable]
-        def free_variables: () -> Set[variable]
-
-        include Helper::NoChild
-
-        def level: () -> Array[Integer]
-
-        def with_location: (untyped new_location) -> Class
-
-        self.@instance: Class
-        def self.instance: () -> Class
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-use RBS::TypeName, RBS::Resolver::TypeNameResolver
-
-module Steep
-  module AST
-    module Types
-      class Factory
-        @env: RBS::Environment
-
-        attr_reader definition_builder: RBS::DefinitionBuilder
-
-        attr_reader type_cache: Hash[RBS::Types::t, t]
-
-        attr_reader type_interface_cache: untyped
-
-        @type_name_resolver: TypeNameResolver?
-
-        def inspect: () -> String
-
-        def initialize: (builder: RBS::DefinitionBuilder) -> void
-
-        def type_name_resolver: () -> TypeNameResolver
-
-        def type: (RBS::Types::t `type`) -> t
-
-        def type_opt: (RBS::Types::t? `type`) -> t?
-
-        def type_1: (t `type`) -> RBS::Types::t
-
-        def type_1_opt: (t?) -> RBS::Types::t?
-
-        def function_1: (Interface::Function func) -> RBS::Types::Function
-
-        def params: (RBS::Types::Function `type`) -> Interface::Function::Params
-
-        def type_param: (RBS::AST::TypeParam type_param) -> Interface::TypeParam
-
-        def type_param_1: (Interface::TypeParam type_param) -> RBS::AST::TypeParam
-
-        @method_type_cache: Hash[RBS::MethodType, Interface::MethodType]
-
-        def method_type: (RBS::MethodType method_type, method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> Interface::MethodType
-
-        def method_type_1: (Interface::MethodType method_type) -> RBS::MethodType
-
-        def unfold: (TypeName type_name, Array[t] args) -> t
-
-        # Unfold type alias one step, or returns itself
-        #
-        def expand_alias: (t `type`) -> t
-
-        # Unfold type alias until non alias type
-        #
-        # * Unions and intersections are expanded
-        # * Returns `nil` if it is recursive
-        #
-        def deep_expand_alias: (t `type`, ?recursive: Set[TypeName]) -> t?
-
-        # Convert union types to array of types
-        #
-        def flatten_union: (t `type`, ?Array[t] acc) -> Array[t]
-
-        # Partition the type components in union types to truthy ones and falsy ones
-        #
-        # * Returns a pair of *truthy* type and *falsy* type
-        # * The pair may contain `nil` if given type always evaluates to truthy or falsy
-        # * Expand (unfold) the type aliases automatically
-        #
-        # ```ruby
-        # partition_union?(`Integer?`)                          # => [`Integer`, `nil`]
-        # partition_union?(`Integer | String | nil | false`)    # => [`Integer | String`, `nil | false`]
-        # partition_union?(`bool`)                              # => [`bool`, `bool`]
-        # partition_union?(`nil`)                               # => [nil, `nil`]
-        # ```
-        #
-        def partition_union: (Types::t) -> [Types::t?, Types::t?]
-
-        # Returns a type that doesn't have `nil` in the union component
-        #
-        # * Returns `nil` if given type is `nil`
-        # * Expand (unfold) the type aliases automatically
-        #
-        # ```ruby
-        # unwrap_optional(`String?`)                               # => `String`
-        # unwrap_optional(`String | Integer | false | nil`)        # => `String | Integer | false`
-        # unwrap_optional(`nil`)                                   # => nil
-        # ```
-        #
-        def unwrap_optional: (Types::t) -> Types::t?
-
-        def module_name?: (TypeName type_name) -> bool
-
-        def class_name?: (TypeName type_name) -> bool
-
-        def env: () -> RBS::Environment
-
-        def absolute_type: (t `type`, context: RBS::Resolver::context) -> t
-
-        def absolute_type_name: (TypeName type_name, context: RBS::Resolver::context) -> TypeName?
-
-        def instance_type: (TypeName type_name, ?args: Array[t]?, ?location: untyped?) -> t
-
-        def try_singleton_type: (t) -> t?
-
-        def try_instance_type: (t) -> t?
-
-        def normalize_type: (t) -> t
-      end
-    end
-  end
-end