steep 1.0.0 → 1.1.0.pre.1

data/sig/steep/diagnostic/signature.rbs

@@ -0,0 +1,215 @@
+module Steep
+  module Diagnostic
+    module Signature
+      class Base
+        include Helper
+
+        attr_reader location: untyped
+
+        def initialize: (location: untyped) -> void
+
+        def header_line: () -> untyped
+
+        def detail_lines: () -> nil
+
+        def diagnostic_code: () -> ::String
+
+        def path: () -> untyped
+      end
+
+      class SyntaxError < Base
+        attr_reader exception: untyped
+
+        def initialize: (untyped exception, location: untyped) -> void
+
+        def self.parser_syntax_error_message: (untyped exception) -> ::String
+
+        def header_line: () -> untyped
+      end
+
+      class DuplicatedDeclaration < Base
+        attr_reader type_name: untyped
+
+        def initialize: (type_name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class UnknownTypeName < Base
+        attr_reader name: untyped
+
+        def initialize: (name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class InvalidTypeApplication < Base
+        attr_reader name: untyped
+
+        attr_reader args: untyped
+
+        attr_reader params: untyped
+
+        def initialize: (name: untyped, args: untyped, params: untyped, location: untyped) -> void
+
+        def header_line: () -> untyped
+      end
+
+      class UnsatisfiableTypeApplication < Base
+        attr_reader type_name: untyped
+
+        attr_reader type_arg: untyped
+
+        attr_reader type_param: untyped
+
+        def initialize: (type_name: untyped, type_arg: untyped, type_param: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class InvalidMethodOverload < Base
+        attr_reader class_name: untyped
+
+        attr_reader method_name: untyped
+
+        def initialize: (class_name: untyped, method_name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class UnknownMethodAlias < Base
+        attr_reader class_name: untyped
+
+        attr_reader method_name: untyped
+
+        def initialize: (class_name: untyped, method_name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class DuplicatedMethodDefinition < Base
+        attr_reader class_name: untyped
+
+        attr_reader method_name: untyped
+
+        def initialize: (class_name: untyped, method_name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class RecursiveAlias < Base
+        attr_reader class_name: untyped
+
+        attr_reader names: untyped
+
+        attr_reader location: untyped
+
+        def initialize: (class_name: untyped, names: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class RecursiveAncestor < Base
+        attr_reader ancestors: untyped
+
+        def initialize: (ancestors: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class SuperclassMismatch < Base
+        attr_reader name: untyped
+
+        def initialize: (name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class GenericParameterMismatch < Base
+        attr_reader name: untyped
+
+        def initialize: (name: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class InvalidVarianceAnnotation < Base
+        attr_reader name: untyped
+
+        attr_reader param: untyped
+
+        def initialize: (name: untyped, param: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class ModuleSelfTypeError < Base
+        attr_reader name: untyped
+
+        attr_reader ancestor: untyped
+
+        attr_reader relation: untyped
+
+        def initialize: (name: untyped, ancestor: untyped, relation: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class InstanceVariableTypeError < Base
+        attr_reader name: untyped
+
+        attr_reader variable: untyped
+
+        attr_reader var_type: untyped
+
+        attr_reader parent_type: untyped
+
+        def initialize: (name: untyped, location: untyped, var_type: untyped, parent_type: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class MixinClassError < Base
+        attr_reader member: untyped
+
+        attr_reader type_name: untyped
+
+        def initialize: (location: untyped, member: untyped, type_name: untyped) -> void
+
+        def header_line: () -> ::String
+
+        private
+
+        def mixin_name: () -> untyped
+      end
+
+      class UnexpectedError < Base
+        attr_reader message: untyped
+
+        def initialize: (message: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class RecursiveTypeAlias < Base
+        attr_reader alias_names: untyped
+
+        def initialize: (alias_names: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      class NonregularTypeAlias < Base
+        attr_reader type_name: untyped
+
+        attr_reader nonregular_type: untyped
+
+        def initialize: (type_name: untyped, nonregular_type: untyped, location: untyped) -> void
+
+        def header_line: () -> ::String
+      end
+
+      def self.from_rbs_error: (untyped error, factory: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/interface/block.rbs

@@ -0,0 +1,35 @@
+module Steep
+  module Interface
+    class Block
+      attr_reader type: Function
+
+      attr_reader optional: bool
+
+      def initialize: (type: Function, optional: bool) -> void
+
+      def optional?: () -> bool
+
+      def required?: () -> bool
+
+      def to_optional: () -> Block
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def closed?: () -> bool
+
+      def subst: (Substitution s) -> Block
+
+      def free_variables: () -> Set[Symbol]
+
+      def to_s: () -> ::String
+
+      def map_type: () { (AST::Types::t) -> AST::Types::t } -> Block
+
+      def +: (Block other) -> Block
+    end
+  end
+end

data/sig/steep/interface/function.rbs

@@ -0,0 +1,253 @@
+module Steep
+  module Interface
+    class Function
+      class Params
+        module Utils
+          def union: (*AST::Types::t types, ?null: bool) -> AST::Types::t
+
+          def intersection: (*AST::Types::t types) -> AST::Types::t
+        end
+
+        class PositionalParams
+          class Base
+            attr_reader type: untyped
+
+            def initialize: (untyped `type`) -> void
+
+            def ==: (untyped other) -> untyped
+
+            alias eql? ==
+
+            def hash: () -> untyped
+
+            def subst: (untyped s) -> untyped
+
+            def var_type: () -> untyped
+
+            def map_type: () { (untyped) -> untyped } -> untyped
+          end
+
+          class Required < Base
+          end
+
+          class Optional < Base
+          end
+
+          class Rest < Base
+          end
+
+          attr_reader head: untyped
+
+          attr_reader tail: untyped
+
+          def initialize: (head: untyped, tail: untyped) -> void
+
+          def self.required: (untyped `type`, ?untyped? tail) -> untyped
+
+          def self.optional: (untyped `type`, ?untyped? tail) -> untyped
+
+          def self.rest: (untyped `type`, ?untyped? tail) -> untyped
+
+          def to_ary: () -> ::Array[untyped]
+
+          def map: () { (untyped) -> untyped } -> untyped
+
+          def map_type: () { () -> untyped } -> untyped
+
+          def subst: (untyped s) -> untyped
+
+          def ==: (untyped other) -> untyped
+
+          alias eql? ==
+
+          def hash: () -> untyped
+
+          def each: () { (untyped) -> untyped } -> untyped
+
+          def each_type: () { (untyped) -> untyped } -> untyped
+
+          def size: () -> untyped
+
+          def self.build: (required: untyped, optional: untyped, rest: untyped) -> untyped
+
+          extend Utils
+
+          # Calculates xs + ys.
+          # Never fails.
+          def self.merge_for_overload: (untyped xs, untyped ys) -> untyped
+
+          # xs | ys
+          def self.merge_for_union: (untyped xs, untyped ys) -> untyped
+
+          # Calculates xs & ys.
+          # Raises when failed.
+          #
+          def self.merge_for_intersection: (untyped xs, untyped ys) -> untyped
+        end
+
+        class KeywordParams
+          attr_reader requireds: untyped
+
+          attr_reader optionals: untyped
+
+          attr_reader rest: untyped
+
+          def initialize: (?requireds: ::Hash[untyped, untyped], ?optionals: ::Hash[untyped, untyped], ?rest: untyped?) -> void
+
+          def ==: (untyped other) -> untyped
+
+          alias eql? ==
+
+          def hash: () -> untyped
+
+          def update: (?requireds: untyped, ?optionals: untyped, ?rest: untyped) -> untyped
+
+          def empty?: () -> untyped
+
+          def each: () { (untyped, untyped) -> untyped } -> untyped
+
+          def each_type: () { (untyped) -> untyped } -> untyped
+
+          def map_type: () { () -> untyped } -> untyped
+
+          def subst: (untyped s) -> untyped
+
+          def size: () -> untyped
+
+          def keywords: () -> untyped
+
+          include Utils
+
+          # For overloading
+          def +: (untyped other) -> untyped
+
+          # For union
+          def |: (untyped other) -> untyped
+
+          # For intersection
+          def &: (untyped other) -> (nil | untyped)
+        end
+
+        def required: () -> Array[AST::Types::t]
+
+        def optional: () -> Array[AST::Types::t]
+
+        def rest: () -> AST::Types::t?
+
+        attr_reader positional_params: PositionalParams
+
+        attr_reader keyword_params: KeywordParams
+
+        def self.build: (?required: untyped, ?optional: untyped, ?rest: untyped?, ?required_keywords: ::Hash[untyped, untyped], ?optional_keywords: ::Hash[untyped, untyped], ?rest_keywords: untyped?) -> untyped
+
+        def initialize: (positional_params: untyped, keyword_params: untyped) -> void
+
+        def update: (?positional_params: untyped, ?keyword_params: untyped) -> untyped
+
+        def first_param: () -> untyped
+
+        def with_first_param: (untyped param) -> untyped
+
+        def has_positional?: () -> (true | false)
+
+        def self.empty: () -> untyped
+
+        def ==: (untyped other) -> untyped
+
+        alias eql? ==
+
+        def hash: () -> untyped
+
+        def flat_unnamed_params: () -> (untyped | ::Array[untyped])
+
+        def flat_keywords: () -> untyped
+
+        def required_keywords: () -> untyped
+
+        def optional_keywords: () -> untyped
+
+        def rest_keywords: () -> untyped
+
+        def has_keywords?: () -> untyped
+
+        def each_positional_param: () { () -> untyped } -> (untyped | nil | untyped)
+
+        def without_keywords: () -> untyped
+
+        def drop_first: () -> untyped
+
+        def each_type: () { () -> untyped } -> untyped
+
+        def free_variables: () -> untyped
+
+        def closed?: () -> untyped
+
+        def subst: (untyped s) -> untyped
+
+        def size: () -> untyped
+
+        def to_s: () -> ::String
+
+        def map_type: () { () -> untyped } -> untyped
+
+        def empty?: () -> untyped
+
+        # Returns true if all arguments are non-required.
+        def optional?: () -> untyped
+
+        # self + params returns a new params for overloading.
+        #
+        def +: (untyped other) -> untyped
+
+        # Returns the intersection between self and other.
+        # Returns nil if the intersection cannot be computed.
+        #
+        #   (self & other) <: self
+        #   (self & other) <: other
+        #
+        # `self & other` accept `arg` if `arg` is acceptable for both of `self` and `other`.
+        #
+        def &: (untyped other) -> (nil | untyped)
+
+        # Returns the union between self and other.
+        #
+        #    self <: (self | other)
+        #   other <: (self | other)
+        #
+        # `self | other` accept `arg` if `self` accepts `arg` or `other` accepts `arg`.
+        #
+        def |: (untyped other) -> (nil | untyped)
+      end
+
+      attr_reader params: untyped
+
+      attr_reader return_type: AST::Types::t
+
+      attr_reader location: untyped
+
+      def initialize: (params: untyped, return_type: untyped, location: untyped) -> void
+
+      def ==: (untyped other) -> untyped
+
+      alias eql? ==
+
+      def hash: () -> untyped
+
+      def free_variables: () -> Set[Symbol]
+
+      def subst: (Substitution s) -> Function
+
+      def each_child: () { () -> untyped } -> untyped
+
+      def each_type: () { (untyped) -> untyped } -> untyped
+
+      def map_type: () { (untyped) -> untyped } -> untyped
+
+      def with: (?params: untyped, ?return_type: untyped) -> untyped
+
+      def to_s: () -> ::String
+
+      def closed?: () -> bool
+    end
+  end
+end

data/sig/steep/interface/interface.rbs

@@ -0,0 +1,23 @@
+module Steep
+  module Interface
+    class Interface
+      class Entry
+        attr_reader method_types: untyped
+
+        def initialize: (method_types: untyped) -> void
+
+        def to_s: () -> ::String
+      end
+
+      attr_reader type: untyped
+
+      attr_reader methods: untyped
+
+      def initialize: (type: untyped, private: untyped) -> void
+
+      def private?: () -> untyped
+
+      def public?: () -> untyped
+    end
+  end
+end

data/sig/steep/interface/method_type.rbs

@@ -0,0 +1,55 @@
+module Steep
+  module Interface
+    class MethodType
+      attr_reader type_params: Array[TypeParam]
+
+      attr_reader type: Function
+
+      attr_reader block: Block
+
+      attr_reader method_decls: untyped
+
+      def initialize: (type_params: untyped, type: untyped, block: untyped, method_decls: untyped) -> void
+
+      def ==: (untyped other) -> untyped
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def free_variables: () -> Set[Symbol]
+
+      def subst: (Substitution s) -> MethodType
+
+      def each_type: () { (untyped) -> untyped } -> untyped
+
+      def instantiate: (Substitution s) -> MethodType
+
+      def with: (?type_params: untyped, ?type: untyped, ?block: untyped, ?method_decls: untyped) -> MethodType
+
+      def to_s: () -> ::String
+
+      def map_type: () { (AST::Types::t) -> AST::Types::t } -> MethodType
+
+      # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
+      #
+      def unify_overload: (untyped other) -> untyped
+
+      def +: (untyped other) -> untyped
+
+      # Returns a method type which is a super-type of both self and other.
+      #   self <: (self | other) && other <: (self | other)
+      #
+      # Returns nil if self and other are incompatible.
+      #
+      def |: (untyped other) -> (nil | untyped)
+
+      # Returns a method type which is a sub-type of both self and other.
+      #   (self & other) <: self && (self & other) <: other
+      #
+      # Returns nil if self and other are incompatible.
+      #
+      def &: (untyped other) -> (nil | untyped)
+    end
+  end
+end

data/sig/steep/interface/substitution.rbs

@@ -0,0 +1,53 @@
+module Steep
+  module Interface
+    class Substitution
+      class InvalidSubstitutionError < StandardError
+        attr_reader vars_size: untyped
+
+        attr_reader types_size: untyped
+
+        def initialize: (vars_size: untyped, types_size: untyped) -> void
+      end
+
+      attr_reader dictionary: untyped
+
+      attr_reader instance_type: untyped
+
+      attr_reader module_type: untyped
+
+      attr_reader self_type: untyped
+
+      def initialize: (dictionary: untyped, instance_type: untyped, module_type: untyped, self_type: untyped) -> void
+
+      def self.empty: () -> untyped
+
+      def empty?: () -> untyped
+
+      INSTANCE_TYPE: untyped
+
+      CLASS_TYPE: untyped
+
+      SELF_TYPE: untyped
+
+      def domain: () -> untyped
+
+      def to_s: () -> ::String
+
+      def []: (untyped key) -> untyped
+
+      def key?: (untyped var) -> untyped
+
+      def self.build: (untyped vars, ?untyped? types, ?instance_type: untyped, ?module_type: untyped, ?self_type: untyped) -> Substitution
+
+      def except: (untyped vars) -> untyped
+
+      def except!: (untyped vars) -> self
+
+      def merge!: (untyped s, ?overwrite: bool) -> self
+
+      def merge: (untyped s) -> untyped
+
+      def add!: (untyped v, untyped ty) -> untyped
+    end
+  end
+end

data/sig/steep/interface/type_param.rbs

@@ -0,0 +1,35 @@
+module Steep
+  module Interface
+    class TypeParam
+      type loc = RBS::Location[untyped, untyped]
+
+      type variance = RBS::AST::TypeParam::variance
+
+      attr_reader name: Symbol
+
+      attr_reader upper_bound: AST::Types::t?
+
+      attr_reader variance: variance
+
+      attr_reader unchecked: bool
+
+      attr_reader location: loc?
+
+      def initialize: (name: Symbol, upper_bound: AST::Types::t?, variance: variance, unchecked: bool, ?location: loc?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def self.rename: (Array[TypeParam] params, ?Array[Symbol] conflicting_names) -> [Array[TypeParam], Substitution]
+
+      def to_s: () -> String
+
+      def update: (?name: Symbol, ?upper_bound: AST::Types::t?, ?variance: variance, ?unchecked: bool, ?location: loc?) -> TypeParam
+
+      def subst: (Substitution s) -> TypeParam
+    end
+  end
+end

data/sig/steep/method_name.rbs

@@ -0,0 +1,26 @@
+module Steep
+  type method_name = InstanceMethodName | SingletonMethodName
+
+  class InstanceMethodName
+    attr_reader type_name: RBS::TypeName
+    attr_reader method_name: Symbol
+
+    def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
+  end
+
+  class SingletonMethodName
+    attr_reader type_name: RBS::TypeName
+    attr_reader method_name: Symbol
+
+    def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
+  end
+
+  class ::Object
+    # Returns method name corresponding to given `string`.
+    #
+    # * `ClassName#method_name` syntax returns an `InstanceMethodName` object
+    # * `ClassName.method_name` syntax returns a `SingletonMethodName` object
+    # 
+    def MethodName: (String string) -> (InstanceMethodName | SingletonMethodName)
+  end
+end

data/sig/steep/module_helper.rbs

@@ -0,0 +1,7 @@
+module Steep
+  module ModuleHelper
+    def module_name_from_node: (Parser::AST::Node? parent_node, Symbol constant_name) -> RBS::TypeName?
+
+    def namespace_from_node: (Parser::AST::Node? node) -> RBS::Namespace?
+  end
+end