steep 1.2.1 → 1.3.0.pre.1

data/sig/shims/parser/comment.rbs

@@ -0,0 +1,33 @@
+module Parser
+  module Source
+    class Comment
+      def self.associate: (untyped ast, untyped comments) -> untyped
+
+      def self.associate_by_identity: (untyped ast, untyped comments) -> untyped
+
+      def self.associate_locations: (untyped ast, untyped comments) -> untyped
+
+      public
+
+      def ==: (untyped other) -> bool
+
+      def document?: () -> bool
+
+      def inline?: () -> bool
+
+      def inspect: () -> String
+
+      alias loc location
+
+      def location: () -> Map
+
+      def text: () -> String
+
+      def type: () -> (:inline | :document)
+
+      private
+
+      def initialize: (untyped range) -> void
+    end
+  end
+end

data/sig/shims/parser.rbs

@@ -5,13 +5,41 @@ module Parser
 
       attr_reader children: Array[untyped]
 
-      def initialize: (Symbol `type`, Array[untyped] children) -> void
+      def initialize: (Symbol `type`, ?Array[untyped] children, ?Hash[Symbol, untyped] properties) -> void
 
-      def updated: (?Symbol?, ?Array[untyped]?) -> Node
+      def updated: (?Symbol?, ?Array[untyped]?, ?Hash[Symbol, untyped]? properties) -> Node
 
       attr_reader location: Source::Map
 
       alias loc location
     end
   end
+
+  class Ruby31
+    def initialize: (untyped builder) -> void
+
+    def parse: (Source::Buffer) -> AST
+
+    def parse_with_comments: (Source::Buffer) -> [AST::Node, Array[Source::Comment]]
+
+    attr_reader diagnostics: untyped
+  end
+
+  module Source
+    class Buffer
+      def initialize: (String file, Integer lineno, source: String) -> void
+    end
+  end
+
+  module Builders
+    class Default
+      attr_accessor self.emit_lambda: bool
+      attr_accessor self.emit_procarg0: bool
+      attr_accessor self.emit_kwargs: bool
+
+      def string_value: (untyped) -> untyped
+
+      def value: (untyped) -> untyped
+    end
+  end
 end

data/sig/steep/annotation_parser.rbs

@@ -0,0 +1,59 @@
+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
+    end
+
+    TYPE: Regexp
+
+    COLON: Regexp
+
+    PARAM: Regexp
+
+    TYPE_PARAMS: Regexp
+
+    def parse_type: (String) -> 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.rbs

@@ -7,14 +7,20 @@ module Steep
 
       type loc = RBS::Location[untyped, untyped]
 
-      class Named
-        attr_reader name: Symbol
+      module Located
+        attr_reader location: loc?
 
-        attr_reader type: Types::t
+        %a{pure} def line: () -> Integer?
+      end
 
-        attr_reader location: loc?
+      class Named[T, N]
+        attr_reader name: N
+
+        attr_reader type: T
 
-        def initialize: (name: Symbol, type: Types::t, ?location: loc?) -> void
+        include Located
+
+        def initialize: (name: N, type: T, ?location: loc?) -> void
 
         def ==: (untyped other) -> bool
       end
@@ -22,13 +28,11 @@ module Steep
       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
+
+        include Located
       end
 
       class ReturnType < Typed
@@ -49,34 +53,25 @@ module Steep
       class BreakType < Typed
       end
 
-      class MethodType < Named
+      class MethodType < Named[Interface::MethodType, Symbol]
       end
 
-      class VarType < Named
+      class VarType < Named[Types::t, Symbol]
       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
+      class ConstType < Named[Types::t, RBS::TypeName]
       end
 
-      class IvarType < Named
+      class IvarType < Named[Types::t, Symbol]
       end
 
       class Implements
         class Module
           attr_reader name: RBS::TypeName
 
-          attr_reader args: Array[Types::t]
+          attr_reader args: Array[Symbol]
 
-          def initialize: (name: RBS::TypeName, args: Array[Types::t]) -> void
+          def initialize: (name: RBS::TypeName, args: Array[Symbol]) -> void
 
           def ==: (untyped other) -> bool
 
@@ -85,7 +80,7 @@ module Steep
           def hash: () -> Integer
         end
 
-        attr_reader location: loc?
+        include Located
 
         attr_reader name: Module
 
@@ -113,7 +108,7 @@ module Steep
           def ==: (untyped other) -> bool
         end
 
-        attr_reader location: loc?
+        include Located
 
         attr_reader names: Array[Name]
 

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

@@ -0,0 +1,31 @@
+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, Types::Factory, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError)
+
+        def types?: (RBS::Resolver::context, Types::Factory, 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

@@ -0,0 +1,26 @@
+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, Types::Factory, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | nil)
+
+        def type?: (RBS::Resolver::context, Types::Factory, Array[Symbol] type_vars) -> Types::t?
+
+        @type_str: String?
+        def type_str: () -> String
+
+        def type_location: () -> RBS::Location[untyped, untyped]
+
+        def self.parse: (RBS::Location[untyped, untyped]) -> TypeAssertion?
+      end
+    end
+  end
+end

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

@@ -4,8 +4,6 @@ module Steep
       class Factory
         @env: RBS::Environment
 
