rbs 0.5.0 → 0.9.1

data/lib/rbs/test/tester.rb

@@ -0,0 +1,118 @@
+module RBS
+  module Test
+    class Tester
+      attr_reader :env
+      attr_reader :targets
+
+      def initialize(env:)
+        @env = env
+        @targets = []
+      end
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def install!(klass, sample_size:)
+        RBS.logger.info { "Installing runtime type checker in #{klass}..." }
+
+        type_name = factory.type_name(klass.name).absolute!
+
+        builder.build_instance(type_name).tap do |definition|
+          instance_key = new_key(type_name, "InstanceChecker")
+          Observer.register(instance_key, MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size))
+
+          definition.methods.each do |name, method|
+            if method.implemented_in == type_name
+              RBS.logger.info { "Setting up method hook in ##{name}..." }
+              Hook.hook_instance_method klass, name, key: instance_key
+            end
+          end
+        end
+
+        builder.build_singleton(type_name).tap do |definition|
+          singleton_key = new_key(type_name, "SingletonChecker")
+          Observer.register(singleton_key, MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size))
+
+          definition.methods.each do |name, method|
+            if method.implemented_in == type_name || name == :new
+              RBS.logger.info { "Setting up method hook in .#{name}..." }
+              Hook.hook_singleton_method klass, name, key: singleton_key
+            end
+          end
+        end
+
+        targets << klass
+      end
+
+      def new_key(type_name, prefix)
+        "#{prefix}__#{type_name}__#{SecureRandom.hex(10)}"
+      end
+
+      class TypeError < Exception
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+
+          super "TypeError: #{errors.map {|e| Errors.to_string(e) }.join(", ")}"
+        end
+      end
+
+      class MethodCallTester
+        attr_reader :self_class
+        attr_reader :definition
+        attr_reader :builder
+        attr_reader :kind
+        attr_reader :sample_size
+
+        def initialize(self_class, builder, definition, kind:, sample_size:)
+          @self_class = self_class
+          @definition = definition
+          @builder = builder
+          @kind = kind
+          @sample_size = sample_size
+        end
+
+        def env
+          builder.env
+        end
+
+        def check
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size)
+        end
+
+        def format_method_name(name)
+          case kind
+          when :instance
+            "##{name}"
+          when :singleton
+            ".#{name}"
+          end
+        end
+
+        def call(receiver, trace)
+          method_name = trace.method_name
+          method = definition.methods[method_name]
+          if method
+            RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
+            errors = check.overloaded_call(method, format_method_name(method_name), trace, errors: [])
+
+            if errors.empty?
+              RBS.logger.debug { "No type error detected 👏" }
+            else
+              RBS.logger.debug { "Detected type error 🚨" }
+              raise TypeError.new(errors)
+            end
+          else
+            RBS.logger.error { "Type checking `#{self_class}#{method_name}` call but no method found in definition" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/type_check.rb

@@ -3,10 +3,38 @@ module RBS
     class TypeCheck
       attr_reader :self_class
       attr_reader :builder
+      attr_reader :sample_size
 
-      def initialize(self_class:, builder:)
+      DEFAULT_SAMPLE_SIZE = 100
+
+      def initialize(self_class:, builder:, sample_size:)
         @self_class = self_class
         @builder = builder
+        @sample_size = sample_size
+      end
+
+      def overloaded_call(method, method_name, call, errors:)
+        es = method.method_types.map do |method_type|
+          es = method_call(method_name, method_type, call, errors: [])
+
+          if es.empty?
+            return errors
+          else
+            es
+          end
+        end
+
+        if es.size == 1
+          errors.push(*es[0])
+        else
+          errors << Errors::UnresolvedOverloadingError.new(
+            klass: self_class,
+            method_name: method_name,
+            method_types: method.method_types
+          )
+        end
+
+        errors
       end
 
       def method_call(method_name, method_type, call, errors:)
@@ -56,7 +84,7 @@ module RBS
       end
 
       def return(method_name, method_type, fun, call, errors, return_error:)
-        unless call.exception
+        if call.return?
           unless value(call.return_value, fun.return_type)
             errors << return_error.new(klass: self_class,
                                        method_name: method_name,
@@ -151,6 +179,10 @@ module RBS
         end
       end
 
+      def sample(array)
+        sample_size && (array.size > sample_size) ? array.sample(sample_size) : array
+      end
+
       def value(val, type)
         case type
         when Types::Bases::Any
@@ -175,9 +207,14 @@ module RBS
           klass = Object.const_get(type.name.to_s)
           case
           when klass == ::Array
-            Test.call(val, IS_AP, klass) && val.all? {|v| value(v, type.args[0]) }
+            Test.call(val, IS_AP, klass) && sample(val).yield_self do |val|
+              val.all? {|v| value(v, type.args[0]) }
+            end
           when klass == ::Hash
-            Test.call(val, IS_AP, klass) && val.all? {|k, v| value(k, type.args[0]) && value(v, type.args[1]) }
+            Test.call(val, IS_AP, klass) && sample(val.keys).yield_self do |keys|
+              values = val.values_at(*keys)
+              keys.all? {|key| value(key, type.args[0]) } && values.all? {|v| value(v, type.args[1]) }
+            end 
           when klass == ::Range
             Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
           when klass == ::Enumerator
@@ -198,7 +235,7 @@ module RBS
                 end
               end
 
-              values.all? do |v|
+              sample(values).all? do |v|
                 if v.size == 1
                   # Only one block argument.
                   value(v[0], type.args[0]) || value(v, type.args[0])

data/lib/rbs/validator.rb

@@ -41,6 +41,10 @@ module RBS
           params: type_params.each.map(&:name),
           location: type.location
         )
+
+      when Types::Alias, Types::ClassSingleton
+        type = absolute_type(type, context: context) { type.name.absolute! }
+        NoTypeFoundError.check!(type.name, env: env, location: type.location)
       end
 
       type.each_type do |type|

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.5.0"
+  VERSION = "0.9.1"
 end

data/lib/rbs/writer.rb

@@ -85,8 +85,8 @@ module RBS
         puts "end"
 
       when AST::Declarations::Module
-        self_type = if decl.self_type
-                      " : #{decl.self_type}"
+        self_type = unless decl.self_types.empty?
+                      " : #{decl.self_types.join(", ")}"
                     end
 
         write_comment decl.comment

data/schema/decls.json

@@ -226,15 +226,11 @@
             "$ref": "#/definitions/classMember"
           }
         },
