steep 1.0.2 → 1.1.0.pre.1

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

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

@@ -0,0 +1,76 @@
+module Steep
+  module AST
+    module Types
+      class Factory
+        attr_reader definition_builder: RBS::DefinitionBuilder
+
+        attr_reader type_name_cache: untyped
+
+        attr_reader type_cache: untyped
+
+        attr_reader type_interface_cache: untyped
+
+        def inspect: () -> String
+
+        def initialize: (builder: RBS::DefinitionBuilder) -> void
+
+        def type_name_resolver: () -> untyped
+
+        def type_opt: (untyped `type`) -> (untyped | nil)
+
+        def type: (RBS::Types::t `type`) -> AST::Types::t
+
+        def type_1: (AST::Types::t `type`) -> RBS::Types::t
+
+        def function_1: (untyped func) -> untyped
+
+        def params: (untyped `type`) -> untyped
+
+        def type_param: (untyped type_param) -> untyped
+
+        def type_param_1: (untyped type_param) -> untyped
+
+        def method_type: (RBS::MethodType method_type, self_type: AST::Types::t, method_decls: untyped, ?subst2: Interface::Substitution?) -> Interface::MethodType
+                       | [A] (RBS::MethodType method_type, self_type: AST::Types::t, method_decls: untyped, ?subst2: Interface::Substitution?) { (Interface::MethodType) -> A } -> A
+
+        def method_type_1: (untyped method_type, self_type: untyped) { (untyped) -> untyped } -> untyped
+
+        class InterfaceCalculationError < StandardError
+          attr_reader type: untyped
+
+          def initialize: (type: untyped, message: untyped) -> void
+        end
+
+        def unfold: (RBS::TypeName type_name, Array[t] args) -> t
+
+        def expand_alias: (t `type`) -> t
+                        | [A] (t) { (t) -> A } -> A
+
+        def deep_expand_alias: (t `type`, ?recursive: Set[t]) -> t
+                             | [A] (t `type`, ?recursive: Set[t]) { (t) -> A }-> A
+
+        def flatten_union: (untyped `type`, ?untyped acc) -> untyped
+
+        def unwrap_optional: (Types::t `type`) -> [Types::t, Types::t]
+
+        NilClassName: untyped
+
+        def setup_primitives: (untyped method_name, untyped method_def, untyped method_type) -> untyped
+
+        def interface: (untyped `type`, private: untyped, ?self_type: untyped) -> untyped
+
+        def module_name?: (untyped type_name) -> untyped
+
+        def class_name?: (untyped type_name) -> untyped
+
+        def env: () -> RBS::Environment
+
+        def absolute_type: (untyped `type`, context: untyped) -> untyped
+
+        def absolute_type_name: (untyped type_name, context: untyped) -> untyped
+
+        def instance_type: (RBS::TypeName type_name, ?args: Array[t]?, ?location: untyped?) -> t
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Steep
+  module AST
+    module Types
+      module Helper
+        module ChildrenLevel
+          def level_of_children: (untyped children) -> untyped
+        end
+
+        module NoFreeVariables
+          def free_variables: () -> untyped
+        end
+
+        module NoChild
+          def each_child: () ?{ () -> untyped } -> (untyped | nil)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Intersection
+        attr_reader types: untyped
+
+        attr_reader location: untyped
+
+        def initialize: (types: untyped, ?location: untyped?) -> void
+
+        def self.build: (types: untyped, ?location: untyped?) -> untyped
+
+        def ==: (untyped other) -> untyped
+
+        def hash: () -> untyped
+
+        alias eql? ==
+
+        def subst: (untyped s) -> untyped
+
+        def to_s: () -> ::String
+
+        def free_variables: () -> untyped
+
+        include Helper::ChildrenLevel
+
+        def each_child: () ?{ () -> untyped } -> untyped
+
+        def level: () -> untyped
+
+        def with_location: (untyped new_location) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Steep
+  module AST
+    module Types
+      class Literal
+        attr_reader location: untyped
+
+        attr_reader value: untyped
+
+        def initialize: (value: untyped, ?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[0]
+
+        def with_location: (untyped new_location) -> untyped
+
+        def back_type: () -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Steep
+  module AST
+    module Types
+      module Logic
+        type loc = RBS::Location[untyped, untyped]
+
+        class Base
+          attr_reader location: untyped
+
+          def subst: (untyped s) -> self
+
+          def free_variables: () -> untyped
+
+          include Helper::NoChild
+
+          def hash: () -> untyped
+
+          def ==: (untyped other) -> untyped
+
+          alias eql? ==
+
+          def to_s: () -> ::String
+        end
+
+        # A type for `!` (not) operator results.
+        class Not < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        # A type for `foo.nil?` call results.
+        class ReceiverIsNil < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        #
+        class ReceiverIsNotNil < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        # A type for `receiver.is_a?(C)` call results.
+        class ReceiverIsArg < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        # A type for `Class#===` call results.
+        class ArgIsReceiver < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        # A type for `Object#===` call results.
+        class ArgEqualsReceiver < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
+        # A type with truthy/falsy type environment.
+        class Env < Base
+          attr_reader truthy: TypeInference::TypeEnv
+
+          attr_reader falsy: TypeInference::TypeEnv
+
+          attr_reader type: t
+
+          def initialize: (truthy: TypeInference::TypeEnv, falsy: TypeInference::TypeEnv, type: t, ?location: loc?) -> void
+
+          def ==: (untyped other) -> bool
+
+          alias eql? ==
+
+          def hash: () -> Integer
+
+          def inspect: () -> ::String
+
+          alias to_s inspect
+        end
+      end
+    end
+  end
+end