steep 1.0.2 → 1.1.0.pre.1

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

data/sig/steep/node_helper.rbs

@@ -0,0 +1,11 @@
+module Steep
+  module NodeHelper
+    def each_child_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
+                       | (Parser::AST::Node) { (Parser::AST::Node) -> void } -> void
+
+    def each_descendant_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
+                            | (Parser::AST::Node) { (Parser::AST::Node) -> void } -> void
+
+    def value_node?: (Parser::AST::Node) -> bool
+  end
+end

data/sig/steep/project/dsl.rbs

@@ -0,0 +1,94 @@
+module Steep
+  class Project
+    class DSL
+      class TargetDSL
+        attr_reader name: untyped
+
+        attr_reader sources: untyped
+
+        attr_reader libraries: untyped
+
+        attr_reader signatures: untyped
+
+        attr_reader ignored_sources: untyped
+
+        attr_reader stdlib_root: untyped
+
+        attr_reader core_root: untyped
+
+        attr_reader repo_paths: untyped
+
+        attr_reader code_diagnostics_config: untyped
+
+        attr_reader project: untyped
+
+        attr_reader collection_config_path: untyped
+
+        NONE: untyped
+
+        def initialize: (untyped name, ?sources: untyped, ?libraries: untyped, ?signatures: untyped, ?ignored_sources: untyped, ?repo_paths: untyped, ?code_diagnostics_config: ::Hash[untyped, untyped], ?project: untyped?, ?collection_config_path: untyped) -> void
+
+        def initialize_copy: (untyped other) -> untyped
+
+        def check: (*untyped args) -> untyped
+
+        def ignore: (*untyped args) -> untyped
+
+        def library: (*untyped args) -> untyped
+
+        def typing_options: (?untyped? level, **untyped hash) -> untyped
+
+        def signature: (*untyped args) -> untyped
+
+        def update: (?name: untyped, ?sources: untyped, ?libraries: untyped, ?ignored_sources: untyped, ?signatures: untyped, ?project: untyped) -> untyped
+
+        def no_builtin!: (?bool value) -> untyped
+
+        def vendor: (?::String dir, ?stdlib: untyped?, ?gems: untyped?) -> untyped
+
+        def stdlib_path: (core_root: untyped, stdlib_root: untyped) -> untyped
+
+        def repo_path: (*untyped paths) -> untyped
+
+        # Configure the code diagnostics printing setup.
+        #
+        # Yields a hash, and the update the hash in the block.
+        #
+        # ```rb
+        # D = Steep::Diagnostic
+        #
+        # configure_code_diagnostics do |hash|
+        #   # Assign one of :error, :warning, :information, :hint or :nil to error classes.
+        #   hash[D::Ruby::UnexpectedPositionalArgument] = :error
+        # end
+        # ```
+        #
+        # Passing a hash is also allowed.
+        #
+        # ```rb
+        # D = Steep::Diagnostic
+        #
+        # configure_code_diagnostics(D::Ruby.lenient)
+        # ```
+        #
+        def configure_code_diagnostics: (?untyped? hash) { (untyped) -> untyped } -> untyped
+
+        def collection_config: (untyped path) -> untyped
+
+        def disable_collection: () -> untyped
+      end
+
+      attr_reader project: untyped
+
+      def self.templates: () -> untyped
+
+      def initialize: (project: untyped) -> void
+
+      def self.register_template: (untyped name, untyped target) -> untyped
+
+      def self.parse: (untyped project, untyped code, ?filename: ::String) -> untyped
+
+      def target: (untyped name, ?template: untyped?) ?{ () -> untyped } -> untyped
+    end
+  end
+end

data/sig/steep/project/options.rbs

@@ -0,0 +1,15 @@
+module Steep
+  class Project
+    class Options
+      PathOptions: untyped
+
+      attr_reader libraries: untyped
+
+      attr_accessor paths: untyped
+
+      attr_accessor collection_lock: untyped
+
+      def initialize: () -> void
+    end
+  end
+end

data/sig/steep/project/pattern.rbs

@@ -0,0 +1,25 @@
+module Steep
+  class Project
+    class Pattern
+      attr_reader patterns: untyped
+
+      attr_reader ignores: untyped
+
+      attr_reader prefixes: untyped
+
+      attr_reader ignore_prefixes: untyped
+
+      attr_reader ext: untyped
+
+      def initialize: (patterns: untyped, ext: untyped, ?ignores: untyped) -> void
+
+      def =~: (untyped path) -> untyped
+
+      def match?: (untyped path) -> untyped
+
+      def ignore?: (untyped path) -> untyped
+
+      def test_string: (untyped path, untyped patterns, untyped prefixes) -> untyped
+    end
+  end
+end

data/sig/steep/project/target.rbs

@@ -0,0 +1,25 @@
+module Steep
+  class Project
+    class Target
+      attr_reader name: untyped
+
+      attr_reader options: untyped
+
+      attr_reader source_pattern: untyped
+
+      attr_reader signature_pattern: untyped
+
+      attr_reader code_diagnostics_config: untyped
+
+      def initialize: (name: untyped, options: untyped, source_pattern: untyped, signature_pattern: untyped, code_diagnostics_config: untyped) -> void
+
+      def possible_source_file?: (untyped path) -> untyped
+
+      def possible_signature_file?: (untyped path) -> untyped
+
+      def new_env_loader: (project: untyped) -> untyped
+
+      def self.construct_env_loader: (options: untyped, project: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/project.rbs

@@ -0,0 +1,19 @@
+module Steep
+  class Project
+    attr_reader targets: untyped
+
+    attr_reader steepfile_path: untyped
+
+    def initialize: (steepfile_path: untyped) -> void
+
+    def base_dir: () -> untyped
+
+    def relative_path: (untyped path) -> untyped
+
+    def absolute_path: (untyped path) -> untyped
+
+    def target_for_source_path: (untyped path) -> untyped
+
+    def targets_for_path: (untyped path) -> (::Array[untyped | ::Array[untyped]] | ::Array[nil | untyped])
+  end
+end