-        "self_type": {
-          "oneOf": [
-            {
-              "$ref": "types.json"
-            },
-            {
-              "type": "null"
-            }
-          ]
+        "self_types": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/moduleSelf"
+          }
         },
         "annotations": {
           "type": "array",
@@ -249,7 +245,22 @@
           "$ref": "location.json"
         }
       },
-      "required": ["declaration", "name", "type_params", "members", "self_type", "annotations", "location", "comment"]
+      "required": ["declaration", "name", "type_params", "members", "self_types", "annotations", "location", "comment"]
+    },
+    "moduleSelf": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "types.json"
+          }
+        }
+      },
+      "required": ["name", "args"]
     },
     "interfaceMember": {
       "oneOf": [

data/stdlib/builtin/enumerable.rbs

@@ -46,7 +46,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
             | () { (Elem arg0) -> untyped } -> bool
 
   def collect: [U] () { (Elem arg0) -> U } -> ::Array[U]
-             | () -> ::Enumerator[Elem, Return]
+             | () -> ::Enumerator[Elem, ::Array[untyped]]
 
   def collect_concat: [U] () { (Elem arg0) -> ::Enumerator[U, untyped] } -> ::Array[U]
 
@@ -317,7 +317,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
               | () -> ::Enumerator[Elem, Return]
 
   def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
-         | () -> ::Enumerator[Elem, Return]
+         | () -> ::Enumerator[Elem, ::Array[untyped]]
 
   def member?: (untyped arg0) -> bool
 

data/stdlib/builtin/proc.rbs

@@ -269,8 +269,7 @@ class Proc < Object
   # See also Object\#hash.
   def hash: () -> Integer
 
-  def initialize: () -> void
-                | () { (*untyped) -> untyped } -> void
+  def initialize: () { (*untyped) -> untyped } -> void
 
   # Returns `true` for a [Proc](Proc.downloaded.ruby_doc) object for which
   # argument handling is rigid. Such procs are typically generated by

data/stdlib/json/json.rbs

@@ -42,6 +42,9 @@ end
 class JSON::Ext::Generator::State
 end
 
+class JSON::Ext::Parser
+end
+
 module JSON::Pure
 end
 
@@ -51,6 +54,9 @@ end
 class JSON::Pure::Generator::State
 end
 
+class JSON::Pure::Parser
+end
+
 type json_generator = singleton(::JSON::Ext::Generator) | singleton(::JSON::Pure::Generator)
 type json_parser = singleton(::JSON::Ext::Parser) | singleton(::JSON::Pure::Parser)
 type json_state = singleton(JSON::Ext::Generator::State) | singleton(JSON::Pure::Generator::State)

data/stdlib/logger/formatter.rbs

@@ -0,0 +1,23 @@
+class Logger
+  class Formatter
+    public
+
+    attr_accessor datetime_format: String?
+
+    def call: (String severity, Time time, untyped progname, untyped msg) -> String
+
+    private
+
+    def format_datetime: (Time time) -> untyped
+
+    def initialize: () -> void
+
+    def msg2str: (String | Exception | untyped msg) -> String
+  end
+
+  interface _Formatter
+    def call: (String severity, Time time, untyped progname, untyped msg) -> _ToS
+  end
+end
+
+Logger::Formatter::Format: String

data/stdlib/logger/log_device.rbs

@@ -0,0 +1,39 @@
+class Logger
+  class LogDevice
+    # TODO: Write type signature for MonitorMixin
+    # include MonitorMixin
+
+    include Period
+
+    attr_reader dev: _WriteCloser
+    attr_reader filename: String?
+
+    public
+
+    def close: () -> nil
+
+    def reopen: (?logdev log) -> self
+
+    def write: (untyped message) -> untyped
+
+    private
+
+    def add_log_header: (IO file) -> untyped
+
+    def check_shift_log: () -> untyped
+
+    def create_logfile: (String filename) -> File
+
+    def initialize: (?untyped logdev, ?binmode: bool, ?shift_period_suffix: String, ?shift_size: Integer, ?shift_age: Numeric | String) -> void
+
+    def lock_shift_log: () { () -> untyped } -> untyped
+
+    def open_logfile: (String filename) -> File
+
+    def set_dev: (logdev log) -> untyped
+
+    def shift_log_age: () -> true
+
+    def shift_log_period: (Time period_end) -> true
+  end
+end

data/stdlib/logger/logger.rbs

@@ -0,0 +1,507 @@
+# ## Description
+#
+# The Logger class provides a simple but sophisticated logging utility that you
+# can use to output messages.
+#
+# The messages have associated levels, such as `INFO` or `ERROR` that indicate
+# their importance.  You can then give the Logger a level, and only messages at
+# that level or higher will be printed.
+#
+# The levels are:
+#
+# `UNKNOWN`
+# :   An unknown message that should always be logged.
+# `FATAL`
+# :   An unhandleable error that results in a program crash.
+# `ERROR`
+# :   A handleable error condition.
+# `WARN`
+# :   A warning.
+# `INFO`
+# :   Generic (useful) information about system operation.
+# `DEBUG`
+# :   Low-level information for developers.
+#
+#
+# For instance, in a production system, you may have your Logger set to `INFO`
+# or even `WARN`. When you are developing the system, however, you probably want
+# to know about the program's internal state, and would set the Logger to
+# `DEBUG`.
+#
+# **Note**: Logger does not escape or sanitize any messages passed to it.
+# Developers should be aware of when potentially malicious data (user-input) is
+# passed to Logger, and manually escape the untrusted data:
+#
+#     logger.info("User-input: #{input.dump}")
+#     logger.info("User-input: %p" % input)
+#
+# You can use #formatter= for escaping all data.
+#
+#     original_formatter = Logger::Formatter.new
+#     logger.formatter = proc { |severity, datetime, progname, msg|
+#       original_formatter.call(severity, datetime, progname, msg.dump)
+#     }
+#     logger.info(input)
+#
+# ### Example
+#
+# This creates a Logger that outputs to the standard output stream, with a level
+# of `WARN`:
+#
+#     require 'logger'
+#
+#     logger = Logger.new(STDOUT)
+#     logger.level = Logger::WARN
+#
+#     logger.debug("Created logger")
+#     logger.info("Program started")
+#     logger.warn("Nothing to do!")
+#
+#     path = "a_non_existent_file"
+#
+#     begin
+#       File.foreach(path) do |line|
+#         unless line =~ /^(\w+) = (.*)$/
+#           logger.error("Line in wrong format: #{line.chomp}")
+#         end
+#       end
+#     rescue => err
+#       logger.fatal("Caught exception; exiting")
+#       logger.fatal(err)
+#     end
+#
+# Because the Logger's level is set to `WARN`, only the warning, error, and
+# fatal messages are recorded.  The debug and info messages are silently
+# discarded.
+#
+# ### Features
+#
+# There are several interesting features that Logger provides, like auto-rolling
+# of log files, setting the format of log messages, and specifying a program
+# name in conjunction with the message.  The next section shows you how to
+# achieve these things.
+#
+# ## HOWTOs
+#
+# ### How to create a logger
+#
+# The options below give you various choices, in more or less increasing
+# complexity.
+#
+# 1.  Create a logger which logs messages to STDERR/STDOUT.
+#
+#         logger = Logger.new(STDERR)
+#         logger = Logger.new(STDOUT)
+#
+# 2.  Create a logger for the file which has the specified name.
+#
+#         logger = Logger.new('logfile.log')
+#
+# 3.  Create a logger for the specified file.
+#
+#         file = File.open('foo.log', File::WRONLY | File::APPEND)
+#         # To create new logfile, add File::CREAT like:
+#         # file = File.open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
+#         logger = Logger.new(file)
+#
+# 4.  Create a logger which ages the logfile once it reaches a certain size.
+#     Leave 10 "old" log files where each file is about 1,024,000 bytes.
+#
+#         logger = Logger.new('foo.log', 10, 1024000)
+#
+# 5.  Create a logger which ages the logfile daily/weekly/monthly.
+#
+#         logger = Logger.new('foo.log', 'daily')
+#         logger = Logger.new('foo.log', 'weekly')
+#         logger = Logger.new('foo.log', 'monthly')
+#
+#
+# ### How to log a message
+#
+# Notice the different methods (`fatal`, `error`, `info`) being used to log
+# messages of various levels?  Other methods in this family are `warn` and
+# `debug`.  `add` is used below to log a message of an arbitrary (perhaps
+# dynamic) level.
+#
+# 1.  Message in a block.
+#
+#         logger.fatal { "Argument 'foo' not given." }
+#
+# 2.  Message as a string.
+#
+#         logger.error "Argument #{@foo} mismatch."
+#
+# 3.  With progname.
+#
+#         logger.info('initialize') { "Initializing..." }
+#
+# 4.  With severity.
+#
+#         logger.add(Logger::FATAL) { 'Fatal error!' }
+#
+#
+# The block form allows you to create potentially complex log messages, but to
+# delay their evaluation until and unless the message is logged.  For example,
+# if we have the following:
+#
+#     logger.debug { "This is a " + potentially + " expensive operation" }
+#
+# If the logger's level is `INFO` or higher, no debug messages will be logged,
+# and the entire block will not even be evaluated.  Compare to this:
+#
+#     logger.debug("This is a " + potentially + " expensive operation")
+#
+# Here, the string concatenation is done every time, even if the log level is
+# not set to show the debug message.
+#
+# ### How to close a logger
+#
+#     logger.close
+#
+# ### Setting severity threshold
+#
+# 1.  Original interface.
+#
+#         logger.sev_threshold = Logger::WARN
+#
+# 2.  Log4r (somewhat) compatible interface.
+#
+#         logger.level = Logger::INFO
+#
+#         # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+#
+# 3.  Symbol or String (case insensitive)
+#
+#         logger.level = :info
+#         logger.level = 'INFO'
+#
+#         # :debug < :info < :warn < :error < :fatal < :unknown
+#
+# 4.  Constructor
+#
+#         Logger.new(logdev, level: Logger::INFO)
+#         Logger.new(logdev, level: :info)
+#         Logger.new(logdev, level: 'INFO')
+#
+#
+# ## Format
+#
+# Log messages are rendered in the output stream in a certain format by default.
+#  The default format and a sample are shown below:
+#
+# Log format:
+#     SeverityID, [DateTime #pid] SeverityLabel -- ProgName: message
+#
+# Log sample:
+#     I, [1999-03-03T02:34:24.895701 #19074]  INFO -- Main: info.
+#
+# You may change the date and time format via #datetime_format=.
+#
+#     logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+#           # e.g. "2004-01-03 00:54:26"
+#
+# or via the constructor.
+#
+#     Logger.new(logdev, datetime_format: '%Y-%m-%d %H:%M:%S')
+#
+# Or, you may change the overall format via the #formatter= method.
+#
+#     logger.formatter = proc do |severity, datetime, progname, msg|
+#       "#{datetime}: #{msg}\n"
+#     end
+#     # e.g. "2005-09-22 08:51:08 +0900: hello world"
+#
+# or via the constructor.
+#
+#     Logger.new(logdev, formatter: proc {|severity, datetime, progname, msg|
+#       "#{datetime}: #{msg}\n"
+#     })
+#
+class Logger
+  interface _WriteCloser
+    def write: (_ToS) -> untyped
+
+    def close: () -> untyped
+  end
+  type logdev = _WriteCloser | String
+
+  include Logger::Severity
+
+  public
+
+  # Dump given message to the log device without any formatting.  If no log device
+  # exists, return `nil`.
+  #
+  def <<: (untyped msg) -> (untyped | nil)
+
+  # ### Args
+  #
+  # `severity`
+  # :   Severity.  Constants are defined in Logger namespace: `DEBUG`, `INFO`,
+  #     `WARN`, `ERROR`, `FATAL`, or `UNKNOWN`.
+  # `message`
+  # :   The log message.  A String or Exception.
+  # `progname`
+  # :   Program name string.  Can be omitted.  Treated as a message if no
+  #     `message` and `block` are given.
+  # `block`
+  # :   Can be omitted.  Called to get a message string if `message` is nil.
+  #
+  #
+  # ### Return
+  #
+  # When the given severity is not high enough (for this particular logger), log
+  # no message, and return `true`.
+  #
+  # ### Description
+  #
+  # Log a message if the given severity is high enough.  This is the generic
+  # logging method.  Users will be more inclined to use #debug, #info, #warn,
+  # #error, and #fatal.
+  #
+  # **Message format**: `message` can be any object, but it has to be converted to
+  # a String in order to log it.  Generally, `inspect` is used if the given object
+  # is not a String. A special case is an `Exception` object, which will be
+  # printed in detail, including message, class, and backtrace.  See #msg2str for
+  # the implementation if required.
+  #
+  # ### Bugs
+  #
+  # *   Logfile is not locked.
+  # *   Append open does not need to lock file.
+  # *   If the OS supports multi I/O, records possibly may be mixed.
+  #
+  def add: (Integer severity, ?untyped message, ?untyped progname) ?{ () -> untyped } -> true
+
+  # Close the logging device.
+  #
+  def close: () -> untyped
+
+  # Returns the date format being used.  See #datetime_format=
+  #
+  def datetime_format: () -> String?
+
+  # Set date-time format.
+  #
+  # `datetime_format`
+  # :   A string suitable for passing to `strftime`.
+  #
+  def datetime_format=: (String datetime_format) -> String
+                      | (nil datetime_format) -> nil
+
+  # Log a `DEBUG` message.
+  #
+  # See #info for more information.
+  #
+  def debug: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Sets the severity to DEBUG.
+  #
+  def debug!: () -> Integer
+
+  # Returns `true` iff the current severity level allows for the printing of
+  # `DEBUG` messages.
+  #
+  def debug?: () -> bool
+
+  # Log an `ERROR` message.
+  #
+  # See #info for more information.
+  #
+  def error: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Sets the severity to ERROR.
+  #
+  def error!: () -> Integer
+
+  # Returns `true` iff the current severity level allows for the printing of
+  # `ERROR` messages.
+  #
+  def error?: () -> bool
+
+  # Log a `FATAL` message.
+  #
+  # See #info for more information.
+  #
+  def fatal: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Sets the severity to FATAL.
+  #
+  def fatal!: () -> Integer
+
+  # Returns `true` iff the current severity level allows for the printing of
+  # `FATAL` messages.
+  #
+  def fatal?: () -> bool
+
+  # Logging formatter, as a `Proc` that will take four arguments and return the
+  # formatted message. The arguments are:
+  #
+  # `severity`
+  # :   The Severity of the log message.
+  # `time`
+  # :   A Time instance representing when the message was logged.
+  # `progname`
+  # :   The #progname configured, or passed to the logger method.
+  # `msg`
+  # :   The *Object* the user passed to the log message; not necessarily a String.
+  #
+  #
+  # The block should return an Object that can be written to the logging device
+  # via `write`.  The default formatter is used when no formatter is set.
+  #
+  def formatter: () -> (_Formatter | nil)
+
+  def formatter=: (_Formatter) -> _Formatter
+                | (nil) -> nil
+
+  # Log an `INFO` message.
+  #
+  # `message`
+  # :   The message to log; does not need to be a String.
+  # `progname`
+  # :   In the block form, this is the #progname to use in the log message.  The
+  #     default can be set with #progname=.
+  # `block`
+  # :   Evaluates to the message to log.  This is not evaluated unless the
+  #     logger's level is sufficient to log the message.  This allows you to
+  #     create potentially expensive logging messages that are only called when
+  #     the logger is configured to show them.
+  #
+  #
+  # ### Examples
+  #
+  #     logger.info("MainApp") { "Received connection from #{ip}" }
+  #     # ...
+  #     logger.info "Waiting for input from user"
+  #     # ...
+  #     logger.info { "User typed #{input}" }
+  #
+  # You'll probably stick to the second form above, unless you want to provide a
+  # program name (which you can do with #progname= as well).
+  #
+  # ### Return
+  #
+  # See #add.
+  #
+  def info: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Sets the severity to INFO.
+  #
+  def info!: () -> Integer
+
+  # Returns `true` iff the current severity level allows for the printing of
+  # `INFO` messages.
+  #
+  def info?: () -> bool
+
+  # Logging severity threshold (e.g. `Logger::INFO`).
+  #
+  def level: () -> Integer
+
+  # Set logging severity threshold.
+  #
+  # `severity`
+  # :   The Severity of the log message.
+  #
+  #
+  def level=: (Integer | String severity) -> Integer
+
+  alias log add
+
+  # Program name to include in log messages.
+  #
+  def progname: () -> untyped
+
+  def progname=: (untyped) -> untyped
+
+  # ### Args
+  #
+  # `logdev`
+  # :   The log device.  This is a filename (String) or IO object (typically
+  #     `STDOUT`, `STDERR`, or an open file).  reopen the same filename if it is
+  #     `nil`, do nothing for IO.  Default is `nil`.
+  #
+  #
+  # ### Description
+  #
+  # Reopen a log device.
+  #
+  def reopen: () -> self
+            | (logdev?) -> self
+
+  # Logging severity threshold (e.g. `Logger::INFO`).
+  #
+  alias sev_threshold level
+
+  alias sev_threshold= level=
+
+  # Log an `UNKNOWN` message.  This will be printed no matter what the logger's
+  # level is.
+  #
+  # See #info for more information.
+  #
+  def unknown: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Log a `WARN` message.
+  #
+  # See #info for more information.
+  #
+  def warn: (?untyped progname) ?{ () -> untyped } -> true
+
+  # Sets the severity to WARN.
+  #
+  def warn!: () -> Integer
+
+  # Returns `true` iff the current severity level allows for the printing of
+  # `WARN` messages.
+  #
+  def warn?: () -> bool
+
+  private
+
+  def format_message: (String severity, Time datetime, untyped progname, untyped msg) -> _ToS
+
+  def format_severity: (Integer severity) -> String
+
+  # ### Args
+  #
+  # `logdev`
+  # :   The log device.  This is a filename (String) or IO object (typically
+  #     `STDOUT`, `STDERR`, or an open file).
+  # `shift_age`
+  # :   Number of old log files to keep, **or** frequency of rotation (`daily`,
+  #     `weekly` or `monthly`). Default value is 0, which disables log file
+  #     rotation.
+  # `shift_size`
+  # :   Maximum logfile size in bytes (only applies when `shift_age` is a positive
+  #     Integer). Defaults to `1048576` (1MB).
+  # `level`
+  # :   Logging severity threshold. Default values is Logger::DEBUG.
+  # `progname`
+  # :   Program name to include in log messages. Default value is nil.
+  # `formatter`
+  # :   Logging formatter. Default values is an instance of Logger::Formatter.
+  # `datetime_format`
+  # :   Date and time format. Default value is '%Y-%m-%d %H:%M:%S'.
+  # `binmode`
+  # :   Use binary mode on the log device. Default value is false.
+  # `shift_period_suffix`
+  # :   The log file suffix format for `daily`, `weekly` or `monthly` rotation.
+  #     Default is '%Y%m%d'.
+  #
+  #
+  # ### Description
+  #
+  # Create an instance.
+  #
+  def initialize: (logdev logdev, ?Numeric | String shift_age, ?Integer shift_size, ?shift_period_suffix: String, ?binmode: bool, ?datetime_format: String, ?formatter: _Formatter, ?progname: String, ?level: Integer) -> void
+end
+
+Logger::ProgName: String
+
+# Severity label for logging (max 5 chars).
+#
+Logger::SEV_LABEL: Array[String]
+
+Logger::VERSION: String