-        @type_name_resolver: RBS::Resolver::TypeNameResolver
-
         attr_reader definition_builder: RBS::DefinitionBuilder
 
         attr_reader type_cache: Hash[RBS::Types::t, t]

data/sig/steep/diagnostic/helper.rbs

@@ -1,9 +1,15 @@
 module Steep
   module Diagnostic
-    module Helper
-      def error_name: () -> untyped
+    module Helper : _DiagnosticMessage
+      def error_name: () -> String
 
-      def full_message: () -> ::String
+      def full_message: () -> String
+    end
+
+    interface _DiagnosticMessage
+      %a{pure} def detail_lines: () -> String?
+
+      def header_line: () -> String
     end
   end
 end

data/sig/steep/diagnostic/lsp_formatter.rbs

@@ -1,11 +1,15 @@
 module Steep
   module Diagnostic
     class LSPFormatter
-      LSP: untyped
+      LSP: singleton(LanguageServer::Protocol)
 
-      attr_reader config: untyped
+      type config = Hash[singleton(Diagnostic::Ruby::Base) | singleton(Diagnostic::Signature::Base), severity?]
 
-      attr_reader default_severity: untyped
+      type severity = :error | :warning | :information | :hint
+
+      attr_reader config: config
+
+      attr_reader default_severity: severity
 
       ERROR: :error
 
@@ -15,15 +19,15 @@ module Steep
 
       HINT: :hint
 
-      def initialize: (?::Hash[untyped, untyped] config, ?default_severity: untyped) -> void
+      def initialize: (?config config, ?default_severity: severity) -> void
 
-      def validate_class: (untyped klass) -> (untyped | nil)
+      def validate_class: (Class klass) -> void
 
-      def validate_severity: (untyped klass, untyped severity) -> untyped
+      def validate_severity: (Class | :default klass, severity?) -> void
 
-      def format: (untyped diagnostic) -> untyped
+      def format: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> Hash[Symbol, untyped]?
 
-      def severity_for: (untyped diagnostic) -> untyped
+      def severity_for: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> String?
     end
   end
 end

data/sig/steep/diagnostic/ruby.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Diagnostic
     module Ruby
-      type location = Parser::Source::Range | Parser::Source::Range
+      type location = Parser::Source::Range | RBS::Location[untyped, untyped]
 
       class Base
         include Helper
@@ -384,11 +384,11 @@ module Steep
       class IncompatibleAnnotation < Base
         attr_reader result: Subtyping::Result::Base
 
-        attr_reader relation: Subtyping::Relation
+        attr_reader relation: Subtyping::Relation[untyped]
 
         attr_reader var_name: Symbol
 
-        def initialize: (node: Parser::AST::Node, var_name: Symbol, result: Subtyping::Result::Base, relation: Subtyping::Relation) -> void
+        def initialize: (node: Parser::AST::Node, var_name: Symbol, result: Subtyping::Result::Base, relation: Subtyping::Relation[untyped]) -> void
 
         include ResultPrinter
 
@@ -476,15 +476,69 @@ module Steep
         def header_line: () -> ::String
       end
 
-      ALL: untyped
+      class FalseAssertion < Base
+        attr_reader assertion_type: AST::Types::t
 
-      def self.all_error: () -> untyped
+        attr_reader node_type: AST::Types::t
 
-      def self.default: () -> untyped
+        def initialize: (node: Parser::AST::Node, assertion_type: AST::Types::t, node_type: AST::Types::t) -> void
 
-      def self.strict: () -> untyped
+        def header_line: () -> String
+      end
+
+      class UnexpectedTypeArgument < Base
+        attr_reader type_arg: AST::Types::t
+
+        attr_reader method_type: Interface::MethodType
+
+        def node: () -> nil
+
+        def initialize: (type_arg: AST::Types::t, method_type: Interface::MethodType) -> void
+
+        def header_line: () -> String
+      end
+
+      class InsufficientTypeArgument < Base
+        attr_reader type_args: Array[AST::Types::t]
+
+        attr_reader method_type: Interface::MethodType
+
+        def initialize: (node: Parser::AST::Node, type_args: Array[AST::Types::t], method_type: Interface::MethodType) -> void
+
+        def header_line: () -> String
+      end
+
+      class TypeArgumentMismatchError < Base
+        attr_reader type_argument: AST::Types::t
+
+        attr_reader type_parameter: Interface::TypeParam
+
+        attr_reader result: Subtyping::Result::Base
+
+        include ResultPrinter
+
+        def node: () -> nil
+
+        def initialize: (type_arg: AST::Types::t, type_param: Interface::TypeParam, result: Subtyping::Result::Base) -> void
+
+        def header_line: () -> String
+      end
+
+      ALL: Array[singleton(Base)]
+
+      type template = Hash[singleton(Base), LSPFormatter::severity]
+
+      self.@all_error: template?
+      def self.all_error: () -> template
+
+      self.@default: template?
+      def self.default: () -> template
+
+      self.@strict: template?
+      def self.strict: () -> template
 
-      def self.lenient: () -> untyped
+      self.@lenient: template?
+      def self.lenient: () -> template
     end
   end
 end