From 8fae8ae1a43925e5c329966d7509486815409fd9 Mon Sep 17 00:00:00 2001 From: kai Date: Sat, 14 Sep 2024 15:33:13 -0400 Subject: [PATCH] Run GoodJob migrations --- db/schema.rb | 19 +- .../rbi/dsl/action_mailbox/inbound_email.rbi | 9 + .../dsl/action_mailbox/incineration_job.rbi | 9 +- sorbet/rbi/dsl/action_mailbox/routing_job.rbi | 9 +- .../dsl/action_mailer/mail_delivery_job.rbi | 5 +- .../dsl/action_text/encrypted_rich_text.rbi | 9 + sorbet/rbi/dsl/action_text/rich_text.rbi | 9 + .../destroy_association_async_job.rbi | 5 +- sorbet/rbi/dsl/active_storage/analyze_job.rbi | 9 +- sorbet/rbi/dsl/active_storage/attachment.rbi | 9 + sorbet/rbi/dsl/active_storage/blob.rbi | 84 + .../dsl/active_storage/cleanup_blobs_job.rbi | 8 +- sorbet/rbi/dsl/active_storage/current.rbi | 14 +- sorbet/rbi/dsl/active_storage/mirror_job.rbi | 10 +- sorbet/rbi/dsl/active_storage/purge_job.rbi | 9 +- .../rbi/dsl/active_storage/variant_record.rbi | 9 + sorbet/rbi/dsl/activity.rbi | 9 + sorbet/rbi/dsl/activity/habtm_groups.rbi | 9 + sorbet/rbi/dsl/address.rbi | 9 + sorbet/rbi/dsl/clear_activity_status_job.rbi | 8 +- .../rbi/dsl/destroy_demo_activities_job.rbi | 8 +- .../good_job/active_job_extensions/labels.rbi | 18 + .../dsl/good_job/application_controller.rbi | 1 + sorbet/rbi/dsl/good_job/base_execution.rbi | 2014 -- sorbet/rbi/dsl/good_job/batch_record.rbi | 15 + .../rbi/dsl/good_job/discrete_execution.rbi | 180 + sorbet/rbi/dsl/good_job/execution.rbi | 204 +- .../rbi/dsl/good_job/frontends_controller.rbi | 1 + sorbet/rbi/dsl/good_job/job.rbi | 262 + sorbet/rbi/dsl/good_job/process.rbi | 83 + sorbet/rbi/dsl/good_job/setting.rbi | 9 + sorbet/rbi/dsl/google_calendar_channel.rbi | 9 + sorbet/rbi/dsl/group.rbi | 9 + sorbet/rbi/dsl/group/habtm_activities.rbi | 9 + sorbet/rbi/dsl/group_membership.rbi | 9 + .../dsl/import_activities_for_user_job.rbi | 9 +- sorbet/rbi/dsl/import_activities_job.rbi | 9 +- sorbet/rbi/dsl/mobile_subscriber.rbi | 9 + sorbet/rbi/dsl/mobile_subscription.rbi | 9 + ...r_google_calendar_channel_for_user_job.rbi | 9 +- sorbet/rbi/dsl/reservation.rbi | 9 + ...dule_activity_mobile_notifications_job.rbi | 9 +- .../rbi/dsl/scheduled_mobile_notification.rbi | 9 + .../dsl/send_mobile_subscriber_text_job.rbi | 5 +- ...cheduled_mobile_notification_texts_job.rbi | 8 +- sorbet/rbi/dsl/sentry/send_event_job.rbi | 10 +- sorbet/rbi/dsl/subscription.rbi | 9 + .../dsl/sync_google_calendar_channels_job.rbi | 8 +- sorbet/rbi/dsl/user.rbi | 9 + ...ood_job@3.19.1.rbi => good_job@3.99.1.rbi} | 1572 +- sorbet/rbi/gems/irb@1.8.1.rbi | 2797 --- sorbet/rbi/gems/yarp@0.11.0.rbi | 15141 ---------------- 52 files changed, 2187 insertions(+), 20536 deletions(-) create mode 100644 sorbet/rbi/dsl/good_job/active_job_extensions/labels.rbi delete mode 100644 sorbet/rbi/dsl/good_job/base_execution.rbi rename sorbet/rbi/gems/{good_job@3.19.1.rbi => good_job@3.99.1.rbi} (80%) delete mode 100644 sorbet/rbi/gems/irb@1.8.1.rbi delete mode 100644 sorbet/rbi/gems/yarp@0.11.0.rbi diff --git a/db/schema.rb b/db/schema.rb index b0d6b58..95c91ad 100644 --- a/db/schema.rb +++ b/db/schema.rb @@ -10,7 +10,7 @@ # # It's strongly recommended that you check this file into your version control system. -ActiveRecord::Schema[7.0].define(version: 2023_09_24_181329) do +ActiveRecord::Schema[7.0].define(version: 2024_08_11_043457) do # These are extensions that must be enabled in order to support this database enable_extension "pgcrypto" enable_extension "plpgsql" @@ -114,13 +114,18 @@ t.datetime "finished_at" t.text "error" t.integer "error_event", limit: 2 + t.text "error_backtrace", array: true + t.uuid "process_id" + t.interval "duration" t.index ["active_job_id", "created_at"], name: "index_good_job_executions_on_active_job_id_and_created_at" + t.index ["process_id", "created_at"], name: "index_good_job_executions_on_process_id_and_created_at" end create_table "good_job_processes", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t| t.datetime "created_at", null: false t.datetime "updated_at", null: false t.jsonb "state" + t.integer "lock_type", limit: 2 end create_table "good_job_settings", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t| @@ -152,15 +157,21 @@ t.integer "executions_count" t.text "job_class" t.integer "error_event", limit: 2 + t.text "labels", array: true + t.uuid "locked_by_id" + t.datetime "locked_at" t.index ["active_job_id", "created_at"], name: "index_good_jobs_on_active_job_id_and_created_at" - t.index ["active_job_id"], name: "index_good_jobs_on_active_job_id" t.index ["batch_callback_id"], name: "index_good_jobs_on_batch_callback_id", where: "(batch_callback_id IS NOT NULL)" t.index ["batch_id"], name: "index_good_jobs_on_batch_id", where: "(batch_id IS NOT NULL)" t.index ["concurrency_key"], name: "index_good_jobs_on_concurrency_key_when_unfinished", where: "(finished_at IS NULL)" - t.index ["cron_key", "created_at"], name: "index_good_jobs_on_cron_key_and_created_at" - t.index ["cron_key", "cron_at"], name: "index_good_jobs_on_cron_key_and_cron_at", unique: true + t.index ["cron_key", "created_at"], name: "index_good_jobs_on_cron_key_and_created_at_cond", where: "(cron_key IS NOT NULL)" + t.index ["cron_key", "cron_at"], name: "index_good_jobs_on_cron_key_and_cron_at_cond", unique: true, where: "(cron_key IS NOT NULL)" t.index ["finished_at"], name: "index_good_jobs_jobs_on_finished_at", where: "((retried_good_job_id IS NULL) AND (finished_at IS NOT NULL))" + t.index ["labels"], name: "index_good_jobs_on_labels", where: "(labels IS NOT NULL)", using: :gin + t.index ["locked_by_id"], name: "index_good_jobs_on_locked_by_id", where: "(locked_by_id IS NOT NULL)" + t.index ["priority", "created_at"], name: "index_good_job_jobs_for_candidate_lookup", where: "(finished_at IS NULL)" t.index ["priority", "created_at"], name: "index_good_jobs_jobs_on_priority_created_at_when_unfinished", order: { priority: "DESC NULLS LAST" }, where: "(finished_at IS NULL)" + t.index ["priority", "scheduled_at"], name: "index_good_jobs_on_priority_scheduled_at_unfinished_unlocked", where: "((finished_at IS NULL) AND (locked_by_id IS NULL))" t.index ["queue_name", "scheduled_at"], name: "index_good_jobs_on_queue_name_and_scheduled_at", where: "(finished_at IS NULL)" t.index ["scheduled_at"], name: "index_good_jobs_on_scheduled_at", where: "(finished_at IS NULL)" end diff --git a/sorbet/rbi/dsl/action_mailbox/inbound_email.rbi b/sorbet/rbi/dsl/action_mailbox/inbound_email.rbi index a060427..8288652 100644 --- a/sorbet/rbi/dsl/action_mailbox/inbound_email.rbi +++ b/sorbet/rbi/dsl/action_mailbox/inbound_email.rbi @@ -743,6 +743,9 @@ class ActionMailbox::InboundEmail sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } + def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_ary; end end @@ -837,6 +840,9 @@ class ActionMailbox::InboundEmail sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } + def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_ary; end end @@ -850,6 +856,9 @@ class ActionMailbox::InboundEmail sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } + def to_a; end + sig { returns(T::Array[::ActionMailbox::InboundEmail]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/action_mailbox/incineration_job.rbi b/sorbet/rbi/dsl/action_mailbox/incineration_job.rbi index d26676d..c830e08 100644 --- a/sorbet/rbi/dsl/action_mailbox/incineration_job.rbi +++ b/sorbet/rbi/dsl/action_mailbox/incineration_job.rbi @@ -6,8 +6,13 @@ class ActionMailbox::IncinerationJob class << self - sig { params(inbound_email: T.untyped).returns(T.any(ActionMailbox::IncinerationJob, FalseClass)) } - def perform_later(inbound_email); end + sig do + params( + inbound_email: T.untyped, + block: T.nilable(T.proc.params(job: ActionMailbox::IncinerationJob).void) + ).returns(T.any(ActionMailbox::IncinerationJob, FalseClass)) + end + def perform_later(inbound_email, &block); end sig { params(inbound_email: T.untyped).returns(T.untyped) } def perform_now(inbound_email); end diff --git a/sorbet/rbi/dsl/action_mailbox/routing_job.rbi b/sorbet/rbi/dsl/action_mailbox/routing_job.rbi index 7b3e4f3..56c14ef 100644 --- a/sorbet/rbi/dsl/action_mailbox/routing_job.rbi +++ b/sorbet/rbi/dsl/action_mailbox/routing_job.rbi @@ -6,8 +6,13 @@ class ActionMailbox::RoutingJob class << self - sig { params(inbound_email: T.untyped).returns(T.any(ActionMailbox::RoutingJob, FalseClass)) } - def perform_later(inbound_email); end + sig do + params( + inbound_email: T.untyped, + block: T.nilable(T.proc.params(job: ActionMailbox::RoutingJob).void) + ).returns(T.any(ActionMailbox::RoutingJob, FalseClass)) + end + def perform_later(inbound_email, &block); end sig { params(inbound_email: T.untyped).returns(T.untyped) } def perform_now(inbound_email); end diff --git a/sorbet/rbi/dsl/action_mailer/mail_delivery_job.rbi b/sorbet/rbi/dsl/action_mailer/mail_delivery_job.rbi index 48b9d85..a98ca5a 100644 --- a/sorbet/rbi/dsl/action_mailer/mail_delivery_job.rbi +++ b/sorbet/rbi/dsl/action_mailer/mail_delivery_job.rbi @@ -13,10 +13,11 @@ class ActionMailer::MailDeliveryJob delivery_method: T.untyped, args: T.untyped, kwargs: T.untyped, - params: T.untyped + params: T.untyped, + block: T.nilable(T.proc.params(job: ActionMailer::MailDeliveryJob).void) ).returns(T.any(ActionMailer::MailDeliveryJob, FalseClass)) end - def perform_later(mailer, mail_method, delivery_method, args:, kwargs: T.unsafe(nil), params: T.unsafe(nil)); end + def perform_later(mailer, mail_method, delivery_method, args:, kwargs: T.unsafe(nil), params: T.unsafe(nil), &block); end sig do params( diff --git a/sorbet/rbi/dsl/action_text/encrypted_rich_text.rbi b/sorbet/rbi/dsl/action_text/encrypted_rich_text.rbi index a11ee77..ba538b5 100644 --- a/sorbet/rbi/dsl/action_text/encrypted_rich_text.rbi +++ b/sorbet/rbi/dsl/action_text/encrypted_rich_text.rbi @@ -646,6 +646,9 @@ class ActionText::EncryptedRichText sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_ary; end end @@ -740,6 +743,9 @@ class ActionText::EncryptedRichText sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_ary; end end @@ -753,6 +759,9 @@ class ActionText::EncryptedRichText sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::EncryptedRichText]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/action_text/rich_text.rbi b/sorbet/rbi/dsl/action_text/rich_text.rbi index 359d956..c404cf8 100644 --- a/sorbet/rbi/dsl/action_text/rich_text.rbi +++ b/sorbet/rbi/dsl/action_text/rich_text.rbi @@ -646,6 +646,9 @@ class ActionText::RichText sig { returns(T::Array[::ActionText::RichText]) } def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } def to_ary; end end @@ -740,6 +743,9 @@ class ActionText::RichText sig { returns(T::Array[::ActionText::RichText]) } def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } def to_ary; end end @@ -753,6 +759,9 @@ class ActionText::RichText sig { returns(T::Array[::ActionText::RichText]) } def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } + def to_a; end + sig { returns(T::Array[::ActionText::RichText]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/active_record/destroy_association_async_job.rbi b/sorbet/rbi/dsl/active_record/destroy_association_async_job.rbi index b47c875..2886b54 100644 --- a/sorbet/rbi/dsl/active_record/destroy_association_async_job.rbi +++ b/sorbet/rbi/dsl/active_record/destroy_association_async_job.rbi @@ -13,10 +13,11 @@ class ActiveRecord::DestroyAssociationAsyncJob association_class: T.untyped, association_ids: T.untyped, association_primary_key_column: T.untyped, - ensuring_owner_was_method: T.untyped + ensuring_owner_was_method: T.untyped, + block: T.nilable(T.proc.params(job: ActiveRecord::DestroyAssociationAsyncJob).void) ).returns(T.any(ActiveRecord::DestroyAssociationAsyncJob, FalseClass)) end - def perform_later(owner_model_name: T.unsafe(nil), owner_id: T.unsafe(nil), association_class: T.unsafe(nil), association_ids: T.unsafe(nil), association_primary_key_column: T.unsafe(nil), ensuring_owner_was_method: T.unsafe(nil)); end + def perform_later(owner_model_name: T.unsafe(nil), owner_id: T.unsafe(nil), association_class: T.unsafe(nil), association_ids: T.unsafe(nil), association_primary_key_column: T.unsafe(nil), ensuring_owner_was_method: T.unsafe(nil), &block); end sig do params( diff --git a/sorbet/rbi/dsl/active_storage/analyze_job.rbi b/sorbet/rbi/dsl/active_storage/analyze_job.rbi index 9b4b085..87eb5d7 100644 --- a/sorbet/rbi/dsl/active_storage/analyze_job.rbi +++ b/sorbet/rbi/dsl/active_storage/analyze_job.rbi @@ -6,8 +6,13 @@ class ActiveStorage::AnalyzeJob class << self - sig { params(blob: T.untyped).returns(T.any(ActiveStorage::AnalyzeJob, FalseClass)) } - def perform_later(blob); end + sig do + params( + blob: T.untyped, + block: T.nilable(T.proc.params(job: ActiveStorage::AnalyzeJob).void) + ).returns(T.any(ActiveStorage::AnalyzeJob, FalseClass)) + end + def perform_later(blob, &block); end sig { params(blob: T.untyped).returns(T.untyped) } def perform_now(blob); end diff --git a/sorbet/rbi/dsl/active_storage/attachment.rbi b/sorbet/rbi/dsl/active_storage/attachment.rbi index cfd6cee..4ad8960 100644 --- a/sorbet/rbi/dsl/active_storage/attachment.rbi +++ b/sorbet/rbi/dsl/active_storage/attachment.rbi @@ -975,6 +975,9 @@ class ActiveStorage::Attachment sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_ary; end end @@ -1069,6 +1072,9 @@ class ActiveStorage::Attachment sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_ary; end end @@ -1082,6 +1088,9 @@ class ActiveStorage::Attachment sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Attachment]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/active_storage/blob.rbi b/sorbet/rbi/dsl/active_storage/blob.rbi index 3242b1f..5ee1fd2 100644 --- a/sorbet/rbi/dsl/active_storage/blob.rbi +++ b/sorbet/rbi/dsl/active_storage/blob.rbi @@ -10,6 +10,7 @@ class ActiveStorage::Blob extend CommonRelationMethods extend GeneratedRelationMethods include GeneratedSecureTokenMethods + include GeneratedStoredAttributesMethods sig { returns(ActiveStorage::Attached::One) } def preview_image; end @@ -1192,6 +1193,80 @@ class ActiveStorage::Blob def regenerate_key; end end + module GeneratedStoredAttributesMethods + sig { returns(T.untyped) } + def analyzed; end + + sig { params(value: T.untyped).returns(T.untyped) } + def analyzed=(value); end + + sig { returns(T.untyped) } + def analyzed_before_last_save; end + + sig { returns(T.untyped) } + def analyzed_change; end + + sig { returns(T::Boolean) } + def analyzed_changed?; end + + sig { returns(T.untyped) } + def analyzed_was; end + + sig { returns(T.untyped) } + def composed; end + + sig { params(value: T.untyped).returns(T.untyped) } + def composed=(value); end + + sig { returns(T.untyped) } + def composed_before_last_save; end + + sig { returns(T.untyped) } + def composed_change; end + + sig { returns(T::Boolean) } + def composed_changed?; end + + sig { returns(T.untyped) } + def composed_was; end + + sig { returns(T.untyped) } + def identified; end + + sig { params(value: T.untyped).returns(T.untyped) } + def identified=(value); end + + sig { returns(T.untyped) } + def identified_before_last_save; end + + sig { returns(T.untyped) } + def identified_change; end + + sig { returns(T::Boolean) } + def identified_changed?; end + + sig { returns(T.untyped) } + def identified_was; end + + sig { returns(T.untyped) } + def saved_change_to_analyzed; end + + sig { returns(T::Boolean) } + def saved_change_to_analyzed?; end + + sig { returns(T.untyped) } + def saved_change_to_composed; end + + sig { returns(T::Boolean) } + def saved_change_to_composed?; end + + sig { returns(T.untyped) } + def saved_change_to_identified; end + + sig { returns(T::Boolean) } + def saved_change_to_identified?; end + end + class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation include CommonRelationMethods include GeneratedAssociationRelationMethods @@ -1201,6 +1276,9 @@ class ActiveStorage::Blob sig { returns(T::Array[::ActiveStorage::Blob]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } def to_ary; end end @@ -1295,6 +1373,9 @@ class ActiveStorage::Blob sig { returns(T::Array[::ActiveStorage::Blob]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } def to_ary; end end @@ -1308,6 +1389,9 @@ class ActiveStorage::Blob sig { returns(T::Array[::ActiveStorage::Blob]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::Blob]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/active_storage/cleanup_blobs_job.rbi b/sorbet/rbi/dsl/active_storage/cleanup_blobs_job.rbi index 359d6f4..098cb90 100644 --- a/sorbet/rbi/dsl/active_storage/cleanup_blobs_job.rbi +++ b/sorbet/rbi/dsl/active_storage/cleanup_blobs_job.rbi @@ -6,8 +6,12 @@ class ActiveStorage::CleanupBlobsJob class << self - sig { returns(T.any(ActiveStorage::CleanupBlobsJob, FalseClass)) } - def perform_later; end + sig do + params( + block: T.nilable(T.proc.params(job: ActiveStorage::CleanupBlobsJob).void) + ).returns(T.any(ActiveStorage::CleanupBlobsJob, FalseClass)) + end + def perform_later(&block); end sig { void } def perform_now; end diff --git a/sorbet/rbi/dsl/active_storage/current.rbi b/sorbet/rbi/dsl/active_storage/current.rbi index 3f68d0d..41057c2 100644 --- a/sorbet/rbi/dsl/active_storage/current.rbi +++ b/sorbet/rbi/dsl/active_storage/current.rbi @@ -5,11 +5,7 @@ # Please instead update this file by running `bin/tapioca dsl ActiveStorage::Current`. class ActiveStorage::Current - sig { returns(T.untyped) } - def url_options; end - - sig { params(value: T.untyped).returns(T.untyped) } - def url_options=(value); end + include GeneratedAttributeMethods class << self sig { returns(T.untyped) } @@ -24,4 +20,12 @@ class ActiveStorage::Current sig { params(value: T.untyped).returns(T.untyped) } def url_options=(value); end end + + module GeneratedAttributeMethods + sig { returns(T.untyped) } + def url_options; end + + sig { params(value: T.untyped).returns(T.untyped) } + def url_options=(value); end + end end diff --git a/sorbet/rbi/dsl/active_storage/mirror_job.rbi b/sorbet/rbi/dsl/active_storage/mirror_job.rbi index d8aefed..7a44128 100644 --- a/sorbet/rbi/dsl/active_storage/mirror_job.rbi +++ b/sorbet/rbi/dsl/active_storage/mirror_job.rbi @@ -6,8 +6,14 @@ class ActiveStorage::MirrorJob class << self - sig { params(key: T.untyped, checksum: T.untyped).returns(T.any(ActiveStorage::MirrorJob, FalseClass)) } - def perform_later(key, checksum:); end + sig do + params( + key: T.untyped, + checksum: T.untyped, + block: T.nilable(T.proc.params(job: ActiveStorage::MirrorJob).void) + ).returns(T.any(ActiveStorage::MirrorJob, FalseClass)) + end + def perform_later(key, checksum:, &block); end sig { params(key: T.untyped, checksum: T.untyped).returns(T.untyped) } def perform_now(key, checksum:); end diff --git a/sorbet/rbi/dsl/active_storage/purge_job.rbi b/sorbet/rbi/dsl/active_storage/purge_job.rbi index 07e3bbb..f5fe5ab 100644 --- a/sorbet/rbi/dsl/active_storage/purge_job.rbi +++ b/sorbet/rbi/dsl/active_storage/purge_job.rbi @@ -6,8 +6,13 @@ class ActiveStorage::PurgeJob class << self - sig { params(blob: T.untyped).returns(T.any(ActiveStorage::PurgeJob, FalseClass)) } - def perform_later(blob); end + sig do + params( + blob: T.untyped, + block: T.nilable(T.proc.params(job: ActiveStorage::PurgeJob).void) + ).returns(T.any(ActiveStorage::PurgeJob, FalseClass)) + end + def perform_later(blob, &block); end sig { params(blob: T.untyped).returns(T.untyped) } def perform_now(blob); end diff --git a/sorbet/rbi/dsl/active_storage/variant_record.rbi b/sorbet/rbi/dsl/active_storage/variant_record.rbi index 336c56c..2dc3a63 100644 --- a/sorbet/rbi/dsl/active_storage/variant_record.rbi +++ b/sorbet/rbi/dsl/active_storage/variant_record.rbi @@ -837,6 +837,9 @@ class ActiveStorage::VariantRecord sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_ary; end end @@ -931,6 +934,9 @@ class ActiveStorage::VariantRecord sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_ary; end end @@ -944,6 +950,9 @@ class ActiveStorage::VariantRecord sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } + def to_a; end + sig { returns(T::Array[::ActiveStorage::VariantRecord]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/activity.rbi b/sorbet/rbi/dsl/activity.rbi index bd75fae..fa78a5b 100644 --- a/sorbet/rbi/dsl/activity.rbi +++ b/sorbet/rbi/dsl/activity.rbi @@ -1529,6 +1529,9 @@ class Activity sig { returns(T::Array[::Activity]) } def to_a; end + sig { returns(T::Array[::Activity]) } + def to_a; end + sig { returns(T::Array[::Activity]) } def to_ary; end end @@ -1626,6 +1629,9 @@ class Activity sig { returns(T::Array[::Activity]) } def to_a; end + sig { returns(T::Array[::Activity]) } + def to_a; end + sig { returns(T::Array[::Activity]) } def to_ary; end end @@ -1642,6 +1648,9 @@ class Activity sig { returns(T::Array[::Activity]) } def to_a; end + sig { returns(T::Array[::Activity]) } + def to_a; end + sig { returns(T::Array[::Activity]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/activity/habtm_groups.rbi b/sorbet/rbi/dsl/activity/habtm_groups.rbi index 59822cf..2ad0122 100644 --- a/sorbet/rbi/dsl/activity/habtm_groups.rbi +++ b/sorbet/rbi/dsl/activity/habtm_groups.rbi @@ -813,6 +813,9 @@ class Activity::HABTM_Groups sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } + def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_ary; end end @@ -907,6 +910,9 @@ class Activity::HABTM_Groups sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } + def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_ary; end end @@ -920,6 +926,9 @@ class Activity::HABTM_Groups sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } + def to_a; end + sig { returns(T::Array[::Activity::HABTM_Groups]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/address.rbi b/sorbet/rbi/dsl/address.rbi index 82f510b..cd238e1 100644 --- a/sorbet/rbi/dsl/address.rbi +++ b/sorbet/rbi/dsl/address.rbi @@ -1196,6 +1196,9 @@ class Address sig { returns(T::Array[::Address]) } def to_a; end + sig { returns(T::Array[::Address]) } + def to_a; end + sig { returns(T::Array[::Address]) } def to_ary; end end @@ -1290,6 +1293,9 @@ class Address sig { returns(T::Array[::Address]) } def to_a; end + sig { returns(T::Array[::Address]) } + def to_a; end + sig { returns(T::Array[::Address]) } def to_ary; end end @@ -1303,6 +1309,9 @@ class Address sig { returns(T::Array[::Address]) } def to_a; end + sig { returns(T::Array[::Address]) } + def to_a; end + sig { returns(T::Array[::Address]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/clear_activity_status_job.rbi b/sorbet/rbi/dsl/clear_activity_status_job.rbi index 767707c..c4d97ae 100644 --- a/sorbet/rbi/dsl/clear_activity_status_job.rbi +++ b/sorbet/rbi/dsl/clear_activity_status_job.rbi @@ -6,8 +6,12 @@ class ClearActivityStatusJob class << self - sig { returns(T.any(ClearActivityStatusJob, FalseClass)) } - def perform_later; end + sig do + params( + block: T.nilable(T.proc.params(job: ClearActivityStatusJob).void) + ).returns(T.any(ClearActivityStatusJob, FalseClass)) + end + def perform_later(&block); end sig { void } def perform_now; end diff --git a/sorbet/rbi/dsl/destroy_demo_activities_job.rbi b/sorbet/rbi/dsl/destroy_demo_activities_job.rbi index 19b803f..5f0516d 100644 --- a/sorbet/rbi/dsl/destroy_demo_activities_job.rbi +++ b/sorbet/rbi/dsl/destroy_demo_activities_job.rbi @@ -6,8 +6,12 @@ class DestroyDemoActivitiesJob class << self - sig { returns(T.any(DestroyDemoActivitiesJob, FalseClass)) } - def perform_later; end + sig do + params( + block: T.nilable(T.proc.params(job: DestroyDemoActivitiesJob).void) + ).returns(T.any(DestroyDemoActivitiesJob, FalseClass)) + end + def perform_later(&block); end sig { void } def perform_now; end diff --git a/sorbet/rbi/dsl/good_job/active_job_extensions/labels.rbi b/sorbet/rbi/dsl/good_job/active_job_extensions/labels.rbi new file mode 100644 index 0000000..14665dc --- /dev/null +++ b/sorbet/rbi/dsl/good_job/active_job_extensions/labels.rbi @@ -0,0 +1,18 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `GoodJob::ActiveJobExtensions::Labels`. +# Please instead update this file by running `bin/tapioca dsl GoodJob::ActiveJobExtensions::Labels`. + +module GoodJob::ActiveJobExtensions::Labels + include GeneratedInstanceMethods + + mixes_in_class_methods GeneratedClassMethods + + module GeneratedClassMethods + def good_job_labels; end + def good_job_labels=(value); end + end + + module GeneratedInstanceMethods; end +end diff --git a/sorbet/rbi/dsl/good_job/application_controller.rbi b/sorbet/rbi/dsl/good_job/application_controller.rbi index 9f65b01..01d8c4b 100644 --- a/sorbet/rbi/dsl/good_job/application_controller.rbi +++ b/sorbet/rbi/dsl/good_job/application_controller.rbi @@ -14,6 +14,7 @@ class GoodJob::ApplicationController include ::ViteRails::TagHelpers include ::InertiaRails::Helper include ::ActionController::Base::HelperMethods + include ::GoodJob::IconsHelper include ::GoodJob::ApplicationHelper end diff --git a/sorbet/rbi/dsl/good_job/base_execution.rbi b/sorbet/rbi/dsl/good_job/base_execution.rbi deleted file mode 100644 index e022d16..0000000 --- a/sorbet/rbi/dsl/good_job/base_execution.rbi +++ /dev/null @@ -1,2014 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for dynamic methods in `GoodJob::BaseExecution`. -# Please instead update this file by running `bin/tapioca dsl GoodJob::BaseExecution`. - -class GoodJob::BaseExecution - include GeneratedAttributeMethods - extend CommonRelationMethods - extend GeneratedRelationMethods - - private - - sig { returns(NilClass) } - def to_ary; end - - module CommonRelationMethods - sig do - params( - block: T.nilable(T.proc.params(record: ::GoodJob::BaseExecution).returns(T.untyped)) - ).returns(T::Boolean) - end - def any?(&block); end - - sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } - def average(column_name); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def build(attributes = nil, &block); end - - sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.untyped) } - def calculate(operation, column_name); end - - sig { params(column_name: T.untyped).returns(T.untyped) } - def count(column_name = nil); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def create(attributes = nil, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def create!(attributes = nil, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def create_or_find_by(attributes, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def create_or_find_by!(attributes, &block); end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def destroy_all; end - - sig { params(conditions: T.untyped).returns(T::Boolean) } - def exists?(conditions = :none); end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def fifth; end - - sig { returns(::GoodJob::BaseExecution) } - def fifth!; end - - sig { params(args: T.untyped).returns(T.untyped) } - def find(*args); end - - sig { params(args: T.untyped).returns(T.nilable(::GoodJob::BaseExecution)) } - def find_by(*args); end - - sig { params(args: T.untyped).returns(::GoodJob::BaseExecution) } - def find_by!(*args); end - - sig do - params( - start: T.untyped, - finish: T.untyped, - batch_size: Integer, - error_on_ignore: T.untyped, - order: Symbol, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(T.nilable(T::Enumerator[::GoodJob::BaseExecution])) - end - def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end - - sig do - params( - start: T.untyped, - finish: T.untyped, - batch_size: Integer, - error_on_ignore: T.untyped, - order: Symbol, - block: T.nilable(T.proc.params(object: T::Array[::GoodJob::BaseExecution]).void) - ).returns(T.nilable(T::Enumerator[T::Enumerator[::GoodJob::BaseExecution]])) - end - def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def find_or_create_by(attributes, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def find_or_create_by!(attributes, &block); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def find_or_initialize_by(attributes, &block); end - - sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::GoodJob::BaseExecution)) } - def find_signed(signed_id, purpose: nil); end - - sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::GoodJob::BaseExecution) } - def find_signed!(signed_id, purpose: nil); end - - sig { params(arg: T.untyped, args: T.untyped).returns(::GoodJob::BaseExecution) } - def find_sole_by(arg, *args); end - - sig { params(limit: T.untyped).returns(T.untyped) } - def first(limit = nil); end - - sig { returns(::GoodJob::BaseExecution) } - def first!; end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def forty_two; end - - sig { returns(::GoodJob::BaseExecution) } - def forty_two!; end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def fourth; end - - sig { returns(::GoodJob::BaseExecution) } - def fourth!; end - - sig { returns(Array) } - def ids; end - - sig do - params( - of: Integer, - start: T.untyped, - finish: T.untyped, - load: T.untyped, - error_on_ignore: T.untyped, - order: Symbol, - block: T.nilable(T.proc.params(object: PrivateRelation).void) - ).returns(T.nilable(::ActiveRecord::Batches::BatchEnumerator)) - end - def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, &block); end - - sig { params(record: T.untyped).returns(T::Boolean) } - def include?(record); end - - sig { params(limit: T.untyped).returns(T.untyped) } - def last(limit = nil); end - - sig { returns(::GoodJob::BaseExecution) } - def last!; end - - sig do - params( - block: T.nilable(T.proc.params(record: ::GoodJob::BaseExecution).returns(T.untyped)) - ).returns(T::Boolean) - end - def many?(&block); end - - sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } - def maximum(column_name); end - - sig { params(record: T.untyped).returns(T::Boolean) } - def member?(record); end - - sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } - def minimum(column_name); end - - sig do - params( - attributes: T.untyped, - block: T.nilable(T.proc.params(object: ::GoodJob::BaseExecution).void) - ).returns(::GoodJob::BaseExecution) - end - def new(attributes = nil, &block); end - - sig do - params( - block: T.nilable(T.proc.params(record: ::GoodJob::BaseExecution).returns(T.untyped)) - ).returns(T::Boolean) - end - def none?(&block); end - - sig do - params( - block: T.nilable(T.proc.params(record: ::GoodJob::BaseExecution).returns(T.untyped)) - ).returns(T::Boolean) - end - def one?(&block); end - - sig { params(column_names: T.untyped).returns(T.untyped) } - def pick(*column_names); end - - sig { params(column_names: T.untyped).returns(T.untyped) } - def pluck(*column_names); end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def second; end - - sig { returns(::GoodJob::BaseExecution) } - def second!; end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def second_to_last; end - - sig { returns(::GoodJob::BaseExecution) } - def second_to_last!; end - - sig { returns(::GoodJob::BaseExecution) } - def sole; end - - sig do - params( - column_name: T.nilable(T.any(String, Symbol)), - block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped)) - ).returns(T.untyped) - end - def sum(column_name = nil, &block); end - - sig { params(limit: T.untyped).returns(T.untyped) } - def take(limit = nil); end - - sig { returns(::GoodJob::BaseExecution) } - def take!; end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def third; end - - sig { returns(::GoodJob::BaseExecution) } - def third!; end - - sig { returns(T.nilable(::GoodJob::BaseExecution)) } - def third_to_last; end - - sig { returns(::GoodJob::BaseExecution) } - def third_to_last!; end - end - - module GeneratedAssociationRelationMethods - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def advisory_lock(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def advisory_locked(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def advisory_unlocked(*args, &blk); end - - sig { returns(PrivateAssociationRelation) } - def all; end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def and(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def annotate(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def create_with(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def display_all(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def distinct(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def eager_load(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def except(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def excluding(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def extending(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def extract_associated(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def from(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def group(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def having(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def in_order_of(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def includes(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def includes_advisory_locks(*args, &blk); end - - sig do - params( - attributes: Hash, - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), - unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) - ).returns(ActiveRecord::Result) - end - def insert(attributes, returning: nil, unique_by: nil); end - - sig do - params( - attributes: Hash, - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)) - ).returns(ActiveRecord::Result) - end - def insert!(attributes, returning: nil); end - - sig do - params( - attributes: T::Array[Hash], - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), - unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) - ).returns(ActiveRecord::Result) - end - def insert_all(attributes, returning: nil, unique_by: nil); end - - sig do - params( - attributes: T::Array[Hash], - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)) - ).returns(ActiveRecord::Result) - end - def insert_all!(attributes, returning: nil); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def invert_where(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def job_class(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def joins_advisory_locks(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def left_joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def left_outer_joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def limit(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def lock(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def merge(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def none(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def offset(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def only(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def optimizer_hints(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def or(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def order(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def owns_advisory_locked(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def preload(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def readonly(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def references(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def reorder(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def reselect(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def reverse_order(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def rewhere(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def search_text(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def select(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def strict_loading(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def structurally_compatible?(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def uniq!(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def unscope(*args, &blk); end - - sig do - params( - attributes: Hash, - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), - unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) - ).returns(ActiveRecord::Result) - end - def upsert(attributes, returning: nil, unique_by: nil); end - - sig do - params( - attributes: T::Array[Hash], - returning: T.nilable(T.any(T::Array[Symbol], FalseClass)), - unique_by: T.nilable(T.any(T::Array[Symbol], Symbol)) - ).returns(ActiveRecord::Result) - end - def upsert_all(attributes, returning: nil, unique_by: nil); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationWhereChain) } - def where(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def without(*args, &blk); end - end - - module GeneratedAttributeMethods - sig { returns(T.nilable(::String)) } - def active_job_id; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def active_job_id=(value); end - - sig { returns(T::Boolean) } - def active_job_id?; end - - sig { returns(T.nilable(::String)) } - def active_job_id_before_last_save; end - - sig { returns(T.untyped) } - def active_job_id_before_type_cast; end - - sig { returns(T::Boolean) } - def active_job_id_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def active_job_id_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def active_job_id_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def active_job_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def active_job_id_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def active_job_id_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def active_job_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def active_job_id_previously_was; end - - sig { returns(T.nilable(::String)) } - def active_job_id_was; end - - sig { void } - def active_job_id_will_change!; end - - sig { returns(T.nilable(::String)) } - def batch_callback_id; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def batch_callback_id=(value); end - - sig { returns(T::Boolean) } - def batch_callback_id?; end - - sig { returns(T.nilable(::String)) } - def batch_callback_id_before_last_save; end - - sig { returns(T.untyped) } - def batch_callback_id_before_type_cast; end - - sig { returns(T::Boolean) } - def batch_callback_id_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_callback_id_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_callback_id_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def batch_callback_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def batch_callback_id_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_callback_id_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def batch_callback_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def batch_callback_id_previously_was; end - - sig { returns(T.nilable(::String)) } - def batch_callback_id_was; end - - sig { void } - def batch_callback_id_will_change!; end - - sig { returns(T.nilable(::String)) } - def batch_id; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def batch_id=(value); end - - sig { returns(T::Boolean) } - def batch_id?; end - - sig { returns(T.nilable(::String)) } - def batch_id_before_last_save; end - - sig { returns(T.untyped) } - def batch_id_before_type_cast; end - - sig { returns(T::Boolean) } - def batch_id_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_id_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_id_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def batch_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def batch_id_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def batch_id_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def batch_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def batch_id_previously_was; end - - sig { returns(T.nilable(::String)) } - def batch_id_was; end - - sig { void } - def batch_id_will_change!; end - - sig { returns(T.nilable(::String)) } - def concurrency_key; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def concurrency_key=(value); end - - sig { returns(T::Boolean) } - def concurrency_key?; end - - sig { returns(T.nilable(::String)) } - def concurrency_key_before_last_save; end - - sig { returns(T.untyped) } - def concurrency_key_before_type_cast; end - - sig { returns(T::Boolean) } - def concurrency_key_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def concurrency_key_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def concurrency_key_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def concurrency_key_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def concurrency_key_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def concurrency_key_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def concurrency_key_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def concurrency_key_previously_was; end - - sig { returns(T.nilable(::String)) } - def concurrency_key_was; end - - sig { void } - def concurrency_key_will_change!; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def created_at; end - - sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) } - def created_at=(value); end - - sig { returns(T::Boolean) } - def created_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def created_at_before_last_save; end - - sig { returns(T.untyped) } - def created_at_before_type_cast; end - - sig { returns(T::Boolean) } - def created_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def created_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def created_at_change_to_be_saved; end - - sig { params(from: ::ActiveSupport::TimeWithZone, to: ::ActiveSupport::TimeWithZone).returns(T::Boolean) } - def created_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def created_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def created_at_previous_change; end - - sig { params(from: ::ActiveSupport::TimeWithZone, to: ::ActiveSupport::TimeWithZone).returns(T::Boolean) } - def created_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def created_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def created_at_was; end - - sig { void } - def created_at_will_change!; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at; end - - sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at=(value); end - - sig { returns(T::Boolean) } - def cron_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at_before_last_save; end - - sig { returns(T.untyped) } - def cron_at_before_type_cast; end - - sig { returns(T::Boolean) } - def cron_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def cron_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def cron_at_change_to_be_saved; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def cron_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def cron_at_previous_change; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def cron_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def cron_at_was; end - - sig { void } - def cron_at_will_change!; end - - sig { returns(T.nilable(::String)) } - def cron_key; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def cron_key=(value); end - - sig { returns(T::Boolean) } - def cron_key?; end - - sig { returns(T.nilable(::String)) } - def cron_key_before_last_save; end - - sig { returns(T.untyped) } - def cron_key_before_type_cast; end - - sig { returns(T::Boolean) } - def cron_key_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def cron_key_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def cron_key_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def cron_key_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def cron_key_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def cron_key_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def cron_key_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def cron_key_previously_was; end - - sig { returns(T.nilable(::String)) } - def cron_key_was; end - - sig { void } - def cron_key_will_change!; end - - sig { returns(T.nilable(::String)) } - def error; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def error=(value); end - - sig { returns(T::Boolean) } - def error?; end - - sig { returns(T.nilable(::String)) } - def error_before_last_save; end - - sig { returns(T.untyped) } - def error_before_type_cast; end - - sig { returns(T::Boolean) } - def error_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def error_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def error_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def error_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def error_event; end - - sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } - def error_event=(value); end - - sig { returns(T::Boolean) } - def error_event?; end - - sig { returns(T.nilable(::Integer)) } - def error_event_before_last_save; end - - sig { returns(T.untyped) } - def error_event_before_type_cast; end - - sig { returns(T::Boolean) } - def error_event_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def error_event_change; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def error_event_change_to_be_saved; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def error_event_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def error_event_in_database; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def error_event_previous_change; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def error_event_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def error_event_previously_was; end - - sig { returns(T.nilable(::Integer)) } - def error_event_was; end - - sig { void } - def error_event_will_change!; end - - sig { returns(T.nilable(::String)) } - def error_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def error_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def error_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def error_previously_was; end - - sig { returns(T.nilable(::String)) } - def error_was; end - - sig { void } - def error_will_change!; end - - sig { returns(T.nilable(::Integer)) } - def executions_count; end - - sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } - def executions_count=(value); end - - sig { returns(T::Boolean) } - def executions_count?; end - - sig { returns(T.nilable(::Integer)) } - def executions_count_before_last_save; end - - sig { returns(T.untyped) } - def executions_count_before_type_cast; end - - sig { returns(T::Boolean) } - def executions_count_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def executions_count_change; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def executions_count_change_to_be_saved; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def executions_count_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def executions_count_in_database; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def executions_count_previous_change; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def executions_count_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def executions_count_previously_was; end - - sig { returns(T.nilable(::Integer)) } - def executions_count_was; end - - sig { void } - def executions_count_will_change!; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at; end - - sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at=(value); end - - sig { returns(T::Boolean) } - def finished_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at_before_last_save; end - - sig { returns(T.untyped) } - def finished_at_before_type_cast; end - - sig { returns(T::Boolean) } - def finished_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def finished_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def finished_at_change_to_be_saved; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def finished_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def finished_at_previous_change; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def finished_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def finished_at_was; end - - sig { void } - def finished_at_will_change!; end - - sig { returns(T.nilable(::String)) } - def id; end - - sig { params(value: ::String).returns(::String) } - def id=(value); end - - sig { returns(T::Boolean) } - def id?; end - - sig { returns(T.nilable(::String)) } - def id_before_last_save; end - - sig { returns(T.untyped) } - def id_before_type_cast; end - - sig { returns(T::Boolean) } - def id_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def id_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def id_change_to_be_saved; end - - sig { params(from: ::String, to: ::String).returns(T::Boolean) } - def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def id_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def id_previous_change; end - - sig { params(from: ::String, to: ::String).returns(T::Boolean) } - def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def id_previously_was; end - - sig { returns(T.nilable(::String)) } - def id_was; end - - sig { void } - def id_will_change!; end - - sig { returns(T.nilable(T::Boolean)) } - def is_discrete; end - - sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) } - def is_discrete=(value); end - - sig { returns(T::Boolean) } - def is_discrete?; end - - sig { returns(T.nilable(T::Boolean)) } - def is_discrete_before_last_save; end - - sig { returns(T.untyped) } - def is_discrete_before_type_cast; end - - sig { returns(T::Boolean) } - def is_discrete_came_from_user?; end - - sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) } - def is_discrete_change; end - - sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) } - def is_discrete_change_to_be_saved; end - - sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) } - def is_discrete_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(T::Boolean)) } - def is_discrete_in_database; end - - sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) } - def is_discrete_previous_change; end - - sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) } - def is_discrete_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(T::Boolean)) } - def is_discrete_previously_was; end - - sig { returns(T.nilable(T::Boolean)) } - def is_discrete_was; end - - sig { void } - def is_discrete_will_change!; end - - sig { returns(T.nilable(::String)) } - def job_class; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def job_class=(value); end - - sig { returns(T::Boolean) } - def job_class?; end - - sig { returns(T.nilable(::String)) } - def job_class_before_last_save; end - - sig { returns(T.untyped) } - def job_class_before_type_cast; end - - sig { returns(T::Boolean) } - def job_class_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def job_class_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def job_class_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def job_class_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def job_class_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def job_class_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def job_class_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def job_class_previously_was; end - - sig { returns(T.nilable(::String)) } - def job_class_was; end - - sig { void } - def job_class_will_change!; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at; end - - sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at=(value); end - - sig { returns(T::Boolean) } - def performed_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at_before_last_save; end - - sig { returns(T.untyped) } - def performed_at_before_type_cast; end - - sig { returns(T::Boolean) } - def performed_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def performed_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def performed_at_change_to_be_saved; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def performed_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def performed_at_previous_change; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def performed_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def performed_at_was; end - - sig { void } - def performed_at_will_change!; end - - sig { returns(T.nilable(::Integer)) } - def priority; end - - sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } - def priority=(value); end - - sig { returns(T::Boolean) } - def priority?; end - - sig { returns(T.nilable(::Integer)) } - def priority_before_last_save; end - - sig { returns(T.untyped) } - def priority_before_type_cast; end - - sig { returns(T::Boolean) } - def priority_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def priority_change; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def priority_change_to_be_saved; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def priority_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def priority_in_database; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def priority_previous_change; end - - sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } - def priority_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::Integer)) } - def priority_previously_was; end - - sig { returns(T.nilable(::Integer)) } - def priority_was; end - - sig { void } - def priority_will_change!; end - - sig { returns(T.nilable(::String)) } - def queue_name; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def queue_name=(value); end - - sig { returns(T::Boolean) } - def queue_name?; end - - sig { returns(T.nilable(::String)) } - def queue_name_before_last_save; end - - sig { returns(T.untyped) } - def queue_name_before_type_cast; end - - sig { returns(T::Boolean) } - def queue_name_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def queue_name_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def queue_name_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def queue_name_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def queue_name_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def queue_name_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def queue_name_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def queue_name_previously_was; end - - sig { returns(T.nilable(::String)) } - def queue_name_was; end - - sig { void } - def queue_name_will_change!; end - - sig { void } - def restore_active_job_id!; end - - sig { void } - def restore_batch_callback_id!; end - - sig { void } - def restore_batch_id!; end - - sig { void } - def restore_concurrency_key!; end - - sig { void } - def restore_created_at!; end - - sig { void } - def restore_cron_at!; end - - sig { void } - def restore_cron_key!; end - - sig { void } - def restore_error!; end - - sig { void } - def restore_error_event!; end - - sig { void } - def restore_executions_count!; end - - sig { void } - def restore_finished_at!; end - - sig { void } - def restore_id!; end - - sig { void } - def restore_is_discrete!; end - - sig { void } - def restore_job_class!; end - - sig { void } - def restore_performed_at!; end - - sig { void } - def restore_priority!; end - - sig { void } - def restore_queue_name!; end - - sig { void } - def restore_retried_good_job_id!; end - - sig { void } - def restore_scheduled_at!; end - - sig { void } - def restore_serialized_params!; end - - sig { void } - def restore_updated_at!; end - - sig { returns(T.nilable(::String)) } - def retried_good_job_id; end - - sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } - def retried_good_job_id=(value); end - - sig { returns(T::Boolean) } - def retried_good_job_id?; end - - sig { returns(T.nilable(::String)) } - def retried_good_job_id_before_last_save; end - - sig { returns(T.untyped) } - def retried_good_job_id_before_type_cast; end - - sig { returns(T::Boolean) } - def retried_good_job_id_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def retried_good_job_id_change; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def retried_good_job_id_change_to_be_saved; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def retried_good_job_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def retried_good_job_id_in_database; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def retried_good_job_id_previous_change; end - - sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } - def retried_good_job_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::String)) } - def retried_good_job_id_previously_was; end - - sig { returns(T.nilable(::String)) } - def retried_good_job_id_was; end - - sig { void } - def retried_good_job_id_will_change!; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_active_job_id; end - - sig { returns(T::Boolean) } - def saved_change_to_active_job_id?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_batch_callback_id; end - - sig { returns(T::Boolean) } - def saved_change_to_batch_callback_id?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_batch_id; end - - sig { returns(T::Boolean) } - def saved_change_to_batch_id?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_concurrency_key; end - - sig { returns(T::Boolean) } - def saved_change_to_concurrency_key?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_created_at; end - - sig { returns(T::Boolean) } - def saved_change_to_created_at?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_cron_at; end - - sig { returns(T::Boolean) } - def saved_change_to_cron_at?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_cron_key; end - - sig { returns(T::Boolean) } - def saved_change_to_cron_key?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_error; end - - sig { returns(T::Boolean) } - def saved_change_to_error?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def saved_change_to_error_event; end - - sig { returns(T::Boolean) } - def saved_change_to_error_event?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def saved_change_to_executions_count; end - - sig { returns(T::Boolean) } - def saved_change_to_executions_count?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_finished_at; end - - sig { returns(T::Boolean) } - def saved_change_to_finished_at?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_id; end - - sig { returns(T::Boolean) } - def saved_change_to_id?; end - - sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) } - def saved_change_to_is_discrete; end - - sig { returns(T::Boolean) } - def saved_change_to_is_discrete?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_job_class; end - - sig { returns(T::Boolean) } - def saved_change_to_job_class?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_performed_at; end - - sig { returns(T::Boolean) } - def saved_change_to_performed_at?; end - - sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } - def saved_change_to_priority; end - - sig { returns(T::Boolean) } - def saved_change_to_priority?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_queue_name; end - - sig { returns(T::Boolean) } - def saved_change_to_queue_name?; end - - sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } - def saved_change_to_retried_good_job_id; end - - sig { returns(T::Boolean) } - def saved_change_to_retried_good_job_id?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_scheduled_at; end - - sig { returns(T::Boolean) } - def saved_change_to_scheduled_at?; end - - sig { returns(T.nilable([T.untyped, T.untyped])) } - def saved_change_to_serialized_params; end - - sig { returns(T::Boolean) } - def saved_change_to_serialized_params?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def saved_change_to_updated_at; end - - sig { returns(T::Boolean) } - def saved_change_to_updated_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at; end - - sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at=(value); end - - sig { returns(T::Boolean) } - def scheduled_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at_before_last_save; end - - sig { returns(T.untyped) } - def scheduled_at_before_type_cast; end - - sig { returns(T::Boolean) } - def scheduled_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def scheduled_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def scheduled_at_change_to_be_saved; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def scheduled_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def scheduled_at_previous_change; end - - sig do - params( - from: T.nilable(::ActiveSupport::TimeWithZone), - to: T.nilable(::ActiveSupport::TimeWithZone) - ).returns(T::Boolean) - end - def scheduled_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def scheduled_at_was; end - - sig { void } - def scheduled_at_will_change!; end - - sig { returns(T.untyped) } - def serialized_params; end - - sig { params(value: T.untyped).returns(T.untyped) } - def serialized_params=(value); end - - sig { returns(T::Boolean) } - def serialized_params?; end - - sig { returns(T.untyped) } - def serialized_params_before_last_save; end - - sig { returns(T.untyped) } - def serialized_params_before_type_cast; end - - sig { returns(T::Boolean) } - def serialized_params_came_from_user?; end - - sig { returns(T.nilable([T.untyped, T.untyped])) } - def serialized_params_change; end - - sig { returns(T.nilable([T.untyped, T.untyped])) } - def serialized_params_change_to_be_saved; end - - sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } - def serialized_params_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.untyped) } - def serialized_params_in_database; end - - sig { returns(T.nilable([T.untyped, T.untyped])) } - def serialized_params_previous_change; end - - sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } - def serialized_params_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.untyped) } - def serialized_params_previously_was; end - - sig { returns(T.untyped) } - def serialized_params_was; end - - sig { void } - def serialized_params_will_change!; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def updated_at; end - - sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) } - def updated_at=(value); end - - sig { returns(T::Boolean) } - def updated_at?; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def updated_at_before_last_save; end - - sig { returns(T.untyped) } - def updated_at_before_type_cast; end - - sig { returns(T::Boolean) } - def updated_at_came_from_user?; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def updated_at_change; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def updated_at_change_to_be_saved; end - - sig { params(from: ::ActiveSupport::TimeWithZone, to: ::ActiveSupport::TimeWithZone).returns(T::Boolean) } - def updated_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def updated_at_in_database; end - - sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } - def updated_at_previous_change; end - - sig { params(from: ::ActiveSupport::TimeWithZone, to: ::ActiveSupport::TimeWithZone).returns(T::Boolean) } - def updated_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def updated_at_previously_was; end - - sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } - def updated_at_was; end - - sig { void } - def updated_at_will_change!; end - - sig { returns(T::Boolean) } - def will_save_change_to_active_job_id?; end - - sig { returns(T::Boolean) } - def will_save_change_to_batch_callback_id?; end - - sig { returns(T::Boolean) } - def will_save_change_to_batch_id?; end - - sig { returns(T::Boolean) } - def will_save_change_to_concurrency_key?; end - - sig { returns(T::Boolean) } - def will_save_change_to_created_at?; end - - sig { returns(T::Boolean) } - def will_save_change_to_cron_at?; end - - sig { returns(T::Boolean) } - def will_save_change_to_cron_key?; end - - sig { returns(T::Boolean) } - def will_save_change_to_error?; end - - sig { returns(T::Boolean) } - def will_save_change_to_error_event?; end - - sig { returns(T::Boolean) } - def will_save_change_to_executions_count?; end - - sig { returns(T::Boolean) } - def will_save_change_to_finished_at?; end - - sig { returns(T::Boolean) } - def will_save_change_to_id?; end - - sig { returns(T::Boolean) } - def will_save_change_to_is_discrete?; end - - sig { returns(T::Boolean) } - def will_save_change_to_job_class?; end - - sig { returns(T::Boolean) } - def will_save_change_to_performed_at?; end - - sig { returns(T::Boolean) } - def will_save_change_to_priority?; end - - sig { returns(T::Boolean) } - def will_save_change_to_queue_name?; end - - sig { returns(T::Boolean) } - def will_save_change_to_retried_good_job_id?; end - - sig { returns(T::Boolean) } - def will_save_change_to_scheduled_at?; end - - sig { returns(T::Boolean) } - def will_save_change_to_serialized_params?; end - - sig { returns(T::Boolean) } - def will_save_change_to_updated_at?; end - end - - module GeneratedRelationMethods - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def advisory_lock(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def advisory_locked(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def advisory_unlocked(*args, &blk); end - - sig { returns(PrivateRelation) } - def all; end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def and(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def annotate(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def create_with(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def display_all(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def distinct(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def eager_load(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def except(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def excluding(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def extending(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def extract_associated(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def from(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def group(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def having(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def in_order_of(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def includes(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def includes_advisory_locks(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def invert_where(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def job_class(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def joins_advisory_locks(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def left_joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def left_outer_joins(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def limit(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def lock(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def merge(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def none(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def offset(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def only(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def optimizer_hints(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def or(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def order(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def owns_advisory_locked(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def preload(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def readonly(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def references(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def reorder(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def reselect(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def reverse_order(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def rewhere(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def search_text(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def select(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def strict_loading(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def structurally_compatible?(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def uniq!(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def unscope(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationWhereChain) } - def where(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def without(*args, &blk); end - end - - class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation - include CommonRelationMethods - include GeneratedAssociationRelationMethods - - Elem = type_member { { fixed: ::GoodJob::BaseExecution } } - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_a; end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_ary; end - end - - class PrivateAssociationRelationWhereChain < PrivateAssociationRelation - Elem = type_member { { fixed: ::GoodJob::BaseExecution } } - - sig { params(args: T.untyped).returns(PrivateAssociationRelation) } - def associated(*args); end - - sig { params(args: T.untyped).returns(PrivateAssociationRelation) } - def missing(*args); end - - sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) } - def not(opts, *rest); end - end - - class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy - include CommonRelationMethods - include GeneratedAssociationRelationMethods - - Elem = type_member { { fixed: ::GoodJob::BaseExecution } } - - sig do - params( - records: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(PrivateCollectionProxy) - end - def <<(*records); end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(PrivateCollectionProxy) - end - def append(*records); end - - sig { returns(PrivateCollectionProxy) } - def clear; end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(PrivateCollectionProxy) - end - def concat(*records); end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, Integer, String, T::Enumerable[T.any(::GoodJob::BaseExecution, Integer, String, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(T::Array[::GoodJob::BaseExecution]) - end - def delete(*records); end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, Integer, String, T::Enumerable[T.any(::GoodJob::BaseExecution, Integer, String, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(T::Array[::GoodJob::BaseExecution]) - end - def destroy(*records); end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def load_target; end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(PrivateCollectionProxy) - end - def prepend(*records); end - - sig do - params( - records: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(PrivateCollectionProxy) - end - def push(*records); end - - sig do - params( - other_array: T.any(::GoodJob::BaseExecution, T::Enumerable[T.any(::GoodJob::BaseExecution, T::Enumerable[::GoodJob::BaseExecution])]) - ).returns(T::Array[::GoodJob::BaseExecution]) - end - def replace(other_array); end - - sig { returns(PrivateAssociationRelation) } - def scope; end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def target; end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_a; end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_ary; end - end - - class PrivateRelation < ::ActiveRecord::Relation - include CommonRelationMethods - include GeneratedRelationMethods - - Elem = type_member { { fixed: ::GoodJob::BaseExecution } } - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_a; end - - sig { returns(T::Array[::GoodJob::BaseExecution]) } - def to_ary; end - end - - class PrivateRelationWhereChain < PrivateRelation - Elem = type_member { { fixed: ::GoodJob::BaseExecution } } - - sig { params(args: T.untyped).returns(PrivateRelation) } - def associated(*args); end - - sig { params(args: T.untyped).returns(PrivateRelation) } - def missing(*args); end - - sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) } - def not(opts, *rest); end - end -end diff --git a/sorbet/rbi/dsl/good_job/batch_record.rbi b/sorbet/rbi/dsl/good_job/batch_record.rbi index a9bbd6e..310c449 100644 --- a/sorbet/rbi/dsl/good_job/batch_record.rbi +++ b/sorbet/rbi/dsl/good_job/batch_record.rbi @@ -372,6 +372,9 @@ class GoodJob::BatchRecord sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def finished(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def finished_before(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def from(*args, &blk); end @@ -1433,6 +1436,9 @@ class GoodJob::BatchRecord sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def finished(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def finished_before(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def from(*args, &blk); end @@ -1554,6 +1560,9 @@ class GoodJob::BatchRecord sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } + def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_ary; end end @@ -1648,6 +1657,9 @@ class GoodJob::BatchRecord sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } + def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_ary; end end @@ -1661,6 +1673,9 @@ class GoodJob::BatchRecord sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } + def to_a; end + sig { returns(T::Array[::GoodJob::BatchRecord]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/good_job/discrete_execution.rbi b/sorbet/rbi/dsl/good_job/discrete_execution.rbi index 3ae7110..c8fa907 100644 --- a/sorbet/rbi/dsl/good_job/discrete_execution.rbi +++ b/sorbet/rbi/dsl/good_job/discrete_execution.rbi @@ -591,6 +591,51 @@ class GoodJob::DiscreteExecution sig { void } def created_at_will_change!; end + sig { returns(T.untyped) } + def duration; end + + sig { params(value: T.untyped).returns(T.untyped) } + def duration=(value); end + + sig { returns(T::Boolean) } + def duration?; end + + sig { returns(T.untyped) } + def duration_before_last_save; end + + sig { returns(T.untyped) } + def duration_before_type_cast; end + + sig { returns(T::Boolean) } + def duration_came_from_user?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def duration_change; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def duration_change_to_be_saved; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def duration_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def duration_in_database; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def duration_previous_change; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def duration_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def duration_previously_was; end + + sig { returns(T.untyped) } + def duration_was; end + + sig { void } + def duration_will_change!; end + sig { returns(T.nilable(::String)) } def error; end @@ -600,6 +645,51 @@ class GoodJob::DiscreteExecution sig { returns(T::Boolean) } def error?; end + sig { returns(T.nilable(T::Array[::String])) } + def error_backtrace; end + + sig { params(value: T.nilable(T::Array[::String])).returns(T.nilable(T::Array[::String])) } + def error_backtrace=(value); end + + sig { returns(T::Boolean) } + def error_backtrace?; end + + sig { returns(T.nilable(T::Array[::String])) } + def error_backtrace_before_last_save; end + + sig { returns(T.untyped) } + def error_backtrace_before_type_cast; end + + sig { returns(T::Boolean) } + def error_backtrace_came_from_user?; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def error_backtrace_change; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def error_backtrace_change_to_be_saved; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def error_backtrace_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def error_backtrace_in_database; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def error_backtrace_previous_change; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def error_backtrace_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def error_backtrace_previously_was; end + + sig { returns(T.nilable(T::Array[::String])) } + def error_backtrace_was; end + + sig { void } + def error_backtrace_will_change!; end + sig { returns(T.nilable(::String)) } def error_before_last_save; end @@ -871,6 +961,51 @@ class GoodJob::DiscreteExecution sig { void } def performed_at_will_change!; end + sig { returns(T.nilable(::String)) } + def process_id; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def process_id=(value); end + + sig { returns(T::Boolean) } + def process_id?; end + + sig { returns(T.nilable(::String)) } + def process_id_before_last_save; end + + sig { returns(T.untyped) } + def process_id_before_type_cast; end + + sig { returns(T::Boolean) } + def process_id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def process_id_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def process_id_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def process_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def process_id_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def process_id_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def process_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def process_id_previously_was; end + + sig { returns(T.nilable(::String)) } + def process_id_was; end + + sig { void } + def process_id_will_change!; end + sig { returns(T.nilable(::String)) } def queue_name; end @@ -922,9 +1057,15 @@ class GoodJob::DiscreteExecution sig { void } def restore_created_at!; end + sig { void } + def restore_duration!; end + sig { void } def restore_error!; end + sig { void } + def restore_error_backtrace!; end + sig { void } def restore_error_event!; end @@ -940,6 +1081,9 @@ class GoodJob::DiscreteExecution sig { void } def restore_performed_at!; end + sig { void } + def restore_process_id!; end + sig { void } def restore_queue_name!; end @@ -964,12 +1108,24 @@ class GoodJob::DiscreteExecution sig { returns(T::Boolean) } def saved_change_to_created_at?; end + sig { returns(T.nilable([T.untyped, T.untyped])) } + def saved_change_to_duration; end + + sig { returns(T::Boolean) } + def saved_change_to_duration?; end + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } def saved_change_to_error; end sig { returns(T::Boolean) } def saved_change_to_error?; end + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def saved_change_to_error_backtrace; end + + sig { returns(T::Boolean) } + def saved_change_to_error_backtrace?; end + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } def saved_change_to_error_event; end @@ -1000,6 +1156,12 @@ class GoodJob::DiscreteExecution sig { returns(T::Boolean) } def saved_change_to_performed_at?; end + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_process_id; end + + sig { returns(T::Boolean) } + def saved_change_to_process_id?; end + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } def saved_change_to_queue_name; end @@ -1175,9 +1337,15 @@ class GoodJob::DiscreteExecution sig { returns(T::Boolean) } def will_save_change_to_created_at?; end + sig { returns(T::Boolean) } + def will_save_change_to_duration?; end + sig { returns(T::Boolean) } def will_save_change_to_error?; end + sig { returns(T::Boolean) } + def will_save_change_to_error_backtrace?; end + sig { returns(T::Boolean) } def will_save_change_to_error_event?; end @@ -1193,6 +1361,9 @@ class GoodJob::DiscreteExecution sig { returns(T::Boolean) } def will_save_change_to_performed_at?; end + sig { returns(T::Boolean) } + def will_save_change_to_process_id?; end + sig { returns(T::Boolean) } def will_save_change_to_queue_name?; end @@ -1346,6 +1517,9 @@ class GoodJob::DiscreteExecution sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_ary; end end @@ -1440,6 +1614,9 @@ class GoodJob::DiscreteExecution sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_ary; end end @@ -1453,6 +1630,9 @@ class GoodJob::DiscreteExecution sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::DiscreteExecution]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/good_job/execution.rbi b/sorbet/rbi/dsl/good_job/execution.rbi index 7d0e174..c9d28a7 100644 --- a/sorbet/rbi/dsl/good_job/execution.rbi +++ b/sorbet/rbi/dsl/good_job/execution.rbi @@ -310,7 +310,7 @@ class GoodJob::Execution sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } def discrete_execution_ids=(ids); end - # This method is created by ActiveRecord on the `GoodJob::Execution` class because it declared `has_many :discrete_executions`. + # This method is created by ActiveRecord on the `GoodJob::BaseExecution` class because it declared `has_many :discrete_executions`. # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) sig { returns(::GoodJob::DiscreteExecution::PrivateCollectionProxy) } def discrete_executions; end @@ -359,9 +359,6 @@ class GoodJob::Execution sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def creation_ordered(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def dead(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def dequeueing_ordered(*args, &blk); end @@ -398,9 +395,6 @@ class GoodJob::Execution sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def having(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def head(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def in_order_of(*args, &blk); end @@ -1228,6 +1222,151 @@ class GoodJob::Execution sig { void } def job_class_will_change!; end + sig { returns(T.nilable(T::Array[::String])) } + def labels; end + + sig { params(value: T.nilable(T::Array[::String])).returns(T.nilable(T::Array[::String])) } + def labels=(value); end + + sig { returns(T::Boolean) } + def labels?; end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_before_last_save; end + + sig { returns(T.untyped) } + def labels_before_type_cast; end + + sig { returns(T::Boolean) } + def labels_came_from_user?; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_change; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_change_to_be_saved; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def labels_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_in_database; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_previous_change; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def labels_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_previously_was; end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_was; end + + sig { void } + def labels_will_change!; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at=(value); end + + sig { returns(T::Boolean) } + def locked_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_before_last_save; end + + sig { returns(T.untyped) } + def locked_at_before_type_cast; end + + sig { returns(T::Boolean) } + def locked_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def locked_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def locked_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_was; end + + sig { void } + def locked_at_will_change!; end + + sig { returns(T.nilable(::String)) } + def locked_by_id; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def locked_by_id=(value); end + + sig { returns(T::Boolean) } + def locked_by_id?; end + + sig { returns(T.nilable(::String)) } + def locked_by_id_before_last_save; end + + sig { returns(T.untyped) } + def locked_by_id_before_type_cast; end + + sig { returns(T::Boolean) } + def locked_by_id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def locked_by_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def locked_by_id_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def locked_by_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def locked_by_id_previously_was; end + + sig { returns(T.nilable(::String)) } + def locked_by_id_was; end + + sig { void } + def locked_by_id_will_change!; end + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } def performed_at; end @@ -1415,6 +1554,15 @@ class GoodJob::Execution sig { void } def restore_job_class!; end + sig { void } + def restore_labels!; end + + sig { void } + def restore_locked_at!; end + + sig { void } + def restore_locked_by_id!; end + sig { void } def restore_performed_at!; end @@ -1565,6 +1713,24 @@ class GoodJob::Execution sig { returns(T::Boolean) } def saved_change_to_job_class?; end + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def saved_change_to_labels; end + + sig { returns(T::Boolean) } + def saved_change_to_labels?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_locked_at; end + + sig { returns(T::Boolean) } + def saved_change_to_locked_at?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_locked_by_id; end + + sig { returns(T::Boolean) } + def saved_change_to_locked_by_id?; end + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } def saved_change_to_performed_at; end @@ -1794,6 +1960,15 @@ class GoodJob::Execution sig { returns(T::Boolean) } def will_save_change_to_job_class?; end + sig { returns(T::Boolean) } + def will_save_change_to_labels?; end + + sig { returns(T::Boolean) } + def will_save_change_to_locked_at?; end + + sig { returns(T::Boolean) } + def will_save_change_to_locked_by_id?; end + sig { returns(T::Boolean) } def will_save_change_to_performed_at?; end @@ -1844,9 +2019,6 @@ class GoodJob::Execution sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def creation_ordered(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def dead(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def dequeueing_ordered(*args, &blk); end @@ -1883,9 +2055,6 @@ class GoodJob::Execution sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def having(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def head(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def in_order_of(*args, &blk); end @@ -2019,6 +2188,9 @@ class GoodJob::Execution sig { returns(T::Array[::GoodJob::Execution]) } def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } def to_ary; end end @@ -2113,6 +2285,9 @@ class GoodJob::Execution sig { returns(T::Array[::GoodJob::Execution]) } def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } def to_ary; end end @@ -2126,6 +2301,9 @@ class GoodJob::Execution sig { returns(T::Array[::GoodJob::Execution]) } def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Execution]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/good_job/frontends_controller.rbi b/sorbet/rbi/dsl/good_job/frontends_controller.rbi index e6bd0dc..fc79a6a 100644 --- a/sorbet/rbi/dsl/good_job/frontends_controller.rbi +++ b/sorbet/rbi/dsl/good_job/frontends_controller.rbi @@ -14,6 +14,7 @@ class GoodJob::FrontendsController include ::ViteRails::TagHelpers include ::InertiaRails::Helper include ::ActionController::Base::HelperMethods + include ::GoodJob::IconsHelper include ::GoodJob::ApplicationHelper end diff --git a/sorbet/rbi/dsl/good_job/job.rbi b/sorbet/rbi/dsl/good_job/job.rbi index 66e973c..a5f6f0c 100644 --- a/sorbet/rbi/dsl/good_job/job.rbi +++ b/sorbet/rbi/dsl/good_job/job.rbi @@ -273,12 +273,21 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) } def build_batch(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) } + def build_locked_by_process(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) } def create_batch(*args, &blk); end sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::BatchRecord) } def create_batch!(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) } + def create_locked_by_process(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(::GoodJob::Process) } + def create_locked_by_process!(*args, &blk); end + sig { returns(T::Array[T.untyped]) } def discrete_execution_ids; end @@ -307,11 +316,23 @@ class GoodJob::Job sig { params(value: T::Enumerable[::GoodJob::Execution]).void } def executions=(value); end + sig { returns(T.nilable(::GoodJob::Process)) } + def locked_by_process; end + + sig { params(value: T.nilable(::GoodJob::Process)).void } + def locked_by_process=(value); end + sig { returns(T.nilable(::GoodJob::BatchRecord)) } def reload_batch; end + + sig { returns(T.nilable(::GoodJob::Process)) } + def reload_locked_by_process; end end module GeneratedAssociationRelationMethods + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def active_job_id(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def advisory_lock(*args, &blk); end @@ -333,6 +354,12 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def create_with(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def creation_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def dequeueing_ordered(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def discarded(*args, &blk); end @@ -451,6 +478,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def only(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def only_scheduled(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def optimizer_hints(*args, &blk); end @@ -466,6 +496,15 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def preload(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def priority_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def queue_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def queue_string(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def queued(*args, &blk); end @@ -493,6 +532,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def running(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def schedule_ordered(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def scheduled(*args, &blk); end @@ -511,6 +553,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def succeeded(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def unfinished(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def unfinished_undiscrete(*args, &blk); end @@ -1196,6 +1241,151 @@ class GoodJob::Job sig { void } def job_class_will_change!; end + sig { returns(T.nilable(T::Array[::String])) } + def labels; end + + sig { params(value: T.nilable(T::Array[::String])).returns(T.nilable(T::Array[::String])) } + def labels=(value); end + + sig { returns(T::Boolean) } + def labels?; end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_before_last_save; end + + sig { returns(T.untyped) } + def labels_before_type_cast; end + + sig { returns(T::Boolean) } + def labels_came_from_user?; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_change; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_change_to_be_saved; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def labels_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_in_database; end + + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def labels_previous_change; end + + sig { params(from: T.nilable(T::Array[::String]), to: T.nilable(T::Array[::String])).returns(T::Boolean) } + def labels_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_previously_was; end + + sig { returns(T.nilable(T::Array[::String])) } + def labels_was; end + + sig { void } + def labels_will_change!; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at=(value); end + + sig { returns(T::Boolean) } + def locked_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_before_last_save; end + + sig { returns(T.untyped) } + def locked_at_before_type_cast; end + + sig { returns(T::Boolean) } + def locked_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def locked_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def locked_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def locked_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def locked_at_was; end + + sig { void } + def locked_at_will_change!; end + + sig { returns(T.nilable(::String)) } + def locked_by_id; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def locked_by_id=(value); end + + sig { returns(T::Boolean) } + def locked_by_id?; end + + sig { returns(T.nilable(::String)) } + def locked_by_id_before_last_save; end + + sig { returns(T.untyped) } + def locked_by_id_before_type_cast; end + + sig { returns(T::Boolean) } + def locked_by_id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def locked_by_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def locked_by_id_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def locked_by_id_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def locked_by_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def locked_by_id_previously_was; end + + sig { returns(T.nilable(::String)) } + def locked_by_id_was; end + + sig { void } + def locked_by_id_will_change!; end + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } def performed_at; end @@ -1383,6 +1573,15 @@ class GoodJob::Job sig { void } def restore_job_class!; end + sig { void } + def restore_labels!; end + + sig { void } + def restore_locked_at!; end + + sig { void } + def restore_locked_by_id!; end + sig { void } def restore_performed_at!; end @@ -1533,6 +1732,24 @@ class GoodJob::Job sig { returns(T::Boolean) } def saved_change_to_job_class?; end + sig { returns(T.nilable([T.nilable(T::Array[::String]), T.nilable(T::Array[::String])])) } + def saved_change_to_labels; end + + sig { returns(T::Boolean) } + def saved_change_to_labels?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_locked_at; end + + sig { returns(T::Boolean) } + def saved_change_to_locked_at?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_locked_by_id; end + + sig { returns(T::Boolean) } + def saved_change_to_locked_by_id?; end + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } def saved_change_to_performed_at; end @@ -1762,6 +1979,15 @@ class GoodJob::Job sig { returns(T::Boolean) } def will_save_change_to_job_class?; end + sig { returns(T::Boolean) } + def will_save_change_to_labels?; end + + sig { returns(T::Boolean) } + def will_save_change_to_locked_at?; end + + sig { returns(T::Boolean) } + def will_save_change_to_locked_by_id?; end + sig { returns(T::Boolean) } def will_save_change_to_performed_at?; end @@ -1785,6 +2011,9 @@ class GoodJob::Job end module GeneratedRelationMethods + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def active_job_id(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def advisory_lock(*args, &blk); end @@ -1806,6 +2035,12 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def create_with(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def creation_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def dequeueing_ordered(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def discarded(*args, &blk); end @@ -1890,6 +2125,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def only(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def only_scheduled(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def optimizer_hints(*args, &blk); end @@ -1905,6 +2143,15 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def preload(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def priority_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def queue_ordered(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def queue_string(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def queued(*args, &blk); end @@ -1932,6 +2179,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def running(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def schedule_ordered(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def scheduled(*args, &blk); end @@ -1950,6 +2200,9 @@ class GoodJob::Job sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def succeeded(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def unfinished(*args, &blk); end + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def unfinished_undiscrete(*args, &blk); end @@ -1975,6 +2228,9 @@ class GoodJob::Job sig { returns(T::Array[::GoodJob::Job]) } def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } def to_ary; end end @@ -2069,6 +2325,9 @@ class GoodJob::Job sig { returns(T::Array[::GoodJob::Job]) } def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } def to_ary; end end @@ -2082,6 +2341,9 @@ class GoodJob::Job sig { returns(T::Array[::GoodJob::Job]) } def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Job]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/good_job/process.rbi b/sorbet/rbi/dsl/good_job/process.rbi index 9b578cb..fa0a299 100644 --- a/sorbet/rbi/dsl/good_job/process.rbi +++ b/sorbet/rbi/dsl/good_job/process.rbi @@ -5,6 +5,7 @@ # Please instead update this file by running `bin/tapioca dsl GoodJob::Process`. class GoodJob::Process + include GeneratedAssociationMethods include GeneratedAttributeMethods extend CommonRelationMethods extend GeneratedRelationMethods @@ -262,6 +263,22 @@ class GoodJob::Process def third_to_last!; end end + module GeneratedAssociationMethods + sig { returns(T::Array[T.untyped]) } + def locked_job_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def locked_job_ids=(ids); end + + # This method is created by ActiveRecord on the `GoodJob::Process` class because it declared `has_many :locked_jobs`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::GoodJob::Job::PrivateCollectionProxy) } + def locked_jobs; end + + sig { params(value: T::Enumerable[::GoodJob::Job]).void } + def locked_jobs=(value); end + end + module GeneratedAssociationRelationMethods sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def active(*args, &blk); end @@ -557,12 +574,60 @@ class GoodJob::Process sig { void } def id_will_change!; end + sig { returns(T.nilable(::Integer)) } + def lock_type; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def lock_type=(value); end + + sig { returns(T::Boolean) } + def lock_type?; end + + sig { returns(T.nilable(::Integer)) } + def lock_type_before_last_save; end + + sig { returns(T.untyped) } + def lock_type_before_type_cast; end + + sig { returns(T::Boolean) } + def lock_type_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def lock_type_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def lock_type_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def lock_type_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def lock_type_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def lock_type_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def lock_type_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def lock_type_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def lock_type_was; end + + sig { void } + def lock_type_will_change!; end + sig { void } def restore_created_at!; end sig { void } def restore_id!; end + sig { void } + def restore_lock_type!; end + sig { void } def restore_state!; end @@ -581,6 +646,12 @@ class GoodJob::Process sig { returns(T::Boolean) } def saved_change_to_id?; end + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_lock_type; end + + sig { returns(T::Boolean) } + def saved_change_to_lock_type?; end + sig { returns(T.nilable([T.untyped, T.untyped])) } def saved_change_to_state; end @@ -689,6 +760,9 @@ class GoodJob::Process sig { returns(T::Boolean) } def will_save_change_to_id?; end + sig { returns(T::Boolean) } + def will_save_change_to_lock_type?; end + sig { returns(T::Boolean) } def will_save_change_to_state?; end @@ -857,6 +931,9 @@ class GoodJob::Process sig { returns(T::Array[::GoodJob::Process]) } def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } def to_ary; end end @@ -951,6 +1028,9 @@ class GoodJob::Process sig { returns(T::Array[::GoodJob::Process]) } def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } def to_ary; end end @@ -964,6 +1044,9 @@ class GoodJob::Process sig { returns(T::Array[::GoodJob::Process]) } def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Process]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/good_job/setting.rbi b/sorbet/rbi/dsl/good_job/setting.rbi index bb64b5c..a23fe81 100644 --- a/sorbet/rbi/dsl/good_job/setting.rbi +++ b/sorbet/rbi/dsl/good_job/setting.rbi @@ -866,6 +866,9 @@ class GoodJob::Setting sig { returns(T::Array[::GoodJob::Setting]) } def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } def to_ary; end end @@ -960,6 +963,9 @@ class GoodJob::Setting sig { returns(T::Array[::GoodJob::Setting]) } def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } def to_ary; end end @@ -973,6 +979,9 @@ class GoodJob::Setting sig { returns(T::Array[::GoodJob::Setting]) } def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } + def to_a; end + sig { returns(T::Array[::GoodJob::Setting]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/google_calendar_channel.rbi b/sorbet/rbi/dsl/google_calendar_channel.rbi index 37567cd..e2a8f51 100644 --- a/sorbet/rbi/dsl/google_calendar_channel.rbi +++ b/sorbet/rbi/dsl/google_calendar_channel.rbi @@ -1149,6 +1149,9 @@ class GoogleCalendarChannel sig { returns(T::Array[::GoogleCalendarChannel]) } def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } + def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } def to_ary; end end @@ -1243,6 +1246,9 @@ class GoogleCalendarChannel sig { returns(T::Array[::GoogleCalendarChannel]) } def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } + def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } def to_ary; end end @@ -1256,6 +1262,9 @@ class GoogleCalendarChannel sig { returns(T::Array[::GoogleCalendarChannel]) } def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } + def to_a; end + sig { returns(T::Array[::GoogleCalendarChannel]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/group.rbi b/sorbet/rbi/dsl/group.rbi index a3e359e..a055098 100644 --- a/sorbet/rbi/dsl/group.rbi +++ b/sorbet/rbi/dsl/group.rbi @@ -956,6 +956,9 @@ class Group sig { returns(T::Array[::Group]) } def to_a; end + sig { returns(T::Array[::Group]) } + def to_a; end + sig { returns(T::Array[::Group]) } def to_ary; end end @@ -1053,6 +1056,9 @@ class Group sig { returns(T::Array[::Group]) } def to_a; end + sig { returns(T::Array[::Group]) } + def to_a; end + sig { returns(T::Array[::Group]) } def to_ary; end end @@ -1069,6 +1075,9 @@ class Group sig { returns(T::Array[::Group]) } def to_a; end + sig { returns(T::Array[::Group]) } + def to_a; end + sig { returns(T::Array[::Group]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/group/habtm_activities.rbi b/sorbet/rbi/dsl/group/habtm_activities.rbi index 22e6d2d..89d672c 100644 --- a/sorbet/rbi/dsl/group/habtm_activities.rbi +++ b/sorbet/rbi/dsl/group/habtm_activities.rbi @@ -813,6 +813,9 @@ class Group::HABTM_Activities sig { returns(T::Array[::Group::HABTM_Activities]) } def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } + def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } def to_ary; end end @@ -907,6 +910,9 @@ class Group::HABTM_Activities sig { returns(T::Array[::Group::HABTM_Activities]) } def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } + def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } def to_ary; end end @@ -920,6 +926,9 @@ class Group::HABTM_Activities sig { returns(T::Array[::Group::HABTM_Activities]) } def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } + def to_a; end + sig { returns(T::Array[::Group::HABTM_Activities]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/group_membership.rbi b/sorbet/rbi/dsl/group_membership.rbi index b1f74cb..8046942 100644 --- a/sorbet/rbi/dsl/group_membership.rbi +++ b/sorbet/rbi/dsl/group_membership.rbi @@ -917,6 +917,9 @@ class GroupMembership sig { returns(T::Array[::GroupMembership]) } def to_a; end + sig { returns(T::Array[::GroupMembership]) } + def to_a; end + sig { returns(T::Array[::GroupMembership]) } def to_ary; end end @@ -1011,6 +1014,9 @@ class GroupMembership sig { returns(T::Array[::GroupMembership]) } def to_a; end + sig { returns(T::Array[::GroupMembership]) } + def to_a; end + sig { returns(T::Array[::GroupMembership]) } def to_ary; end end @@ -1024,6 +1030,9 @@ class GroupMembership sig { returns(T::Array[::GroupMembership]) } def to_a; end + sig { returns(T::Array[::GroupMembership]) } + def to_a; end + sig { returns(T::Array[::GroupMembership]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/import_activities_for_user_job.rbi b/sorbet/rbi/dsl/import_activities_for_user_job.rbi index 13ee835..d97dd81 100644 --- a/sorbet/rbi/dsl/import_activities_for_user_job.rbi +++ b/sorbet/rbi/dsl/import_activities_for_user_job.rbi @@ -6,8 +6,13 @@ class ImportActivitiesForUserJob class << self - sig { params(user: ::User).returns(T.any(ImportActivitiesForUserJob, FalseClass)) } - def perform_later(user); end + sig do + params( + user: ::User, + block: T.nilable(T.proc.params(job: ImportActivitiesForUserJob).void) + ).returns(T.any(ImportActivitiesForUserJob, FalseClass)) + end + def perform_later(user, &block); end sig { params(user: ::User).void } def perform_now(user); end diff --git a/sorbet/rbi/dsl/import_activities_job.rbi b/sorbet/rbi/dsl/import_activities_job.rbi index e25074e..a02f8d7 100644 --- a/sorbet/rbi/dsl/import_activities_job.rbi +++ b/sorbet/rbi/dsl/import_activities_job.rbi @@ -6,8 +6,13 @@ class ImportActivitiesJob class << self - sig { params(options: T.untyped).returns(T.any(ImportActivitiesJob, FalseClass)) } - def perform_later(**options); end + sig do + params( + options: T.untyped, + block: T.nilable(T.proc.params(job: ImportActivitiesJob).void) + ).returns(T.any(ImportActivitiesJob, FalseClass)) + end + def perform_later(**options, &block); end sig { params(options: T.untyped).void } def perform_now(**options); end diff --git a/sorbet/rbi/dsl/mobile_subscriber.rbi b/sorbet/rbi/dsl/mobile_subscriber.rbi index edcda56..1476a1b 100644 --- a/sorbet/rbi/dsl/mobile_subscriber.rbi +++ b/sorbet/rbi/dsl/mobile_subscriber.rbi @@ -866,6 +866,9 @@ class MobileSubscriber sig { returns(T::Array[::MobileSubscriber]) } def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } + def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } def to_ary; end end @@ -960,6 +963,9 @@ class MobileSubscriber sig { returns(T::Array[::MobileSubscriber]) } def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } + def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } def to_ary; end end @@ -973,6 +979,9 @@ class MobileSubscriber sig { returns(T::Array[::MobileSubscriber]) } def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } + def to_a; end + sig { returns(T::Array[::MobileSubscriber]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/mobile_subscription.rbi b/sorbet/rbi/dsl/mobile_subscription.rbi index 91b675c..b3b9528 100644 --- a/sorbet/rbi/dsl/mobile_subscription.rbi +++ b/sorbet/rbi/dsl/mobile_subscription.rbi @@ -876,6 +876,9 @@ class MobileSubscription sig { returns(T::Array[::MobileSubscription]) } def to_a; end + sig { returns(T::Array[::MobileSubscription]) } + def to_a; end + sig { returns(T::Array[::MobileSubscription]) } def to_ary; end end @@ -970,6 +973,9 @@ class MobileSubscription sig { returns(T::Array[::MobileSubscription]) } def to_a; end + sig { returns(T::Array[::MobileSubscription]) } + def to_a; end + sig { returns(T::Array[::MobileSubscription]) } def to_ary; end end @@ -983,6 +989,9 @@ class MobileSubscription sig { returns(T::Array[::MobileSubscription]) } def to_a; end + sig { returns(T::Array[::MobileSubscription]) } + def to_a; end + sig { returns(T::Array[::MobileSubscription]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/register_google_calendar_channel_for_user_job.rbi b/sorbet/rbi/dsl/register_google_calendar_channel_for_user_job.rbi index 622e918..7272def 100644 --- a/sorbet/rbi/dsl/register_google_calendar_channel_for_user_job.rbi +++ b/sorbet/rbi/dsl/register_google_calendar_channel_for_user_job.rbi @@ -6,8 +6,13 @@ class RegisterGoogleCalendarChannelForUserJob class << self - sig { params(user: ::User).returns(T.any(RegisterGoogleCalendarChannelForUserJob, FalseClass)) } - def perform_later(user); end + sig do + params( + user: ::User, + block: T.nilable(T.proc.params(job: RegisterGoogleCalendarChannelForUserJob).void) + ).returns(T.any(RegisterGoogleCalendarChannelForUserJob, FalseClass)) + end + def perform_later(user, &block); end sig { params(user: ::User).void } def perform_now(user); end diff --git a/sorbet/rbi/dsl/reservation.rbi b/sorbet/rbi/dsl/reservation.rbi index ffeccdc..e6e5a2f 100644 --- a/sorbet/rbi/dsl/reservation.rbi +++ b/sorbet/rbi/dsl/reservation.rbi @@ -1135,6 +1135,9 @@ class Reservation sig { returns(T::Array[::Reservation]) } def to_a; end + sig { returns(T::Array[::Reservation]) } + def to_a; end + sig { returns(T::Array[::Reservation]) } def to_ary; end end @@ -1229,6 +1232,9 @@ class Reservation sig { returns(T::Array[::Reservation]) } def to_a; end + sig { returns(T::Array[::Reservation]) } + def to_a; end + sig { returns(T::Array[::Reservation]) } def to_ary; end end @@ -1242,6 +1248,9 @@ class Reservation sig { returns(T::Array[::Reservation]) } def to_a; end + sig { returns(T::Array[::Reservation]) } + def to_a; end + sig { returns(T::Array[::Reservation]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/schedule_activity_mobile_notifications_job.rbi b/sorbet/rbi/dsl/schedule_activity_mobile_notifications_job.rbi index 6a2cc3b..a765e60 100644 --- a/sorbet/rbi/dsl/schedule_activity_mobile_notifications_job.rbi +++ b/sorbet/rbi/dsl/schedule_activity_mobile_notifications_job.rbi @@ -6,8 +6,13 @@ class ScheduleActivityMobileNotificationsJob class << self - sig { params(activity: ::Activity).returns(T.any(ScheduleActivityMobileNotificationsJob, FalseClass)) } - def perform_later(activity); end + sig do + params( + activity: ::Activity, + block: T.nilable(T.proc.params(job: ScheduleActivityMobileNotificationsJob).void) + ).returns(T.any(ScheduleActivityMobileNotificationsJob, FalseClass)) + end + def perform_later(activity, &block); end sig { params(activity: ::Activity).void } def perform_now(activity); end diff --git a/sorbet/rbi/dsl/scheduled_mobile_notification.rbi b/sorbet/rbi/dsl/scheduled_mobile_notification.rbi index abb6aad..3adb1e8 100644 --- a/sorbet/rbi/dsl/scheduled_mobile_notification.rbi +++ b/sorbet/rbi/dsl/scheduled_mobile_notification.rbi @@ -1069,6 +1069,9 @@ class ScheduledMobileNotification sig { returns(T::Array[::ScheduledMobileNotification]) } def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } + def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } def to_ary; end end @@ -1163,6 +1166,9 @@ class ScheduledMobileNotification sig { returns(T::Array[::ScheduledMobileNotification]) } def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } + def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } def to_ary; end end @@ -1176,6 +1182,9 @@ class ScheduledMobileNotification sig { returns(T::Array[::ScheduledMobileNotification]) } def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } + def to_a; end + sig { returns(T::Array[::ScheduledMobileNotification]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/send_mobile_subscriber_text_job.rbi b/sorbet/rbi/dsl/send_mobile_subscriber_text_job.rbi index c432eb3..6e39373 100644 --- a/sorbet/rbi/dsl/send_mobile_subscriber_text_job.rbi +++ b/sorbet/rbi/dsl/send_mobile_subscriber_text_job.rbi @@ -9,10 +9,11 @@ class SendMobileSubscriberTextJob sig do params( subscriber: ::MobileSubscriber, - message: ::String + message: ::String, + block: T.nilable(T.proc.params(job: SendMobileSubscriberTextJob).void) ).returns(T.any(SendMobileSubscriberTextJob, FalseClass)) end - def perform_later(subscriber, message); end + def perform_later(subscriber, message, &block); end sig { params(subscriber: ::MobileSubscriber, message: ::String).void } def perform_now(subscriber, message); end diff --git a/sorbet/rbi/dsl/send_scheduled_mobile_notification_texts_job.rbi b/sorbet/rbi/dsl/send_scheduled_mobile_notification_texts_job.rbi index d1688fe..b299229 100644 --- a/sorbet/rbi/dsl/send_scheduled_mobile_notification_texts_job.rbi +++ b/sorbet/rbi/dsl/send_scheduled_mobile_notification_texts_job.rbi @@ -6,8 +6,12 @@ class SendScheduledMobileNotificationTextsJob class << self - sig { returns(T.any(SendScheduledMobileNotificationTextsJob, FalseClass)) } - def perform_later; end + sig do + params( + block: T.nilable(T.proc.params(job: SendScheduledMobileNotificationTextsJob).void) + ).returns(T.any(SendScheduledMobileNotificationTextsJob, FalseClass)) + end + def perform_later(&block); end sig { void } def perform_now; end diff --git a/sorbet/rbi/dsl/sentry/send_event_job.rbi b/sorbet/rbi/dsl/sentry/send_event_job.rbi index be3c086..a22c38c 100644 --- a/sorbet/rbi/dsl/sentry/send_event_job.rbi +++ b/sorbet/rbi/dsl/sentry/send_event_job.rbi @@ -6,8 +6,14 @@ class Sentry::SendEventJob class << self - sig { params(event: T.untyped, hint: T.untyped).returns(T.any(Sentry::SendEventJob, FalseClass)) } - def perform_later(event, hint = T.unsafe(nil)); end + sig do + params( + event: T.untyped, + hint: T.untyped, + block: T.nilable(T.proc.params(job: Sentry::SendEventJob).void) + ).returns(T.any(Sentry::SendEventJob, FalseClass)) + end + def perform_later(event, hint = T.unsafe(nil), &block); end sig { params(event: T.untyped, hint: T.untyped).returns(T.untyped) } def perform_now(event, hint = T.unsafe(nil)); end diff --git a/sorbet/rbi/dsl/subscription.rbi b/sorbet/rbi/dsl/subscription.rbi index 557eba3..a6cfeda 100644 --- a/sorbet/rbi/dsl/subscription.rbi +++ b/sorbet/rbi/dsl/subscription.rbi @@ -982,6 +982,9 @@ class Subscription sig { returns(T::Array[::Subscription]) } def to_a; end + sig { returns(T::Array[::Subscription]) } + def to_a; end + sig { returns(T::Array[::Subscription]) } def to_ary; end end @@ -1076,6 +1079,9 @@ class Subscription sig { returns(T::Array[::Subscription]) } def to_a; end + sig { returns(T::Array[::Subscription]) } + def to_a; end + sig { returns(T::Array[::Subscription]) } def to_ary; end end @@ -1089,6 +1095,9 @@ class Subscription sig { returns(T::Array[::Subscription]) } def to_a; end + sig { returns(T::Array[::Subscription]) } + def to_a; end + sig { returns(T::Array[::Subscription]) } def to_ary; end end diff --git a/sorbet/rbi/dsl/sync_google_calendar_channels_job.rbi b/sorbet/rbi/dsl/sync_google_calendar_channels_job.rbi index 137b167..4f459c8 100644 --- a/sorbet/rbi/dsl/sync_google_calendar_channels_job.rbi +++ b/sorbet/rbi/dsl/sync_google_calendar_channels_job.rbi @@ -6,8 +6,12 @@ class SyncGoogleCalendarChannelsJob class << self - sig { returns(T.any(SyncGoogleCalendarChannelsJob, FalseClass)) } - def perform_later; end + sig do + params( + block: T.nilable(T.proc.params(job: SyncGoogleCalendarChannelsJob).void) + ).returns(T.any(SyncGoogleCalendarChannelsJob, FalseClass)) + end + def perform_later(&block); end sig { void } def perform_now; end diff --git a/sorbet/rbi/dsl/user.rbi b/sorbet/rbi/dsl/user.rbi index f29540a..e6c676e 100644 --- a/sorbet/rbi/dsl/user.rbi +++ b/sorbet/rbi/dsl/user.rbi @@ -2258,6 +2258,9 @@ class User sig { returns(T::Array[::User]) } def to_a; end + sig { returns(T::Array[::User]) } + def to_a; end + sig { returns(T::Array[::User]) } def to_ary; end end @@ -2355,6 +2358,9 @@ class User sig { returns(T::Array[::User]) } def to_a; end + sig { returns(T::Array[::User]) } + def to_a; end + sig { returns(T::Array[::User]) } def to_ary; end end @@ -2371,6 +2377,9 @@ class User sig { returns(T::Array[::User]) } def to_a; end + sig { returns(T::Array[::User]) } + def to_a; end + sig { returns(T::Array[::User]) } def to_ary; end end diff --git a/sorbet/rbi/gems/good_job@3.19.1.rbi b/sorbet/rbi/gems/good_job@3.99.1.rbi similarity index 80% rename from sorbet/rbi/gems/good_job@3.19.1.rbi rename to sorbet/rbi/gems/good_job@3.99.1.rbi index 1bd8b2b..9d08cb9 100644 --- a/sorbet/rbi/gems/good_job@3.19.1.rbi +++ b/sorbet/rbi/gems/good_job@3.99.1.rbi @@ -35,13 +35,15 @@ class ActiveJob::QueueAdapters::GoodJobAdapter < ::GoodJob::Adapter; end # source://good_job//lib/good_job/version.rb#3 module GoodJob include ::GoodJob::Dependencies + include ::GoodJob::ThreadStatus include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor extend ::GoodJob::Dependencies::ClassMethods + extend ::GoodJob::ThreadStatus::ClassMethods - # source://good_job//lib/good_job.rb#124 + # source://good_job//lib/good_job.rb#136 def _active_record_configuration; end - # source://good_job//lib/good_job.rb#124 + # source://good_job//lib/good_job.rb#136 def _active_record_configuration=(val); end # source://good_job//lib/good_job/dependencies.rb#9 @@ -50,53 +52,53 @@ module GoodJob # source://good_job//lib/good_job/dependencies.rb#9 def _framework_ready=(val); end - # source://good_job//lib/good_job.rb#54 + # source://good_job//lib/good_job.rb#66 def active_record_parent_class; end - # source://good_job//lib/good_job.rb#54 + # source://good_job//lib/good_job.rb#66 def active_record_parent_class=(val); end - # source://good_job//lib/good_job.rb#104 + # source://good_job//lib/good_job.rb#116 def capsule; end - # source://good_job//lib/good_job.rb#104 + # source://good_job//lib/good_job.rb#116 def capsule=(val); end - # source://good_job//lib/good_job.rb#98 + # source://good_job//lib/good_job.rb#110 def configuration; end - # source://good_job//lib/good_job.rb#98 + # source://good_job//lib/good_job.rb#110 def configuration=(val); end - # source://good_job//lib/good_job.rb#63 + # source://good_job//lib/good_job.rb#75 def logger; end - # source://good_job//lib/good_job.rb#63 + # source://good_job//lib/good_job.rb#75 def logger=(val); end - # source://good_job//lib/good_job.rb#92 + # source://good_job//lib/good_job.rb#104 def on_thread_error; end - # source://good_job//lib/good_job.rb#92 + # source://good_job//lib/good_job.rb#104 def on_thread_error=(val); end - # source://good_job//lib/good_job.rb#73 + # source://good_job//lib/good_job.rb#85 def preserve_job_records; end - # source://good_job//lib/good_job.rb#73 + # source://good_job//lib/good_job.rb#85 def preserve_job_records=(val); end - # source://good_job//lib/good_job.rb#82 + # source://good_job//lib/good_job.rb#94 def retry_on_unhandled_error; end - # source://good_job//lib/good_job.rb#82 + # source://good_job//lib/good_job.rb#94 def retry_on_unhandled_error=(val); end class << self - # source://good_job//lib/good_job.rb#124 + # source://good_job//lib/good_job.rb#136 def _active_record_configuration; end - # source://good_job//lib/good_job.rb#124 + # source://good_job//lib/good_job.rb#136 def _active_record_configuration=(val); end # source://good_job//lib/good_job/dependencies.rb#9 @@ -110,18 +112,19 @@ module GoodJob # @param exception [Exception] Exception that was raised # @return [void] # - # source://good_job//lib/good_job.rb#109 + # source://good_job//lib/good_job.rb#121 def _on_thread_error(exception); end # Sends +#shutdown+ or +#restart+ to executable objects ({GoodJob::Notifier}, {GoodJob::Poller}, {GoodJob::Scheduler}, {GoodJob::MultiScheduler}, {GoodJob::CronManager}) # - # @param executables [Array] Objects to shut down. + # @param executables [Array] Objects to shut down. # @param method_name [:symbol] Method to call, e.g. +:shutdown+ or +:restart+. # @param timeout [nil, Numeric] + # @param after [Array] Objects to shut down after initial executables shut down. # @return [void] # - # source://good_job//lib/good_job.rb#165 - def _shutdown_all(executables, method_name = T.unsafe(nil), timeout: T.unsafe(nil)); end + # source://good_job//lib/good_job.rb#178 + def _shutdown_all(executables, method_name = T.unsafe(nil), timeout: T.unsafe(nil), after: T.unsafe(nil)); end # The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+). # Use this when using multiple databases or other custom ActiveRecord configuration. @@ -130,7 +133,7 @@ module GoodJob # GoodJob.active_record_parent_class = "CustomApplicationRecord" # @return [ActiveRecord::Base] # - # source://good_job//lib/good_job.rb#54 + # source://good_job//lib/good_job.rb#66 def active_record_parent_class; end # The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+). @@ -140,21 +143,21 @@ module GoodJob # GoodJob.active_record_parent_class = "CustomApplicationRecord" # @return [ActiveRecord::Base] # - # source://good_job//lib/good_job.rb#54 + # source://good_job//lib/good_job.rb#66 def active_record_parent_class=(val); end # Global/default execution capsule for GoodJob. # # @return [GoodJob::Capsule, nil] # - # source://good_job//lib/good_job.rb#104 + # source://good_job//lib/good_job.rb#116 def capsule; end # Global/default execution capsule for GoodJob. # # @return [GoodJob::Capsule, nil] # - # source://good_job//lib/good_job.rb#104 + # source://good_job//lib/good_job.rb#116 def capsule=(val); end # Destroys preserved job and batch records. @@ -168,21 +171,21 @@ module GoodJob # @param older_than [nil, Numeric, ActiveSupport::Duration] Jobs older than this will be destroyed (default: +86400+). # @return [Integer] Number of job execution records and batches that were destroyed. # - # source://good_job//lib/good_job.rb#185 + # source://good_job//lib/good_job.rb#205 def cleanup_preserved_jobs(older_than: T.unsafe(nil), in_batches_of: T.unsafe(nil)); end # Global configuration object for GoodJob. # # @return [GoodJob::Configuration, nil] # - # source://good_job//lib/good_job.rb#98 + # source://good_job//lib/good_job.rb#110 def configuration; end # Global configuration object for GoodJob. # # @return [GoodJob::Configuration, nil] # - # source://good_job//lib/good_job.rb#98 + # source://good_job//lib/good_job.rb#110 def configuration=(val); end # Custom Active Record configuration that is class_eval'ed into +GoodJob::BaseRecord+ @@ -194,14 +197,14 @@ module GoodJob # @param block Custom Active Record configuration # @return [void] # - # source://good_job//lib/good_job.rb#121 + # source://good_job//lib/good_job.rb#133 def configure_active_record(&block); end # Deprecator for providing deprecation warnings. # # @return [ActiveSupport::Deprecation] # - # source://good_job//lib/good_job.rb#248 + # source://good_job//lib/good_job.rb#280 def deprecator; end # The logger used by GoodJob (default: +Rails.logger+). @@ -211,7 +214,7 @@ module GoodJob # GoodJob.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new("log/my_logs.log")) # @return [Logger, nil] # - # source://good_job//lib/good_job.rb#63 + # source://good_job//lib/good_job.rb#75 def logger; end # The logger used by GoodJob (default: +Rails.logger+). @@ -221,7 +224,7 @@ module GoodJob # GoodJob.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new("log/my_logs.log")) # @return [Logger, nil] # - # source://good_job//lib/good_job.rb#63 + # source://good_job//lib/good_job.rb#75 def logger=(val); end # Whether all GoodJob migrations have been applied. @@ -229,7 +232,7 @@ module GoodJob # # @return [Boolean] # - # source://good_job//lib/good_job.rb#261 + # source://good_job//lib/good_job.rb#293 def migrated?; end # This callable will be called when an exception reaches GoodJob (default: +nil+). @@ -240,7 +243,7 @@ module GoodJob # GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) } # @return [Proc, nil] # - # source://good_job//lib/good_job.rb#92 + # source://good_job//lib/good_job.rb#104 def on_thread_error; end # This callable will be called when an exception reaches GoodJob (default: +nil+). @@ -251,7 +254,7 @@ module GoodJob # GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) } # @return [Proc, nil] # - # source://good_job//lib/good_job.rb#92 + # source://good_job//lib/good_job.rb#104 def on_thread_error=(val); end # Perform all queued jobs in the current thread. @@ -259,10 +262,11 @@ module GoodJob # Unhandled job errors will be raised. # # @param queue_string [String] Queues to execute jobs from + # @param limit [Integer, nil] Maximum number of iterations for the loop # @return [void] # - # source://good_job//lib/good_job.rb#237 - def perform_inline(queue_string = T.unsafe(nil)); end + # source://good_job//lib/good_job.rb#258 + def perform_inline(queue_string = T.unsafe(nil), limit: T.unsafe(nil)); end # Whether to preserve job records in the database after they have finished (default: +true+). # If you want to preserve jobs for latter inspection, set this to +true+. @@ -272,7 +276,7 @@ module GoodJob # # @return [Boolean, Symbol, nil] # - # source://good_job//lib/good_job.rb#73 + # source://good_job//lib/good_job.rb#85 def preserve_job_records; end # Whether to preserve job records in the database after they have finished (default: +true+). @@ -283,7 +287,7 @@ module GoodJob # # @return [Boolean, Symbol, nil] # - # source://good_job//lib/good_job.rb#73 + # source://good_job//lib/good_job.rb#85 def preserve_job_records=(val); end # source://railties/7.0.8/lib/rails/engine.rb#405 @@ -304,7 +308,7 @@ module GoodJob # @param timeout [Numeric] Seconds to wait for active threads to finish. # @return [void] # - # source://good_job//lib/good_job.rb#154 + # source://good_job//lib/good_job.rb#166 def restart(timeout: T.unsafe(nil)); end # Whether to re-perform a job when a type of +StandardError+ is raised to GoodJob (default: +false+). @@ -314,7 +318,7 @@ module GoodJob # # @return [Boolean, nil] # - # source://good_job//lib/good_job.rb#82 + # source://good_job//lib/good_job.rb#94 def retry_on_unhandled_error; end # Whether to re-perform a job when a type of +StandardError+ is raised to GoodJob (default: +false+). @@ -324,7 +328,7 @@ module GoodJob # # @return [Boolean, nil] # - # source://good_job//lib/good_job.rb#82 + # source://good_job//lib/good_job.rb#94 def retry_on_unhandled_error=(val); end # Stop executing jobs. @@ -340,14 +344,14 @@ module GoodJob # * +1..+, the scheduler will wait that many seconds before stopping any remaining active tasks. # @return [void] # - # source://good_job//lib/good_job.rb#137 + # source://good_job//lib/good_job.rb#149 def shutdown(timeout: T.unsafe(nil)); end # Tests whether jobs have stopped executing. # # @return [Boolean] whether background threads are shut down # - # source://good_job//lib/good_job.rb#143 + # source://good_job//lib/good_job.rb#155 def shutdown?; end # source://railties/7.0.8/lib/rails/engine.rb#397 @@ -355,6 +359,13 @@ module GoodJob # source://railties/7.0.8/lib/rails/engine.rb#401 def use_relative_model_naming?; end + + # Tests whether GoodJob can be safely upgraded to v4 + # + # @return [Boolean] + # + # source://good_job//lib/good_job.rb#274 + def v4_ready?; end end end @@ -365,10 +376,10 @@ module GoodJob::ActiveJobExtensions; end module GoodJob::ActiveJobExtensions::Batches extend ::ActiveSupport::Concern - # source://good_job//lib/good_job/active_job_extensions/batches.rb#8 + # source://good_job//lib/good_job/active_job_extensions/batches.rb#14 def batch; end - # source://good_job//lib/good_job/active_job_extensions/batches.rb#8 + # source://good_job//lib/good_job/active_job_extensions/batches.rb#14 def batch?; end end @@ -385,19 +396,26 @@ module GoodJob::ActiveJobExtensions::Concurrency # @raise [TypeError] # @return [Object] concurrency key # - # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#92 + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#125 def _good_job_concurrency_key; end + # Generates the default concurrency key when the configuration doesn't provide one + # + # @return [String] concurrency key + # + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#139 + def _good_job_default_concurrency_key; end + # Existing or dynamically generated concurrency key # # @return [Object] concurrency key # - # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#86 + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#119 def good_job_concurrency_key; end private - # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#104 + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#145 def good_job_enqueue_concurrency_check(job, on_abort:, on_enqueue:); end module GeneratedClassMethods @@ -411,7 +429,7 @@ end # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#0 module GoodJob::ActiveJobExtensions::Concurrency::ClassMethods - # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#79 + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#112 def good_job_control_concurrency_with(config); end end @@ -421,12 +439,15 @@ class GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError < ::St def backtrace; end end -# source://good_job//lib/good_job/active_job_extensions/concurrency.rb#16 +# source://good_job//lib/good_job/active_job_extensions/concurrency.rb#18 module GoodJob::ActiveJobExtensions::Concurrency::Prepends - # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#17 + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#19 def deserialize(job_data); end end +# source://good_job//lib/good_job/active_job_extensions/concurrency.rb#16 +class GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError < ::GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError; end + # source://good_job//lib/good_job/active_job_extensions/concurrency.rb#8 GoodJob::ActiveJobExtensions::Concurrency::VALID_TYPES = T.let(T.unsafe(nil), Array) @@ -435,6 +456,33 @@ module GoodJob::ActiveJobExtensions::InterruptErrors extend ::ActiveSupport::Concern end +# source://good_job//lib/good_job/active_job_extensions/labels.rb#5 +module GoodJob::ActiveJobExtensions::Labels + extend ::ActiveSupport::Concern + include GeneratedInstanceMethods + + mixes_in_class_methods GeneratedClassMethods + + module GeneratedClassMethods + def good_job_labels; end + def good_job_labels=(value); end + end + + module GeneratedInstanceMethods; end +end + +# source://good_job//lib/good_job/active_job_extensions/labels.rb#8 +module GoodJob::ActiveJobExtensions::Labels::Prepends + # source://good_job//lib/good_job/active_job_extensions/labels.rb#9 + def initialize(*arguments); end + + # source://good_job//lib/good_job/active_job_extensions/labels.rb#19 + def deserialize(job_data); end + + # source://good_job//lib/good_job/active_job_extensions/labels.rb#14 + def enqueue(options = T.unsafe(nil)); end +end + # Allows configuring whether GoodJob should emit a NOTIFY event when a job is enqueued. # Configuration will apply either globally to the Job Class, or individually to jobs # on initial enqueue and subsequent retries. @@ -442,7 +490,7 @@ end # @example # # Include the concern to your job class: # class MyJob < ApplicationJob -# include GoodJob::ActiveJobExtensions::Notify +# include GoodJob::ActiveJobExtensions::NotifyOptions # self.good_job_notify = false # end # @@ -504,7 +552,7 @@ class GoodJob::Adapter # # @return [Boolean] # - # source://good_job//lib/good_job/adapter.rb#216 + # source://good_job//lib/good_job/adapter.rb#252 def async_started?; end # Enqueues the ActiveJob job to be performed. @@ -516,12 +564,20 @@ class GoodJob::Adapter # source://good_job//lib/good_job/adapter.rb#41 def enqueue(active_job); end + # Defines if enqueueing this job from inside an Active Record transaction + # automatically defers the enqueue to after the transaction commit. + # + # @return [Boolean] + # + # source://good_job//lib/good_job/adapter.rb#47 + def enqueue_after_transaction_commit?; end + # Enqueues multiple ActiveJob instances at once # # @param active_jobs [Array] jobs to be enqueued # @return [Integer] number of jobs that were successfully enqueued # - # source://good_job//lib/good_job/adapter.rb#48 + # source://good_job//lib/good_job/adapter.rb#54 def enqueue_all(active_jobs); end # Enqueues an ActiveJob job to be run at a specific time. @@ -531,61 +587,61 @@ class GoodJob::Adapter # @param timestamp [Integer, nil] the epoch time to perform the job # @return [GoodJob::Execution] # - # source://good_job//lib/good_job/adapter.rb#133 + # source://good_job//lib/good_job/adapter.rb#150 def enqueue_at(active_job, timestamp); end # Whether in +:async+ execution mode. # # @return [Boolean] # - # source://good_job//lib/good_job/adapter.rb#186 + # source://good_job//lib/good_job/adapter.rb#222 def execute_async?; end # Whether in +:external+ execution mode. # # @return [Boolean] # - # source://good_job//lib/good_job/adapter.rb#193 + # source://good_job//lib/good_job/adapter.rb#229 def execute_externally?; end # Whether in +:inline+ execution mode. # # @return [Boolean] # - # source://good_job//lib/good_job/adapter.rb#201 + # source://good_job//lib/good_job/adapter.rb#237 def execute_inline?; end # This adapter's execution mode # # @return [Symbol, nil] # - # source://good_job//lib/good_job/adapter.rb#180 + # source://good_job//lib/good_job/adapter.rb#216 def execution_mode; end # Shut down the thread pool executors. # - # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads. + # @param timeout [nil, Numeric, NONE] Seconds to wait for active threads. # * +nil+ trigger a shutdown but not wait for it to complete. # * +-1+ wait until the shutdown is complete. # * +0+ immediately shutdown and stop any threads. # * A positive number will wait that many seconds before stopping any remaining active threads. # @return [void] # - # source://good_job//lib/good_job/adapter.rb#173 + # source://good_job//lib/good_job/adapter.rb#209 def shutdown(timeout: T.unsafe(nil)); end # Start async executors # # @return [void] # - # source://good_job//lib/good_job/adapter.rb#207 + # source://good_job//lib/good_job/adapter.rb#243 def start_async; end private # @return [Boolean] # - # source://good_job//lib/good_job/adapter.rb#222 + # source://good_job//lib/good_job/adapter.rb#258 def send_notify?(active_job); end class << self @@ -683,44 +739,19 @@ module GoodJob::ApplicationController::HelperMethods include ::ViteRails::TagHelpers include ::InertiaRails::Helper include ::ActionController::Base::HelperMethods + include ::GoodJob::IconsHelper include ::GoodJob::ApplicationHelper end module GoodJob::ApplicationHelper + include ::GoodJob::IconsHelper + def format_duration(sec); end def relative_time(timestamp, **options); end - def render_icon(name); end - def status_badge(status); end - def status_icon(status, **options); end def translate_hash(key, **options); end def translation_exists?(key, **options); end end -GoodJob::ApplicationHelper::STATUS_COLOR = T.let(T.unsafe(nil), Hash) -GoodJob::ApplicationHelper::STATUS_ICONS = T.let(T.unsafe(nil), Hash) - -# Extends an ActiveRecord odel to override the connection and use -# an explicit connection that has been removed from the pool. -# -# source://good_job//lib/good_job/assignable_connection.rb#6 -module GoodJob::AssignableConnection - extend ::ActiveSupport::Concern - - mixes_in_class_methods ::GoodJob::AssignableConnection::ClassMethods -end - -# source://good_job//lib/good_job/assignable_connection.rb#0 -module GoodJob::AssignableConnection::ClassMethods - # source://good_job//lib/good_job/assignable_connection.rb#23 - def connection; end - - # source://good_job//lib/good_job/assignable_connection.rb#17 - def connection=(conn); end - - # source://good_job//lib/good_job/assignable_connection.rb#30 - def with_connection(conn); end -end - class GoodJob::BaseExecution < ::GoodJob::BaseRecord include ::GoodJob::BaseExecution::GeneratedAttributeMethods include ::GoodJob::BaseExecution::GeneratedAssociationMethods @@ -731,26 +762,80 @@ class GoodJob::BaseExecution < ::GoodJob::BaseRecord extend ::GoodJob::AdvisoryLockable::ClassMethods extend ::GoodJob::Filterable::ClassMethods + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#940 + def _perform_callbacks; end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#940 + def _perform_unlocked_callbacks; end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#928 + def _run_perform_callbacks(&block); end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#928 + def _run_perform_unlocked_callbacks(&block); end + def active_job(ignore_deserialization_errors: T.unsafe(nil)); end def advisory_lockable_function; end def advisory_lockable_function=(_arg0); end def advisory_lockable_function?; end + + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def autosave_associated_records_for_batch(*args); end + + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def autosave_associated_records_for_discrete_executions(*args); end + def create_with_advisory_lock; end def create_with_advisory_lock=(_arg0); end + def destroy_job; end def discrete?; end + def display_serialized_params; end + def executable?; end def job_class; end + def job_state; end + def make_discrete; end + def number; end + def perform(lock_id:); end + def queue_latency; end + def running?; end + def runtime_latency; end + + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def validate_associated_records_for_discrete_executions(*args); end private def active_job_data; end + def continue_discard_or_finish_batch; end + def reset_batch_values(&block); end class << self # source://activesupport/7.0.8/lib/active_support/callbacks.rb#68 def __callbacks; end + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#932 + def _perform_callbacks; end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#936 + def _perform_callbacks=(value); end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#932 + def _perform_unlocked_callbacks; end + + # source://activesupport/7.0.8/lib/active_support/callbacks.rb#936 + def _perform_unlocked_callbacks=(value); end + + # source://activerecord/7.0.8/lib/active_record/reflection.rb#11 + def _reflections; end + # source://activemodel/7.0.8/lib/active_model/validations.rb#52 def _validators; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def active_job_id(*args, **_arg1); end + + def active_job_id_index_removal_migrated?; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def advisory_lock(*args, **_arg1); end @@ -767,18 +852,50 @@ class GoodJob::BaseExecution < ::GoodJob::BaseRecord # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def advisory_unlocked(*args, **_arg1); end + # source://activemodel/7.0.8/lib/active_model/callbacks.rb#144 + def after_perform(*args, **options, &block); end + + # source://activemodel/7.0.8/lib/active_model/callbacks.rb#144 + def after_perform_unlocked(*args, **options, &block); end + + # source://activemodel/7.0.8/lib/active_model/callbacks.rb#137 + def around_perform(*args, **options, &block); end + + # source://activemodel/7.0.8/lib/active_model/callbacks.rb#130 + def before_perform(*args, **options, &block); end + + def build_for_enqueue(active_job, overrides = T.unsafe(nil)); end + def candidate_lookup_index_migrated?; end def coalesce_scheduled_at_created_at; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def creation_ordered(*args, **_arg1); end + + def cron_indices_migrated?; end + # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def dequeueing_ordered(*args, **_arg1); end + def discrete_support?; end # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def display_all(*args, **_arg1); end + def enqueue(active_job, scheduled_at: T.unsafe(nil), create_with_advisory_lock: T.unsafe(nil)); end + def enqueue_args(active_job, overrides = T.unsafe(nil)); end def error_event_migrated?; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def finished(*args, **_arg1); end + + def format_error(error); end + + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def includes_advisory_locks(*args, **_arg1); end @@ -789,20 +906,91 @@ class GoodJob::BaseExecution < ::GoodJob::BaseRecord def joins_advisory_locks(*args, **_arg1); end def json_string(json, attr); end + def labels_indices_migrated?; end + def labels_migrated?; end + def next_scheduled_at(after: T.unsafe(nil), limit: T.unsafe(nil), now_limit: T.unsafe(nil)); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def only_scheduled(*args, **_arg1); end # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def owns_advisory_locked(*args, **_arg1); end def params_execution_count; end def params_job_class; end + def perform_with_advisory_lock(lock_id:, parsed_queues: T.unsafe(nil), queue_select_limit: T.unsafe(nil)); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def priority_ordered(*args, **_arg1); end + + def process_lock_migrated?; end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def queue_ordered(*args, **_arg1); end + + def queue_parser(string); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def queue_string(*args, **_arg1); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def running(*args, **_arg1); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def schedule_ordered(*args, **_arg1); end # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def search_text(*args, **_arg1); end + + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def unfinished(*args, **_arg1); end end end -module GoodJob::BaseExecution::GeneratedAssociationMethods; end +GoodJob::BaseExecution::DEFAULT_PRIORITY = T.let(T.unsafe(nil), Integer) +GoodJob::BaseExecution::DEFAULT_QUEUE_NAME = T.let(T.unsafe(nil), String) +GoodJob::BaseExecution::ERROR_MESSAGE_SEPARATOR = T.let(T.unsafe(nil), String) + +module GoodJob::BaseExecution::GeneratedAssociationMethods + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 + def batch; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 + def batch=(value); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#132 + def batch_changed?; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#136 + def batch_previously_changed?; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#28 + def build_batch(*args, &block); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#32 + def create_batch(*args, &block); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#36 + def create_batch!(*args, &block); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#62 + def discrete_execution_ids; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#72 + def discrete_execution_ids=(ids); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 + def discrete_executions; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 + def discrete_executions=(value); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#19 + def reload_batch; end +end + module GoodJob::BaseExecution::GeneratedAttributeMethods; end +class GoodJob::BaseExecution::PreviouslyPerformedError < ::StandardError; end class GoodJob::BaseFilter def initialize(params, base_query = T.unsafe(nil)); end @@ -817,6 +1005,7 @@ class GoodJob::BaseFilter def params=(_arg0); end def queues; end def records; end + def state_names; end def states; end def to_params(override = T.unsafe(nil)); end @@ -837,6 +1026,8 @@ class GoodJob::BaseRecord < ::ActiveRecord::Base # source://activemodel/7.0.8/lib/active_model/validations.rb#52 def _validators; end + def bind_value(name, value, type_class); end + # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end @@ -1093,6 +1284,12 @@ class GoodJob::BatchRecord < ::GoodJob::BaseRecord # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def finished(*args, **_arg1); end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 + def finished_before(*args, **_arg1); end + + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def includes_advisory_locks(*args, **_arg1); end @@ -1196,7 +1393,7 @@ module GoodJob::Bulk # Capture jobs to a buffer. Pass either a block, or specific Active Jobs to be buffered. # # @param active_jobs [Array] Active Jobs to be buffered. - # @param queue_adapter Override the jobs implict queue adapter with an explicit one. + # @param queue_adapter Override the jobs implicit queue adapter with an explicit one. # @raise [ArgumentError] # @return [nil, Array] The ActiveJob instances that have been buffered; nil if no active buffer # @@ -1275,65 +1472,65 @@ class GoodJob::CLI < ::Thor # # @return [void] # - # source://good_job//lib/good_job/cli.rb#141 + # source://good_job//lib/good_job/cli.rb#156 def cleanup_preserved_jobs; end - # source://good_job//lib/good_job/cli.rb#154 + # source://good_job//lib/good_job/cli.rb#169 def set_up_application!; end # The +good_job start+ command. Executes queued jobs. # # @return [void] # - # source://good_job//lib/good_job/cli.rb#92 + # source://good_job//lib/good_job/cli.rb#105 def start; end class << self # @return [Boolean] # - # source://good_job//lib/good_job/cli.rb#32 + # source://good_job//lib/good_job/cli.rb#38 def exit_on_failure?; end # Whether to log to STDOUT # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#28 + # source://good_job//lib/good_job/cli.rb#34 def log_to_stdout; end # Whether to log to STDOUT # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#28 + # source://good_job//lib/good_job/cli.rb#34 def log_to_stdout=(_arg0); end # Whether to log to STDOUT # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#28 + # source://good_job//lib/good_job/cli.rb#34 def log_to_stdout?; end # Whether the CLI is running from the executable # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#23 + # source://good_job//lib/good_job/cli.rb#29 def within_exe; end # Whether the CLI is running from the executable # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#23 + # source://good_job//lib/good_job/cli.rb#29 def within_exe=(_arg0); end # Whether the CLI is running from the executable # # @return [Boolean, nil] # - # source://good_job//lib/good_job/cli.rb#23 + # source://good_job//lib/good_job/cli.rb#29 def within_exe?; end end end @@ -1344,6 +1541,16 @@ end # source://good_job//lib/good_job/cli.rb#18 GoodJob::CLI::RAILS_ENVIRONMENT_RB = T.let(T.unsafe(nil), String) +# Number of seconds between checking shutdown conditions +# +# source://good_job//lib/good_job/cli.rb#21 +GoodJob::CLI::SHUTDOWN_EVENT_TIMEOUT = T.let(T.unsafe(nil), Integer) + +# Number of seconds between checking shutdown conditions when idle-timeout is enabled +# +# source://good_job//lib/good_job/cli.rb#24 +GoodJob::CLI::SHUTDOWN_EVENT_TIMEOUT_FOR_IDLE_TIMEOUT = T.let(T.unsafe(nil), Integer) + # An object that has case-equality to a Proc or Lambda by responding to #call. # This can be used to duck-type match in a case statement. # @@ -1366,60 +1573,93 @@ class GoodJob::Capsule # @param configuration [GoodJob::Configuration] Configuration to use for this capsule. # @return [Capsule] a new instance of Capsule # - # source://good_job//lib/good_job/capsule.rb#15 + # source://good_job//lib/good_job/capsule.rb#19 def initialize(configuration: T.unsafe(nil)); end + # source://good_job//lib/good_job/capsule.rb#14 + def _tracker_id_for_lock(*_arg0, **_arg1, &_arg2); end + + # source://good_job//lib/good_job/capsule.rb#14 + def _tracker_register(*_arg0, **_arg1, &_arg2); end + + # source://good_job//lib/good_job/capsule.rb#14 + def _tracker_renew(*_arg0, **_arg1, &_arg2); end + + # source://good_job//lib/good_job/capsule.rb#14 + def _tracker_unregister(*_arg0, **_arg1, &_arg2); end + # Creates an execution thread(s) with the given attributes. # # @param job_state [Hash, nil] See {GoodJob::Scheduler#create_thread}. # @return [Boolean, nil] Whether the thread was created. # - # source://good_job//lib/good_job/capsule.rb#83 + # source://good_job//lib/good_job/capsule.rb#102 def create_thread(job_state = T.unsafe(nil)); end + # @param duration [nil, Numeric] Length of idleness to check for (in seconds). + # @return [Boolean] Whether the capsule is idle + # + # source://good_job//lib/good_job/capsule.rb#87 + def idle?(duration = T.unsafe(nil)); end + + # UUID for this capsule; to be used for inspection (not directly for locking jobs). + # + # @return [String] + # + # source://good_job//lib/good_job/capsule.rb#109 + def process_id; end + # Shutdown and then start the capsule again. # - # @param timeout [Numeric, Symbol] Seconds to wait for active threads. + # @param timeout [Numeric, NONE] Seconds to wait for active threads. # @raise [ArgumentError] # @return [void] # - # source://good_job//lib/good_job/capsule.rb#63 + # source://good_job//lib/good_job/capsule.rb#68 def restart(timeout: T.unsafe(nil)); end # @return [Boolean] Whether the capsule is currently running. # - # source://good_job//lib/good_job/capsule.rb#71 + # source://good_job//lib/good_job/capsule.rb#76 def running?; end # Shut down the thread pool executors. # - # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads. + # @param timeout [nil, Numeric, NONE] Seconds to wait for active threads. # * +-1+ will wait for all active threads to complete. # * +0+ will interrupt active threads. # * +N+ will wait at most N seconds and then interrupt active threads. # * +nil+ will trigger a shutdown but not wait for it to complete. # @return [void] # - # source://good_job//lib/good_job/capsule.rb#53 + # source://good_job//lib/good_job/capsule.rb#58 def shutdown(timeout: T.unsafe(nil)); end # @return [Boolean] Whether the capsule has been shutdown. # - # source://good_job//lib/good_job/capsule.rb#76 + # source://good_job//lib/good_job/capsule.rb#81 def shutdown?; end # Start the capsule once. After a shutdown, {#restart} must be used to start again. # # @return [nil, Boolean] Whether the capsule was started. # - # source://good_job//lib/good_job/capsule.rb#26 + # source://good_job//lib/good_job/capsule.rb#33 def start(force: T.unsafe(nil)); end + # Returns the value of attribute tracker. + # + # source://good_job//lib/good_job/capsule.rb#16 + def tracker; end + private + # source://good_job//lib/good_job/capsule.rb#115 + def configuration; end + # @return [Boolean] # - # source://good_job//lib/good_job/capsule.rb#90 + # source://good_job//lib/good_job/capsule.rb#119 def startable?(force: T.unsafe(nil)); end class << self @@ -1432,6 +1672,132 @@ class GoodJob::Capsule end end +# CapsuleTracker save a record in the database and periodically refreshes it. The intention is to +# create a heartbeat that can be used to determine whether a capsule/process is still active +# and use that to lock (or unlock) jobs. +# +# source://good_job//lib/good_job/capsule_tracker.rb#7 +class GoodJob::CapsuleTracker + # @param executor [Concurrent::AbstractExecutorService] The executor to use for refreshing the process record. + # @return [CapsuleTracker] a new instance of CapsuleTracker + # + # source://good_job//lib/good_job/capsule_tracker.rb#26 + def initialize(executor: T.unsafe(nil)); end + + # Tests whether an active advisory lock has been taken on the record. + # + # @return [Boolean] + # + # source://good_job//lib/good_job/capsule_tracker.rb#155 + def advisory_locked?; end + + # Number of tracked job executions with advisory locks. + # + # @return [Integer] + # + # source://good_job//lib/good_job/capsule_tracker.rb#17 + def advisory_locks; end + + # The UUID to use for locking. May be nil if the process is not registered or is unusable/expired. + # If UUID has not yet been persisted to the database, this method will make a query to insert or update it. + # + # @return [String, nil] + # + # source://good_job//lib/good_job/capsule_tracker.rb#51 + def id_for_lock; end + + # Number of tracked job executions. + # + # source://good_job//lib/good_job/capsule_tracker.rb#13 + def locks; end + + # The expected UUID of the process for use in inspection. + # Use {#id_for_lock} if using this as a lock key. + # + # @return [String] + # + # source://good_job//lib/good_job/capsule_tracker.rb#71 + def process_id; end + + # The database record used for tracking. + # + # @return [GoodJob::Process, nil] + # + # source://good_job//lib/good_job/capsule_tracker.rb#10 + def record; end + + # Registers the current process around a job execution site. + # +register+ is expected to be called multiple times in a process, but should be advisory locked only once (in a single thread). + # + # @param with_advisory_lock [Boolean] Whether the lock strategy should us an advisory lock; the connection must be retained to support advisory locks. + # @return [void] + # @yield [void] If a block is given, the process will be unregistered after the block completes. + # + # source://good_job//lib/good_job/capsule_tracker.rb#80 + def register(with_advisory_lock: T.unsafe(nil)); end + + # Refreshes the process record in the database. + # + # @param silent [Boolean] Whether to silence logging. + # @return [void] + # + # source://good_job//lib/good_job/capsule_tracker.rb#145 + def renew(silent: T.unsafe(nil)); end + + # source://good_job//lib/good_job/capsule_tracker.rb#160 + def task_observer(_time, _output, thread_error); end + + # Unregisters the current process from the database. + # + # @param with_advisory_lock [Boolean] Whether the lock strategy should unlock an advisory lock; the connection must be able to support advisory locks. + # @return [void] + # + # source://good_job//lib/good_job/capsule_tracker.rb#112 + def unregister(with_advisory_lock: T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://good_job//lib/good_job/capsule_tracker.rb#166 + def advisory_locked_connection?; end + + # source://good_job//lib/good_job/capsule_tracker.rb#198 + def cancel_refresh_task; end + + # source://good_job//lib/good_job/capsule_tracker.rb#178 + def create_refresh_task(delay: T.unsafe(nil)); end + + # source://good_job//lib/good_job/capsule_tracker.rb#174 + def jitter; end + + # source://good_job//lib/good_job/capsule_tracker.rb#215 + def ns_reset; end + + # source://good_job//lib/good_job/capsule_tracker.rb#203 + def reset; end + + # source://good_job//lib/good_job/capsule_tracker.rb#207 + def reset_on_fork; end + + # Synchronize must always be called from within a Rails Executor; it may deadlock if the order is reversed. + # + # source://good_job//lib/good_job/capsule_tracker.rb#221 + def synchronize(&block); end + + # source://good_job//lib/good_job/capsule_tracker.rb#170 + def task_interval; end + + class << self + # List of all instantiated CapsuleTrackers in the current process. + # + # @return [Array, nil] + # + # source://good_job//lib/good_job/capsule_tracker.rb#23 + def instances; end + end +end + # Tracks thresholds for cleaning up old jobs. # # source://good_job//lib/good_job/cleanup_tracker.rb#5 @@ -1524,14 +1890,14 @@ class GoodJob::Configuration # might specify additional configuration values. # @return [Configuration] a new instance of Configuration # - # source://good_job//lib/good_job/configuration.rb#79 + # source://good_job//lib/good_job/configuration.rb#83 def initialize(options, env: T.unsafe(nil)); end # Whether to automatically destroy discarded jobs that have been preserved. # # @return [Boolean] # - # source://good_job//lib/good_job/configuration.rb#233 + # source://good_job//lib/good_job/configuration.rb#248 def cleanup_discarded_jobs?; end # Number of jobs a {Scheduler} will execute before automatically cleaning up preserved jobs. @@ -1539,7 +1905,7 @@ class GoodJob::Configuration # # @return [Integer, Boolean, nil] # - # source://good_job//lib/good_job/configuration.rb#254 + # source://good_job//lib/good_job/configuration.rb#269 def cleanup_interval_jobs; end # Number of seconds a {Scheduler} will wait before automatically cleaning up preserved jobs. @@ -1547,56 +1913,66 @@ class GoodJob::Configuration # # @return [Integer, nil] # - # source://good_job//lib/good_job/configuration.rb#288 + # source://good_job//lib/good_job/configuration.rb#303 def cleanup_interval_seconds; end # Number of seconds to preserve jobs before automatic destruction. # # @return [Integer] # - # source://good_job//lib/good_job/configuration.rb#242 + # source://good_job//lib/good_job/configuration.rb#257 def cleanup_preserved_jobs_before_seconds_ago; end - # source://good_job//lib/good_job/configuration.rb#205 + # source://good_job//lib/good_job/configuration.rb#209 def cron; end - # source://good_job//lib/good_job/configuration.rb#214 + # source://good_job//lib/good_job/configuration.rb#219 def cron_entries; end # Tests whether to daemonize the process. # # @return [Boolean] # - # source://good_job//lib/good_job/configuration.rb#322 + # source://good_job//lib/good_job/configuration.rb#337 def daemonize?; end - # source://good_job//lib/good_job/configuration.rb#353 + # source://good_job//lib/good_job/configuration.rb#384 def dashboard_default_locale; end + # source://good_job//lib/good_job/configuration.rb#388 + def dashboard_live_poll_enabled; end + # Whether to run cron # # @return [Boolean] # - # source://good_job//lib/good_job/configuration.rb#193 + # source://good_job//lib/good_job/configuration.rb#197 def enable_cron; end # Whether to run cron # # @return [Boolean] # - # source://good_job//lib/good_job/configuration.rb#193 + # source://good_job//lib/good_job/configuration.rb#197 def enable_cron?; end - # source://good_job//lib/good_job/configuration.rb#341 + # source://good_job//lib/good_job/configuration.rb#372 def enable_listen_notify; end + # Whether the Adapter should have Active Job enqueue jobs after the transaction has committed. + # + # @return [Boolean] + # + # source://good_job//lib/good_job/configuration.rb#396 + def enqueue_after_transaction_commit; end + # The environment from which to read GoodJob's environment variables. By # default, this is the current process's environment, but it can be set # to something else in {#initialize}. # # @return [Hash] # - # source://good_job//lib/good_job/configuration.rb#48 + # source://good_job//lib/good_job/configuration.rb#52 def env; end # Specifies how and where jobs should be executed. See {Adapter#initialize} @@ -1604,19 +1980,26 @@ class GoodJob::Configuration # # @return [Symbol] # - # source://good_job//lib/good_job/configuration.rb#93 + # source://good_job//lib/good_job/configuration.rb#97 def execution_mode; end + # The number of seconds that a good_job process will idle with out running a job before exiting + # + # @return [Integer, nil] Number of seconds or nil means do not idle out. + # + # source://good_job//lib/good_job/configuration.rb#238 + def idle_timeout; end + # Whether running in a web server process. # # @return [Boolean, nil] # - # source://good_job//lib/good_job/configuration.rb#359 + # source://good_job//lib/good_job/configuration.rb#404 def in_webserver?; end # @return [Boolean] # - # source://good_job//lib/good_job/configuration.rb#162 + # source://good_job//lib/good_job/configuration.rb#166 def inline_execution_respects_schedule?; end # The maximum number of future-scheduled jobs to store in memory. @@ -1625,7 +2008,7 @@ class GoodJob::Configuration # # @return [Integer] # - # source://good_job//lib/good_job/configuration.rb#170 + # source://good_job//lib/good_job/configuration.rb#174 def max_cache; end # Indicates the number of threads to use per {Scheduler}. Note that @@ -1634,7 +2017,7 @@ class GoodJob::Configuration # # @return [Integer] # - # source://good_job//lib/good_job/configuration.rb#120 + # source://good_job//lib/good_job/configuration.rb#124 def max_threads; end # The options that were explicitly set when initializing +Configuration+. @@ -1642,14 +2025,14 @@ class GoodJob::Configuration # # @return [Hash] # - # source://good_job//lib/good_job/configuration.rb#42 + # source://good_job//lib/good_job/configuration.rb#46 def options; end # Path of the pidfile to create when running as a daemon. # # @return [Pathname, String] # - # source://good_job//lib/good_job/configuration.rb#328 + # source://good_job//lib/good_job/configuration.rb#343 def pidfile; end # The number of seconds between polls for jobs. GoodJob will execute jobs @@ -1658,14 +2041,28 @@ class GoodJob::Configuration # # @return [Integer] # - # source://good_job//lib/good_job/configuration.rb#146 + # source://good_job//lib/good_job/configuration.rb#150 def poll_interval; end + # Rack compliant application to be run on the ProbeServer + # + # @return [nil, Class] + # + # source://good_job//lib/good_job/configuration.rb#368 + def probe_app; end + + # Probe server handler + # + # @return [nil, Symbol] + # + # source://good_job//lib/good_job/configuration.rb#359 + def probe_handler; end + # Port of the probe server # # @return [nil, Integer] # - # source://good_job//lib/good_job/configuration.rb#336 + # source://good_job//lib/good_job/configuration.rb#351 def probe_port; end # The number of queued jobs to select when polling for a job to run. @@ -1675,7 +2072,7 @@ class GoodJob::Configuration # # @return [Integer, nil] # - # source://good_job//lib/good_job/configuration.rb#223 + # source://good_job//lib/good_job/configuration.rb#228 def queue_select_limit; end # Describes which queues to execute jobs from and how those queues should @@ -1685,7 +2082,7 @@ class GoodJob::Configuration # # @return [String] # - # source://good_job//lib/good_job/configuration.rb#135 + # source://good_job//lib/good_job/configuration.rb#139 def queue_string; end # The number of seconds to wait for jobs to finish when shutting down @@ -1693,18 +2090,18 @@ class GoodJob::Configuration # # @return [Float] # - # source://good_job//lib/good_job/configuration.rb#182 + # source://good_job//lib/good_job/configuration.rb#186 def shutdown_timeout; end - # source://good_job//lib/good_job/configuration.rb#349 + # source://good_job//lib/good_job/configuration.rb#380 def smaller_number_is_higher_priority; end - # source://good_job//lib/good_job/configuration.rb#86 + # source://good_job//lib/good_job/configuration.rb#90 def validate!; end private - # source://good_job//lib/good_job/configuration.rb#373 + # source://good_job//lib/good_job/configuration.rb#418 def rails_config; end class << self @@ -1713,12 +2110,12 @@ class GoodJob::Configuration # @param warn [Boolean] whether to print a warning when over the limit # @return [Integer] # - # source://good_job//lib/good_job/configuration.rb#53 + # source://good_job//lib/good_job/configuration.rb#57 def total_estimated_threads(warn: T.unsafe(nil)); end # @raise [ArgumentError] # - # source://good_job//lib/good_job/configuration.rb#35 + # source://good_job//lib/good_job/configuration.rb#39 def validate_execution_mode(execution_mode); end end end @@ -1743,6 +2140,11 @@ GoodJob::Configuration::DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = T.le # source://good_job//lib/good_job/configuration.rb#33 GoodJob::Configuration::DEFAULT_DASHBOARD_DEFAULT_LOCALE = T.let(T.unsafe(nil), Symbol) +# Default Dashboard Live Poll button enabled +# +# source://good_job//lib/good_job/configuration.rb#35 +GoodJob::Configuration::DEFAULT_DASHBOARD_LIVE_POLL_ENABLED = T.let(T.unsafe(nil), TrueClass) + # Default poll interval for async in development environment # # source://good_job//lib/good_job/configuration.rb#17 @@ -1758,6 +2160,11 @@ GoodJob::Configuration::DEFAULT_ENABLE_CRON = T.let(T.unsafe(nil), FalseClass) # source://good_job//lib/good_job/configuration.rb#31 GoodJob::Configuration::DEFAULT_ENABLE_LISTEN_NOTIFY = T.let(T.unsafe(nil), TrueClass) +# Default enqueue_after_transaction_commit +# +# source://good_job//lib/good_job/configuration.rb#37 +GoodJob::Configuration::DEFAULT_ENQUEUE_AFTER_TRANSACTION_COMMIT = T.let(T.unsafe(nil), FalseClass) + # Default number of threads to use per {Scheduler} # # source://good_job//lib/good_job/configuration.rb#19 @@ -1883,6 +2290,7 @@ class GoodJob::CronEntry def cron; end def cron_proc?; end def display_property(value); end + def enabled_by_default?; end def fugit; end def kwargs_value; end def set_value; end @@ -2051,10 +2459,16 @@ module GoodJob::CurrentThread # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#100 def execution_retried=(obj); end + # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#56 + def retry_now; end + + # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#100 + def retry_now=(obj); end + class << self # @return [String] UUID of the currently executing GoodJob::Execution # - # source://good_job//lib/good_job/current_thread.rb#87 + # source://good_job//lib/good_job/current_thread.rb#94 def active_job_id; end # Cron At @@ -2163,7 +2577,7 @@ module GoodJob::CurrentThread # @return [Integer] Current process ID # - # source://good_job//lib/good_job/current_thread.rb#92 + # source://good_job//lib/good_job/current_thread.rb#99 def process_id; end # Resets attributes @@ -2171,19 +2585,33 @@ module GoodJob::CurrentThread # @param values [Hash] to assign # @return [void] # - # source://good_job//lib/good_job/current_thread.rb#72 + # source://good_job//lib/good_job/current_thread.rb#79 def reset(values = T.unsafe(nil)); end + # Execution Retried + # + # @return [Boolean, nil] + # + # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#48 + def retry_now; end + + # Execution Retried + # + # @return [Boolean, nil] + # + # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#92 + def retry_now=(obj); end + # @return [String] Current thread name # - # source://good_job//lib/good_job/current_thread.rb#97 + # source://good_job//lib/good_job/current_thread.rb#104 def thread_name; end # Exports values to hash # # @return [Hash] # - # source://good_job//lib/good_job/current_thread.rb#80 + # source://good_job//lib/good_job/current_thread.rb#87 def to_h; end # Wrap the yielded block with CurrentThread values and reset after the block @@ -2191,7 +2619,7 @@ module GoodJob::CurrentThread # @return [void] # @yield [self] # - # source://good_job//lib/good_job/current_thread.rb#104 + # source://good_job//lib/good_job/current_thread.rb#111 def within; end end end @@ -2201,7 +2629,9 @@ end # source://good_job//lib/good_job/current_thread.rb#10 GoodJob::CurrentThread::ACCESSORS = T.let(T.unsafe(nil), Array) -# source://good_job//lib/good_job.rb#45 +# Default logger for GoodJob; overridden by Rails.logger in Railtie. +# +# source://good_job//lib/good_job.rb#57 GoodJob::DEFAULT_LOGGER = T.let(T.unsafe(nil), ActiveSupport::Logger) # Manages daemonization of the current process. @@ -2232,23 +2662,28 @@ class GoodJob::Daemon # @return [void] # - # source://good_job//lib/good_job/daemon.rb#42 + # source://good_job//lib/good_job/daemon.rb#51 def check_pid; end # @return [void] # - # source://good_job//lib/good_job/daemon.rb#37 + # source://good_job//lib/good_job/daemon.rb#43 + def check_pid_dir; end + + # @return [void] + # + # source://good_job//lib/good_job/daemon.rb#38 def delete_pid; end # @param pidfile [Pathname, String] # @return [Symbol] # - # source://good_job//lib/good_job/daemon.rb#53 + # source://good_job//lib/good_job/daemon.rb#62 def pid_status(pidfile); end # @return [void] # - # source://good_job//lib/good_job/daemon.rb#28 + # source://good_job//lib/good_job/daemon.rb#29 def write_pid; end end @@ -2285,6 +2720,7 @@ class GoodJob::DiscreteExecution < ::GoodJob::BaseRecord def clear_performed_at_change; end def display_serialized_params; end + def filtered_error_backtrace; end def last_status_at; end def number; end @@ -2367,13 +2803,20 @@ class GoodJob::DiscreteExecution < ::GoodJob::BaseRecord # source://activemodel/7.0.8/lib/active_model/attribute_methods.rb#72 def attribute_aliases; end + def backtrace_migrated?; end + # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end + def duration_interval_migrated?; end + def duration_interval_usable?; end def error_event_migrated?; end # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def finished(*args, **_arg1); end + + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end end end @@ -2459,185 +2902,34 @@ class GoodJob::Execution < ::GoodJob::BaseExecution include ::GoodJob::Execution::GeneratedAttributeMethods include ::GoodJob::Execution::GeneratedAssociationMethods - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#940 - def _perform_callbacks; end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#940 - def _perform_unlocked_callbacks; end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#928 - def _run_perform_callbacks(&block); end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#928 - def _run_perform_unlocked_callbacks(&block); end - - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 - def autosave_associated_records_for_batch(*args); end - - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 - def autosave_associated_records_for_discrete_executions(*args); end - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 def autosave_associated_records_for_job(*args); end - def destroy_job; end - def display_serialized_params; end - def executable?; end - def make_discrete; end - def number; end - def perform; end - def queue_latency; end - def running?; end - def runtime_latency; end - - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 - def validate_associated_records_for_discrete_executions(*args); end - - private - - def continue_discard_or_finish_batch; end - def reset_batch_values(&block); end - class << self # source://activesupport/7.0.8/lib/active_support/callbacks.rb#68 def __callbacks; end - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#932 - def _perform_callbacks; end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#936 - def _perform_callbacks=(value); end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#932 - def _perform_unlocked_callbacks; end - - # source://activesupport/7.0.8/lib/active_support/callbacks.rb#936 - def _perform_unlocked_callbacks=(value); end - # source://activerecord/7.0.8/lib/active_record/reflection.rb#11 def _reflections; end # source://activemodel/7.0.8/lib/active_model/validations.rb#52 def _validators; end - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def active_job_id(*args, **_arg1); end - - def advisory_lockable_column; end - - # source://activemodel/7.0.8/lib/active_model/callbacks.rb#144 - def after_perform(*args, **options, &block); end - - # source://activemodel/7.0.8/lib/active_model/callbacks.rb#144 - def after_perform_unlocked(*args, **options, &block); end - - # source://activemodel/7.0.8/lib/active_model/callbacks.rb#137 - def around_perform(*args, **options, &block); end - - # source://activemodel/7.0.8/lib/active_model/callbacks.rb#130 - def before_perform(*args, **options, &block); end - - def build_for_enqueue(active_job, overrides = T.unsafe(nil)); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def creation_ordered(*args, **_arg1); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def dead(*args, **_arg1); end - # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def dequeueing_ordered(*args, **_arg1); end - - def enqueue(active_job, scheduled_at: T.unsafe(nil), create_with_advisory_lock: T.unsafe(nil)); end - def enqueue_args(active_job, overrides = T.unsafe(nil)); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def finished(*args, **_arg1); end - - def format_error(error); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def head(*args, **_arg1); end - - def next_scheduled_at(after: T.unsafe(nil), limit: T.unsafe(nil), now_limit: T.unsafe(nil)); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def only_scheduled(*args, **_arg1); end - - def perform_with_advisory_lock(parsed_queues: T.unsafe(nil), queue_select_limit: T.unsafe(nil)); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def priority_ordered(*args, **_arg1); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def queue_ordered(*args, **_arg1); end - - def queue_parser(string); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def queue_string(*args, **_arg1); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def running(*args, **_arg1); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def schedule_ordered(*args, **_arg1); end - - # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 - def unfinished(*args, **_arg1); end end end -GoodJob::Execution::DEFAULT_PRIORITY = T.let(T.unsafe(nil), Integer) -GoodJob::Execution::DEFAULT_QUEUE_NAME = T.let(T.unsafe(nil), String) -GoodJob::Execution::ERROR_MESSAGE_SEPARATOR = T.let(T.unsafe(nil), String) - module GoodJob::Execution::GeneratedAssociationMethods - # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 - def batch; end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 - def batch=(value); end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#132 - def batch_changed?; end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#136 - def batch_previously_changed?; end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#28 - def build_batch(*args, &block); end - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#28 def build_job(*args, &block); end - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#32 - def create_batch(*args, &block); end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#36 - def create_batch!(*args, &block); end - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#32 def create_job(*args, &block); end # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#36 def create_job!(*args, &block); end - # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#62 - def discrete_execution_ids; end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#72 - def discrete_execution_ids=(ids); end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 - def discrete_executions; end - - # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 - def discrete_executions=(value); end - # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 def job; end @@ -2650,15 +2942,11 @@ module GoodJob::Execution::GeneratedAssociationMethods # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#136 def job_previously_changed?; end - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#19 - def reload_batch; end - # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#19 def reload_job; end end module GoodJob::Execution::GeneratedAttributeMethods; end -class GoodJob::Execution::PreviouslyPerformedError < ::StandardError; end class GoodJob::ExecutionResult def initialize(value:, handled_error: T.unsafe(nil), unhandled_error: T.unsafe(nil), error_event: T.unsafe(nil), unexecutable: T.unsafe(nil), retried: T.unsafe(nil)); end @@ -2718,54 +3006,17 @@ module GoodJob::FrontendsController::HelperMethods include ::ViteRails::TagHelpers include ::InertiaRails::Helper include ::ActionController::Base::HelperMethods + include ::GoodJob::IconsHelper include ::GoodJob::ApplicationHelper end GoodJob::FrontendsController::MODULE_OVERRIDES = T.let(T.unsafe(nil), Hash) GoodJob::FrontendsController::STATIC_ASSETS = T.let(T.unsafe(nil), Hash) -# GoodJob version as Gem::Version object -# -# source://good_job//lib/good_job/version.rb#8 -GoodJob::GEM_VERSION = T.let(T.unsafe(nil), Gem::Version) - -# source://good_job//lib/good_job/http_server.rb#4 -class GoodJob::HttpServer - # @return [HttpServer] a new instance of HttpServer - # - # source://good_job//lib/good_job/http_server.rb#7 - def initialize(app, options = T.unsafe(nil)); end - - # source://good_job//lib/good_job/http_server.rb#15 - def run; end - - # @return [Boolean] - # - # source://good_job//lib/good_job/http_server.rb#30 - def running?; end - - # source://good_job//lib/good_job/http_server.rb#25 - def stop; end - - private - - # source://good_job//lib/good_job/http_server.rb#43 - def handle_connections; end - - # source://good_job//lib/good_job/http_server.rb#64 - def parse_request(request); end - - # source://good_job//lib/good_job/http_server.rb#70 - def respond(client, status, headers, body); end - - # source://good_job//lib/good_job/http_server.rb#36 - def start_server; end -end - -# in seconds +# GoodJob version as Gem::Version object # -# source://good_job//lib/good_job/http_server.rb#5 -GoodJob::HttpServer::SOCKET_READ_TIMEOUT = T.let(T.unsafe(nil), Integer) +# source://good_job//lib/good_job/version.rb#8 +GoodJob::GEM_VERSION = T.let(T.unsafe(nil), Gem::Version) class GoodJob::I18nConfig < ::I18n::Config def available_locales; end @@ -2778,6 +3029,15 @@ GoodJob::I18nConfig::AVAILABLE_LOCALES = T.let(T.unsafe(nil), Array) GoodJob::I18nConfig::AVAILABLE_LOCALES_SET = T.let(T.unsafe(nil), Set) GoodJob::I18nConfig::BACKEND = T.let(T.unsafe(nil), I18n::Backend::Simple) +module GoodJob::IconsHelper + def render_icon(name, **options); end + def status_badge(status); end + def status_icon(status, **options); end +end + +GoodJob::IconsHelper::STATUS_COLOR = T.let(T.unsafe(nil), Hash) +GoodJob::IconsHelper::STATUS_ICONS = T.let(T.unsafe(nil), Hash) + # Exception raised when a job is interrupted by a SIGKILL or power failure. # # source://good_job//lib/good_job/interrupt_error.rb#5 @@ -2799,6 +3059,9 @@ class GoodJob::Job < ::GoodJob::BaseExecution # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 def autosave_associated_records_for_executions(*args); end + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def autosave_associated_records_for_locked_by_process(*args); end + def destroy_job; end def discard_job(message); end def discarded?; end @@ -2819,9 +3082,6 @@ class GoodJob::Job < ::GoodJob::BaseExecution def succeeded?; end def tail_execution; end - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 - def validate_associated_records_for_discrete_executions(*args); end - # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 def validate_associated_records_for_executions(*args); end @@ -2856,6 +3116,9 @@ class GoodJob::Job < ::GoodJob::BaseExecution # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def finished_before(*args, **_arg1); end + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def queued(*args, **_arg1); end @@ -2880,6 +3143,7 @@ class GoodJob::Job < ::GoodJob::BaseExecution end class GoodJob::Job::ActionForStateMismatchError < ::StandardError; end +class GoodJob::Job::ActiveJobDeserializationError < ::StandardError; end class GoodJob::Job::AdapterNotGoodJobError < ::StandardError; end class GoodJob::Job::DiscardJobError < ::StandardError; end @@ -2899,12 +3163,21 @@ module GoodJob::Job::GeneratedAssociationMethods # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#28 def build_batch(*args, &block); end + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#28 + def build_locked_by_process(*args, &block); end + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#32 def create_batch(*args, &block); end # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#36 def create_batch!(*args, &block); end + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#32 + def create_locked_by_process(*args, &block); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#36 + def create_locked_by_process!(*args, &block); end + # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#62 def discrete_execution_ids; end @@ -2929,8 +3202,23 @@ module GoodJob::Job::GeneratedAssociationMethods # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 def executions=(value); end + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 + def locked_by_process; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 + def locked_by_process=(value); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#132 + def locked_by_process_changed?; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/belongs_to.rb#136 + def locked_by_process_previously_changed?; end + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#19 def reload_batch; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/singular_association.rb#19 + def reload_locked_by_process; end end module GoodJob::Job::GeneratedAttributeMethods; end @@ -2947,27 +3235,28 @@ class GoodJob::JobPerformer # @return [JobPerformer] a new instance of JobPerformer # # source://good_job//lib/good_job/job_performer.rb#17 - def initialize(queue_string); end + def initialize(queue_string, capsule: T.unsafe(nil)); end # Destroy expired preserved jobs # # @return [void] # - # source://good_job//lib/good_job/job_performer.rb#71 + # source://good_job//lib/good_job/job_performer.rb#88 def cleanup; end # A meaningful name to identify the performer in logs and for debugging. # # @return [String] The queues from which Jobs are worked # - # source://good_job//lib/good_job/job_performer.rb#23 + # source://good_job//lib/good_job/job_performer.rb#25 def name; end # Perform the next eligible job # # @return [Object, nil] Returns job result or +nil+ if no job was found + # @yield [Execution] Yields the execution, if one is dequeued # - # source://good_job//lib/good_job/job_performer.rb#29 + # source://good_job//lib/good_job/job_performer.rb#32 def next; end # Tests whether this performer should be used in GoodJob's current state. @@ -2980,7 +3269,7 @@ class GoodJob::JobPerformer # @return [Boolean] whether the performer's {#next} method should be # called in the current state. # - # source://good_job//lib/good_job/job_performer.rb#48 + # source://good_job//lib/good_job/job_performer.rb#65 def next?(state = T.unsafe(nil)); end # The Returns timestamps of when next tasks may be available. @@ -2990,7 +3279,7 @@ class GoodJob::JobPerformer # @param now_limit [Integer] number of past timestamps to return # @return [Array, nil] # - # source://good_job//lib/good_job/job_performer.rb#65 + # source://good_job//lib/good_job/job_performer.rb#82 def next_at(after: T.unsafe(nil), limit: T.unsafe(nil), now_limit: T.unsafe(nil)); end # source://good_job//lib/good_job/job_performer.rb#14 @@ -2999,17 +3288,31 @@ class GoodJob::JobPerformer # source://good_job//lib/good_job/job_performer.rb#14 def performing_active_job_ids=(val); end + # Reset metrics about this performer + # + # @return [void] + # + # source://good_job//lib/good_job/job_performer.rb#102 + def reset_stats; end + + # Metrics about this performer + # + # @return [Hash] + # + # source://good_job//lib/good_job/job_performer.rb#94 + def stats; end + private - # source://good_job//lib/good_job/job_performer.rb#79 + # source://good_job//lib/good_job/job_performer.rb#110 def job_query; end - # source://good_job//lib/good_job/job_performer.rb#83 + # source://good_job//lib/good_job/job_performer.rb#114 def parsed_queues; end # Returns the value of attribute queue_string. # - # source://good_job//lib/good_job/job_performer.rb#77 + # source://good_job//lib/good_job/job_performer.rb#108 def queue_string; end class << self @@ -3021,6 +3324,65 @@ class GoodJob::JobPerformer end end +# Metrics for the scheduler. +# +# source://good_job//lib/good_job/job_performer/metrics.rb#8 +class GoodJob::JobPerformer::Metrics + # @return [Metrics] a new instance of Metrics + # + # source://good_job//lib/good_job/job_performer/metrics.rb#9 + def initialize; end + + # Increments number of dequeue attempts with no executions. + # + # @return [Integer] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#34 + def increment_empty_executions; end + + # Increments number of failed executions. + # + # @return [Integer] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#20 + def increment_errored_executions; end + + # Increments number of succeeded executions. + # + # @return [Integer] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#27 + def increment_succeeded_executions; end + + # Reset counters. + # + # @return [void] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#66 + def reset; end + + # All metrics in a Hash. + # + # @return [Hash] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#52 + def to_h; end + + # Last time the queue was checked for jobs. + # + # @return [Time, nil] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#46 + def touch_check_queue_at; end + + # Last time a job was executed (started or finished). + # + # @return [Time, nil] + # + # source://good_job//lib/good_job/job_performer/metrics.rb#40 + def touch_execution_at; end +end + class GoodJob::JobsController < ::GoodJob::ApplicationController def destroy; end def discard; end @@ -3060,6 +3422,7 @@ GoodJob::JobsController::FORCE_DISCARD_MESSAGE = T.let(T.unsafe(nil), String) class GoodJob::JobsFilter < ::GoodJob::BaseFilter def filtered_count; end def filtered_query(filter_params = T.unsafe(nil)); end + def state_names; end def states; end private @@ -3103,13 +3466,13 @@ class GoodJob::LogSubscriber < ::ActiveSupport::LogSubscriber # source://good_job//lib/good_job/log_subscriber.rb#62 def cron_manager_start(event); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def debug(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def error(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def fatal(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end # Responds to the +finished_job_task.good_job+ notification. @@ -3128,7 +3491,7 @@ class GoodJob::LogSubscriber < ::ActiveSupport::LogSubscriber # source://good_job//lib/good_job/log_subscriber.rb#31 def finished_timer_task(event); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def info(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end # Get the logger associated with this {LogSubscriber} instance. @@ -3229,10 +3592,10 @@ class GoodJob::LogSubscriber < ::ActiveSupport::LogSubscriber # source://good_job//lib/good_job/log_subscriber.rb#165 def systemd_watchdog_start(event); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def unknown(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end - # source://good_job//lib/good_job/log_subscriber.rb#265 + # source://good_job//lib/good_job/log_subscriber.rb#267 def warn(progname = T.unsafe(nil), tags: T.unsafe(nil), &block); end private @@ -3244,7 +3607,7 @@ class GoodJob::LogSubscriber < ::ActiveSupport::LogSubscriber # @return [void] # @yield [void] # - # source://good_job//lib/good_job/log_subscriber.rb#236 + # source://good_job//lib/good_job/log_subscriber.rb#238 def tag_logger(*tags, &block); end class << self @@ -3279,57 +3642,33 @@ class GoodJob::LogSubscriber < ::ActiveSupport::LogSubscriber # # @return [void] # - # source://good_job//lib/good_job/log_subscriber.rb#224 + # source://good_job//lib/good_job/log_subscriber.rb#226 def reset_logger; end end end -# Metrics for the scheduler. -# -# source://good_job//lib/good_job/metrics.rb#5 -class GoodJob::Metrics - # @return [Metrics] a new instance of Metrics - # - # source://good_job//lib/good_job/metrics.rb#6 - def initialize; end +class GoodJob::MetricsController < ::GoodJob::ApplicationController + def job_status; end + def primary_nav; end - # Increments number of empty queried executions. - # - # @return [Integer] - # - # source://good_job//lib/good_job/metrics.rb#15 - def increment_empty_executions; end + private - # Increments number of failed executions. - # - # @return [Integer] - # - # source://good_job//lib/good_job/metrics.rb#21 - def increment_errored_executions; end + # source://actionview/7.0.8/lib/action_view/layouts.rb#328 + def _layout(lookup_context, formats); end - # Increments number of succeeded executions. - # - # @return [Integer] - # - # source://good_job//lib/good_job/metrics.rb#27 - def increment_succeeded_executions; end + def number_to_human(count); end + def number_with_delimiter(count); end - # Increments number of unlocked executions. - # - # @return [Integer] - # - # source://good_job//lib/good_job/metrics.rb#33 - def increment_unexecutable_executions; end + class << self + # source://actionpack/7.0.8/lib/action_controller/metal/params_wrapper.rb#185 + def _wrapper_options; end - # Reset counters. - # - # @return [void] - # - # source://good_job//lib/good_job/metrics.rb#50 - def reset; end + # source://actionpack/7.0.8/lib/action_controller/metal/helpers.rb#63 + def helpers_path; end - # source://good_job//lib/good_job/metrics.rb#37 - def to_h; end + # source://actionpack/7.0.8/lib/action_controller/metal.rb#210 + def middleware_stack; end + end end # Delegates the interface of a single {Scheduler} to multiple Schedulers. @@ -3339,7 +3678,7 @@ class GoodJob::MultiScheduler # @param schedulers [Array] # @return [MultiScheduler] a new instance of MultiScheduler # - # source://good_job//lib/good_job/multi_scheduler.rb#10 + # source://good_job//lib/good_job/multi_scheduler.rb#33 def initialize(schedulers); end # Delegates to {Scheduler#create_thread}. @@ -3347,7 +3686,7 @@ class GoodJob::MultiScheduler # @param state [Hash] # @return [Boolean, nil] # - # source://good_job//lib/good_job/multi_scheduler.rb#43 + # source://good_job//lib/good_job/multi_scheduler.rb#66 def create_thread(state = T.unsafe(nil)); end # Delegates to {Scheduler#restart}. @@ -3355,19 +3694,19 @@ class GoodJob::MultiScheduler # @param timeout [Numeric, nil] # @return [void] # - # source://good_job//lib/good_job/multi_scheduler.rb#36 + # source://good_job//lib/good_job/multi_scheduler.rb#59 def restart(timeout: T.unsafe(nil)); end # Delegates to {Scheduler#running?}. # # @return [Boolean, nil] # - # source://good_job//lib/good_job/multi_scheduler.rb#16 + # source://good_job//lib/good_job/multi_scheduler.rb#39 def running?; end # @return [Array] List of the scheduler delegates # - # source://good_job//lib/good_job/multi_scheduler.rb#7 + # source://good_job//lib/good_job/multi_scheduler.rb#30 def schedulers; end # Delegates to {Scheduler#shutdown}. @@ -3375,17 +3714,36 @@ class GoodJob::MultiScheduler # @param timeout [Numeric, nil] # @return [void] # - # source://good_job//lib/good_job/multi_scheduler.rb#29 + # source://good_job//lib/good_job/multi_scheduler.rb#52 def shutdown(timeout: T.unsafe(nil)); end # Delegates to {Scheduler#shutdown?}. # # @return [Boolean, nil] # - # source://good_job//lib/good_job/multi_scheduler.rb#22 + # source://good_job//lib/good_job/multi_scheduler.rb#45 def shutdown?; end + + # source://good_job//lib/good_job/multi_scheduler.rb#88 + def stats; end + + class << self + # Creates MultiScheduler from a GoodJob::Configuration instance. + # + # @param configuration [GoodJob::Configuration] + # @param warm_cache_on_initialize [Boolean] + # @return [GoodJob::MultiScheduler] + # + # source://good_job//lib/good_job/multi_scheduler.rb#10 + def from_configuration(configuration, capsule: T.unsafe(nil), warm_cache_on_initialize: T.unsafe(nil)); end + end end +# Default, null, blank value placeholder. +# +# source://good_job//lib/good_job.rb#54 +module GoodJob::NONE; end + # Notifiers hook into Postgres LISTEN/NOTIFY functionality to emit and listen for notifications across processes. # # Notifiers can emit NOTIFY messages through Postgres. @@ -3401,11 +3759,10 @@ class GoodJob::Notifier # @param recipients [Array<#call, Array(Object, Symbol)>] # @param enable_listening [true, false] - # @param executor [Concurrent::ExecutorService] # @return [Notifier] a new instance of Notifier # # source://good_job//lib/good_job/notifier.rb#66 - def initialize(*recipients, enable_listening: T.unsafe(nil), executor: T.unsafe(nil)); end + def initialize(*recipients, enable_listening: T.unsafe(nil), capsule: T.unsafe(nil), executor: T.unsafe(nil)); end # source://activesupport/7.0.8/lib/active_support/callbacks.rb#68 def __callbacks; end @@ -3436,7 +3793,7 @@ class GoodJob::Notifier # @param timeout [Numeric, nil] Seconds to wait for condition to be true, -1 is forever # @return [true, false, nil] # - # source://good_job//lib/good_job/notifier.rb#92 + # source://good_job//lib/good_job/notifier.rb#93 def connected?(timeout: T.unsafe(nil)); end # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#56 @@ -3449,7 +3806,7 @@ class GoodJob::Notifier # # @return [void] # - # source://good_job//lib/good_job/notifier.rb#154 + # source://good_job//lib/good_job/notifier.rb#155 def listen_observer(_time, _result, thread_error); end # Tests whether the notifier is listening for new messages. @@ -3457,14 +3814,14 @@ class GoodJob::Notifier # @param timeout [Numeric, nil] Seconds to wait for condition to be true, -1 is forever # @return [true, false, nil] # - # source://good_job//lib/good_job/notifier.rb#103 + # source://good_job//lib/good_job/notifier.rb#104 def listening?(timeout: T.unsafe(nil)); end # List of recipients that will receive notifications. # # @return [Array<#call, Array(Object, Symbol)>] # - # source://good_job//lib/good_job/notifier.rb#61 + # source://good_job//lib/good_job/notifier.rb#62 def recipients; end # Restart the notifier. @@ -3473,12 +3830,12 @@ class GoodJob::Notifier # @param timeout [nil, Numeric] Seconds to wait; shares same values as {#shutdown}. # @return [void] # - # source://good_job//lib/good_job/notifier.rb#144 + # source://good_job//lib/good_job/notifier.rb#145 def restart(timeout: T.unsafe(nil)); end # @return [Boolean] # - # source://good_job//lib/good_job/notifier.rb#85 + # source://good_job//lib/good_job/notifier.rb#86 def running?; end # Shut down the notifier. @@ -3491,32 +3848,32 @@ class GoodJob::Notifier # * A positive number will wait that many seconds before stopping any remaining active threads. # @return [void] # - # source://good_job//lib/good_job/notifier.rb#123 + # source://good_job//lib/good_job/notifier.rb#124 def shutdown(timeout: T.unsafe(nil)); end # @return [Boolean] # - # source://good_job//lib/good_job/notifier.rb#111 + # source://good_job//lib/good_job/notifier.rb#112 def shutdown?; end + # source://good_job//lib/good_job/notifier.rb#187 + def synchronize(*_arg0, **_arg1, &_arg2); end + private - # source://good_job//lib/good_job/notifier.rb#196 + # source://good_job//lib/good_job/notifier.rb#199 def create_listen_task(delay: T.unsafe(nil)); end - # source://good_job//lib/good_job/notifier.rb#283 + # source://good_job//lib/good_job/notifier.rb#286 def reset_connection_errors; end - # source://good_job//lib/good_job/notifier.rb#186 + # source://good_job//lib/good_job/notifier.rb#189 def start; end - # source://good_job//lib/good_job/notifier.rb#288 - def synchronize(&block); end - - # source://good_job//lib/good_job/notifier.rb#263 + # source://good_job//lib/good_job/notifier.rb#266 def wait_for_notify; end - # source://good_job//lib/good_job/notifier.rb#249 + # source://good_job//lib/good_job/notifier.rb#252 def with_connection; end class << self @@ -3565,31 +3922,31 @@ class GoodJob::Notifier # # @return [Array, nil] # - # source://good_job//lib/good_job/notifier.rb#42 + # source://good_job//lib/good_job/notifier.rb#43 def instances; end # Send a message via Postgres NOTIFY # # @param message [#to_json] # - # source://good_job//lib/good_job/notifier.rb#52 + # source://good_job//lib/good_job/notifier.rb#53 def notify(message); end end end # Default Postgres channel for LISTEN/NOTIFY # -# source://good_job//lib/good_job/notifier.rb#22 +# source://good_job//lib/good_job/notifier.rb#23 GoodJob::Notifier::CHANNEL = T.let(T.unsafe(nil), String) # Connection errors that will wait {RECONNECT_INTERVAL} before reconnecting # -# source://good_job//lib/good_job/notifier.rb#31 +# source://good_job//lib/good_job/notifier.rb#32 GoodJob::Notifier::CONNECTION_ERRORS = T.let(T.unsafe(nil), Array) # Number of consecutive connection errors before reporting an error # -# source://good_job//lib/good_job/notifier.rb#28 +# source://good_job//lib/good_job/notifier.rb#29 GoodJob::Notifier::CONNECTION_ERRORS_REPORTING_THRESHOLD = T.let(T.unsafe(nil), Integer) # Extends the Notifier to register the process in the database. @@ -3614,14 +3971,53 @@ end # Seconds to wait if database cannot be connected to # -# source://good_job//lib/good_job/notifier.rb#26 +# source://good_job//lib/good_job/notifier.rb#27 GoodJob::Notifier::RECONNECT_INTERVAL = T.let(T.unsafe(nil), Integer) # Seconds to block while LISTENing for a message # -# source://good_job//lib/good_job/notifier.rb#24 +# source://good_job//lib/good_job/notifier.rb#25 GoodJob::Notifier::WAIT_INTERVAL = T.let(T.unsafe(nil), Integer) +# Extends an ActiveRecord odel to override the connection and use +# an explicit connection that has been removed from the pool. +# +# source://good_job//lib/good_job/overridable_connection.rb#6 +module GoodJob::OverridableConnection + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::GoodJob::OverridableConnection::ClassMethods +end + +# source://good_job//lib/good_job/overridable_connection.rb#0 +module GoodJob::OverridableConnection::ClassMethods + # source://good_job//lib/good_job/overridable_connection.rb#16 + def connection; end + + # source://good_job//lib/good_job/overridable_connection.rb#23 + def override_connection(conn); end +end + +class GoodJob::PerformancesController < ::GoodJob::ApplicationController + def show; end + + private + + # source://actionview/7.0.8/lib/action_view/layouts.rb#328 + def _layout(lookup_context, formats); end + + class << self + # source://actionpack/7.0.8/lib/action_controller/metal/params_wrapper.rb#185 + def _wrapper_options; end + + # source://actionpack/7.0.8/lib/action_controller/metal/helpers.rb#63 + def helpers_path; end + + # source://actionpack/7.0.8/lib/action_controller/metal.rb#210 + def middleware_stack; end + end +end + # Pollers regularly wake up execution threads to check for new work. # # source://good_job//lib/good_job/poller.rb#9 @@ -3726,76 +4122,159 @@ GoodJob::Poller::DEFAULT_TIMER_OPTIONS = T.let(T.unsafe(nil), Hash) class GoodJob::ProbeServer # @return [ProbeServer] a new instance of ProbeServer # - # source://good_job//lib/good_job/probe_server.rb#11 - def initialize(port:); end + # source://good_job//lib/good_job/probe_server.rb#18 + def initialize(port:, handler: T.unsafe(nil), app: T.unsafe(nil)); end - # source://good_job//lib/good_job/probe_server.rb#31 - def call(env); end + # source://good_job//lib/good_job/probe_server.rb#38 + def build_handler(port:, handler:, app:); end # @return [Boolean] # - # source://good_job//lib/good_job/probe_server.rb#22 + # source://good_job//lib/good_job/probe_server.rb#29 def running?; end - # source://good_job//lib/good_job/probe_server.rb#15 + # source://good_job//lib/good_job/probe_server.rb#23 def start; end - # source://good_job//lib/good_job/probe_server.rb#26 + # source://good_job//lib/good_job/probe_server.rb#33 def stop; end class << self + # source://good_job//lib/good_job/probe_server.rb#11 + def default_app; end + # source://good_job//lib/good_job/probe_server.rb#5 def task_observer(time, output, thread_error); end end end +# source://good_job//lib/good_job/probe_server/healthcheck_middleware.rb#5 +class GoodJob::ProbeServer::HealthcheckMiddleware + # @return [HealthcheckMiddleware] a new instance of HealthcheckMiddleware + # + # source://good_job//lib/good_job/probe_server/healthcheck_middleware.rb#6 + def initialize(app); end + + # source://good_job//lib/good_job/probe_server/healthcheck_middleware.rb#10 + def call(env); end +end + +# source://good_job//lib/good_job/probe_server/not_found_app.rb#5 +module GoodJob::ProbeServer::NotFoundApp + class << self + # source://good_job//lib/good_job/probe_server/not_found_app.rb#6 + def call(_env); end + end +end + +# source://good_job//lib/good_job/probe_server/simple_handler.rb#5 +class GoodJob::ProbeServer::SimpleHandler + # @return [SimpleHandler] a new instance of SimpleHandler + # + # source://good_job//lib/good_job/probe_server/simple_handler.rb#8 + def initialize(app, options = T.unsafe(nil)); end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#25 + def build_future; end + + # @return [Boolean] + # + # source://good_job//lib/good_job/probe_server/simple_handler.rb#21 + def running?; end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#16 + def stop; end + + private + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#48 + def handle_connections; end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#69 + def parse_request(request); end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#75 + def respond(client, status, headers, body); end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#31 + def run; end + + # source://good_job//lib/good_job/probe_server/simple_handler.rb#41 + def start_server; end +end + +# in seconds +# +# source://good_job//lib/good_job/probe_server/simple_handler.rb#6 +GoodJob::ProbeServer::SimpleHandler::SOCKET_READ_TIMEOUT = T.let(T.unsafe(nil), Integer) + +# source://good_job//lib/good_job/probe_server/webrick_handler.rb#5 +class GoodJob::ProbeServer::WebrickHandler + # @return [WebrickHandler] a new instance of WebrickHandler + # + # source://good_job//lib/good_job/probe_server/webrick_handler.rb#6 + def initialize(app, options = T.unsafe(nil)); end + + # source://good_job//lib/good_job/probe_server/webrick_handler.rb#31 + def build_future; end + + # @return [Boolean] + # + # source://good_job//lib/good_job/probe_server/webrick_handler.rb#27 + def running?; end + + # source://good_job//lib/good_job/probe_server/webrick_handler.rb#23 + def stop; end +end + class GoodJob::Process < ::GoodJob::BaseRecord include ::GoodJob::Process::GeneratedAttributeMethods include ::GoodJob::Process::GeneratedAssociationMethods include ::GoodJob::AdvisoryLockable - include ::GoodJob::AssignableConnection + include ::GoodJob::OverridableConnection extend ::GoodJob::AdvisoryLockable::ClassMethods - extend ::GoodJob::AssignableConnection::ClassMethods + extend ::GoodJob::OverridableConnection::ClassMethods # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#56 - def _connection; end + def _overridden_connection; end # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#100 - def _connection=(obj); end + def _overridden_connection=(obj); end - def _current_id; end - def _current_id=(val); end - def _pid; end - def _pid=(val); end def advisory_lockable_function; end def advisory_lockable_function=(_arg0); end def advisory_lockable_function?; end + + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def autosave_associated_records_for_locked_jobs(*args); end + def basename; end def create_with_advisory_lock; end def create_with_advisory_lock=(_arg0); end - def deregister; end def expired?; end - def mutex; end + def lock_type; end + def lock_type=(value); end def refresh; end def refresh_if_stale(cleanup: T.unsafe(nil)); end def schedulers; end def stale?; end def state; end + # source://activerecord/7.0.8/lib/active_record/autosave_association.rb#160 + def validate_associated_records_for_locked_jobs(*args); end + class << self # source://activesupport/7.0.8/lib/active_support/callbacks.rb#68 def __callbacks; end # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#48 - def _connection; end + def _overridden_connection; end # source://activesupport/7.0.8/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb#92 - def _connection=(obj); end + def _overridden_connection=(obj); end - def _current_id; end - def _current_id=(val); end - def _pid; end - def _pid=(val); end + # source://activerecord/7.0.8/lib/active_record/reflection.rb#11 + def _reflections; end # source://activemodel/7.0.8/lib/active_model/validations.rb#52 def _validators; end @@ -3820,12 +4299,14 @@ class GoodJob::Process < ::GoodJob::BaseRecord def advisory_unlocked(*args, **_arg1); end def cleanup; end - def current_id; end - def current_state; end + def create_record(id:, with_advisory_lock: T.unsafe(nil)); end # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end + # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def inactive(*args, **_arg1); end @@ -3835,20 +4316,35 @@ class GoodJob::Process < ::GoodJob::BaseRecord # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def joins_advisory_locks(*args, **_arg1); end - def mutex; end - def ns_current_id; end - def ns_current_state; end + def lock_type_migrated?; end # source://activerecord/7.0.8/lib/active_record/scoping/named.rb#174 def owns_advisory_locked(*args, **_arg1); end - def register; end + def process_state; end end end GoodJob::Process::EXPIRED_INTERVAL = T.let(T.unsafe(nil), ActiveSupport::Duration) -module GoodJob::Process::GeneratedAssociationMethods; end + +module GoodJob::Process::GeneratedAssociationMethods + # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#62 + def locked_job_ids; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/collection_association.rb#72 + def locked_job_ids=(ids); end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#103 + def locked_jobs; end + + # source://activerecord/7.0.8/lib/active_record/associations/builder/association.rb#111 + def locked_jobs=(value); end +end + module GoodJob::Process::GeneratedAttributeMethods; end +GoodJob::Process::LOCK_TYPES = T.let(T.unsafe(nil), Array) +GoodJob::Process::LOCK_TYPE_ADVISORY = T.let(T.unsafe(nil), String) +GoodJob::Process::LOCK_TYPE_ENUMS = T.let(T.unsafe(nil), Hash) GoodJob::Process::STALE_INTERVAL = T.let(T.unsafe(nil), ActiveSupport::Duration) class GoodJob::ProcessesController < ::GoodJob::ApplicationController @@ -3892,7 +4388,7 @@ end # If a performer does not have work, the thread will go to sleep. # The scheduler maintains an instance of +Concurrent::TimerTask+, which wakes sleeping threads and causes them to check whether the performer has new work. # -# source://good_job//lib/good_job/scheduler.rb#20 +# source://good_job//lib/good_job/scheduler.rb#19 class GoodJob::Scheduler # @param performer [GoodJob::JobPerformer] # @param max_threads [Numeric, nil] number of seconds between polls for jobs @@ -3903,33 +4399,32 @@ class GoodJob::Scheduler # @raise [ArgumentError] # @return [Scheduler] a new instance of Scheduler # - # source://good_job//lib/good_job/scheduler.rb#76 + # source://good_job//lib/good_job/scheduler.rb#48 def initialize(performer, max_threads: T.unsafe(nil), max_cache: T.unsafe(nil), warm_cache_on_initialize: T.unsafe(nil), cleanup_interval_seconds: T.unsafe(nil), cleanup_interval_jobs: T.unsafe(nil)); end # Preload existing runnable and future-scheduled jobs # # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#273 + # source://good_job//lib/good_job/scheduler.rb#238 def cleanup; end # Wakes a thread to allow the performer to execute a task. # # @param state [Hash, nil] Contextual information for the performer. See {JobPerformer#next?}. # @return [Boolean, nil] Whether work was started. - # # * +nil+ if the scheduler is unable to take new work, for example if the thread pool is shut down or at capacity. # * +true+ if the performer started executing work. # * +false+ if the performer decides not to attempt to execute a task based on the +state+ that is passed to it. # - # source://good_job//lib/good_job/scheduler.rb#159 + # source://good_job//lib/good_job/scheduler.rb#131 def create_thread(state = T.unsafe(nil)); end # Human readable name of the scheduler that includes configuration values. # # @return [String] # - # source://good_job//lib/good_job/scheduler.rb#68 + # source://good_job//lib/good_job/scheduler.rb#40 def name; end # Restart the Scheduler. @@ -3939,14 +4434,14 @@ class GoodJob::Scheduler # @raise [ArgumentError] # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#141 + # source://good_job//lib/good_job/scheduler.rb#114 def restart(timeout: T.unsafe(nil)); end # Tests whether the scheduler is running. # # @return [Boolean, nil] # - # source://good_job//lib/good_job/scheduler.rb#101 + # source://good_job//lib/good_job/scheduler.rb#72 def running?(*_arg0, **_arg1, &_arg2); end # Shut down the scheduler. @@ -3960,93 +4455,85 @@ class GoodJob::Scheduler # * A positive number will wait that many seconds before stopping any remaining active tasks. # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#116 + # source://good_job//lib/good_job/scheduler.rb#89 def shutdown(timeout: T.unsafe(nil)); end - # Tests whether the scheduler is shutdown. + # Tests whether the scheduler is shutdown and no tasks are running. # # @return [Boolean, nil] # - # source://good_job//lib/good_job/scheduler.rb#105 - def shutdown?(*_arg0, **_arg1, &_arg2); end + # source://good_job//lib/good_job/scheduler.rb#76 + def shutdown?; end # Information about the Scheduler # # @return [Hash] # - # source://good_job//lib/good_job/scheduler.rb#233 + # source://good_job//lib/good_job/scheduler.rb#197 def stats; end # Invoked on completion of ThreadPoolExecutor task # # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#204 + # source://good_job//lib/good_job/scheduler.rb#178 def task_observer(time, output, thread_error); end # Preload existing runnable and future-scheduled jobs # # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#249 + # source://good_job//lib/good_job/scheduler.rb#214 def warm_cache; end private - # source://good_job//lib/good_job/scheduler.rb#328 + # source://good_job//lib/good_job/scheduler.rb#298 def cache_count; end # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#295 + # source://good_job//lib/good_job/scheduler.rb#260 def create_executor; end # @param delay [Integer] + # @param fanout [Boolean] Whether to eagerly create a 2nd execution thread if a job is found. # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#304 - def create_task(delay = T.unsafe(nil)); end + # source://good_job//lib/good_job/scheduler.rb#270 + def create_task(delay = T.unsafe(nil), fanout: T.unsafe(nil)); end # Returns the value of attribute executor. # - # source://good_job//lib/good_job/scheduler.rb#292 + # source://good_job//lib/good_job/scheduler.rb#257 def executor; end # @param name [String] # @param payload [Hash] # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#318 + # source://good_job//lib/good_job/scheduler.rb#288 def instrument(name, payload = T.unsafe(nil), &block); end # Returns the value of attribute performer. # - # source://good_job//lib/good_job/scheduler.rb#292 + # source://good_job//lib/good_job/scheduler.rb#257 def performer; end - # source://good_job//lib/good_job/scheduler.rb#332 + # source://good_job//lib/good_job/scheduler.rb#302 def remaining_cache_count; end # Returns the value of attribute timer_set. # - # source://good_job//lib/good_job/scheduler.rb#292 + # source://good_job//lib/good_job/scheduler.rb#257 def timer_set; end class << self - # Creates GoodJob::Scheduler(s) and Performers from a GoodJob::Configuration instance. - # - # @param configuration [GoodJob::Configuration] - # @param warm_cache_on_initialize [Boolean] - # @return [GoodJob::Scheduler, GoodJob::MultiScheduler] - # - # source://good_job//lib/good_job/scheduler.rb#43 - def from_configuration(configuration, warm_cache_on_initialize: T.unsafe(nil)); end - # List of all instantiated Schedulers in the current process. # # @return [Array, nil] # - # source://good_job//lib/good_job/scheduler.rb#37 + # source://good_job//lib/good_job/scheduler.rb#36 def instances; end end end @@ -4054,21 +4541,21 @@ end # Defaults for instance of Concurrent::ThreadPoolExecutor # The thread pool executor is where work is performed. # -# source://good_job//lib/good_job/scheduler.rb#23 +# source://good_job//lib/good_job/scheduler.rb#22 GoodJob::Scheduler::DEFAULT_EXECUTOR_OPTIONS = T.let(T.unsafe(nil), Hash) # Custom sub-class of +Concurrent::ThreadPoolExecutor+ to add additional worker status. # # @private # -# source://good_job//lib/good_job/scheduler.rb#338 +# source://good_job//lib/good_job/scheduler.rb#308 class GoodJob::Scheduler::ThreadPoolExecutor < ::Concurrent::ThreadPoolExecutor # Number of inactive threads available to execute tasks. # https://github.com/ruby-concurrency/concurrent-ruby/issues/684#issuecomment-427594437 # # @return [Integer] # - # source://good_job//lib/good_job/scheduler.rb#342 + # source://good_job//lib/good_job/scheduler.rb#312 def ready_worker_count; end end @@ -4076,20 +4563,20 @@ end # # @private # -# source://good_job//lib/good_job/scheduler.rb#357 +# source://good_job//lib/good_job/scheduler.rb#327 class GoodJob::Scheduler::TimerSet < ::Concurrent::TimerSet # Number of scheduled jobs in the queue # # @return [Integer] # - # source://good_job//lib/good_job/scheduler.rb#360 + # source://good_job//lib/good_job/scheduler.rb#330 def length; end # Clear the queue # # @return [void] # - # source://good_job//lib/good_job/scheduler.rb#366 + # source://good_job//lib/good_job/scheduler.rb#336 def reset; end end @@ -4207,35 +4694,46 @@ class GoodJob::Setting < ::GoodJob::BaseRecord def cron_key_disable(key); end def cron_key_enable(key); end - def cron_key_enabled?(key); end + def cron_key_enabled?(key, default: T.unsafe(nil)); end # source://activerecord/7.0.8/lib/active_record/enum.rb#116 def defined_enums; end + + # source://activerecord/7.0.8/lib/active_record/model_schema.rb#157 + def implicit_order_column; end end end GoodJob::Setting::CRON_KEYS_DISABLED = T.let(T.unsafe(nil), String) +GoodJob::Setting::CRON_KEYS_ENABLED = T.let(T.unsafe(nil), String) module GoodJob::Setting::GeneratedAssociationMethods; end module GoodJob::Setting::GeneratedAttributeMethods; end -# source://good_job//lib/good_job/shared_executor.rb#4 +# source://good_job//lib/good_job/shared_executor.rb#6 class GoodJob::SharedExecutor + include ::Logger::Severity + include ::Concurrent::Concern::Logging + include ::Concurrent::ExecutorService + # @return [SharedExecutor] a new instance of SharedExecutor # - # source://good_job//lib/good_job/shared_executor.rb#15 + # source://good_job//lib/good_job/shared_executor.rb#20 def initialize; end # Returns the value of attribute executor. # - # source://good_job//lib/good_job/shared_executor.rb#13 + # source://good_job//lib/good_job/shared_executor.rb#18 def executor; end - # source://good_job//lib/good_job/shared_executor.rb#51 + # source://good_job//lib/good_job/shared_executor.rb#26 + def post(*args, &task); end + + # source://good_job//lib/good_job/shared_executor.rb#70 def restart(timeout: T.unsafe(nil)); end # @return [Boolean] # - # source://good_job//lib/good_job/shared_executor.rb#20 + # source://good_job//lib/good_job/shared_executor.rb#38 def running?; end # Shut down the SharedExecutor. @@ -4248,17 +4746,19 @@ class GoodJob::SharedExecutor # * A positive number will wait that many seconds before stopping any remaining active threads. # @return [void] # - # source://good_job//lib/good_job/shared_executor.rb#40 + # source://good_job//lib/good_job/shared_executor.rb#56 def shutdown(timeout: T.unsafe(nil)); end - # @return [Boolean] + # Tests whether the scheduler is shutdown and no tasks are running. + # + # @return [Boolean, nil] # - # source://good_job//lib/good_job/shared_executor.rb#24 + # source://good_job//lib/good_job/shared_executor.rb#44 def shutdown?; end private - # source://good_job//lib/good_job/shared_executor.rb#58 + # source://good_job//lib/good_job/shared_executor.rb#77 def create_executor; end class << self @@ -4266,12 +4766,12 @@ class GoodJob::SharedExecutor # # @return [Array, nil] # - # source://good_job//lib/good_job/shared_executor.rb#11 + # source://good_job//lib/good_job/shared_executor.rb#16 def instances; end end end -# source://good_job//lib/good_job/shared_executor.rb#5 +# source://good_job//lib/good_job/shared_executor.rb#10 GoodJob::SharedExecutor::MAX_THREADS = T.let(T.unsafe(nil), Integer) # Manages communication with systemd to notify it about the status of the @@ -4315,6 +4815,26 @@ class GoodJob::SystemdService end end +# Provides methods for determining the status of the +# current job execution thread. This is useful for determining +# whether to continue processing a job or to shut down gracefully. +# +# source://good_job//lib/good_job/thread_status.rb#7 +module GoodJob::ThreadStatus + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::GoodJob::ThreadStatus::ClassMethods +end + +# source://good_job//lib/good_job/thread_status.rb#0 +module GoodJob::ThreadStatus::ClassMethods + # source://good_job//lib/good_job/thread_status.rb#13 + def current_thread_running?; end + + # source://good_job//lib/good_job/thread_status.rb#21 + def current_thread_shutting_down?; end +end + # GoodJob gem version. # # source://good_job//lib/good_job/version.rb#5 diff --git a/sorbet/rbi/gems/irb@1.8.1.rbi b/sorbet/rbi/gems/irb@1.8.1.rbi deleted file mode 100644 index 8952e90..0000000 --- a/sorbet/rbi/gems/irb@1.8.1.rbi +++ /dev/null @@ -1,2797 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `irb` gem. -# Please instead update this file by running `bin/tapioca gem irb`. - -# IRB stands for "interactive Ruby" and is a tool to interactively execute Ruby -# expressions read from the standard input. -# -# The +irb+ command from your shell will start the interpreter. -# -# == Usage -# -# Use of irb is easy if you know Ruby. -# -# When executing irb, prompts are displayed as follows. Then, enter the Ruby -# expression. An input is executed when it is syntactically complete. -# -# $ irb -# irb(main):001:0> 1+2 -# #=> 3 -# irb(main):002:0> class Foo -# irb(main):003:1> def foo -# irb(main):004:2> print 1 -# irb(main):005:2> end -# irb(main):006:1> end -# #=> nil -# -# The singleline editor module or multiline editor module can be used with irb. -# Use of multiline editor is default if it's installed. -# -# == Command line options -# -# :include: ./irb/lc/help-message -# -# == Commands -# -# The following commands are available on IRB. -# -# * cwws -# * Show the current workspace. -# * cb, cws, chws -# * Change the current workspace to an object. -# * bindings, workspaces -# * Show workspaces. -# * pushb, pushws -# * Push an object to the workspace stack. -# * popb, popws -# * Pop a workspace from the workspace stack. -# * load -# * Load a Ruby file. -# * require -# * Require a Ruby file. -# * source -# * Loads a given file in the current session. -# * irb -# * Start a child IRB. -# * jobs -# * List of current sessions. -# * fg -# * Switches to the session of the given number. -# * kill -# * Kills the session with the given number. -# * help -# * Enter the mode to look up RI documents. -# * irb_info -# * Show information about IRB. -# * ls -# * Show methods, constants, and variables. -# -g [query] or -G [query] allows you to filter out the output. -# * measure -# * measure enables the mode to measure processing time. measure :off disables it. -# * $, show_source -# * Show the source code of a given method or constant. -# * @, whereami -# * Show the source code around binding.irb again. -# * debug -# * Start the debugger of debug.gem. -# * break, delete, next, step, continue, finish, backtrace, info, catch -# * Start the debugger of debug.gem and run the command on it. -# -# == Configuration -# -# IRB reads a personal initialization file when it's invoked. -# IRB searches a file in the following order and loads the first one found. -# -# * $IRBRC (if $IRBRC is set) -# * $XDG_CONFIG_HOME/irb/irbrc (if $XDG_CONFIG_HOME is set) -# * ~/.irbrc -# * +.config/irb/irbrc+ -# * +.irbrc+ -# * +irb.rc+ -# * +_irbrc+ -# * $irbrc -# -# The following are alternatives to the command line options. To use them type -# as follows in an +irb+ session: -# -# IRB.conf[:IRB_NAME]="irb" -# IRB.conf[:INSPECT_MODE]=nil -# IRB.conf[:IRB_RC] = nil -# IRB.conf[:BACK_TRACE_LIMIT]=16 -# IRB.conf[:USE_LOADER] = false -# IRB.conf[:USE_MULTILINE] = nil -# IRB.conf[:USE_SINGLELINE] = nil -# IRB.conf[:USE_COLORIZE] = true -# IRB.conf[:USE_TRACER] = false -# IRB.conf[:USE_AUTOCOMPLETE] = true -# IRB.conf[:IGNORE_SIGINT] = true -# IRB.conf[:IGNORE_EOF] = false -# IRB.conf[:PROMPT_MODE] = :DEFAULT -# IRB.conf[:PROMPT] = {...} -# -# === Auto indentation -# -# To disable auto-indent mode in irb, add the following to your +.irbrc+: -# -# IRB.conf[:AUTO_INDENT] = false -# -# === Autocompletion -# -# To disable autocompletion for irb, add the following to your +.irbrc+: -# -# IRB.conf[:USE_AUTOCOMPLETE] = false -# -# === History -# -# By default, irb will store the last 1000 commands you used in -# IRB.conf[:HISTORY_FILE] (~/.irb_history by default). -# -# If you want to disable history, add the following to your +.irbrc+: -# -# IRB.conf[:SAVE_HISTORY] = nil -# -# See IRB::Context#save_history= for more information. -# -# The history of _results_ of commands evaluated is not stored by default, -# but can be turned on to be stored with this +.irbrc+ setting: -# -# IRB.conf[:EVAL_HISTORY] = -# -# See IRB::Context#eval_history= and EvalHistory class. The history of command -# results is not permanently saved in any file. -# -# == Customizing the IRB Prompt -# -# In order to customize the prompt, you can change the following Hash: -# -# IRB.conf[:PROMPT] -# -# This example can be used in your +.irbrc+ -# -# IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode -# :AUTO_INDENT => false, # disables auto-indent mode -# :PROMPT_I => ">> ", # simple prompt -# :PROMPT_S => nil, # prompt for continuated strings -# :PROMPT_C => nil, # prompt for continuated statement -# :RETURN => " ==>%s\n" # format to return value -# } -# -# IRB.conf[:PROMPT_MODE] = :MY_PROMPT -# -# Or, invoke irb with the above prompt mode by: -# -# irb --prompt my-prompt -# -# Constants +PROMPT_I+, +PROMPT_S+ and +PROMPT_C+ specify the format. In the -# prompt specification, some special strings are available: -# -# %N # command name which is running -# %m # to_s of main object (self) -# %M # inspect of main object (self) -# %l # type of string(", ', /, ]), `]' is inner %w[...] -# %NNi # indent level. NN is digits and means as same as printf("%NNd"). -# # It can be omitted -# %NNn # line number. -# %% # % -# -# For instance, the default prompt mode is defined as follows: -# -# IRB.conf[:PROMPT_MODE][:DEFAULT] = { -# :PROMPT_I => "%N(%m):%03n> ", -# :PROMPT_S => "%N(%m):%03n%l ", -# :PROMPT_C => "%N(%m):%03n* ", -# :RETURN => "%s\n" # used to printf -# } -# -# irb comes with a number of available modes: -# -# # :NULL: -# # :PROMPT_I: -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: | -# # %s -# # :DEFAULT: -# # :PROMPT_I: ! '%N(%m):%03n> ' -# # :PROMPT_S: ! '%N(%m):%03n%l ' -# # :PROMPT_C: ! '%N(%m):%03n* ' -# # :RETURN: | -# # => %s -# # :CLASSIC: -# # :PROMPT_I: ! '%N(%m):%03n:%i> ' -# # :PROMPT_S: ! '%N(%m):%03n:%i%l ' -# # :PROMPT_C: ! '%N(%m):%03n:%i* ' -# # :RETURN: | -# # %s -# # :SIMPLE: -# # :PROMPT_I: ! '>> ' -# # :PROMPT_S: -# # :PROMPT_C: ! '?> ' -# # :RETURN: | -# # => %s -# # :INF_RUBY: -# # :PROMPT_I: ! '%N(%m):%03n> ' -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: | -# # %s -# # :AUTO_INDENT: true -# # :XMP: -# # :PROMPT_I: -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: |2 -# # ==>%s -# -# == Restrictions -# -# Because irb evaluates input immediately after it is syntactically complete, -# the results may be slightly different than directly using Ruby. -# -# == IRB Sessions -# -# IRB has a special feature, that allows you to manage many sessions at once. -# -# You can create new sessions with Irb.irb, and get a list of current sessions -# with the +jobs+ command in the prompt. -# -# === Commands -# -# JobManager provides commands to handle the current sessions: -# -# jobs # List of current sessions -# fg # Switches to the session of the given number -# kill # Kills the session with the given number -# -# The +exit+ command, or ::irb_exit, will quit the current session and call any -# exit hooks with IRB.irb_at_exit. -# -# A few commands for loading files within the session are also available: -# -# +source+:: -# Loads a given file in the current session and displays the source lines, -# see IrbLoader#source_file -# +irb_load+:: -# Loads the given file similarly to Kernel#load, see IrbLoader#irb_load -# +irb_require+:: -# Loads the given file similarly to Kernel#require -# -# === Configuration -# -# The command line options, or IRB.conf, specify the default behavior of -# Irb.irb. -# -# On the other hand, each conf in IRB@Command+line+options is used to -# individually configure IRB.irb. -# -# If a proc is set for IRB.conf[:IRB_RC], its will be invoked after execution -# of that proc with the context of the current session as its argument. Each -# session can be configured using this mechanism. -# -# === Session variables -# -# There are a few variables in every Irb session that can come in handy: -# -# _:: -# The value command executed, as a local variable -# __:: -# The history of evaluated commands. Available only if -# IRB.conf[:EVAL_HISTORY] is not +nil+ (which is the default). -# See also IRB::Context#eval_history= and IRB::History. -# __[line_no]:: -# Returns the evaluation value at the given line number, +line_no+. -# If +line_no+ is a negative, the return value +line_no+ many lines before -# the most recent return value. -# -# === Example using IRB Sessions -# -# # invoke a new session -# irb(main):001:0> irb -# # list open sessions -# irb.1(main):001:0> jobs -# #0->irb on main (# : stop) -# #1->irb#1 on main (# : running) -# -# # change the active session -# irb.1(main):002:0> fg 0 -# # define class Foo in top-level session -# irb(main):002:0> class Foo;end -# # invoke a new session with the context of Foo -# irb(main):003:0> irb Foo -# # define Foo#foo -# irb.2(Foo):001:0> def foo -# irb.2(Foo):002:1> print 1 -# irb.2(Foo):003:1> end -# -# # change the active session -# irb.2(Foo):004:0> fg 0 -# # list open sessions -# irb(main):004:0> jobs -# #0->irb on main (# : running) -# #1->irb#1 on main (# : stop) -# #2->irb#2 on Foo (# : stop) -# # check if Foo#foo is available -# irb(main):005:0> Foo.instance_methods #=> [:foo, ...] -# -# # change the active session -# irb(main):006:0> fg 2 -# # define Foo#bar in the context of Foo -# irb.2(Foo):005:0> def bar -# irb.2(Foo):006:1> print "bar" -# irb.2(Foo):007:1> end -# irb.2(Foo):010:0> Foo.instance_methods #=> [:bar, :foo, ...] -# -# # change the active session -# irb.2(Foo):011:0> fg 0 -# irb(main):007:0> f = Foo.new #=> # -# # invoke a new session with the context of f (instance of Foo) -# irb(main):008:0> irb f -# # list open sessions -# irb.3():001:0> jobs -# #0->irb on main (# : stop) -# #1->irb#1 on main (# : stop) -# #2->irb#2 on Foo (# : stop) -# #3->irb#3 on # (# : running) -# # evaluate f.foo -# irb.3():002:0> foo #=> 1 => nil -# # evaluate f.bar -# irb.3():003:0> bar #=> bar => nil -# # kill jobs 1, 2, and 3 -# irb.3():004:0> kill 1, 2, 3 -# # list open sessions, should only include main session -# irb(main):009:0> jobs -# #0->irb on main (# : running) -# # quit irb -# irb(main):010:0> exit -# -# source://irb//lib/irb/init.rb#7 -module IRB - class << self - # The current IRB::Context of the session, see IRB.conf - # - # irb - # irb(main):001:0> IRB.CurrentContext.irb_name = "foo" - # foo(main):002:0> IRB.conf[:MAIN_CONTEXT].irb_name #=> "foo" - # - # source://irb//lib/irb.rb#393 - def CurrentContext; end - - # Convenience method to create a new Inspector, using the given +inspect+ - # proc, and optional +init+ proc and passes them to Inspector.new - # - # irb(main):001:0> ins = IRB::Inspector(proc{ |v| "omg! #{v}" }) - # irb(main):001:0> IRB.CurrentContext.inspect_mode = ins # => omg! # - # irb(main):001:0> "what?" #=> omg! what? - # - # source://irb//lib/irb/inspector.rb#17 - def Inspector(inspect, init = T.unsafe(nil)); end - - # Displays current configuration. - # - # Modifying the configuration is achieved by sending a message to IRB.conf. - # - # See IRB@Configuration for more information. - # - # source://irb//lib/irb.rb#376 - def conf; end - - # source://irb//lib/irb/init.rb#23 - def init_config(ap_path); end - - # source://irb//lib/irb/init.rb#206 - def init_error; end - - # Aborts then interrupts irb. - # - # Will raise an Abort exception, or the given +exception+. - # - # source://irb//lib/irb.rb#420 - def irb_abort(irb, exception = T.unsafe(nil)); end - - # Quits irb - # - # source://irb//lib/irb.rb#413 - def irb_exit(irb, ret); end - - # loading modules - # - # source://irb//lib/irb/init.rb#408 - def load_modules; end - - # option analyzing - # - # source://irb//lib/irb/init.rb#211 - def parse_opts(argv: T.unsafe(nil)); end - - # source://irb//lib/irb/init.rb#367 - def rc_file(ext = T.unsafe(nil)); end - - # enumerate possible rc-file base name generators - # - # @yield [proc{|rc| current_dir+"/.irb#{rc}"}] - # - # source://irb//lib/irb/init.rb#386 - def rc_file_generators; end - - # running config - # - # source://irb//lib/irb/init.rb#351 - def run_config; end - - # source://irb//lib/irb/init.rb#161 - def set_measure_callback(type = T.unsafe(nil), arg = T.unsafe(nil), &block); end - - # initialize config - # - # source://irb//lib/irb/init.rb#10 - def setup(ap_path, argv: T.unsafe(nil)); end - - # Initializes IRB and creates a new Irb.irb object at the +TOPLEVEL_BINDING+ - # - # source://irb//lib/irb.rb#398 - def start(ap_path = T.unsafe(nil)); end - - # source://irb//lib/irb/init.rb#197 - def unset_measure_callback(type = T.unsafe(nil)); end - - # Returns the current version of IRB, including release version and last - # updated date. - # - # source://irb//lib/irb.rb#382 - def version; end - - private - - # source://irb//lib/irb/easter-egg.rb#101 - def easter_egg(type = T.unsafe(nil)); end - - # source://irb//lib/irb/init.rb#420 - def set_encoding(extern, intern = T.unsafe(nil), override: T.unsafe(nil)); end - end -end - -# source://irb//lib/irb/color.rb#7 -module IRB::Color - class << self - # source://irb//lib/irb/color.rb#114 - def clear(colorable: T.unsafe(nil)); end - - # @return [Boolean] - # - # source://irb//lib/irb/color.rb#81 - def colorable?; end - - # source://irb//lib/irb/color.rb#119 - def colorize(text, seq, colorable: T.unsafe(nil)); end - - # If `complete` is false (code is incomplete), this does not warn compile_error. - # This option is needed to avoid warning a user when the compile_error is happening - # because the input is not wrong but just incomplete. - # - # source://irb//lib/irb/color.rb#128 - def colorize_code(code, complete: T.unsafe(nil), ignore_error: T.unsafe(nil), colorable: T.unsafe(nil), local_variables: T.unsafe(nil)); end - - # @return [Boolean] - # - # source://irb//lib/irb/color.rb#93 - def inspect_colorable?(obj, seen: T.unsafe(nil)); end - - private - - # source://irb//lib/irb/color.rb#213 - def dispatch_seq(token, expr, str, in_symbol:); end - - # source://irb//lib/irb/color.rb#177 - def scan(code, allow_last_error:); end - - # source://irb//lib/irb/color.rb#169 - def without_circular_ref(obj, seen:, &block); end - end -end - -# A constant of all-bit 1 to match any Ripper's state in #dispatch_seq -# -# source://irb//lib/irb/color.rb#28 -IRB::Color::ALL = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#12 -IRB::Color::BLACK = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#16 -IRB::Color::BLUE = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#9 -IRB::Color::BOLD = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#8 -IRB::Color::CLEAR = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#18 -IRB::Color::CYAN = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#77 -IRB::Color::ERROR_TOKENS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/color.rb#14 -IRB::Color::GREEN = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#17 -IRB::Color::MAGENTA = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#13 -IRB::Color::RED = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#11 -IRB::Color::REVERSE = T.let(T.unsafe(nil), Integer) - -# A class to manage a state to know whether the current token is for Symbol or not. -# -# source://irb//lib/irb/color.rb#229 -class IRB::Color::SymbolState - # @return [SymbolState] a new instance of SymbolState - # - # source://irb//lib/irb/color.rb#230 - def initialize; end - - # Return true if the token is a part of Symbol. - # - # source://irb//lib/irb/color.rb#236 - def scan_token(token); end -end - -# source://irb//lib/irb/color.rb#21 -IRB::Color::TOKEN_KEYWORDS = T.let(T.unsafe(nil), Hash) - -# source://irb//lib/irb/color.rb#34 -IRB::Color::TOKEN_SEQ_EXPRS = T.let(T.unsafe(nil), Hash) - -# source://irb//lib/irb/color.rb#10 -IRB::Color::UNDERLINE = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#19 -IRB::Color::WHITE = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/color.rb#15 -IRB::Color::YELLOW = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb/context.rb#15 -class IRB::Context - # Creates a new IRB context. - # - # The optional +input_method+ argument: - # - # +nil+:: uses stdin or Reline or Readline - # +String+:: uses a File - # +other+:: uses this as InputMethod - # - # @return [Context] a new instance of Context - # - # source://irb//lib/irb/context.rb#23 - def initialize(irb, workspace = T.unsafe(nil), input_method = T.unsafe(nil)); end - - # A copy of the default IRB.conf[:AP_NAME] - # - # source://irb//lib/irb/context.rb#191 - def ap_name; end - - # A copy of the default IRB.conf[:AP_NAME] - # - # source://irb//lib/irb/context.rb#191 - def ap_name=(_arg0); end - - # Can be either the default IRB.conf[:AUTO_INDENT], or the - # mode set by #prompt_mode= - # - # To disable auto-indentation in irb: - # - # IRB.conf[:AUTO_INDENT] = false - # - # or - # - # irb_context.auto_indent_mode = false - # - # or - # - # IRB.CurrentContext.auto_indent_mode = false - # - # See IRB@Configuration for more information. - # - # source://irb//lib/irb/context.rb#261 - def auto_indent_mode; end - - # Can be either the default IRB.conf[:AUTO_INDENT], or the - # mode set by #prompt_mode= - # - # To disable auto-indentation in irb: - # - # IRB.conf[:AUTO_INDENT] = false - # - # or - # - # irb_context.auto_indent_mode = false - # - # or - # - # IRB.CurrentContext.auto_indent_mode = false - # - # See IRB@Configuration for more information. - # - # source://irb//lib/irb/context.rb#261 - def auto_indent_mode=(_arg0); end - - # The limit of backtrace lines displayed as top +n+ and tail +n+. - # - # The default value is 16. - # - # Can also be set using the +--back-trace-limit+ command line option. - # - # See IRB@Command+line+options for more command line options. - # - # source://irb//lib/irb/context.rb#354 - def back_trace_limit; end - - # The limit of backtrace lines displayed as top +n+ and tail +n+. - # - # The default value is 16. - # - # Can also be set using the +--back-trace-limit+ command line option. - # - # See IRB@Command+line+options for more command line options. - # - # source://irb//lib/irb/context.rb#354 - def back_trace_limit=(_arg0); end - - # User-defined IRB command aliases - # - # source://irb//lib/irb/context.rb#357 - def command_aliases; end - - # User-defined IRB command aliases - # - # source://irb//lib/irb/context.rb#357 - def command_aliases=(_arg0); end - - # Whether to echo the return value to output or not. - # - # Uses IRB.conf[:ECHO] if available, or defaults to +true+. - # - # puts "hello" - # # hello - # #=> nil - # IRB.CurrentContext.echo = false - # puts "omg" - # # omg - # - # source://irb//lib/irb/context.rb#292 - def echo; end - - # Whether to echo the return value to output or not. - # - # Uses IRB.conf[:ECHO] if available, or defaults to +true+. - # - # puts "hello" - # # hello - # #=> nil - # IRB.CurrentContext.echo = false - # puts "omg" - # # omg - # - # source://irb//lib/irb/context.rb#292 - def echo=(_arg0); end - - # Whether to echo the return value to output or not. - # - # Uses IRB.conf[:ECHO] if available, or defaults to +true+. - # - # puts "hello" - # # hello - # #=> nil - # IRB.CurrentContext.echo = false - # puts "omg" - # # omg - # - # source://irb//lib/irb/context.rb#292 - def echo?; end - - # Whether to echo for assignment expressions. - # - # If set to +false+, the value of assignment will not be shown. - # - # If set to +true+, the value of assignment will be shown. - # - # If set to +:truncate+, the value of assignment will be shown and truncated. - # - # It defaults to +:truncate+. - # - # a = "omg" - # #=> omg - # - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomg... - # - # IRB.CurrentContext.echo_on_assignment = false - # a = "omg" - # - # IRB.CurrentContext.echo_on_assignment = true - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomgomgomgomg - # - # To set the behaviour of showing on assignment in irb: - # - # IRB.conf[:ECHO_ON_ASSIGNMENT] = :truncate or true or false - # - # or - # - # irb_context.echo_on_assignment = :truncate or true or false - # - # or - # - # IRB.CurrentContext.echo_on_assignment = :truncate or true or false - # - # source://irb//lib/irb/context.rb#327 - def echo_on_assignment; end - - # Whether to echo for assignment expressions. - # - # If set to +false+, the value of assignment will not be shown. - # - # If set to +true+, the value of assignment will be shown. - # - # If set to +:truncate+, the value of assignment will be shown and truncated. - # - # It defaults to +:truncate+. - # - # a = "omg" - # #=> omg - # - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomg... - # - # IRB.CurrentContext.echo_on_assignment = false - # a = "omg" - # - # IRB.CurrentContext.echo_on_assignment = true - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomgomgomgomg - # - # To set the behaviour of showing on assignment in irb: - # - # IRB.conf[:ECHO_ON_ASSIGNMENT] = :truncate or true or false - # - # or - # - # irb_context.echo_on_assignment = :truncate or true or false - # - # or - # - # IRB.CurrentContext.echo_on_assignment = :truncate or true or false - # - # source://irb//lib/irb/context.rb#327 - def echo_on_assignment=(_arg0); end - - # Whether to echo for assignment expressions. - # - # If set to +false+, the value of assignment will not be shown. - # - # If set to +true+, the value of assignment will be shown. - # - # If set to +:truncate+, the value of assignment will be shown and truncated. - # - # It defaults to +:truncate+. - # - # a = "omg" - # #=> omg - # - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomg... - # - # IRB.CurrentContext.echo_on_assignment = false - # a = "omg" - # - # IRB.CurrentContext.echo_on_assignment = true - # a = "omg" * 10 - # #=> omgomgomgomgomgomgomgomgomgomg - # - # To set the behaviour of showing on assignment in irb: - # - # IRB.conf[:ECHO_ON_ASSIGNMENT] = :truncate or true or false - # - # or - # - # irb_context.echo_on_assignment = :truncate or true or false - # - # or - # - # IRB.CurrentContext.echo_on_assignment = :truncate or true or false - # - # source://irb//lib/irb/context.rb#327 - def echo_on_assignment?; end - - # Sets command result history limit. Default value is set from - # IRB.conf[:EVAL_HISTORY]. - # - # +no+ is an Integer or +nil+. - # - # Returns +no+ of history items if greater than 0. - # - # If +no+ is 0, the number of history items is unlimited. - # - # If +no+ is +nil+, execution result history isn't used (default). - # - # EvalHistory values are available via __ variable, see - # IRB::EvalHistory. - # - # source://irb//lib/irb/extend-command.rb#341 - def eval_history=(*opts, &b); end - - # source://irb//lib/irb/context.rb#504 - def evaluate(line, line_no); end - - # Exits the current session, see IRB.irb_exit - # - # source://irb//lib/irb/context.rb#537 - def exit(ret = T.unsafe(nil)); end - - # Specify the installation locations of the ri file to be displayed in the - # document dialog. - # - # source://irb//lib/irb/context.rb#281 - def extra_doc_dirs; end - - # Specify the installation locations of the ri file to be displayed in the - # document dialog. - # - # source://irb//lib/irb/context.rb#281 - def extra_doc_dirs=(_arg0); end - - # Whether #io uses a File for the +input_method+ passed when creating the - # current context, see ::new - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#444 - def file_input?; end - - # A copy of the default IRB.conf[:HISTORY_FILE] - # - # source://irb//lib/irb/context.rb#161 - def history_file; end - - # Set IRB.conf[:HISTORY_FILE] to the given +hist+. - # - # source://irb//lib/irb/context.rb#166 - def history_file=(hist); end - - # Whether ^D (+control-d+) will be ignored or not. - # - # If set to +false+, ^D will quit irb. - # - # source://irb//lib/irb/context.rb#278 - def ignore_eof; end - - # Whether ^D (+control-d+) will be ignored or not. - # - # If set to +false+, ^D will quit irb. - # - # source://irb//lib/irb/context.rb#278 - def ignore_eof=(_arg0); end - - # Whether ^D (+control-d+) will be ignored or not. - # - # If set to +false+, ^D will quit irb. - # - # source://irb//lib/irb/context.rb#278 - def ignore_eof?; end - - # Whether ^C (+control-c+) will be ignored or not. - # - # If set to +false+, ^C will quit irb. - # - # If set to +true+, - # - # * during input: cancel input then return to top level. - # * during execute: abandon current execution. - # - # source://irb//lib/irb/context.rb#274 - def ignore_sigint; end - - # Whether ^C (+control-c+) will be ignored or not. - # - # If set to +false+, ^C will quit irb. - # - # If set to +true+, - # - # * during input: cancel input then return to top level. - # * during execute: abandon current execution. - # - # source://irb//lib/irb/context.rb#274 - def ignore_sigint=(_arg0); end - - # Whether ^C (+control-c+) will be ignored or not. - # - # If set to +false+, ^C will quit irb. - # - # If set to +true+, - # - # * during input: cancel input then return to top level. - # * during execute: abandon current execution. - # - # source://irb//lib/irb/context.rb#274 - def ignore_sigint?; end - - # source://irb//lib/irb/context.rb#548 - def inspect; end - - # Whether #inspect_mode is set or not, see #inspect_mode= for more detail. - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#438 - def inspect?; end - - # source://irb//lib/irb/context.rb#531 - def inspect_last_value; end - - # A copy of the default IRB.conf[:INSPECT_MODE] - # - # source://irb//lib/irb/context.rb#216 - def inspect_mode; end - - # Specifies the inspect mode with +opt+: - # - # +true+:: display +inspect+ - # +false+:: display +to_s+ - # +nil+:: inspect mode in non-math mode, - # non-inspect mode in math mode - # - # See IRB::Inspector for more information. - # - # Can also be set using the +--inspect+ and +--noinspect+ command line - # options. - # - # See IRB@Command+line+options for more command line options. - # - # source://irb//lib/irb/context.rb#461 - def inspect_mode=(opt); end - - # The current input method. - # - # Can be either StdioInputMethod, ReadlineInputMethod, - # RelineInputMethod, FileInputMethod or other specified when the - # context is created. See ::new for more # information on +input_method+. - # - # source://irb//lib/irb/context.rb#186 - def io; end - - # The current input method. - # - # Can be either StdioInputMethod, ReadlineInputMethod, - # RelineInputMethod, FileInputMethod or other specified when the - # context is created. See ::new for more # information on +input_method+. - # - # source://irb//lib/irb/context.rb#186 - def io=(_arg0); end - - # Current irb session. - # - # source://irb//lib/irb/context.rb#189 - def irb; end - - # Current irb session. - # - # source://irb//lib/irb/context.rb#189 - def irb=(_arg0); end - - # Can be either name from IRB.conf[:IRB_NAME], or the number of - # the current job set by JobManager, such as irb#2 - # - # source://irb//lib/irb/context.rb#198 - def irb_name; end - - # Can be either name from IRB.conf[:IRB_NAME], or the number of - # the current job set by JobManager, such as irb#2 - # - # source://irb//lib/irb/context.rb#198 - def irb_name=(_arg0); end - - # Can be either the #irb_name surrounded by parenthesis, or the - # +input_method+ passed to Context.new - # - # source://irb//lib/irb/context.rb#201 - def irb_path; end - - # Can be either the #irb_name surrounded by parenthesis, or the - # +input_method+ passed to Context.new - # - # source://irb//lib/irb/context.rb#201 - def irb_path=(_arg0); end - - # The return value of the last statement evaluated. - # - # source://irb//lib/irb/context.rb#410 - def last_value; end - - # A copy of the default IRB.conf[:LOAD_MODULES] - # - # source://irb//lib/irb/context.rb#195 - def load_modules; end - - # A copy of the default IRB.conf[:LOAD_MODULES] - # - # source://irb//lib/irb/context.rb#195 - def load_modules=(_arg0); end - - # source://irb//lib/irb/context.rb#570 - def local_variables; end - - # The top-level workspace, see WorkSpace#main - # - # source://irb//lib/irb/context.rb#171 - def main; end - - # Whether a newline is put before multiline output. - # - # Uses IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT] if available, - # or defaults to +true+. - # - # "abc\ndef" - # #=> - # abc - # def - # IRB.CurrentContext.newline_before_multiline_output = false - # "abc\ndef" - # #=> abc - # def - # - # source://irb//lib/irb/context.rb#341 - def newline_before_multiline_output; end - - # Whether a newline is put before multiline output. - # - # Uses IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT] if available, - # or defaults to +true+. - # - # "abc\ndef" - # #=> - # abc - # def - # IRB.CurrentContext.newline_before_multiline_output = false - # "abc\ndef" - # #=> abc - # def - # - # source://irb//lib/irb/context.rb#341 - def newline_before_multiline_output=(_arg0); end - - # Whether a newline is put before multiline output. - # - # Uses IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT] if available, - # or defaults to +true+. - # - # "abc\ndef" - # #=> - # abc - # def - # IRB.CurrentContext.newline_before_multiline_output = false - # "abc\ndef" - # #=> abc - # def - # - # source://irb//lib/irb/context.rb#341 - def newline_before_multiline_output?; end - - # IRB prompt for continuated statement. (e.g. immediately after an +if+) - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#231 - def prompt_c; end - - # IRB prompt for continuated statement. (e.g. immediately after an +if+) - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#231 - def prompt_c=(_arg0); end - - # Standard IRB prompt. - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#223 - def prompt_i; end - - # Standard IRB prompt. - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#223 - def prompt_i=(_arg0); end - - # A copy of the default IRB.conf[:PROMPT_MODE] - # - # source://irb//lib/irb/context.rb#219 - def prompt_mode; end - - # Sets the +mode+ of the prompt in this context. - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#422 - def prompt_mode=(mode); end - - # TODO: Remove this when developing v2.0 - # - # source://irb//lib/irb/context.rb#234 - def prompt_n; end - - # TODO: Remove this when developing v2.0 - # - # source://irb//lib/irb/context.rb#240 - def prompt_n=(_); end - - # IRB prompt for continuated strings. - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#227 - def prompt_s; end - - # IRB prompt for continuated strings. - # - # See IRB@Customizing+the+IRB+Prompt for more information. - # - # source://irb//lib/irb/context.rb#227 - def prompt_s=(_arg0); end - - # Whether #verbose? is +true+, and +input_method+ is either - # StdioInputMethod or RelineInputMethod or ReadlineInputMethod, see #io - # for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#403 - def prompting?; end - - # A copy of the default IRB.conf[:RC] - # - # source://irb//lib/irb/context.rb#193 - def rc; end - - # A copy of the default IRB.conf[:RC] - # - # source://irb//lib/irb/context.rb#193 - def rc=(_arg0); end - - # A copy of the default IRB.conf[:RC] - # Alias for #rc - # - # source://irb//lib/irb/context.rb#193 - def rc?; end - - # The format of the return statement, set by #prompt_mode= using the - # +:RETURN+ of the +mode+ passed to set the current #prompt_mode. - # - # source://irb//lib/irb/context.rb#264 - def return_format; end - - # The format of the return statement, set by #prompt_mode= using the - # +:RETURN+ of the +mode+ passed to set the current #prompt_mode. - # - # source://irb//lib/irb/context.rb#264 - def return_format=(_arg0); end - - # source://irb//lib/irb/context.rb#156 - def save_history; end - - # source://irb//lib/irb/context.rb#152 - # def save_history=(val); end - - # Sets the return value from the last statement evaluated in this context - # to #last_value. - # - # source://irb//lib/irb/context.rb#414 - def set_last_value(value); end - - # Return true if it's aliased from the argument and it's not an identifier. - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#575 - def symbol_alias?(command); end - - # The current thread in this context. - # - # source://irb//lib/irb/context.rb#180 - def thread; end - - # source://irb//lib/irb/context.rb#548 - def to_s; end - - # Return true if the command supports transforming args - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#581 - def transform_args?(command); end - - # Whether colorization is enabled or not. - # - # A copy of the default IRB.conf[:USE_AUTOCOMPLETE] - # - # source://irb//lib/irb/context.rb#214 - def use_autocomplete; end - - # Whether colorization is enabled or not. - # - # A copy of the default IRB.conf[:USE_AUTOCOMPLETE] - # Alias for #use_autocomplete - # - # source://irb//lib/irb/context.rb#214 - def use_autocomplete?; end - - # Sets IRB.conf[:USE_LOADER] - # - # See #use_loader for more information. - # - # source://irb//lib/irb/extend-command.rb#341 - def use_loader=(*opts, &b); end - - # Whether multiline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_MULTILINE] - # - # source://irb//lib/irb/context.rb#206 - def use_multiline; end - - # Whether multiline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_MULTILINE] - # Alias for #use_multiline - # - # source://irb//lib/irb/context.rb#206 - def use_multiline?; end - - # Whether singleline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_SINGLELINE] - # backward compatibility - # - # source://irb//lib/irb/context.rb#210 - def use_readline; end - - # Whether singleline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_SINGLELINE] - # backward compatibility - # - # source://irb//lib/irb/context.rb#210 - def use_readline?; end - - # Whether multiline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_MULTILINE] - # backward compatibility - # - # source://irb//lib/irb/context.rb#206 - def use_reline; end - - # Whether multiline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_MULTILINE] - # backward compatibility - # - # source://irb//lib/irb/context.rb#206 - def use_reline?; end - - # Whether singleline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_SINGLELINE] - # - # source://irb//lib/irb/context.rb#210 - def use_singleline; end - - # Whether singleline editor mode is enabled or not. - # - # A copy of the default IRB.conf[:USE_SINGLELINE] - # Alias for #use_singleline - # - # source://irb//lib/irb/context.rb#210 - def use_singleline?; end - - # Sets whether or not to use the Tracer library when evaluating statements - # in this context. - # - # See +lib/tracer.rb+ for more information. - # - # source://irb//lib/irb/extend-command.rb#341 - def use_tracer=(*opts, &b); end - - # Whether verbose messages are displayed or not. - # - # A copy of the default IRB.conf[:VERBOSE] - # - # source://irb//lib/irb/context.rb#345 - def verbose; end - - # Whether verbose messages are displayed or not. - # - # A copy of the default IRB.conf[:VERBOSE] - # - # source://irb//lib/irb/context.rb#345 - def verbose=(_arg0); end - - # Returns whether messages are displayed or not. - # - # @return [Boolean] - # - # source://irb//lib/irb/context.rb#384 - def verbose?; end - - # Returns the value of attribute with_debugger. - # - # source://irb//lib/irb/context.rb#359 - def with_debugger; end - - # Sets the attribute with_debugger - # - # @param value the value to set the attribute with_debugger to. - # - # source://irb//lib/irb/context.rb#359 - def with_debugger=(_arg0); end - - # WorkSpace in the current context. - # - # source://irb//lib/irb/context.rb#178 - def workspace; end - - # WorkSpace in the current context. - # - # source://irb//lib/irb/context.rb#178 - def workspace=(_arg0); end - - # The toplevel workspace, see #home_workspace - # - # source://irb//lib/irb/context.rb#176 - def workspace_home; end -end - -# source://irb//lib/irb/context.rb#545 -IRB::Context::IDNAME_IVARS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/context.rb#543 -IRB::Context::NOPRINTING_IVARS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/context.rb#544 -IRB::Context::NO_INSPECTING_IVARS = T.let(T.unsafe(nil), Array) - -# Extends methods for the Context module -# -# source://irb//lib/irb/extend-command.rb#315 -module IRB::ContextExtender - class << self - # Evaluate the given +command+ from the given +load_file+ on the Context - # module. - # - # Will also define any given +aliases+ for the method. - # - # source://irb//lib/irb/extend-command.rb#339 - def def_extend_command(cmd_name, load_file, *aliases); end - - # Installs the default context extensions as irb commands: - # - # Context#eval_history=:: +irb/ext/history.rb+ - # Context#use_tracer=:: +irb/ext/tracer.rb+ - # Context#use_loader=:: +irb/ext/use-loader.rb+ - # - # source://irb//lib/irb/extend-command.rb#329 - def install_extend_commands; end - end -end - -# source://irb//lib/irb/debug.rb#4 -module IRB::Debug - class << self - # source://irb//lib/irb/debug.rb#8 - def insert_debug_break(pre_cmds: T.unsafe(nil), do_cmds: T.unsafe(nil)); end - - # source://irb//lib/irb/debug.rb#25 - def setup(irb); end - - private - - # source://irb//lib/irb/debug.rb#68 - def configure_irb_for_debugger(irb); end - - # This is used when debug.gem is not written in Gemfile. Even if it's not - # installed by `bundle install`, debug.gem is installed by default because - # it's a bundled gem. This method tries to activate and load that. - # - # source://irb//lib/irb/debug.rb#85 - def load_bundled_debug_gem; end - end -end - -# source://irb//lib/irb/debug.rb#5 -IRB::Debug::IRB_DIR = T.let(T.unsafe(nil), String) - -# Installs the default irb extensions command bundle. -# -# source://irb//lib/irb/extend-command.rb#9 -module IRB::ExtendCommandBundle - # Installs alias methods for the default irb commands, see - # ::install_extend_commands. - # - # source://irb//lib/irb/extend-command.rb#276 - def install_alias_method(to, from, override = T.unsafe(nil)); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_backtrace(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_break(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_catch(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_change_workspace(*opts, **kwargs, &b); end - - # Displays current configuration. - # - # Modifying the configuration is achieved by sending a message to IRB.conf. - # - # source://irb//lib/irb/extend-command.rb#31 - def irb_context; end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_continue(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_current_working_workspace(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_debug(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_debug_info(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_delete(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_edit(*opts, **kwargs, &b); end - - # Quits the current irb context - # - # +ret+ is the optional signal or message to send to Context#exit - # - # Same as IRB.CurrentContext.exit. - # - # source://irb//lib/irb/extend-command.rb#24 - def irb_exit(ret = T.unsafe(nil)); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_fg(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_finish(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_help(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_info(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_jobs(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_kill(*opts, **kwargs, &b); end - - # Loads the given file similarly to Kernel#load, see IrbLoader#irb_load - # - # source://irb//lib/irb/extend-command.rb#263 - # def irb_load(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_ls(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_measure(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_next(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_pop_workspace(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_push_workspace(*opts, **kwargs, &b); end - - # Loads the given file similarly to Kernel#require - # - # source://irb//lib/irb/extend-command.rb#263 - # def irb_require(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_show_cmds(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_show_doc(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_show_source(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_source(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_step(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_whereami(*opts, **kwargs, &b); end - - # source://irb//lib/irb/extend-command.rb#263 - def irb_workspaces(*opts, **kwargs, &b); end - - class << self - # source://irb//lib/irb/extend-command.rb#200 - def all_commands_info; end - - # Evaluate the given +cmd_name+ on the given +cmd_class+ Class. - # - # Will also define any given +aliases+ for the method. - # - # The optional +load_file+ parameter will be required within the method - # definition. - # - # source://irb//lib/irb/extend-command.rb#253 - def def_extend_command(cmd_name, cmd_class, load_file, *aliases); end - - # Installs alias methods for the default irb commands on the given object - # using #install_alias_method. - # - # source://irb//lib/irb/extend-command.rb#302 - def extend_object(obj); end - - # Installs the default irb commands. - # - # source://irb//lib/irb/extend-command.rb#241 - def install_extend_commands; end - - # source://irb//lib/irb/extend-command.rb#296 - def irb_original_method_name(method_name); end - - # Convert a command name to its implementation class if such command exists - # - # source://irb//lib/irb/extend-command.rb#227 - def load_command(command); end - end -end - -# source://irb//lib/irb/extend-command.rb#10 -IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle - -# Use a File for IO with irb, see InputMethod -# -# source://irb//lib/irb/input-method.rb#113 -class IRB::FileInputMethod < ::IRB::InputMethod - # Creates a new input method object - # - # @return [FileInputMethod] a new instance of FileInputMethod - # - # source://irb//lib/irb/input-method.rb#126 - def initialize(file); end - - # source://irb//lib/irb/input-method.rb#157 - def close; end - - # The external encoding for standard input. - # - # source://irb//lib/irb/input-method.rb#148 - def encoding; end - - # Whether the end of this input method has been reached, returns +true+ if - # there is no more data to read. - # - # See IO#eof? for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#135 - def eof?; end - - # Reads the next line from this input method. - # - # See IO#gets for more information. - # - # source://irb//lib/irb/input-method.rb#142 - def gets; end - - # For debug message - # - # source://irb//lib/irb/input-method.rb#153 - def inspect; end - - class << self - # source://irb//lib/irb/input-method.rb#115 - def open(file, &block); end - end -end - -# source://irb//lib/irb/history.rb#2 -module IRB::HistorySavingAbility - # source://irb//lib/irb/history.rb#11 - def load_history; end - - # source://irb//lib/irb/history.rb#7 - def reset_history_counter; end - - # source://irb//lib/irb/history.rb#34 - def save_history; end - - # @return [Boolean] - # - # source://irb//lib/irb/history.rb#3 - def support_history_saving?; end -end - -# source://irb//lib/irb/init.rb#366 -IRB::IRBRC_EXT = T.let(T.unsafe(nil), String) - -# source://irb//lib/irb/completion.rb#11 -module IRB::InputCompletor - class << self - # source://irb//lib/irb/completion.rb#159 - def retrieve_completion_data(input, bind: T.unsafe(nil), doc_namespace: T.unsafe(nil)); end - - # source://irb//lib/irb/completion.rb#87 - def retrieve_files_to_require_from_load_path; end - - # source://irb//lib/irb/completion.rb#106 - def retrieve_files_to_require_relative_from_current_dir; end - - # source://irb//lib/irb/completion.rb#76 - def retrieve_gem_and_system_load_path; end - - # source://irb//lib/irb/completion.rb#434 - def select_message(receiver, message, candidates, sep = T.unsafe(nil)); end - end -end - -# source://irb//lib/irb/completion.rb#59 -IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS = T.let(T.unsafe(nil), String) - -# source://irb//lib/irb/completion.rb#147 -IRB::InputCompletor::CompletionProc = T.let(T.unsafe(nil), Proc) - -# source://irb//lib/irb/completion.rb#112 -IRB::InputCompletor::CompletionRequireProc = T.let(T.unsafe(nil), Proc) - -# source://irb//lib/irb/completion.rb#61 -IRB::InputCompletor::GEM_PATHS = T.let(T.unsafe(nil), Array) - -# Set of available operators in Ruby -# -# source://irb//lib/irb/completion.rb#432 -IRB::InputCompletor::Operators = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/completion.rb#397 -IRB::InputCompletor::PerfectMatchedProc = T.let(T.unsafe(nil), Proc) - -# Set of reserved words used by Ruby, you should not use these for -# constants or variables -# -# source://irb//lib/irb/completion.rb#38 -IRB::InputCompletor::ReservedWords = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/input-method.rb#13 -class IRB::InputMethod - # Reads the next line from this input method. - # - # See IO#gets for more information. - # - # source://irb//lib/irb/input-method.rb#20 - def gets; end - - # For debug message - # - # source://irb//lib/irb/input-method.rb#46 - def inspect; end - - # The irb prompt associated with this input method - # - # source://irb//lib/irb/input-method.rb#15 - def prompt; end - - # The irb prompt associated with this input method - # - # source://irb//lib/irb/input-method.rb#15 - def prompt=(_arg0); end - - # Whether this input method is still readable when there is no more data to - # read. - # - # See IO#eof for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#37 - def readable_after_eof?; end - - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#41 - def support_history_saving?; end - - # source://irb//lib/irb/input-method.rb#25 - def winsize; end -end - -# An irb inspector -# -# In order to create your own custom inspector there are two things you -# should be aware of: -# -# Inspector uses #inspect_value, or +inspect_proc+, for output of return values. -# -# This also allows for an optional #init+, or +init_proc+, which is called -# when the inspector is activated. -# -# Knowing this, you can create a rudimentary inspector as follows: -# -# irb(main):001:0> ins = IRB::Inspector.new(proc{ |v| "omg! #{v}" }) -# irb(main):001:0> IRB.CurrentContext.inspect_mode = ins # => omg! # -# irb(main):001:0> "what?" #=> omg! what? -# -# source://irb//lib/irb/inspector.rb#37 -class IRB::Inspector - # Creates a new inspector object, using the given +inspect_proc+ when - # output return values in irb. - # - # @return [Inspector] a new instance of Inspector - # - # source://irb//lib/irb/inspector.rb#83 - def initialize(inspect_proc, init_proc = T.unsafe(nil)); end - - # Proc to call when the inspector is activated, good for requiring - # dependent libraries. - # - # source://irb//lib/irb/inspector.rb#90 - def init; end - - # Proc to call when the input is evaluated and output in irb. - # - # source://irb//lib/irb/inspector.rb#95 - def inspect_value(v); end - - class << self - # Example - # - # Inspector.def_inspector(key, init_p=nil){|v| v.inspect} - # Inspector.def_inspector([key1,..], init_p=nil){|v| v.inspect} - # Inspector.def_inspector(key, inspector) - # Inspector.def_inspector([key1,...], inspector) - # - # source://irb//lib/irb/inspector.rb#58 - def def_inspector(key, arg = T.unsafe(nil), &block); end - - # Determines the inspector to use where +inspector+ is one of the keys passed - # during inspector definition. - # - # source://irb//lib/irb/inspector.rb#48 - def keys_with_inspector(inspector); end - end -end - -# source://irb//lib/irb/inspector.rb#38 -IRB::Inspector::KERNEL_INSPECT = T.let(T.unsafe(nil), UnboundMethod) - -# source://irb//lib/irb.rb#424 -class IRB::Irb - # Creates a new irb session - # - # @return [Irb] a new instance of Irb - # - # source://irb//lib/irb.rb#435 - def initialize(workspace = T.unsafe(nil), input_method = T.unsafe(nil)); end - - # source://irb//lib/irb.rb#635 - def build_statement(code); end - - # source://irb//lib/irb.rb#655 - def configure_io; end - - # Returns the current context of this irb session - # - # source://irb//lib/irb.rb#512 - def context; end - - # source://irb//lib/irb.rb#707 - def convert_invalid_byte_sequence(str, enc); end - - # A hook point for `debug` command's breakpoint after :IRB_EXIT as well as its clean-up - # - # source://irb//lib/irb.rb#443 - def debug_break; end - - # source://irb//lib/irb.rb#453 - def debug_readline(binding); end - - # source://irb//lib/irb.rb#622 - def each_top_level_statement; end - - # source://irb//lib/irb.rb#714 - def encode_with_invalid_byte_sequence(str, enc); end - - # Evaluates input for this session. - # - # source://irb//lib/irb.rb#517 - def eval_input; end - - # source://irb//lib/irb.rb#736 - def handle_exception(exc); end - - # Outputs the local variables to this current session, including - # #signal_status and #context, using IRB::Locale. - # - # source://irb//lib/irb.rb#962 - def inspect; end - - # source://irb//lib/irb.rb#924 - def output_value(omit = T.unsafe(nil)); end - - # source://irb//lib/irb.rb#885 - def prompt(prompt, ltype, indent, line_no); end - - # source://irb//lib/irb.rb#575 - def read_input; end - - # source://irb//lib/irb.rb#593 - def readmultiline; end - - # source://irb//lib/irb.rb#485 - def run(conf = T.unsafe(nil)); end - - # The lexer used by this irb session - # - # source://irb//lib/irb.rb#514 - def scanner; end - - # The lexer used by this irb session - # - # source://irb//lib/irb.rb#514 - def scanner=(_arg0); end - - # Handler for the signal SIGINT, see Kernel#trap for more information. - # - # source://irb//lib/irb.rb#842 - def signal_handle; end - - # Evaluates the given block using the given +status+. - # - # source://irb//lib/irb.rb#864 - def signal_status(status); end - - # @return [Boolean] - # - # source://irb//lib/irb.rb#650 - def single_line_command?(code); end - - # Evaluates the given block using the given +context+ as the Context. - # - # source://irb//lib/irb.rb#832 - def suspend_context(context); end - - # Evaluates the given block using the given +input_method+ as the - # Context#io. - # - # Used by the irb commands +source+ and +irb_load+, see IRB@IRB+Sessions - # for more information. - # - # source://irb//lib/irb.rb#821 - def suspend_input_method(input_method); end - - # Evaluates the given block using the given +path+ as the Context#irb_path - # and +name+ as the Context#irb_name. - # - # Used by the irb command +source+, see IRB@IRB+Sessions for more - # information. - # - # source://irb//lib/irb.rb#791 - def suspend_name(path = T.unsafe(nil), name = T.unsafe(nil)); end - - # Evaluates the given block using the given +workspace+ as the - # Context#workspace. - # - # Used by the irb command +irb_load+, see IRB@IRB+Sessions for more - # information. - # - # source://irb//lib/irb.rb#807 - def suspend_workspace(workspace); end - - # source://irb//lib/irb.rb#876 - def truncate_prompt_main(str); end -end - -# source://irb//lib/irb.rb#432 -IRB::Irb::CONTROL_CHARACTERS_PATTERN = T.let(T.unsafe(nil), String) - -# Note: instance and index assignment expressions could also be written like: -# "foo.bar=(1)" and "foo.[]=(1, bar)", when expressed that way, the former -# be parsed as :assign and echo will be suppressed, but the latter is -# parsed as a :method_add_arg and the output won't be suppressed -# -# source://irb//lib/irb.rb#430 -IRB::Irb::PROMPT_MAIN_TRUNCATE_LENGTH = T.let(T.unsafe(nil), Integer) - -# source://irb//lib/irb.rb#431 -IRB::Irb::PROMPT_MAIN_TRUNCATE_OMISSION = T.let(T.unsafe(nil), String) - -# source://irb//lib/irb/locale.rb#8 -class IRB::Locale - # @return [Locale] a new instance of Locale - # - # source://irb//lib/irb/locale.rb#25 - def initialize(locale = T.unsafe(nil)); end - - # source://irb//lib/irb/locale.rb#49 - def String(mes); end - - # source://irb//lib/irb/locale.rb#126 - def each_localized_path(dir, file); end - - # @yield [nil] - # - # source://irb//lib/irb/locale.rb#133 - def each_sublocale; end - - # source://irb//lib/irb/locale.rb#45 - def encoding; end - - # source://irb//lib/irb/locale.rb#97 - def find(file, paths = T.unsafe(nil)); end - - # source://irb//lib/irb/locale.rb#58 - def format(*opts); end - - # source://irb//lib/irb/locale.rb#62 - def gets(*rs); end - - # Returns the value of attribute lang. - # - # source://irb//lib/irb/locale.rb#43 - def lang; end - - # source://irb//lib/irb/locale.rb#85 - def load(file); end - - # Returns the value of attribute modifier. - # - # source://irb//lib/irb/locale.rb#43 - def modifier; end - - # source://irb//lib/irb/locale.rb#70 - def print(*opts); end - - # source://irb//lib/irb/locale.rb#75 - def printf(*opts); end - - # source://irb//lib/irb/locale.rb#80 - def puts(*opts); end - - # source://irb//lib/irb/locale.rb#66 - def readline(*rs); end - - # typically, for the parameters and a in paths, it searches - # /// - # - # @param paths load paths in which IRB find a localized file. - # @param dir directory - # @param file basename to be localized - # - # source://irb//lib/irb/locale.rb#115 - def search_file(lib_paths, dir, file); end - - # Returns the value of attribute territory. - # - # source://irb//lib/irb/locale.rb#43 - def territory; end -end - -# source://irb//lib/irb/locale.rb#18 -IRB::Locale::LEGACY_ENCODING_ALIAS_MAP = T.let(T.unsafe(nil), Hash) - -# source://irb//lib/irb/locale.rb#16 -IRB::Locale::LOCALE_DIR = T.let(T.unsafe(nil), String) - -# source://irb//lib/irb/locale.rb#10 -IRB::Locale::LOCALE_NAME_RE = T.let(T.unsafe(nil), Regexp) - -# source://irb//lib/irb/nesting_parser.rb#3 -module IRB::NestingParser - class << self - # source://irb//lib/irb/nesting_parser.rb#182 - def open_tokens(tokens); end - - # Calculates token information [line_tokens, prev_opens, next_opens, min_depth] for each line. - # Example code - # ["hello - # world"+( - # First line - # line_tokens: [[lbracket, '['], [tstring_beg, '"'], [tstring_content("hello\nworld"), "hello\n"]] - # prev_opens: [] - # next_tokens: [lbracket, tstring_beg] - # min_depth: 0 (minimum at beginning of line) - # Second line - # line_tokens: [[tstring_content("hello\nworld"), "world"], [tstring_end, '"'], [op, '+'], [lparen, '(']] - # prev_opens: [lbracket, tstring_beg] - # next_tokens: [lbracket, lparen] - # min_depth: 1 (minimum just after tstring_end) - # - # source://irb//lib/irb/nesting_parser.rb#201 - def parse_by_line(tokens); end - - # Scan each token and call the given block with array of token and other information for parsing - # - # source://irb//lib/irb/nesting_parser.rb#7 - def scan_opens(tokens); end - end -end - -# source://irb//lib/irb/nesting_parser.rb#4 -IRB::NestingParser::IGNORE_TOKENS = T.let(T.unsafe(nil), Array) - -# An output formatter used internally by the lexer. -# -# source://irb//lib/irb/notifier.rb#11 -module IRB::Notifier - private - - # Define a new Notifier output source, returning a new CompositeNotifier - # with the given +prefix+ and +output_method+. - # - # The optional +prefix+ will be appended to all objects being inspected - # during output, using the given +output_method+ as the output source. If - # no +output_method+ is given, StdioOutputMethod will be used, and all - # expressions will be sent directly to STDOUT without any additional - # formatting. - # - # source://irb//lib/irb/notifier.rb#31 - def def_notifier(prefix = T.unsafe(nil), output_method = T.unsafe(nil)); end - - class << self - # Define a new Notifier output source, returning a new CompositeNotifier - # with the given +prefix+ and +output_method+. - # - # The optional +prefix+ will be appended to all objects being inspected - # during output, using the given +output_method+ as the output source. If - # no +output_method+ is given, StdioOutputMethod will be used, and all - # expressions will be sent directly to STDOUT without any additional - # formatting. - # - # source://irb//lib/irb/notifier.rb#31 - def def_notifier(prefix = T.unsafe(nil), output_method = T.unsafe(nil)); end - end -end - -# An abstract class, or superclass, for CompositeNotifier and -# LeveledNotifier to inherit. It provides several wrapper methods for the -# OutputMethod object used by the Notifier. -# -# source://irb//lib/irb/notifier.rb#39 -class IRB::Notifier::AbstractNotifier - # Creates a new Notifier object - # - # @return [AbstractNotifier] a new instance of AbstractNotifier - # - # source://irb//lib/irb/notifier.rb#41 - def initialize(prefix, base_notifier); end - - # Execute the given block if notifications are enabled. - # - # @yield [@base_notifier] - # - # source://irb//lib/irb/notifier.rb#99 - def exec_if; end - - # A wrapper method used to determine whether notifications are enabled. - # - # Defaults to +true+. - # - # @return [Boolean] - # - # source://irb//lib/irb/notifier.rb#53 - def notify?; end - - # Same as #ppx, except it uses the #prefix given during object - # initialization. - # See OutputMethod#ppx for more detail. - # - # source://irb//lib/irb/notifier.rb#82 - def pp(*objs); end - - # Same as #pp, except it concatenates the given +prefix+ with the #prefix - # given during object initialization. - # - # See OutputMethod#ppx for more detail. - # - # source://irb//lib/irb/notifier.rb#92 - def ppx(prefix, *objs); end - - # The +prefix+ for this Notifier, which is appended to all objects being - # inspected during output. - # - # source://irb//lib/irb/notifier.rb#48 - def prefix; end - - # See OutputMethod#print for more detail. - # - # source://irb//lib/irb/notifier.rb#58 - def print(*opts); end - - # See OutputMethod#printf for more detail. - # - # source://irb//lib/irb/notifier.rb#68 - def printf(format, *opts); end - - # See OutputMethod#printn for more detail. - # - # source://irb//lib/irb/notifier.rb#63 - def printn(*opts); end - - # See OutputMethod#puts for more detail. - # - # source://irb//lib/irb/notifier.rb#73 - def puts(*objs); end -end - -# A class that can be used to create a group of notifier objects with the -# intent of representing a leveled notification system for irb. -# -# This class will allow you to generate other notifiers, and assign them -# the appropriate level for output. -# -# The Notifier class provides a class-method Notifier.def_notifier to -# create a new composite notifier. Using the first composite notifier -# object you create, sibling notifiers can be initialized with -# #def_notifier. -# -# source://irb//lib/irb/notifier.rb#114 -class IRB::Notifier::CompositeNotifier < ::IRB::Notifier::AbstractNotifier - # Create a new composite notifier object with the given +prefix+, and - # +base_notifier+ to use for output. - # - # @return [CompositeNotifier] a new instance of CompositeNotifier - # - # source://irb//lib/irb/notifier.rb#117 - def initialize(prefix, base_notifier); end - - # Creates a new LeveledNotifier in the composite #notifiers group. - # - # The given +prefix+ will be assigned to the notifier, and +level+ will - # be used as the index of the #notifiers Array. - # - # This method returns the newly created instance. - # - # source://irb//lib/irb/notifier.rb#133 - def def_notifier(level, prefix = T.unsafe(nil)); end - - # Returns the leveled notifier for this object - # - # source://irb//lib/irb/notifier.rb#140 - def level; end - - # Sets the leveled notifier for this object. - # - # When the given +value+ is an instance of AbstractNotifier, - # #level_notifier is set to the given object. - # - # When an Integer is given, #level_notifier is set to the notifier at the - # index +value+ in the #notifiers Array. - # - # If no notifier exists at the index +value+ in the #notifiers Array, an - # ErrUndefinedNotifier exception is raised. - # - # An ErrUnrecognizedLevel exception is raised if the given +value+ is not - # found in the existing #notifiers Array, or an instance of - # AbstractNotifier - # - # source://irb//lib/irb/notifier.rb#157 - def level=(value); end - - # Returns the leveled notifier for this object - # - # source://irb//lib/irb/notifier.rb#140 - def level_notifier; end - - # Sets the leveled notifier for this object. - # - # When the given +value+ is an instance of AbstractNotifier, - # #level_notifier is set to the given object. - # - # When an Integer is given, #level_notifier is set to the notifier at the - # index +value+ in the #notifiers Array. - # - # If no notifier exists at the index +value+ in the #notifiers Array, an - # ErrUndefinedNotifier exception is raised. - # - # An ErrUnrecognizedLevel exception is raised if the given +value+ is not - # found in the existing #notifiers Array, or an instance of - # AbstractNotifier - # - # source://irb//lib/irb/notifier.rb#157 - def level_notifier=(value); end - - # List of notifiers in the group - # - # source://irb//lib/irb/notifier.rb#125 - def notifiers; end -end - -# source://irb//lib/irb/notifier.rb#12 -class IRB::Notifier::ErrUndefinedNotifier < ::StandardError - # @return [ErrUndefinedNotifier] a new instance of ErrUndefinedNotifier - # - # source://irb//lib/irb/notifier.rb#13 - def initialize(val); end -end - -# source://irb//lib/irb/notifier.rb#17 -class IRB::Notifier::ErrUnrecognizedLevel < ::StandardError - # @return [ErrUnrecognizedLevel] a new instance of ErrUnrecognizedLevel - # - # source://irb//lib/irb/notifier.rb#18 - def initialize(val); end -end - -# A leveled notifier is comparable to the composite group from -# CompositeNotifier#notifiers. -# -# source://irb//lib/irb/notifier.rb#175 -class IRB::Notifier::LeveledNotifier < ::IRB::Notifier::AbstractNotifier - include ::Comparable - - # Create a new leveled notifier with the given +base+, and +prefix+ to - # send to AbstractNotifier.new - # - # The given +level+ is used to compare other leveled notifiers in the - # CompositeNotifier group to determine whether or not to output - # notifications. - # - # @return [LeveledNotifier] a new instance of LeveledNotifier - # - # source://irb//lib/irb/notifier.rb#184 - def initialize(base, level, prefix); end - - # Compares the level of this notifier object with the given +other+ - # notifier. - # - # See the Comparable module for more information. - # - # source://irb//lib/irb/notifier.rb#197 - def <=>(other); end - - # The current level of this notifier object - # - # source://irb//lib/irb/notifier.rb#191 - def level; end - - # Whether to output messages to the output method, depending on the level - # of this notifier object. - # - # @return [Boolean] - # - # source://irb//lib/irb/notifier.rb#203 - def notify?; end -end - -# NoMsgNotifier is a LeveledNotifier that's used as the default notifier -# when creating a new CompositeNotifier. -# -# This notifier is used as the +zero+ index, or level +0+, for -# CompositeNotifier#notifiers, and will not output messages of any sort. -# -# source://irb//lib/irb/notifier.rb#213 -class IRB::Notifier::NoMsgNotifier < ::IRB::Notifier::LeveledNotifier - # Creates a new notifier that should not be used to output messages. - # - # @return [NoMsgNotifier] a new instance of NoMsgNotifier - # - # source://irb//lib/irb/notifier.rb#215 - def initialize; end - - # Ensures notifications are ignored, see AbstractNotifier#notify? for - # more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/notifier.rb#223 - def notify?; end -end - -# An abstract output class for IO in irb. This is mainly used internally by -# IRB::Notifier. You can define your own output method to use with Irb.new, -# or Context.new -# -# source://irb//lib/irb/output-method.rb#11 -class IRB::OutputMethod - # Returns an array of the given +format+ and +opts+ to be used by - # Kernel#sprintf, if there was a successful Regexp match in the given - # +format+ from #printf - # - # % - # [#0- +] - # (\*|\*[1-9][0-9]*\$|[1-9][0-9]*) - # .(\*|\*[1-9][0-9]*\$|[1-9][0-9]*|)? - # #(hh|h|l|ll|L|q|j|z|t) - # [diouxXeEfgGcsb%] - # - # source://irb//lib/irb/output-method.rb#48 - def parse_printf_format(format, opts); end - - # Prints the given +objs+ calling Object#inspect on each. - # - # See #puts for more detail. - # - # source://irb//lib/irb/output-method.rb#64 - def pp(*objs); end - - # Prints the given +objs+ calling Object#inspect on each and appending the - # given +prefix+. - # - # See #puts for more detail. - # - # source://irb//lib/irb/output-method.rb#72 - def ppx(prefix, *objs); end - - # Open this method to implement your own output method, raises a - # NotImplementedError if you don't define #print in your own class. - # - # @raise [NotImplementedError] - # - # source://irb//lib/irb/output-method.rb#20 - def print(*opts); end - - # Extends IO#printf to format the given +opts+ for Kernel#sprintf using - # #parse_printf_format - # - # source://irb//lib/irb/output-method.rb#31 - def printf(format, *opts); end - - # Prints the given +opts+, with a newline delimiter. - # - # source://irb//lib/irb/output-method.rb#25 - def printn(*opts); end - - # Calls #print on each element in the given +objs+, followed by a newline - # character. - # - # source://irb//lib/irb/output-method.rb#54 - def puts(*objs); end -end - -# source://irb//lib/irb/output-method.rb#12 -class IRB::OutputMethod::NotImplementedError < ::StandardError - # @return [NotImplementedError] a new instance of NotImplementedError - # - # source://irb//lib/irb/output-method.rb#13 - def initialize(val); end -end - -# source://irb//lib/irb/input-method.rb#162 -class IRB::ReadlineInputMethod # < ::IRB::StdioInputMethod - include ::IRB::HistorySavingAbility - - # Creates a new input method object using Readline - # - # @return [ReadlineInputMethod] a new instance of ReadlineInputMethod - # - # source://irb//lib/irb/input-method.rb#173 - def initialize; end - - # Whether the end of this input method has been reached, returns +true+ - # if there is no more data to read. - # - # See IO#eof? for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#209 - def eof?; end - - # Reads the next line from this input method. - # - # See IO#gets for more information. - # - # source://irb//lib/irb/input-method.rb#193 - def gets; end - - # For debug message - # - # source://irb//lib/irb/input-method.rb#214 - def inspect; end - - class << self - # source://irb//lib/irb/input-method.rb#163 - def initialize_readline; end - end -end - -# source://irb//lib/irb/input-method.rb#404 -class IRB::ReidlineInputMethod < ::IRB::RelineInputMethod - # @return [ReidlineInputMethod] a new instance of ReidlineInputMethod - # - # source://irb//lib/irb/input-method.rb#405 - def initialize; end -end - -# source://irb//lib/irb/input-method.rb#223 -class IRB::RelineInputMethod # < ::IRB::StdioInputMethod - include ::IRB::HistorySavingAbility - - # Creates a new input method object using Reline - # - # @return [RelineInputMethod] a new instance of RelineInputMethod - # - # source://irb//lib/irb/input-method.rb#227 - def initialize; end - - # source://irb//lib/irb/input-method.rb#270 - def auto_indent(&block); end - - # source://irb//lib/irb/input-method.rb#262 - def check_termination(&block); end - - # source://irb//lib/irb/input-method.rb#266 - def dynamic_prompt(&block); end - - # Whether the end of this input method has been reached, returns +true+ - # if there is no more data to read. - # - # See IO#eof? for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#390 - def eof?; end - - # Reads the next line from this input method. - # - # See IO#gets for more information. - # - # source://irb//lib/irb/input-method.rb#372 - def gets; end - - # For debug message - # - # source://irb//lib/irb/input-method.rb#395 - def inspect; end -end - -# source://irb//lib/irb/input-method.rb#224 -IRB::RelineInputMethod::HISTORY = T.let(T.unsafe(nil), Reline::History) - -# source://irb//lib/irb/input-method.rb#274 -IRB::RelineInputMethod::SHOW_DOC_DIALOG = T.let(T.unsafe(nil), Proc) - -# :stopdoc: -# -# source://irb//lib/irb/ruby-lex.rb#13 -class IRB::RubyLex - # @return [RubyLex] a new instance of RubyLex - # - # source://irb//lib/irb/ruby-lex.rb#47 - def initialize(context); end - - # @return [Boolean] - # - # source://irb//lib/irb/ruby-lex.rb#183 - def assignment_expression?(code); end - - # source://irb//lib/irb/ruby-lex.rb#301 - def calc_indent_level(opens); end - - # source://irb//lib/irb/ruby-lex.rb#155 - def check_code_state(code); end - - # source://irb//lib/irb/ruby-lex.rb#225 - def check_code_syntax(code); end - - # source://irb//lib/irb/ruby-lex.rb#458 - def check_termination_in_prev_line(code); end - - # @return [Boolean] - # - # source://irb//lib/irb/ruby-lex.rb#161 - def code_terminated?(code, tokens, opens); end - - # @return [Boolean] - # - # source://irb//lib/irb/ruby-lex.rb#328 - def free_indent_token?(token); end - - # source://irb//lib/irb/ruby-lex.rb#179 - def increase_line_no(addition); end - - # Calculates the difference of pasted code's indent and indent calculated from tokens - # - # source://irb//lib/irb/ruby-lex.rb#333 - def indent_difference(lines, line_results, line_index); end - - # Returns the value of attribute line_no. - # - # source://irb//lib/irb/ruby-lex.rb#45 - def line_no; end - - # source://irb//lib/irb/ruby-lex.rb#428 - def ltype_from_open_tokens(opens); end - - # source://irb//lib/irb/ruby-lex.rb#352 - def process_indent_level(tokens, lines, line_index, is_newline); end - - # source://irb//lib/irb/ruby-lex.rb#149 - def prompt(opens, continue, line_num_offset); end - - # source://irb//lib/irb/ruby-lex.rb#174 - def save_prompt_to_context_io(opens, continue, line_num_offset); end - - # source://irb//lib/irb/ruby-lex.rb#70 - def set_prompt(&block); end - - # @return [Boolean] - # - # source://irb//lib/irb/ruby-lex.rb#201 - def should_continue?(tokens); end - - class << self - # source://irb//lib/irb/ruby-lex.rb#53 - def compile_with_errors_suppressed(code, line_no: T.unsafe(nil)); end - - # source://irb//lib/irb/ruby-lex.rb#83 - def generate_local_variables_assign_code(local_variables); end - - # Some part of the code is not included in Ripper's token. - # Example: DATA part, token after heredoc_beg when heredoc has unclosed embexpr. - # With interpolated tokens, tokens.map(&:tok).join will be equal to code. - # - # source://irb//lib/irb/ruby-lex.rb#90 - def interpolate_ripper_ignored_tokens(code, tokens); end - - # source://irb//lib/irb/ruby-lex.rb#119 - def ripper_lex_without_warning(code, context: T.unsafe(nil)); end - end -end - -# source://irb//lib/irb/ruby-lex.rb#14 -IRB::RubyLex::ASSIGNMENT_NODE_TYPES = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/ruby-lex.rb#74 -IRB::RubyLex::ERROR_TOKENS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/ruby-lex.rb#326 -IRB::RubyLex::FREE_INDENT_TOKENS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/ruby-lex.rb#421 -IRB::RubyLex::LTYPE_TOKENS = T.let(T.unsafe(nil), Array) - -# source://irb//lib/irb/ruby-lex.rb#39 -class IRB::RubyLex::TerminateLineInput < ::StandardError - # @return [TerminateLineInput] a new instance of TerminateLineInput - # - # source://irb//lib/irb/ruby-lex.rb#40 - def initialize; end -end - -# source://irb//lib/irb/statement.rb#4 -class IRB::Statement - # Returns the value of attribute code. - # - # source://irb//lib/irb/statement.rb#5 - def code; end - - # @raise [NotImplementedError] - # - # source://irb//lib/irb/statement.rb#19 - def evaluable_code; end - - # @raise [NotImplementedError] - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#7 - def is_assignment?; end - - # @raise [NotImplementedError] - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#15 - def should_be_handled_by_debugger?; end - - # @raise [NotImplementedError] - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#11 - def suppresses_echo?; end -end - -# source://irb//lib/irb/statement.rb#46 -class IRB::Statement::Command < ::IRB::Statement - # @return [Command] a new instance of Command - # - # source://irb//lib/irb/statement.rb#47 - def initialize(code, command, arg, command_class); end - - # source://irb//lib/irb/statement.rb#68 - def evaluable_code; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#54 - def is_assignment?; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#62 - def should_be_handled_by_debugger?; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#58 - def suppresses_echo?; end -end - -# source://irb//lib/irb/statement.rb#23 -class IRB::Statement::Expression < ::IRB::Statement - # @return [Expression] a new instance of Expression - # - # source://irb//lib/irb/statement.rb#24 - def initialize(code, is_assignment); end - - # source://irb//lib/irb/statement.rb#41 - def evaluable_code; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#37 - def is_assignment?; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#33 - def should_be_handled_by_debugger?; end - - # @return [Boolean] - # - # source://irb//lib/irb/statement.rb#29 - def suppresses_echo?; end -end - -# source://irb//lib/irb/input-method.rb#51 -class IRB::StdioInputMethod < ::IRB::InputMethod - # Creates a new input method object - # - # @return [StdioInputMethod] a new instance of StdioInputMethod - # - # source://irb//lib/irb/input-method.rb#53 - def initialize; end - - # The external encoding for standard input. - # - # source://irb//lib/irb/input-method.rb#102 - def encoding; end - - # Whether the end of this input method has been reached, returns +true+ if - # there is no more data to read. - # - # See IO#eof? for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#73 - def eof?; end - - # Reads the next line from this input method. - # - # See IO#gets for more information. - # - # source://irb//lib/irb/input-method.rb#63 - def gets; end - - # For debug message - # - # source://irb//lib/irb/input-method.rb#107 - def inspect; end - - # Returns the current line number for #io. - # - # #line counts the number of times #gets is called. - # - # See IO#lineno for more information. - # - # source://irb//lib/irb/input-method.rb#97 - def line(line_no); end - - # Whether this input method is still readable when there is no more data to - # read. - # - # See IO#eof for more information. - # - # @return [Boolean] - # - # source://irb//lib/irb/input-method.rb#88 - def readable_after_eof?; end -end - -# A standard output printer -# -# source://irb//lib/irb/output-method.rb#79 -class IRB::StdioOutputMethod < ::IRB::OutputMethod - # Prints the given +opts+ to standard output, see IO#print for more - # information. - # - # source://irb//lib/irb/output-method.rb#82 - def print(*opts); end -end - -# source://irb//lib/irb/workspace.rb#9 -IRB::TOPLEVEL_BINDING = T.let(T.unsafe(nil), Binding) - -# source://irb//lib/irb/version.rb#8 -IRB::VERSION = T.let(T.unsafe(nil), String) - -# source://irb//lib/irb/workspace.rb#11 -class IRB::WorkSpace - # Creates a new workspace. - # - # set self to main if specified, otherwise - # inherit main from TOPLEVEL_BINDING. - # - # @return [WorkSpace] a new instance of WorkSpace - # - # source://irb//lib/irb/workspace.rb#16 - def initialize(*main); end - - # The Binding of this workspace - # - # source://irb//lib/irb/workspace.rb#106 - def binding; end - - # source://irb//lib/irb/workspace.rb#144 - def code_around_binding; end - - # Evaluate the given +statements+ within the context of this workspace. - # - # source://irb//lib/irb/workspace.rb#116 - # def evaluate(statements, file = T.unsafe(nil), line = T.unsafe(nil)); end - - # error message manipulator - # WARN: Rails patches this method to filter its own backtrace. Be cautious when changing it. - # See: https://github.com/rails/rails/blob/main/railties/lib/rails/commands/console/console_command.rb#L8:~:text=def,filter_backtrace - # - # source://irb//lib/irb/workspace.rb#131 - def filter_backtrace(bt); end - - # source://irb//lib/irb/workspace.rb#111 - def load_commands_to_main; end - - # source://irb//lib/irb/workspace.rb#124 - def local_variable_get(name); end - - # source://irb//lib/irb/workspace.rb#120 - def local_variable_set(name, value); end - - # The top-level workspace of this context, also available as - # IRB.conf[:__MAIN__] - # - # source://irb//lib/irb/workspace.rb#109 - def main; end -end - -# source://irb//lib/irb/ruby-lex.rb#500 -RubyLex = IRB::RubyLex diff --git a/sorbet/rbi/gems/yarp@0.11.0.rbi b/sorbet/rbi/gems/yarp@0.11.0.rbi deleted file mode 100644 index acd3d42..0000000 --- a/sorbet/rbi/gems/yarp@0.11.0.rbi +++ /dev/null @@ -1,15141 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `yarp` gem. -# Please instead update this file by running `bin/tapioca gem yarp`. - -# This file is generated by the templates/template.rb script and should not be -# modified manually. See templates/lib/yarp/node.rb.erb -# if you are looking to modify the template -# -# source://yarp//lib/yarp.rb#3 -module YARP - class << self - # Mirror the YARP.dump API by using the serialization API. - def dump(*_arg0); end - - # Mirror the YARP.dump_file API by using the serialization API. - def dump_file(_arg0); end - - # Mirror the YARP.lex API by using the serialization API. - def lex(*_arg0); end - - # Returns an array of tokens that closely resembles that of the Ripper lexer. - # The only difference is that since we don't keep track of lexer state in the - # same way, it's going to always return the NONE state. - # - # source://yarp//lib/yarp/lex_compat.rb#804 - def lex_compat(source, filepath = T.unsafe(nil)); end - - # Mirror the YARP.lex_file API by using the serialization API. - def lex_file(_arg0); end - - # This lexes with the Ripper lex. It drops any space events but otherwise - # returns the same tokens. Raises SyntaxError if the syntax in source is - # invalid. - # - # source://yarp//lib/yarp/lex_compat.rb#811 - def lex_ripper(source); end - - # Load the serialized AST using the source as a reference into a tree. - # - # source://yarp//lib/yarp.rb#417 - def load(source, serialized); end - - # Mirror the YARP.parse API by using the serialization API. - def parse(*_arg0); end - - # Mirror the YARP.parse_file API by using the serialization API. This uses - # native strings instead of Ruby strings because it allows us to use mmap when - # it is available. - def parse_file(_arg0); end - - # Mirror the YARP.parse_lex API by using the serialization API. - def parse_lex(*_arg0); end - - # Mirror the YARP.parse_lex_file API by using the serialization API. - def parse_lex_file(_arg0); end - end -end - -# Represents the use of the `alias` keyword. -# -# alias foo bar -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#13 -class YARP::AliasNode < ::YARP::Node - # def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void - # - # @return [AliasNode] a new instance of AliasNode - # - # source://yarp//lib/yarp/node.rb#24 - def initialize(new_name, old_name, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#32 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#37 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#42 - def comment_targets; end - - # def copy: (**params) -> AliasNode - # - # source://yarp//lib/yarp/node.rb#47 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#37 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#60 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#69 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#65 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#21 - def keyword_loc; end - - # attr_reader new_name: Node - # - # source://yarp//lib/yarp/node.rb#15 - def new_name; end - - # attr_reader old_name: Node - # - # source://yarp//lib/yarp/node.rb#18 - def old_name; end -end - -# Represents an alternation pattern in pattern matching. -# -# foo => bar | baz -# ^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#84 -class YARP::AlternationPatternNode < ::YARP::Node - # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void - # - # @return [AlternationPatternNode] a new instance of AlternationPatternNode - # - # source://yarp//lib/yarp/node.rb#95 - def initialize(left, right, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#103 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#108 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#113 - def comment_targets; end - - # def copy: (**params) -> AlternationPatternNode - # - # source://yarp//lib/yarp/node.rb#118 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#108 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#131 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#140 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node - # - # source://yarp//lib/yarp/node.rb#86 - def left; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#136 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#92 - def operator_loc; end - - # attr_reader right: Node - # - # source://yarp//lib/yarp/node.rb#89 - def right; end -end - -# Represents the use of the `&&` operator or the `and` keyword. -# -# left and right -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#155 -class YARP::AndNode < ::YARP::Node - # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void - # - # @return [AndNode] a new instance of AndNode - # - # source://yarp//lib/yarp/node.rb#166 - def initialize(left, right, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#174 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#179 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#184 - def comment_targets; end - - # def copy: (**params) -> AndNode - # - # source://yarp//lib/yarp/node.rb#189 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#179 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#202 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#211 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node - # - # source://yarp//lib/yarp/node.rb#157 - def left; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#207 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#163 - def operator_loc; end - - # attr_reader right: Node - # - # source://yarp//lib/yarp/node.rb#160 - def right; end -end - -# Represents a set of arguments to a method or a keyword. -# -# return foo, bar, baz -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#226 -class YARP::ArgumentsNode < ::YARP::Node - # def initialize: (arguments: Array[Node], location: Location) -> void - # - # @return [ArgumentsNode] a new instance of ArgumentsNode - # - # source://yarp//lib/yarp/node.rb#231 - def initialize(arguments, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#237 - def accept(visitor); end - - # attr_reader arguments: Array[Node] - # - # source://yarp//lib/yarp/node.rb#228 - def arguments; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#242 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#247 - def comment_targets; end - - # def copy: (**params) -> ArgumentsNode - # - # source://yarp//lib/yarp/node.rb#252 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#242 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#263 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#267 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents an array literal. This can be a regular array using brackets or -# a special array using % like %w or %i. -# -# [1, 2, 3] -# ^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#279 -class YARP::ArrayNode < ::YARP::Node - # def initialize: (elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void - # - # @return [ArrayNode] a new instance of ArrayNode - # - # source://yarp//lib/yarp/node.rb#290 - def initialize(elements, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#298 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#303 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#336 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#287 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#308 - def comment_targets; end - - # def copy: (**params) -> ArrayNode - # - # source://yarp//lib/yarp/node.rb#313 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#303 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#326 - def deconstruct_keys(keys); end - - # attr_reader elements: Array[Node] - # - # source://yarp//lib/yarp/node.rb#281 - def elements; end - - # source://yarp//lib/yarp/node.rb#340 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#331 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#284 - def opening_loc; end -end - -# Represents an array pattern in pattern matching. -# -# foo in 1, 2 -# ^^^^^^^^^^^ -# -# foo in [1, 2] -# ^^^^^^^^^^^^^ -# -# foo in *1 -# ^^^^^^^^^ -# -# foo in Bar[] -# ^^^^^^^^^^^^ -# -# foo in Bar[1, 2, 3] -# ^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#365 -class YARP::ArrayPatternNode < ::YARP::Node - # def initialize: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void - # - # @return [ArrayPatternNode] a new instance of ArrayPatternNode - # - # source://yarp//lib/yarp/node.rb#385 - def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#396 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#401 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#437 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#382 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#406 - def comment_targets; end - - # attr_reader constant: Node? - # - # source://yarp//lib/yarp/node.rb#367 - def constant; end - - # def copy: (**params) -> ArrayPatternNode - # - # source://yarp//lib/yarp/node.rb#411 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#401 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#427 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#441 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#432 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#379 - def opening_loc; end - - # attr_reader posts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#376 - def posts; end - - # attr_reader requireds: Array[Node] - # - # source://yarp//lib/yarp/node.rb#370 - def requireds; end - - # attr_reader rest: Node? - # - # source://yarp//lib/yarp/node.rb#373 - def rest; end -end - -# Represents a hash key/value pair. -# -# { a => b } -# ^^^^^^ -# -# source://yarp//lib/yarp/node.rb#467 -class YARP::AssocNode < ::YARP::Node - # def initialize: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> void - # - # @return [AssocNode] a new instance of AssocNode - # - # source://yarp//lib/yarp/node.rb#478 - def initialize(key, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#486 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#491 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#496 - def comment_targets; end - - # def copy: (**params) -> AssocNode - # - # source://yarp//lib/yarp/node.rb#501 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#491 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#514 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#523 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader key: Node - # - # source://yarp//lib/yarp/node.rb#469 - def key; end - - # def operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#519 - def operator; end - - # attr_reader operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#475 - def operator_loc; end - - # attr_reader value: Node? - # - # source://yarp//lib/yarp/node.rb#472 - def value; end -end - -# Represents a splat in a hash literal. -# -# { **foo } -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#542 -class YARP::AssocSplatNode < ::YARP::Node - # def initialize: (value: Node?, operator_loc: Location, location: Location) -> void - # - # @return [AssocSplatNode] a new instance of AssocSplatNode - # - # source://yarp//lib/yarp/node.rb#550 - def initialize(value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#557 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#562 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#567 - def comment_targets; end - - # def copy: (**params) -> AssocSplatNode - # - # source://yarp//lib/yarp/node.rb#572 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#562 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#584 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#593 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#589 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#547 - def operator_loc; end - - # attr_reader value: Node? - # - # source://yarp//lib/yarp/node.rb#544 - def value; end -end - -YARP::BACKEND = T.let(T.unsafe(nil), Symbol) - -# Represents reading a reference to a field in the previous match. -# -# $' -# ^^ -# -# source://yarp//lib/yarp/node.rb#610 -class YARP::BackReferenceReadNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode - # - # source://yarp//lib/yarp/node.rb#612 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#617 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#622 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#627 - def comment_targets; end - - # def copy: (**params) -> BackReferenceReadNode - # - # source://yarp//lib/yarp/node.rb#632 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#622 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#642 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#646 - def inspect(inspector = T.unsafe(nil)); end -end - -# A class that knows how to walk down the tree. None of the individual visit -# methods are implemented on this visitor, so it forces the consumer to -# implement each one that they need. For a default implementation that -# continues walking the tree, see the Visitor class. -# -# source://yarp//lib/yarp.rb#209 -class YARP::BasicVisitor - # source://yarp//lib/yarp.rb#210 - def visit(node); end - - # source://yarp//lib/yarp.rb#214 - def visit_all(nodes); end - - # source://yarp//lib/yarp.rb#218 - def visit_child_nodes(node); end -end - -# Represents a begin statement. -# -# begin -# foo -# end -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#658 -class YARP::BeginNode < ::YARP::Node - # def initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void - # - # @return [BeginNode] a new instance of BeginNode - # - # source://yarp//lib/yarp/node.rb#678 - def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#689 - def accept(visitor); end - - # def begin_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#729 - def begin_keyword; end - - # attr_reader begin_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#660 - def begin_keyword_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#698 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#703 - def comment_targets; end - - # def copy: (**params) -> BeginNode - # - # source://yarp//lib/yarp/node.rb#708 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#698 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#724 - def deconstruct_keys(keys); end - - # attr_reader else_clause: ElseNode? - # - # source://yarp//lib/yarp/node.rb#669 - def else_clause; end - - # def end_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#734 - def end_keyword; end - - # attr_reader end_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#675 - def end_keyword_loc; end - - # attr_reader ensure_clause: EnsureNode? - # - # source://yarp//lib/yarp/node.rb#672 - def ensure_clause; end - - # source://yarp//lib/yarp/node.rb#738 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader rescue_clause: RescueNode? - # - # source://yarp//lib/yarp/node.rb#666 - def rescue_clause; end - - # source://yarp//lib/yarp/node.rb#693 - def set_newline_flag(newline_marked); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#663 - def statements; end -end - -# Represents block method arguments. -# -# bar(&args) -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#774 -class YARP::BlockArgumentNode < ::YARP::Node - # def initialize: (expression: Node?, operator_loc: Location, location: Location) -> void - # - # @return [BlockArgumentNode] a new instance of BlockArgumentNode - # - # source://yarp//lib/yarp/node.rb#782 - def initialize(expression, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#789 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#794 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#799 - def comment_targets; end - - # def copy: (**params) -> BlockArgumentNode - # - # source://yarp//lib/yarp/node.rb#804 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#794 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#816 - def deconstruct_keys(keys); end - - # attr_reader expression: Node? - # - # source://yarp//lib/yarp/node.rb#776 - def expression; end - - # source://yarp//lib/yarp/node.rb#825 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#821 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#779 - def operator_loc; end -end - -# Represents a block local variable. -# -# a { |; b| } -# ^ -# -# source://yarp//lib/yarp/node.rb#842 -class YARP::BlockLocalVariableNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode - # - # source://yarp//lib/yarp/node.rb#847 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#853 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#858 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#863 - def comment_targets; end - - # def copy: (**params) -> BlockLocalVariableNode - # - # source://yarp//lib/yarp/node.rb#868 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#858 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#879 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#883 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#844 - def name; end -end - -# Represents a block of ruby code. -# -# [1, 2, 3].each { |i| puts x } -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#894 -class YARP::BlockNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], parameters: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void - # - # @return [BlockNode] a new instance of BlockNode - # - # source://yarp//lib/yarp/node.rb#911 - def initialize(locals, parameters, body, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#921 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#902 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#926 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#961 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#908 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#931 - def comment_targets; end - - # def copy: (**params) -> BlockNode - # - # source://yarp//lib/yarp/node.rb#936 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#926 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#951 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#965 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#896 - def locals; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#956 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#905 - def opening_loc; end - - # attr_reader parameters: BlockParametersNode? - # - # source://yarp//lib/yarp/node.rb#899 - def parameters; end -end - -# Represents a block parameter to a method, block, or lambda definition. -# -# def a(&b) -# ^^ -# end -# -# source://yarp//lib/yarp/node.rb#991 -class YARP::BlockParameterNode < ::YARP::Node - # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void - # - # @return [BlockParameterNode] a new instance of BlockParameterNode - # - # source://yarp//lib/yarp/node.rb#1002 - def initialize(name, name_loc, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1010 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1015 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1020 - def comment_targets; end - - # def copy: (**params) -> BlockParameterNode - # - # source://yarp//lib/yarp/node.rb#1025 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1015 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1038 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#1047 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol? - # - # source://yarp//lib/yarp/node.rb#993 - def name; end - - # attr_reader name_loc: Location? - # - # source://yarp//lib/yarp/node.rb#996 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#1043 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#999 - def operator_loc; end -end - -# Represents a block's parameters declaration. -# -# -> (a, b = 1; local) { } -# ^^^^^^^^^^^^^^^^^ -# -# foo do |a, b = 1; local| -# ^^^^^^^^^^^^^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#1064 -class YARP::BlockParametersNode < ::YARP::Node - # def initialize: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void - # - # @return [BlockParametersNode] a new instance of BlockParametersNode - # - # source://yarp//lib/yarp/node.rb#1078 - def initialize(parameters, locals, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1087 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1092 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#1126 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1075 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1097 - def comment_targets; end - - # def copy: (**params) -> BlockParametersNode - # - # source://yarp//lib/yarp/node.rb#1102 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1092 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1116 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#1130 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Node] - # - # source://yarp//lib/yarp/node.rb#1069 - def locals; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#1121 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1072 - def opening_loc; end - - # attr_reader parameters: ParametersNode? - # - # source://yarp//lib/yarp/node.rb#1066 - def parameters; end -end - -# Represents the use of the `break` keyword. -# -# break foo -# ^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1149 -class YARP::BreakNode < ::YARP::Node - # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void - # - # @return [BreakNode] a new instance of BreakNode - # - # source://yarp//lib/yarp/node.rb#1157 - def initialize(arguments, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1164 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#1151 - def arguments; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1169 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1174 - def comment_targets; end - - # def copy: (**params) -> BreakNode - # - # source://yarp//lib/yarp/node.rb#1179 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1169 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1191 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#1200 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#1196 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#1154 - def keyword_loc; end -end - -# Represents the use of the `&&=` operator on a call. -# -# foo.bar &&= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1217 -class YARP::CallAndWriteNode < ::YARP::Node - # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [CallAndWriteNode] a new instance of CallAndWriteNode - # - # source://yarp//lib/yarp/node.rb#1252 - def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1268 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#1231 - def arguments; end - - # def call_operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#1309 - def call_operator; end - - # attr_reader call_operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1222 - def call_operator_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1273 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#1324 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1234 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1278 - def comment_targets; end - - # def copy: (**params) -> CallAndWriteNode - # - # source://yarp//lib/yarp/node.rb#1283 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1273 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1304 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#1237 - def flags; end - - # source://yarp//lib/yarp/node.rb#1343 - def inspect(inspector = T.unsafe(nil)); end - - # def message: () -> String? - # - # source://yarp//lib/yarp/node.rb#1314 - def message; end - - # attr_reader message_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1225 - def message_loc; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#1319 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1228 - def opening_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#1339 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#1246 - def operator_loc; end - - # attr_reader read_name: String - # - # source://yarp//lib/yarp/node.rb#1240 - def read_name; end - - # attr_reader receiver: Node? - # - # source://yarp//lib/yarp/node.rb#1219 - def receiver; end - - # def safe_navigation?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1329 - def safe_navigation?; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#1249 - def value; end - - # def variable_call?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1334 - def variable_call?; end - - # attr_reader write_name: String - # - # source://yarp//lib/yarp/node.rb#1243 - def write_name; end -end - -# Represents a method call, in all of the various forms that can take. -# -# foo -# ^^^ -# -# foo() -# ^^^^^ -# -# +foo -# ^^^^ -# -# foo + bar -# ^^^^^^^^^ -# -# foo.bar -# ^^^^^^^ -# -# foo&.bar -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1390 -class YARP::CallNode < ::YARP::Node - # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode?, flags: Integer, name: String, location: Location) -> void - # - # @return [CallNode] a new instance of CallNode - # - # source://yarp//lib/yarp/node.rb#1419 - def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1433 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#1404 - def arguments; end - - # attr_reader block: BlockNode? - # - # source://yarp//lib/yarp/node.rb#1410 - def block; end - - # def call_operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#1472 - def call_operator; end - - # attr_reader call_operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1395 - def call_operator_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1438 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#1487 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1407 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1443 - def comment_targets; end - - # def copy: (**params) -> CallNode - # - # source://yarp//lib/yarp/node.rb#1448 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1438 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1467 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#1413 - def flags; end - - # source://yarp//lib/yarp/node.rb#1501 - def inspect(inspector = T.unsafe(nil)); end - - # def message: () -> String? - # - # source://yarp//lib/yarp/node.rb#1477 - def message; end - - # attr_reader message_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1398 - def message_loc; end - - # attr_reader name: String - # - # source://yarp//lib/yarp/node.rb#1416 - def name; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#1482 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1401 - def opening_loc; end - - # attr_reader receiver: Node? - # - # source://yarp//lib/yarp/node.rb#1392 - def receiver; end - - # def safe_navigation?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1492 - def safe_navigation?; end - - # def variable_call?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1497 - def variable_call?; end -end - -# source://yarp//lib/yarp/node.rb#10557 -module YARP::CallNodeFlags; end - -# &. operator -# -# source://yarp//lib/yarp/node.rb#10559 -YARP::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer) - -# a call that could have been a local variable -# -# source://yarp//lib/yarp/node.rb#10562 -YARP::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) - -# Represents the use of an assignment operator on a call. -# -# foo.bar += baz -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1535 -class YARP::CallOperatorWriteNode < ::YARP::Node - # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#1573 - def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1590 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#1549 - def arguments; end - - # def call_operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#1632 - def call_operator; end - - # attr_reader call_operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1540 - def call_operator_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1595 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#1647 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1552 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1600 - def comment_targets; end - - # def copy: (**params) -> CallOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#1605 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1595 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1627 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#1555 - def flags; end - - # source://yarp//lib/yarp/node.rb#1661 - def inspect(inspector = T.unsafe(nil)); end - - # def message: () -> String? - # - # source://yarp//lib/yarp/node.rb#1637 - def message; end - - # attr_reader message_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1543 - def message_loc; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#1642 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1546 - def opening_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#1564 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#1567 - def operator_loc; end - - # attr_reader read_name: String - # - # source://yarp//lib/yarp/node.rb#1558 - def read_name; end - - # attr_reader receiver: Node? - # - # source://yarp//lib/yarp/node.rb#1537 - def receiver; end - - # def safe_navigation?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1652 - def safe_navigation?; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#1570 - def value; end - - # def variable_call?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1657 - def variable_call?; end - - # attr_reader write_name: String - # - # source://yarp//lib/yarp/node.rb#1561 - def write_name; end -end - -# Represents the use of the `||=` operator on a call. -# -# foo.bar ||= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1694 -class YARP::CallOrWriteNode < ::YARP::Node - # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [CallOrWriteNode] a new instance of CallOrWriteNode - # - # source://yarp//lib/yarp/node.rb#1729 - def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1745 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#1708 - def arguments; end - - # def call_operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#1786 - def call_operator; end - - # attr_reader call_operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1699 - def call_operator_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1750 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#1801 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1711 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1755 - def comment_targets; end - - # def copy: (**params) -> CallOrWriteNode - # - # source://yarp//lib/yarp/node.rb#1760 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1750 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1781 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#1714 - def flags; end - - # source://yarp//lib/yarp/node.rb#1820 - def inspect(inspector = T.unsafe(nil)); end - - # def message: () -> String? - # - # source://yarp//lib/yarp/node.rb#1791 - def message; end - - # attr_reader message_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1702 - def message_loc; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#1796 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#1705 - def opening_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#1816 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#1723 - def operator_loc; end - - # attr_reader read_name: String - # - # source://yarp//lib/yarp/node.rb#1717 - def read_name; end - - # attr_reader receiver: Node? - # - # source://yarp//lib/yarp/node.rb#1696 - def receiver; end - - # def safe_navigation?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1806 - def safe_navigation?; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#1726 - def value; end - - # def variable_call?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#1811 - def variable_call?; end - - # attr_reader write_name: String - # - # source://yarp//lib/yarp/node.rb#1720 - def write_name; end -end - -# Represents assigning to a local variable in pattern matching. -# -# foo => [bar => baz] -# ^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#1852 -class YARP::CapturePatternNode < ::YARP::Node - # def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void - # - # @return [CapturePatternNode] a new instance of CapturePatternNode - # - # source://yarp//lib/yarp/node.rb#1863 - def initialize(value, target, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1871 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1876 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1881 - def comment_targets; end - - # def copy: (**params) -> CapturePatternNode - # - # source://yarp//lib/yarp/node.rb#1886 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1876 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1899 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#1908 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#1904 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#1860 - def operator_loc; end - - # attr_reader target: Node - # - # source://yarp//lib/yarp/node.rb#1857 - def target; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#1854 - def value; end -end - -# Represents the use of a case statement. -# -# case true -# ^^^^^^^^^ -# when false -# end -# -# source://yarp//lib/yarp/node.rb#1925 -class YARP::CaseNode < ::YARP::Node - # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void - # - # @return [CaseNode] a new instance of CaseNode - # - # source://yarp//lib/yarp/node.rb#1942 - def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#1952 - def accept(visitor); end - - # def case_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#1987 - def case_keyword; end - - # attr_reader case_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#1936 - def case_keyword_loc; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1957 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#1962 - def comment_targets; end - - # attr_reader conditions: Array[Node] - # - # source://yarp//lib/yarp/node.rb#1930 - def conditions; end - - # attr_reader consequent: ElseNode? - # - # source://yarp//lib/yarp/node.rb#1933 - def consequent; end - - # def copy: (**params) -> CaseNode - # - # source://yarp//lib/yarp/node.rb#1967 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#1957 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#1982 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#1992 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#1939 - def end_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#1996 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader predicate: Node? - # - # source://yarp//lib/yarp/node.rb#1927 - def predicate; end -end - -# Represents a class declaration involving the `class` keyword. -# -# class Foo end -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2021 -class YARP::ClassNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void - # - # @return [ClassNode] a new instance of ClassNode - # - # source://yarp//lib/yarp/node.rb#2047 - def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2060 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#2038 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2065 - def child_nodes; end - - # def class_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#2098 - def class_keyword; end - - # attr_reader class_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#2026 - def class_keyword_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2070 - def comment_targets; end - - # attr_reader constant_path: Node - # - # source://yarp//lib/yarp/node.rb#2029 - def constant_path; end - - # def copy: (**params) -> ClassNode - # - # source://yarp//lib/yarp/node.rb#2075 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2065 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2093 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#2108 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#2041 - def end_keyword_loc; end - - # def inheritance_operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#2103 - def inheritance_operator; end - - # attr_reader inheritance_operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#2032 - def inheritance_operator_loc; end - - # source://yarp//lib/yarp/node.rb#2112 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#2023 - def locals; end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2044 - def name; end - - # attr_reader superclass: Node? - # - # source://yarp//lib/yarp/node.rb#2035 - def superclass; end -end - -# Represents the use of the `&&=` operator for assignment to a class variable. -# -# @@target &&= value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2141 -class YARP::ClassVariableAndWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2155 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2164 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2169 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2174 - def comment_targets; end - - # def copy: (**params) -> ClassVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2179 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2169 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2193 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2202 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2143 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2146 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#2198 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2149 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2152 - def value; end -end - -# Represents assigning to a class variable using an operator that isn't `=`. -# -# @@target += value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2217 -class YARP::ClassVariableOperatorWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void - # - # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2234 - def initialize(name, name_loc, operator_loc, value, operator, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2244 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2249 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2254 - def comment_targets; end - - # def copy: (**params) -> ClassVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2259 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2249 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2274 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2278 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2219 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2222 - def name_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#2231 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2225 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2228 - def value; end -end - -# Represents the use of the `||=` operator for assignment to a class variable. -# -# @@target ||= value -# ^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2294 -class YARP::ClassVariableOrWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#2308 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2317 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2322 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2327 - def comment_targets; end - - # def copy: (**params) -> ClassVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#2332 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2322 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2346 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2355 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2296 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2299 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#2351 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2302 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2305 - def value; end -end - -# Represents referencing a class variable. -# -# @@foo -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#2370 -class YARP::ClassVariableReadNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode - # - # source://yarp//lib/yarp/node.rb#2375 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2381 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2386 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2391 - def comment_targets; end - - # def copy: (**params) -> ClassVariableReadNode - # - # source://yarp//lib/yarp/node.rb#2396 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2386 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2407 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2411 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2372 - def name; end -end - -# Represents writing to a class variable in a context that doesn't have an explicit value. -# -# @@foo, @@bar = baz -# ^^^^^ ^^^^^ -# -# source://yarp//lib/yarp/node.rb#2422 -class YARP::ClassVariableTargetNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#2427 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2433 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2438 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2443 - def comment_targets; end - - # def copy: (**params) -> ClassVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#2448 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2438 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2459 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2463 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2424 - def name; end -end - -# Represents writing to a class variable. -# -# @@foo = 1 -# ^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2474 -class YARP::ClassVariableWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location) -> void - # - # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#2488 - def initialize(name, name_loc, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2497 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2502 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2507 - def comment_targets; end - - # def copy: (**params) -> ClassVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#2512 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2502 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2526 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2535 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2476 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2479 - def name_loc; end - - # def operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#2531 - def operator; end - - # attr_reader operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#2485 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2482 - def value; end -end - -# This represents a comment that was encountered during parsing. -# -# source://yarp//lib/yarp.rb#145 -class YARP::Comment - # @return [Comment] a new instance of Comment - # - # source://yarp//lib/yarp.rb#150 - def initialize(type, location); end - - # source://yarp//lib/yarp.rb#155 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp.rb#164 - def inspect; end - - # Returns the value of attribute location. - # - # source://yarp//lib/yarp.rb#148 - def location; end - - # Returns true if the comment happens on the same line as other code and false if the comment is by itself - # - # @return [Boolean] - # - # source://yarp//lib/yarp.rb#160 - def trailing?; end - - # Returns the value of attribute type. - # - # source://yarp//lib/yarp.rb#148 - def type; end -end - -# source://yarp//lib/yarp.rb#146 -YARP::Comment::TYPES = T.let(T.unsafe(nil), Array) - -# Represents the use of the `&&=` operator for assignment to a constant. -# -# Target &&= value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2550 -class YARP::ConstantAndWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2564 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2573 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2578 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2583 - def comment_targets; end - - # def copy: (**params) -> ConstantAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2588 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2578 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2602 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2611 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2552 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2555 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#2607 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2558 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2561 - def value; end -end - -# Represents assigning to a constant using an operator that isn't `=`. -# -# Target += value -# ^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2626 -class YARP::ConstantOperatorWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void - # - # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2643 - def initialize(name, name_loc, operator_loc, value, operator, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2653 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2658 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2663 - def comment_targets; end - - # def copy: (**params) -> ConstantOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2668 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2658 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2683 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2687 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2628 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2631 - def name_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#2640 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2634 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2637 - def value; end -end - -# Represents the use of the `||=` operator for assignment to a constant. -# -# Target ||= value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2703 -class YARP::ConstantOrWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode - # - # source://yarp//lib/yarp/node.rb#2717 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2726 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2731 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2736 - def comment_targets; end - - # def copy: (**params) -> ConstantOrWriteNode - # - # source://yarp//lib/yarp/node.rb#2741 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2731 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2755 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2764 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#2705 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#2708 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#2760 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2711 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2714 - def value; end -end - -# Represents the use of the `&&=` operator for assignment to a constant path. -# -# Parent::Child &&= value -# ^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2779 -class YARP::ConstantPathAndWriteNode < ::YARP::Node - # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2790 - def initialize(target, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2798 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2803 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2808 - def comment_targets; end - - # def copy: (**params) -> ConstantPathAndWriteNode - # - # source://yarp//lib/yarp/node.rb#2813 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2803 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2826 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2835 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#2831 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2784 - def operator_loc; end - - # attr_reader target: ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#2781 - def target; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2787 - def value; end -end - -# Represents accessing a constant through a path of `::` operators. -# -# Foo::Bar -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2850 -class YARP::ConstantPathNode < ::YARP::Node - # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void - # - # @return [ConstantPathNode] a new instance of ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#2861 - def initialize(parent, child, delimiter_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2869 - def accept(visitor); end - - # attr_reader child: Node - # - # source://yarp//lib/yarp/node.rb#2855 - def child; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2874 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2879 - def comment_targets; end - - # def copy: (**params) -> ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#2884 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2874 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2897 - def deconstruct_keys(keys); end - - # def delimiter: () -> String - # - # source://yarp//lib/yarp/node.rb#2902 - def delimiter; end - - # attr_reader delimiter_loc: Location - # - # source://yarp//lib/yarp/node.rb#2858 - def delimiter_loc; end - - # source://yarp//lib/yarp/node.rb#2906 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader parent: Node? - # - # source://yarp//lib/yarp/node.rb#2852 - def parent; end -end - -# Represents assigning to a constant path using an operator that isn't `=`. -# -# Parent::Child += value -# ^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2925 -class YARP::ConstantPathOperatorWriteNode < ::YARP::Node - # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void - # - # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2939 - def initialize(target, operator_loc, value, operator, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#2948 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2953 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#2958 - def comment_targets; end - - # def copy: (**params) -> ConstantPathOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#2963 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#2953 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#2977 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#2981 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#2936 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#2930 - def operator_loc; end - - # attr_reader target: ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#2927 - def target; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#2933 - def value; end -end - -# Represents the use of the `||=` operator for assignment to a constant path. -# -# Parent::Child ||= value -# ^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#2997 -class YARP::ConstantPathOrWriteNode < ::YARP::Node - # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode - # - # source://yarp//lib/yarp/node.rb#3008 - def initialize(target, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3016 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3021 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3026 - def comment_targets; end - - # def copy: (**params) -> ConstantPathOrWriteNode - # - # source://yarp//lib/yarp/node.rb#3031 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3021 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3044 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3053 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#3049 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#3002 - def operator_loc; end - - # attr_reader target: ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#2999 - def target; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#3005 - def value; end -end - -# Represents writing to a constant path in a context that doesn't have an explicit value. -# -# Foo::Foo, Bar::Bar = baz -# ^^^^^^^^ ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3068 -class YARP::ConstantPathTargetNode < ::YARP::Node - # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void - # - # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode - # - # source://yarp//lib/yarp/node.rb#3079 - def initialize(parent, child, delimiter_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3087 - def accept(visitor); end - - # attr_reader child: Node - # - # source://yarp//lib/yarp/node.rb#3073 - def child; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3092 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3097 - def comment_targets; end - - # def copy: (**params) -> ConstantPathTargetNode - # - # source://yarp//lib/yarp/node.rb#3102 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3092 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3115 - def deconstruct_keys(keys); end - - # def delimiter: () -> String - # - # source://yarp//lib/yarp/node.rb#3120 - def delimiter; end - - # attr_reader delimiter_loc: Location - # - # source://yarp//lib/yarp/node.rb#3076 - def delimiter_loc; end - - # source://yarp//lib/yarp/node.rb#3124 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader parent: Node? - # - # source://yarp//lib/yarp/node.rb#3070 - def parent; end -end - -# Represents writing to a constant path. -# -# ::Foo = 1 -# ^^^^^^^^^ -# -# Foo::Bar = 1 -# ^^^^^^^^^^^^ -# -# ::Foo::Bar = 1 -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3149 -class YARP::ConstantPathWriteNode < ::YARP::Node - # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode - # - # source://yarp//lib/yarp/node.rb#3160 - def initialize(target, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3168 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3173 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3178 - def comment_targets; end - - # def copy: (**params) -> ConstantPathWriteNode - # - # source://yarp//lib/yarp/node.rb#3183 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3173 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3196 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3205 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#3201 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#3154 - def operator_loc; end - - # attr_reader target: ConstantPathNode - # - # source://yarp//lib/yarp/node.rb#3151 - def target; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#3157 - def value; end -end - -# Represents referencing a constant. -# -# Foo -# ^^^ -# -# source://yarp//lib/yarp/node.rb#3220 -class YARP::ConstantReadNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [ConstantReadNode] a new instance of ConstantReadNode - # - # source://yarp//lib/yarp/node.rb#3225 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3231 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3236 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3241 - def comment_targets; end - - # def copy: (**params) -> ConstantReadNode - # - # source://yarp//lib/yarp/node.rb#3246 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3236 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3257 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3261 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#3222 - def name; end -end - -# Represents writing to a constant in a context that doesn't have an explicit value. -# -# Foo, Bar = baz -# ^^^ ^^^ -# -# source://yarp//lib/yarp/node.rb#3272 -class YARP::ConstantTargetNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [ConstantTargetNode] a new instance of ConstantTargetNode - # - # source://yarp//lib/yarp/node.rb#3277 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3283 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3288 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3293 - def comment_targets; end - - # def copy: (**params) -> ConstantTargetNode - # - # source://yarp//lib/yarp/node.rb#3298 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3288 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3309 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3313 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#3274 - def name; end -end - -# Represents writing to a constant. -# -# Foo = 1 -# ^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3324 -class YARP::ConstantWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void - # - # @return [ConstantWriteNode] a new instance of ConstantWriteNode - # - # source://yarp//lib/yarp/node.rb#3338 - def initialize(name, name_loc, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3347 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3352 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3357 - def comment_targets; end - - # def copy: (**params) -> ConstantWriteNode - # - # source://yarp//lib/yarp/node.rb#3362 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3352 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3376 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3385 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#3326 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#3329 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#3381 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#3335 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#3332 - def value; end -end - -# source://yarp//lib/yarp/node.rb#11011 -module YARP::DSL - private - - # Create a new AliasNode node - # - # source://yarp//lib/yarp/node.rb#11020 - def AliasNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end - - # Create a new AlternationPatternNode node - # - # source://yarp//lib/yarp/node.rb#11025 - def AlternationPatternNode(left, right, operator_loc, location = T.unsafe(nil)); end - - # Create a new AndNode node - # - # source://yarp//lib/yarp/node.rb#11030 - def AndNode(left, right, operator_loc, location = T.unsafe(nil)); end - - # Create a new ArgumentsNode node - # - # source://yarp//lib/yarp/node.rb#11035 - def ArgumentsNode(arguments, location = T.unsafe(nil)); end - - # Create a new ArrayNode node - # - # source://yarp//lib/yarp/node.rb#11040 - def ArrayNode(elements, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new ArrayPatternNode node - # - # source://yarp//lib/yarp/node.rb#11045 - def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new AssocNode node - # - # source://yarp//lib/yarp/node.rb#11050 - def AssocNode(key, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new AssocSplatNode node - # - # source://yarp//lib/yarp/node.rb#11055 - def AssocSplatNode(value, operator_loc, location = T.unsafe(nil)); end - - # Create a new BackReferenceReadNode node - # - # source://yarp//lib/yarp/node.rb#11060 - def BackReferenceReadNode(location = T.unsafe(nil)); end - - # Create a new BeginNode node - # - # source://yarp//lib/yarp/node.rb#11065 - def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new BlockArgumentNode node - # - # source://yarp//lib/yarp/node.rb#11070 - def BlockArgumentNode(expression, operator_loc, location = T.unsafe(nil)); end - - # Create a new BlockLocalVariableNode node - # - # source://yarp//lib/yarp/node.rb#11075 - def BlockLocalVariableNode(name, location = T.unsafe(nil)); end - - # Create a new BlockNode node - # - # source://yarp//lib/yarp/node.rb#11080 - def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new BlockParameterNode node - # - # source://yarp//lib/yarp/node.rb#11085 - def BlockParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end - - # Create a new BlockParametersNode node - # - # source://yarp//lib/yarp/node.rb#11090 - def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new BreakNode node - # - # source://yarp//lib/yarp/node.rb#11095 - def BreakNode(arguments, keyword_loc, location = T.unsafe(nil)); end - - # Create a new CallAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11100 - def CallAndWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new CallNode node - # - # source://yarp//lib/yarp/node.rb#11105 - def CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location = T.unsafe(nil)); end - - # Create a new CallOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11110 - def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new CallOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11115 - def CallOrWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new CapturePatternNode node - # - # source://yarp//lib/yarp/node.rb#11120 - def CapturePatternNode(value, target, operator_loc, location = T.unsafe(nil)); end - - # Create a new CaseNode node - # - # source://yarp//lib/yarp/node.rb#11125 - def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new ClassNode node - # - # source://yarp//lib/yarp/node.rb#11130 - def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = T.unsafe(nil)); end - - # Create a new ClassVariableAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11135 - def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ClassVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11140 - def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end - - # Create a new ClassVariableOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11145 - def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ClassVariableReadNode node - # - # source://yarp//lib/yarp/node.rb#11150 - def ClassVariableReadNode(name, location = T.unsafe(nil)); end - - # Create a new ClassVariableTargetNode node - # - # source://yarp//lib/yarp/node.rb#11155 - def ClassVariableTargetNode(name, location = T.unsafe(nil)); end - - # Create a new ClassVariableWriteNode node - # - # source://yarp//lib/yarp/node.rb#11160 - def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new ConstantAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11165 - def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ConstantOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11170 - def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end - - # Create a new ConstantOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11175 - def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ConstantPathAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11180 - def ConstantPathAndWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ConstantPathNode node - # - # source://yarp//lib/yarp/node.rb#11185 - def ConstantPathNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end - - # Create a new ConstantPathOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11190 - def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = T.unsafe(nil)); end - - # Create a new ConstantPathOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11195 - def ConstantPathOrWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ConstantPathTargetNode node - # - # source://yarp//lib/yarp/node.rb#11200 - def ConstantPathTargetNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end - - # Create a new ConstantPathWriteNode node - # - # source://yarp//lib/yarp/node.rb#11205 - def ConstantPathWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new ConstantReadNode node - # - # source://yarp//lib/yarp/node.rb#11210 - def ConstantReadNode(name, location = T.unsafe(nil)); end - - # Create a new ConstantTargetNode node - # - # source://yarp//lib/yarp/node.rb#11215 - def ConstantTargetNode(name, location = T.unsafe(nil)); end - - # Create a new ConstantWriteNode node - # - # source://yarp//lib/yarp/node.rb#11220 - def ConstantWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new DefNode node - # - # source://yarp//lib/yarp/node.rb#11225 - def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new DefinedNode node - # - # source://yarp//lib/yarp/node.rb#11230 - def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = T.unsafe(nil)); end - - # Create a new ElseNode node - # - # source://yarp//lib/yarp/node.rb#11235 - def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new EmbeddedStatementsNode node - # - # source://yarp//lib/yarp/node.rb#11240 - def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = T.unsafe(nil)); end - - # Create a new EmbeddedVariableNode node - # - # source://yarp//lib/yarp/node.rb#11245 - def EmbeddedVariableNode(operator_loc, variable, location = T.unsafe(nil)); end - - # Create a new EnsureNode node - # - # source://yarp//lib/yarp/node.rb#11250 - def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new FalseNode node - # - # source://yarp//lib/yarp/node.rb#11255 - def FalseNode(location = T.unsafe(nil)); end - - # Create a new FindPatternNode node - # - # source://yarp//lib/yarp/node.rb#11260 - def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new FlipFlopNode node - # - # source://yarp//lib/yarp/node.rb#11265 - def FlipFlopNode(left, right, operator_loc, flags, location = T.unsafe(nil)); end - - # Create a new FloatNode node - # - # source://yarp//lib/yarp/node.rb#11270 - def FloatNode(location = T.unsafe(nil)); end - - # Create a new ForNode node - # - # source://yarp//lib/yarp/node.rb#11275 - def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new ForwardingArgumentsNode node - # - # source://yarp//lib/yarp/node.rb#11280 - def ForwardingArgumentsNode(location = T.unsafe(nil)); end - - # Create a new ForwardingParameterNode node - # - # source://yarp//lib/yarp/node.rb#11285 - def ForwardingParameterNode(location = T.unsafe(nil)); end - - # Create a new ForwardingSuperNode node - # - # source://yarp//lib/yarp/node.rb#11290 - def ForwardingSuperNode(block, location = T.unsafe(nil)); end - - # Create a new GlobalVariableAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11295 - def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new GlobalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11300 - def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end - - # Create a new GlobalVariableOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11305 - def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new GlobalVariableReadNode node - # - # source://yarp//lib/yarp/node.rb#11310 - def GlobalVariableReadNode(name, location = T.unsafe(nil)); end - - # Create a new GlobalVariableTargetNode node - # - # source://yarp//lib/yarp/node.rb#11315 - def GlobalVariableTargetNode(name, location = T.unsafe(nil)); end - - # Create a new GlobalVariableWriteNode node - # - # source://yarp//lib/yarp/node.rb#11320 - def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new HashNode node - # - # source://yarp//lib/yarp/node.rb#11325 - def HashNode(opening_loc, elements, closing_loc, location = T.unsafe(nil)); end - - # Create a new HashPatternNode node - # - # source://yarp//lib/yarp/node.rb#11330 - def HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new IfNode node - # - # source://yarp//lib/yarp/node.rb#11335 - def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new ImaginaryNode node - # - # source://yarp//lib/yarp/node.rb#11340 - def ImaginaryNode(numeric, location = T.unsafe(nil)); end - - # Create a new InNode node - # - # source://yarp//lib/yarp/node.rb#11345 - def InNode(pattern, statements, in_loc, then_loc, location = T.unsafe(nil)); end - - # Create a new InstanceVariableAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11350 - def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new InstanceVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11355 - def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end - - # Create a new InstanceVariableOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11360 - def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new InstanceVariableReadNode node - # - # source://yarp//lib/yarp/node.rb#11365 - def InstanceVariableReadNode(name, location = T.unsafe(nil)); end - - # Create a new InstanceVariableTargetNode node - # - # source://yarp//lib/yarp/node.rb#11370 - def InstanceVariableTargetNode(name, location = T.unsafe(nil)); end - - # Create a new InstanceVariableWriteNode node - # - # source://yarp//lib/yarp/node.rb#11375 - def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new IntegerNode node - # - # source://yarp//lib/yarp/node.rb#11380 - def IntegerNode(location = T.unsafe(nil)); end - - # Create a new InterpolatedRegularExpressionNode node - # - # source://yarp//lib/yarp/node.rb#11385 - def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location = T.unsafe(nil)); end - - # Create a new InterpolatedStringNode node - # - # source://yarp//lib/yarp/node.rb#11390 - def InterpolatedStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end - - # Create a new InterpolatedSymbolNode node - # - # source://yarp//lib/yarp/node.rb#11395 - def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end - - # Create a new InterpolatedXStringNode node - # - # source://yarp//lib/yarp/node.rb#11400 - def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end - - # Create a new KeywordHashNode node - # - # source://yarp//lib/yarp/node.rb#11405 - def KeywordHashNode(elements, location = T.unsafe(nil)); end - - # Create a new KeywordParameterNode node - # - # source://yarp//lib/yarp/node.rb#11410 - def KeywordParameterNode(name, name_loc, value, location = T.unsafe(nil)); end - - # Create a new KeywordRestParameterNode node - # - # source://yarp//lib/yarp/node.rb#11415 - def KeywordRestParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end - - # Create a new LambdaNode node - # - # source://yarp//lib/yarp/node.rb#11420 - def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = T.unsafe(nil)); end - - # Create a new LocalVariableAndWriteNode node - # - # source://yarp//lib/yarp/node.rb#11425 - def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end - - # Create a new LocalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/node.rb#11430 - def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = T.unsafe(nil)); end - - # Create a new LocalVariableOrWriteNode node - # - # source://yarp//lib/yarp/node.rb#11435 - def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end - - # Create a new LocalVariableReadNode node - # - # source://yarp//lib/yarp/node.rb#11440 - def LocalVariableReadNode(name, depth, location = T.unsafe(nil)); end - - # Create a new LocalVariableTargetNode node - # - # source://yarp//lib/yarp/node.rb#11445 - def LocalVariableTargetNode(name, depth, location = T.unsafe(nil)); end - - # Create a new LocalVariableWriteNode node - # - # source://yarp//lib/yarp/node.rb#11450 - def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = T.unsafe(nil)); end - - # Create a new Location object - # - # source://yarp//lib/yarp/node.rb#11015 - def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end - - # Create a new MatchPredicateNode node - # - # source://yarp//lib/yarp/node.rb#11455 - def MatchPredicateNode(value, pattern, operator_loc, location = T.unsafe(nil)); end - - # Create a new MatchRequiredNode node - # - # source://yarp//lib/yarp/node.rb#11460 - def MatchRequiredNode(value, pattern, operator_loc, location = T.unsafe(nil)); end - - # Create a new MissingNode node - # - # source://yarp//lib/yarp/node.rb#11465 - def MissingNode(location = T.unsafe(nil)); end - - # Create a new ModuleNode node - # - # source://yarp//lib/yarp/node.rb#11470 - def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = T.unsafe(nil)); end - - # Create a new MultiTargetNode node - # - # source://yarp//lib/yarp/node.rb#11475 - def MultiTargetNode(targets, lparen_loc, rparen_loc, location = T.unsafe(nil)); end - - # Create a new MultiWriteNode node - # - # source://yarp//lib/yarp/node.rb#11480 - def MultiWriteNode(targets, lparen_loc, rparen_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new NextNode node - # - # source://yarp//lib/yarp/node.rb#11485 - def NextNode(arguments, keyword_loc, location = T.unsafe(nil)); end - - # Create a new NilNode node - # - # source://yarp//lib/yarp/node.rb#11490 - def NilNode(location = T.unsafe(nil)); end - - # Create a new NoKeywordsParameterNode node - # - # source://yarp//lib/yarp/node.rb#11495 - def NoKeywordsParameterNode(operator_loc, keyword_loc, location = T.unsafe(nil)); end - - # Create a new NumberedReferenceReadNode node - # - # source://yarp//lib/yarp/node.rb#11500 - def NumberedReferenceReadNode(number, location = T.unsafe(nil)); end - - # Create a new OptionalParameterNode node - # - # source://yarp//lib/yarp/node.rb#11505 - def OptionalParameterNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end - - # Create a new OrNode node - # - # source://yarp//lib/yarp/node.rb#11510 - def OrNode(left, right, operator_loc, location = T.unsafe(nil)); end - - # Create a new ParametersNode node - # - # source://yarp//lib/yarp/node.rb#11515 - def ParametersNode(requireds, optionals, posts, rest, keywords, keyword_rest, block, location = T.unsafe(nil)); end - - # Create a new ParenthesesNode node - # - # source://yarp//lib/yarp/node.rb#11520 - def ParenthesesNode(body, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new PinnedExpressionNode node - # - # source://yarp//lib/yarp/node.rb#11525 - def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = T.unsafe(nil)); end - - # Create a new PinnedVariableNode node - # - # source://yarp//lib/yarp/node.rb#11530 - def PinnedVariableNode(variable, operator_loc, location = T.unsafe(nil)); end - - # Create a new PostExecutionNode node - # - # source://yarp//lib/yarp/node.rb#11535 - def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new PreExecutionNode node - # - # source://yarp//lib/yarp/node.rb#11540 - def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new ProgramNode node - # - # source://yarp//lib/yarp/node.rb#11545 - def ProgramNode(locals, statements, location = T.unsafe(nil)); end - - # Create a new RangeNode node - # - # source://yarp//lib/yarp/node.rb#11550 - def RangeNode(left, right, operator_loc, flags, location = T.unsafe(nil)); end - - # Create a new RationalNode node - # - # source://yarp//lib/yarp/node.rb#11555 - def RationalNode(numeric, location = T.unsafe(nil)); end - - # Create a new RedoNode node - # - # source://yarp//lib/yarp/node.rb#11560 - def RedoNode(location = T.unsafe(nil)); end - - # Create a new RegularExpressionNode node - # - # source://yarp//lib/yarp/node.rb#11565 - def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = T.unsafe(nil)); end - - # Create a new RequiredDestructuredParameterNode node - # - # source://yarp//lib/yarp/node.rb#11570 - def RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location = T.unsafe(nil)); end - - # Create a new RequiredParameterNode node - # - # source://yarp//lib/yarp/node.rb#11575 - def RequiredParameterNode(name, location = T.unsafe(nil)); end - - # Create a new RescueModifierNode node - # - # source://yarp//lib/yarp/node.rb#11580 - def RescueModifierNode(expression, keyword_loc, rescue_expression, location = T.unsafe(nil)); end - - # Create a new RescueNode node - # - # source://yarp//lib/yarp/node.rb#11585 - def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = T.unsafe(nil)); end - - # Create a new RestParameterNode node - # - # source://yarp//lib/yarp/node.rb#11590 - def RestParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end - - # Create a new RetryNode node - # - # source://yarp//lib/yarp/node.rb#11595 - def RetryNode(location = T.unsafe(nil)); end - - # Create a new ReturnNode node - # - # source://yarp//lib/yarp/node.rb#11600 - def ReturnNode(keyword_loc, arguments, location = T.unsafe(nil)); end - - # Create a new SelfNode node - # - # source://yarp//lib/yarp/node.rb#11605 - def SelfNode(location = T.unsafe(nil)); end - - # Create a new SingletonClassNode node - # - # source://yarp//lib/yarp/node.rb#11610 - def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new SourceEncodingNode node - # - # source://yarp//lib/yarp/node.rb#11615 - def SourceEncodingNode(location = T.unsafe(nil)); end - - # Create a new SourceFileNode node - # - # source://yarp//lib/yarp/node.rb#11620 - def SourceFileNode(filepath, location = T.unsafe(nil)); end - - # Create a new SourceLineNode node - # - # source://yarp//lib/yarp/node.rb#11625 - def SourceLineNode(location = T.unsafe(nil)); end - - # Create a new SplatNode node - # - # source://yarp//lib/yarp/node.rb#11630 - def SplatNode(operator_loc, expression, location = T.unsafe(nil)); end - - # Create a new StatementsNode node - # - # source://yarp//lib/yarp/node.rb#11635 - def StatementsNode(body, location = T.unsafe(nil)); end - - # Create a new StringConcatNode node - # - # source://yarp//lib/yarp/node.rb#11640 - def StringConcatNode(left, right, location = T.unsafe(nil)); end - - # Create a new StringNode node - # - # source://yarp//lib/yarp/node.rb#11645 - def StringNode(opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end - - # Create a new SuperNode node - # - # source://yarp//lib/yarp/node.rb#11650 - def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = T.unsafe(nil)); end - - # Create a new SymbolNode node - # - # source://yarp//lib/yarp/node.rb#11655 - def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location = T.unsafe(nil)); end - - # Create a new TrueNode node - # - # source://yarp//lib/yarp/node.rb#11660 - def TrueNode(location = T.unsafe(nil)); end - - # Create a new UndefNode node - # - # source://yarp//lib/yarp/node.rb#11665 - def UndefNode(names, keyword_loc, location = T.unsafe(nil)); end - - # Create a new UnlessNode node - # - # source://yarp//lib/yarp/node.rb#11670 - def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end - - # Create a new UntilNode node - # - # source://yarp//lib/yarp/node.rb#11675 - def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location = T.unsafe(nil)); end - - # Create a new WhenNode node - # - # source://yarp//lib/yarp/node.rb#11680 - def WhenNode(keyword_loc, conditions, statements, location = T.unsafe(nil)); end - - # Create a new WhileNode node - # - # source://yarp//lib/yarp/node.rb#11685 - def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location = T.unsafe(nil)); end - - # Create a new XStringNode node - # - # source://yarp//lib/yarp/node.rb#11690 - def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end - - # Create a new YieldNode node - # - # source://yarp//lib/yarp/node.rb#11695 - def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = T.unsafe(nil)); end -end - -# This module is used for testing and debugging and is not meant to be used by -# consumers of this library. -# -# source://yarp//lib/yarp.rb#423 -module YARP::Debug - class << self - # For the given source, compiles with CRuby and returns a list of all of the - # sets of local variables that were encountered. - # - # source://yarp//lib/yarp.rb#464 - def cruby_locals(source); end - - def memsize(_arg0); end - def named_captures(_arg0); end - - # source://yarp//lib/yarp.rb#570 - def newlines(source); end - - # source://yarp//lib/yarp.rb#574 - def parse_serialize_file(filepath); end - - def parse_serialize_file_metadata(_arg0, _arg1); end - def profile_file(_arg0); end - def unescape_all(_arg0); end - def unescape_minimal(_arg0); end - def unescape_none(_arg0); end - - # For the given source, parses with YARP and returns a list of all of the - # sets of local variables that were encountered. - # - # source://yarp//lib/yarp.rb#503 - def yarp_locals(source); end - end -end - -# source://yarp//lib/yarp.rb#424 -class YARP::Debug::ISeq - # @return [ISeq] a new instance of ISeq - # - # source://yarp//lib/yarp.rb#427 - def initialize(parts); end - - # source://yarp//lib/yarp.rb#443 - def each_child; end - - # source://yarp//lib/yarp.rb#439 - def instructions; end - - # source://yarp//lib/yarp.rb#435 - def local_table; end - - # Returns the value of attribute parts. - # - # source://yarp//lib/yarp.rb#425 - def parts; end - - # source://yarp//lib/yarp.rb#431 - def type; end -end - -# Represents a method definition. -# -# def method -# end -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3401 -class YARP::DefNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void - # - # @return [DefNode] a new instance of DefNode - # - # source://yarp//lib/yarp/node.rb#3439 - def initialize(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3456 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#3415 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3461 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3466 - def comment_targets; end - - # def copy: (**params) -> DefNode - # - # source://yarp//lib/yarp/node.rb#3471 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3461 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3493 - def deconstruct_keys(keys); end - - # def def_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#3498 - def def_keyword; end - - # attr_reader def_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#3421 - def def_keyword_loc; end - - # def end_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#3523 - def end_keyword; end - - # attr_reader end_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3436 - def end_keyword_loc; end - - # def equal: () -> String? - # - # source://yarp//lib/yarp/node.rb#3518 - def equal; end - - # attr_reader equal_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3433 - def equal_loc; end - - # source://yarp//lib/yarp/node.rb#3527 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#3418 - def locals; end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#3508 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3427 - def lparen_loc; end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#3403 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#3406 - def name_loc; end - - # def operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#3503 - def operator; end - - # attr_reader operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3424 - def operator_loc; end - - # attr_reader parameters: ParametersNode? - # - # source://yarp//lib/yarp/node.rb#3412 - def parameters; end - - # attr_reader receiver: Node? - # - # source://yarp//lib/yarp/node.rb#3409 - def receiver; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#3513 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3430 - def rparen_loc; end -end - -# Represents the use of the `defined?` keyword. -# -# defined?(a) -# ^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3564 -class YARP::DefinedNode < ::YARP::Node - # def initialize: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> void - # - # @return [DefinedNode] a new instance of DefinedNode - # - # source://yarp//lib/yarp/node.rb#3578 - def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3587 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3592 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3597 - def comment_targets; end - - # def copy: (**params) -> DefinedNode - # - # source://yarp//lib/yarp/node.rb#3602 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3592 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3616 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3635 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#3631 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#3575 - def keyword_loc; end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#3621 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3566 - def lparen_loc; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#3626 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3572 - def rparen_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#3569 - def value; end -end - -# source://yarp//lib/yarp/desugar_visitor.rb#4 -class YARP::DesugarVisitor < ::YARP::MutationVisitor - # @@foo &&= bar - # - # becomes - # - # @@foo && @@foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#10 - def visit_class_variable_and_write_node(node); end - - # @@foo += bar - # - # becomes - # - # @@foo = @@foo + bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#28 - def visit_class_variable_operator_write_node(node); end - - # @@foo ||= bar - # - # becomes - # - # defined?(@@foo) ? @@foo : @@foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#19 - def visit_class_variable_or_write_node(node); end - - # Foo &&= bar - # - # becomes - # - # Foo && Foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#37 - def visit_constant_and_write_node(node); end - - # Foo += bar - # - # becomes - # - # Foo = Foo + bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#55 - def visit_constant_operator_write_node(node); end - - # Foo ||= bar - # - # becomes - # - # defined?(Foo) ? Foo : Foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#46 - def visit_constant_or_write_node(node); end - - # $foo &&= bar - # - # becomes - # - # $foo && $foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#64 - def visit_global_variable_and_write_node(node); end - - # $foo += bar - # - # becomes - # - # $foo = $foo + bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#82 - def visit_global_variable_operator_write_node(node); end - - # $foo ||= bar - # - # becomes - # - # defined?($foo) ? $foo : $foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#73 - def visit_global_variable_or_write_node(node); end - - # becomes - # - # source://yarp//lib/yarp/desugar_visitor.rb#91 - def visit_instance_variable_and_write_node(node); end - - # becomes - # - # source://yarp//lib/yarp/desugar_visitor.rb#109 - def visit_instance_variable_operator_write_node(node); end - - # becomes - # - # source://yarp//lib/yarp/desugar_visitor.rb#100 - def visit_instance_variable_or_write_node(node); end - - # foo &&= bar - # - # becomes - # - # foo && foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#118 - def visit_local_variable_and_write_node(node); end - - # foo += bar - # - # becomes - # - # foo = foo + bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#136 - def visit_local_variable_operator_write_node(node); end - - # foo ||= bar - # - # becomes - # - # foo || foo = bar - # - # source://yarp//lib/yarp/desugar_visitor.rb#127 - def visit_local_variable_or_write_node(node); end - - private - - # Desugar `x &&= y` to `x && x = y` - # - # source://yarp//lib/yarp/desugar_visitor.rb#143 - def desugar_and_write_node(node, read_class, write_class, *arguments); end - - # Desugar `x += y` to `x = x + y` - # - # source://yarp//lib/yarp/desugar_visitor.rb#153 - def desugar_operator_write_node(node, read_class, write_class, *arguments); end - - # Desugar `x ||= y` to `defined?(x) ? x : x = y` - # - # source://yarp//lib/yarp/desugar_visitor.rb#185 - def desugar_or_write_defined_node(node, read_class, write_class, *arguments); end - - # Desugar `x ||= y` to `x || x = y` - # - # source://yarp//lib/yarp/desugar_visitor.rb#175 - def desugar_or_write_node(node, read_class, write_class, *arguments); end -end - -# Represents an `else` clause in a `case`, `if`, or `unless` statement. -# -# if a then b else c end -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3650 -class YARP::ElseNode < ::YARP::Node - # def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void - # - # @return [ElseNode] a new instance of ElseNode - # - # source://yarp//lib/yarp/node.rb#3661 - def initialize(else_keyword_loc, statements, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3669 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3674 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3679 - def comment_targets; end - - # def copy: (**params) -> ElseNode - # - # source://yarp//lib/yarp/node.rb#3684 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3674 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3697 - def deconstruct_keys(keys); end - - # def else_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#3702 - def else_keyword; end - - # attr_reader else_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#3652 - def else_keyword_loc; end - - # def end_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#3707 - def end_keyword; end - - # attr_reader end_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#3658 - def end_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#3711 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#3655 - def statements; end -end - -# Represents an interpolated set of statements. -# -# "foo #{bar}" -# ^^^^^^ -# -# source://yarp//lib/yarp/node.rb#3729 -class YARP::EmbeddedStatementsNode < ::YARP::Node - # def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void - # - # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode - # - # source://yarp//lib/yarp/node.rb#3740 - def initialize(opening_loc, statements, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3748 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3753 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#3786 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#3737 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3758 - def comment_targets; end - - # def copy: (**params) -> EmbeddedStatementsNode - # - # source://yarp//lib/yarp/node.rb#3763 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3753 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3776 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3790 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#3781 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#3731 - def opening_loc; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#3734 - def statements; end -end - -# Represents an interpolated variable. -# -# "foo #@bar" -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#3808 -class YARP::EmbeddedVariableNode < ::YARP::Node - # def initialize: (operator_loc: Location, variable: Node, location: Location) -> void - # - # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode - # - # source://yarp//lib/yarp/node.rb#3816 - def initialize(operator_loc, variable, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3823 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3828 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3833 - def comment_targets; end - - # def copy: (**params) -> EmbeddedVariableNode - # - # source://yarp//lib/yarp/node.rb#3838 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3828 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3850 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3859 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#3855 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#3810 - def operator_loc; end - - # attr_reader variable: Node - # - # source://yarp//lib/yarp/node.rb#3813 - def variable; end -end - -# Represents an `ensure` clause in a `begin` statement. -# -# begin -# foo -# ensure -# ^^^^^^ -# bar -# end -# -# source://yarp//lib/yarp/node.rb#3876 -class YARP::EnsureNode < ::YARP::Node - # def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void - # - # @return [EnsureNode] a new instance of EnsureNode - # - # source://yarp//lib/yarp/node.rb#3887 - def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3895 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3900 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3905 - def comment_targets; end - - # def copy: (**params) -> EnsureNode - # - # source://yarp//lib/yarp/node.rb#3910 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3900 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3923 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#3933 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#3884 - def end_keyword_loc; end - - # def ensure_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#3928 - def ensure_keyword; end - - # attr_reader ensure_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#3878 - def ensure_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#3937 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#3881 - def statements; end -end - -# Represents the use of the literal `false` keyword. -# -# false -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#3955 -class YARP::FalseNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [FalseNode] a new instance of FalseNode - # - # source://yarp//lib/yarp/node.rb#3957 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#3962 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3967 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#3972 - def comment_targets; end - - # def copy: (**params) -> FalseNode - # - # source://yarp//lib/yarp/node.rb#3977 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#3967 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#3987 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#3991 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents a find pattern in pattern matching. -# -# foo in *bar, baz, *qux -# ^^^^^^^^^^^^^^^^^^^^^^ -# -# foo in [*bar, baz, *qux] -# ^^^^^^^^^^^^^^^^^^^^^^^^ -# -# foo in Foo(*bar, baz, *qux) -# ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4007 -class YARP::FindPatternNode < ::YARP::Node - # def initialize: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> void - # - # @return [FindPatternNode] a new instance of FindPatternNode - # - # source://yarp//lib/yarp/node.rb#4027 - def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4038 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4043 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#4079 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#4024 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4048 - def comment_targets; end - - # attr_reader constant: Node? - # - # source://yarp//lib/yarp/node.rb#4009 - def constant; end - - # def copy: (**params) -> FindPatternNode - # - # source://yarp//lib/yarp/node.rb#4053 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4043 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4069 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4083 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node - # - # source://yarp//lib/yarp/node.rb#4012 - def left; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#4074 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#4021 - def opening_loc; end - - # attr_reader requireds: Array[Node] - # - # source://yarp//lib/yarp/node.rb#4015 - def requireds; end - - # attr_reader right: Node - # - # source://yarp//lib/yarp/node.rb#4018 - def right; end -end - -# Represents the use of the `..` or `...` operators to create flip flops. -# -# baz if foo .. bar -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4106 -class YARP::FlipFlopNode < ::YARP::Node - # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void - # - # @return [FlipFlopNode] a new instance of FlipFlopNode - # - # source://yarp//lib/yarp/node.rb#4120 - def initialize(left, right, operator_loc, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4129 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4134 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4139 - def comment_targets; end - - # def copy: (**params) -> FlipFlopNode - # - # source://yarp//lib/yarp/node.rb#4144 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4134 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4158 - def deconstruct_keys(keys); end - - # def exclude_end?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#4168 - def exclude_end?; end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#4117 - def flags; end - - # source://yarp//lib/yarp/node.rb#4172 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node? - # - # source://yarp//lib/yarp/node.rb#4108 - def left; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#4163 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#4114 - def operator_loc; end - - # attr_reader right: Node? - # - # source://yarp//lib/yarp/node.rb#4111 - def right; end -end - -# Represents a floating point number literal. -# -# 1.0 -# ^^^ -# -# source://yarp//lib/yarp.rb#392 -class YARP::FloatNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [FloatNode] a new instance of FloatNode - # - # source://yarp//lib/yarp/node.rb#4198 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4203 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4208 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4213 - def comment_targets; end - - # def copy: (**params) -> FloatNode - # - # source://yarp//lib/yarp/node.rb#4218 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4208 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4228 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4232 - def inspect(inspector = T.unsafe(nil)); end - - # source://yarp//lib/yarp.rb#393 - def value; end -end - -# Represents the use of the `for` keyword. -# -# for i in a end -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4242 -class YARP::ForNode < ::YARP::Node - # def initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void - # - # @return [ForNode] a new instance of ForNode - # - # source://yarp//lib/yarp/node.rb#4265 - def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4277 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4282 - def child_nodes; end - - # attr_reader collection: Node - # - # source://yarp//lib/yarp/node.rb#4247 - def collection; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4287 - def comment_targets; end - - # def copy: (**params) -> ForNode - # - # source://yarp//lib/yarp/node.rb#4292 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4282 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4309 - def deconstruct_keys(keys); end - - # def do_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#4324 - def do_keyword; end - - # attr_reader do_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#4259 - def do_keyword_loc; end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#4329 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#4262 - def end_keyword_loc; end - - # def for_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#4314 - def for_keyword; end - - # attr_reader for_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#4253 - def for_keyword_loc; end - - # def in_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#4319 - def in_keyword; end - - # attr_reader in_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#4256 - def in_keyword_loc; end - - # attr_reader index: Node - # - # source://yarp//lib/yarp/node.rb#4244 - def index; end - - # source://yarp//lib/yarp/node.rb#4333 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#4250 - def statements; end -end - -# Represents forwarding all arguments to this method to another method. -# -# def foo(...) -# bar(...) -# ^^^^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#4359 -class YARP::ForwardingArgumentsNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode - # - # source://yarp//lib/yarp/node.rb#4361 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4366 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4371 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4376 - def comment_targets; end - - # def copy: (**params) -> ForwardingArgumentsNode - # - # source://yarp//lib/yarp/node.rb#4381 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4371 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4391 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4395 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the forwarding parameter in a method, block, or lambda declaration. -# -# def foo(...) -# ^^^ -# end -# -# source://yarp//lib/yarp/node.rb#4406 -class YARP::ForwardingParameterNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode - # - # source://yarp//lib/yarp/node.rb#4408 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4413 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4418 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4423 - def comment_targets; end - - # def copy: (**params) -> ForwardingParameterNode - # - # source://yarp//lib/yarp/node.rb#4428 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4418 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4438 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4442 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `super` keyword without parentheses or arguments. -# -# super -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#4452 -class YARP::ForwardingSuperNode < ::YARP::Node - # def initialize: (block: BlockNode?, location: Location) -> void - # - # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode - # - # source://yarp//lib/yarp/node.rb#4457 - def initialize(block, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4463 - def accept(visitor); end - - # attr_reader block: BlockNode? - # - # source://yarp//lib/yarp/node.rb#4454 - def block; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4468 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4473 - def comment_targets; end - - # def copy: (**params) -> ForwardingSuperNode - # - # source://yarp//lib/yarp/node.rb#4478 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4468 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4489 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4493 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `&&=` operator for assignment to a global variable. -# -# $target &&= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4509 -class YARP::GlobalVariableAndWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#4523 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4532 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4537 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4542 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#4547 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4537 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4561 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4570 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4511 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#4514 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#4566 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#4517 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#4520 - def value; end -end - -# Represents assigning to a global variable using an operator that isn't `=`. -# -# $target += value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4585 -class YARP::GlobalVariableOperatorWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void - # - # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#4602 - def initialize(name, name_loc, operator_loc, value, operator, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4612 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4617 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4622 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#4627 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4617 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4642 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4646 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4587 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#4590 - def name_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#4599 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#4593 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#4596 - def value; end -end - -# Represents the use of the `||=` operator for assignment to a global variable. -# -# $target ||= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4662 -class YARP::GlobalVariableOrWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#4676 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4685 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4690 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4695 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#4700 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4690 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4714 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4723 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4664 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#4667 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#4719 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#4670 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#4673 - def value; end -end - -# Represents referencing a global variable. -# -# $foo -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#4738 -class YARP::GlobalVariableReadNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode - # - # source://yarp//lib/yarp/node.rb#4743 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4749 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4754 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4759 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableReadNode - # - # source://yarp//lib/yarp/node.rb#4764 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4754 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4775 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4779 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4740 - def name; end -end - -# Represents writing to a global variable in a context that doesn't have an explicit value. -# -# $foo, $bar = baz -# ^^^^ ^^^^ -# -# source://yarp//lib/yarp/node.rb#4790 -class YARP::GlobalVariableTargetNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#4795 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4801 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4806 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4811 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#4816 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4806 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4827 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4831 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4792 - def name; end -end - -# Represents writing to a global variable. -# -# $foo = 1 -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4842 -class YARP::GlobalVariableWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void - # - # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#4856 - def initialize(name, name_loc, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4865 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4870 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4875 - def comment_targets; end - - # def copy: (**params) -> GlobalVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#4880 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4870 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4894 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#4903 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#4844 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#4847 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#4899 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#4853 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#4850 - def value; end -end - -# Represents a hash literal. -# -# { a => b } -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4918 -class YARP::HashNode < ::YARP::Node - # def initialize: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> void - # - # @return [HashNode] a new instance of HashNode - # - # source://yarp//lib/yarp/node.rb#4929 - def initialize(opening_loc, elements, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#4937 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4942 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#4975 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#4926 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#4947 - def comment_targets; end - - # def copy: (**params) -> HashNode - # - # source://yarp//lib/yarp/node.rb#4952 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#4942 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#4965 - def deconstruct_keys(keys); end - - # attr_reader elements: Array[Node] - # - # source://yarp//lib/yarp/node.rb#4923 - def elements; end - - # source://yarp//lib/yarp/node.rb#4979 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#4970 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#4920 - def opening_loc; end -end - -# Represents a hash pattern in pattern matching. -# -# foo => { a: 1, b: 2 } -# ^^^^^^^^^^^^^^ -# -# foo => { a: 1, b: 2, **c } -# ^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#4995 -class YARP::HashPatternNode < ::YARP::Node - # def initialize: (constant: Node?, assocs: Array[Node], kwrest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void - # - # @return [HashPatternNode] a new instance of HashPatternNode - # - # source://yarp//lib/yarp/node.rb#5012 - def initialize(constant, assocs, kwrest, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5022 - def accept(visitor); end - - # attr_reader assocs: Array[Node] - # - # source://yarp//lib/yarp/node.rb#5000 - def assocs; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5027 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#5062 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5009 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5032 - def comment_targets; end - - # attr_reader constant: Node? - # - # source://yarp//lib/yarp/node.rb#4997 - def constant; end - - # def copy: (**params) -> HashPatternNode - # - # source://yarp//lib/yarp/node.rb#5037 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5027 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5052 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5066 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader kwrest: Node? - # - # source://yarp//lib/yarp/node.rb#5003 - def kwrest; end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#5057 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5006 - def opening_loc; end -end - -# Represents the use of the `if` keyword, either in the block form or the modifier form. -# -# bar if foo -# ^^^^^^^^^^ -# -# if foo then bar end -# ^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5094 -class YARP::IfNode < ::YARP::Node - # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void - # - # @return [IfNode] a new instance of IfNode - # - # source://yarp//lib/yarp/node.rb#5111 - def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5121 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5130 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5135 - def comment_targets; end - - # attr_reader consequent: Node? - # - # source://yarp//lib/yarp/node.rb#5105 - def consequent; end - - # def copy: (**params) -> IfNode - # - # source://yarp//lib/yarp/node.rb#5140 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5130 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5155 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#5165 - def end_keyword; end - - # attr_reader end_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5108 - def end_keyword_loc; end - - # def if_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#5160 - def if_keyword; end - - # attr_reader if_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5096 - def if_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#5169 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader predicate: Node - # - # source://yarp//lib/yarp/node.rb#5099 - def predicate; end - - # source://yarp//lib/yarp/node.rb#5125 - def set_newline_flag(newline_marked); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#5102 - def statements; end -end - -# Represents an imaginary number literal. -# -# 1.0i -# ^^^^ -# -# source://yarp//lib/yarp.rb#398 -class YARP::ImaginaryNode < ::YARP::Node - # def initialize: (numeric: Node, location: Location) -> void - # - # @return [ImaginaryNode] a new instance of ImaginaryNode - # - # source://yarp//lib/yarp/node.rb#5200 - def initialize(numeric, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5206 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5211 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5216 - def comment_targets; end - - # def copy: (**params) -> ImaginaryNode - # - # source://yarp//lib/yarp/node.rb#5221 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5211 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5232 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5236 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader numeric: Node - # - # source://yarp//lib/yarp/node.rb#5197 - def numeric; end - - # source://yarp//lib/yarp.rb#399 - def value; end -end - -# Represents the use of the `in` keyword in a case statement. -# -# case a; in b then c end -# ^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5248 -class YARP::InNode < ::YARP::Node - # def initialize: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void - # - # @return [InNode] a new instance of InNode - # - # source://yarp//lib/yarp/node.rb#5262 - def initialize(pattern, statements, in_loc, then_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5271 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5276 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5281 - def comment_targets; end - - # def copy: (**params) -> InNode - # - # source://yarp//lib/yarp/node.rb#5286 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5276 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5300 - def deconstruct_keys(keys); end - - # def in: () -> String - # - # source://yarp//lib/yarp/node.rb#5305 - def in; end - - # attr_reader in_loc: Location - # - # source://yarp//lib/yarp/node.rb#5256 - def in_loc; end - - # source://yarp//lib/yarp/node.rb#5314 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader pattern: Node - # - # source://yarp//lib/yarp/node.rb#5250 - def pattern; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#5253 - def statements; end - - # def then: () -> String? - # - # source://yarp//lib/yarp/node.rb#5310 - def then; end - - # attr_reader then_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5259 - def then_loc; end -end - -# Represents the use of the `&&=` operator for assignment to an instance variable. -# -# @target &&= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5334 -class YARP::InstanceVariableAndWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#5348 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5357 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5362 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5367 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#5372 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5362 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5386 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5395 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5336 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#5339 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#5391 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#5342 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#5345 - def value; end -end - -# Represents assigning to an instance variable using an operator that isn't `=`. -# -# @target += value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5410 -class YARP::InstanceVariableOperatorWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void - # - # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#5427 - def initialize(name, name_loc, operator_loc, value, operator, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5437 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5442 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5447 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#5452 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5442 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5467 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5471 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5412 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#5415 - def name_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#5424 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#5418 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#5421 - def value; end -end - -# Represents the use of the `||=` operator for assignment to an instance variable. -# -# @target ||= value -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5487 -class YARP::InstanceVariableOrWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#5501 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5510 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5515 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5520 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#5525 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5515 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5539 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5548 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5489 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#5492 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#5544 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#5495 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#5498 - def value; end -end - -# Represents referencing an instance variable. -# -# @foo -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#5563 -class YARP::InstanceVariableReadNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode - # - # source://yarp//lib/yarp/node.rb#5568 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5574 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5579 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5584 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableReadNode - # - # source://yarp//lib/yarp/node.rb#5589 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5579 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5600 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5604 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5565 - def name; end -end - -# Represents writing to an instance variable in a context that doesn't have an explicit value. -# -# @foo, @bar = baz -# ^^^^ ^^^^ -# -# source://yarp//lib/yarp/node.rb#5615 -class YARP::InstanceVariableTargetNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#5620 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5626 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5631 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5636 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#5641 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5631 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5652 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5656 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5617 - def name; end -end - -# Represents writing to an instance variable. -# -# @foo = 1 -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5667 -class YARP::InstanceVariableWriteNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void - # - # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#5681 - def initialize(name, name_loc, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5690 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5695 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5700 - def comment_targets; end - - # def copy: (**params) -> InstanceVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#5705 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5695 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5719 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5728 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#5669 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#5672 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#5724 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#5678 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#5675 - def value; end -end - -# Represents an integer number literal. -# -# 1 -# ^ -# -# source://yarp//lib/yarp.rb#404 -class YARP::IntegerNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [IntegerNode] a new instance of IntegerNode - # - # source://yarp//lib/yarp/node.rb#5745 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5750 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5755 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5760 - def comment_targets; end - - # def copy: (**params) -> IntegerNode - # - # source://yarp//lib/yarp/node.rb#5765 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5755 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5775 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5779 - def inspect(inspector = T.unsafe(nil)); end - - # source://yarp//lib/yarp.rb#405 - def value; end -end - -# Represents a regular expression literal that contains interpolation. -# -# /foo #{bar} baz/ -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5789 -class YARP::InterpolatedRegularExpressionNode < ::YARP::Node - # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void - # - # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode - # - # source://yarp//lib/yarp/node.rb#5803 - def initialize(opening_loc, parts, closing_loc, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5812 - def accept(visitor); end - - # def ascii_8bit?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5881 - def ascii_8bit?; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5822 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#5856 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#5797 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5827 - def comment_targets; end - - # def copy: (**params) -> InterpolatedRegularExpressionNode - # - # source://yarp//lib/yarp/node.rb#5832 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5822 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5846 - def deconstruct_keys(keys); end - - # def euc_jp?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5876 - def euc_jp?; end - - # def extended?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5871 - def extended?; end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#5800 - def flags; end - - # def ignore_case?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5861 - def ignore_case?; end - - # source://yarp//lib/yarp/node.rb#5900 - def inspect(inspector = T.unsafe(nil)); end - - # def multi_line?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5866 - def multi_line?; end - - # def once?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5896 - def once?; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#5851 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#5791 - def opening_loc; end - - # attr_reader parts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#5794 - def parts; end - - # source://yarp//lib/yarp/node.rb#5816 - def set_newline_flag(newline_marked); end - - # def utf_8?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5891 - def utf_8?; end - - # def windows_31j?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#5886 - def windows_31j?; end -end - -# Represents a string literal that contains interpolation. -# -# "foo #{bar} baz" -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5914 -class YARP::InterpolatedStringNode < ::YARP::Node - # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void - # - # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode - # - # source://yarp//lib/yarp/node.rb#5925 - def initialize(opening_loc, parts, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#5933 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5943 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#5976 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5922 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#5948 - def comment_targets; end - - # def copy: (**params) -> InterpolatedStringNode - # - # source://yarp//lib/yarp/node.rb#5953 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#5943 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#5966 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#5980 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#5971 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5916 - def opening_loc; end - - # attr_reader parts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#5919 - def parts; end - - # source://yarp//lib/yarp/node.rb#5937 - def set_newline_flag(newline_marked); end -end - -# Represents a symbol literal that contains interpolation. -# -# :"foo #{bar} baz" -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#5993 -class YARP::InterpolatedSymbolNode < ::YARP::Node - # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void - # - # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode - # - # source://yarp//lib/yarp/node.rb#6004 - def initialize(opening_loc, parts, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6012 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6022 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#6055 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#6001 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6027 - def comment_targets; end - - # def copy: (**params) -> InterpolatedSymbolNode - # - # source://yarp//lib/yarp/node.rb#6032 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6022 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6045 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6059 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#6050 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#5995 - def opening_loc; end - - # attr_reader parts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#5998 - def parts; end - - # source://yarp//lib/yarp/node.rb#6016 - def set_newline_flag(newline_marked); end -end - -# Represents an xstring literal that contains interpolation. -# -# `foo #{bar} baz` -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6072 -class YARP::InterpolatedXStringNode < ::YARP::Node - # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void - # - # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode - # - # source://yarp//lib/yarp/node.rb#6083 - def initialize(opening_loc, parts, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6091 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6101 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#6134 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#6080 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6106 - def comment_targets; end - - # def copy: (**params) -> InterpolatedXStringNode - # - # source://yarp//lib/yarp/node.rb#6111 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6101 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6124 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6138 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#6129 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#6074 - def opening_loc; end - - # attr_reader parts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#6077 - def parts; end - - # source://yarp//lib/yarp/node.rb#6095 - def set_newline_flag(newline_marked); end -end - -# Represents a hash literal without opening and closing braces. -# -# foo(a: b) -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#6151 -class YARP::KeywordHashNode < ::YARP::Node - # def initialize: (elements: Array[Node], location: Location) -> void - # - # @return [KeywordHashNode] a new instance of KeywordHashNode - # - # source://yarp//lib/yarp/node.rb#6156 - def initialize(elements, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6162 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6167 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6172 - def comment_targets; end - - # def copy: (**params) -> KeywordHashNode - # - # source://yarp//lib/yarp/node.rb#6177 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6167 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6188 - def deconstruct_keys(keys); end - - # attr_reader elements: Array[Node] - # - # source://yarp//lib/yarp/node.rb#6153 - def elements; end - - # source://yarp//lib/yarp/node.rb#6192 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents a keyword parameter to a method, block, or lambda definition. -# -# def a(b:) -# ^^ -# end -# -# def a(b: 1) -# ^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#6208 -class YARP::KeywordParameterNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, value: Node?, location: Location) -> void - # - # @return [KeywordParameterNode] a new instance of KeywordParameterNode - # - # source://yarp//lib/yarp/node.rb#6219 - def initialize(name, name_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6227 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6232 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6237 - def comment_targets; end - - # def copy: (**params) -> KeywordParameterNode - # - # source://yarp//lib/yarp/node.rb#6242 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6232 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6255 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6259 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6210 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#6213 - def name_loc; end - - # attr_reader value: Node? - # - # source://yarp//lib/yarp/node.rb#6216 - def value; end -end - -# Represents a keyword rest parameter to a method, block, or lambda definition. -# -# def a(**b) -# ^^^ -# end -# -# source://yarp//lib/yarp/node.rb#6278 -class YARP::KeywordRestParameterNode < ::YARP::Node - # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void - # - # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode - # - # source://yarp//lib/yarp/node.rb#6289 - def initialize(name, name_loc, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6297 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6302 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6307 - def comment_targets; end - - # def copy: (**params) -> KeywordRestParameterNode - # - # source://yarp//lib/yarp/node.rb#6312 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6302 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6325 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6334 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol? - # - # source://yarp//lib/yarp/node.rb#6280 - def name; end - - # attr_reader name_loc: Location? - # - # source://yarp//lib/yarp/node.rb#6283 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6330 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6286 - def operator_loc; end -end - -# Represents using a lambda literal (not the lambda method call). -# -# ->(value) { value * 2 } -# ^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6347 -class YARP::LambdaNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> void - # - # @return [LambdaNode] a new instance of LambdaNode - # - # source://yarp//lib/yarp/node.rb#6367 - def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6378 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#6364 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6383 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#6424 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#6358 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6388 - def comment_targets; end - - # def copy: (**params) -> LambdaNode - # - # source://yarp//lib/yarp/node.rb#6393 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6383 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6409 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6428 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#6349 - def locals; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#6419 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#6355 - def opening_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6414 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6352 - def operator_loc; end - - # attr_reader parameters: BlockParametersNode? - # - # source://yarp//lib/yarp/node.rb#6361 - def parameters; end -end - -# This class is responsible for lexing the source using YARP and then -# converting those tokens to be compatible with Ripper. In the vast majority -# of cases, this is a one-to-one mapping of the token type. Everything else -# generally lines up. However, there are a few cases that require special -# handling. -# -# source://yarp//lib/yarp/lex_compat.rb#11 -class YARP::LexCompat - # @return [LexCompat] a new instance of LexCompat - # - # source://yarp//lib/yarp/lex_compat.rb#554 - def initialize(source, filepath = T.unsafe(nil)); end - - # Returns the value of attribute filepath. - # - # source://yarp//lib/yarp/lex_compat.rb#552 - def filepath; end - - # source://yarp//lib/yarp/lex_compat.rb#559 - def result; end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp/lex_compat.rb#552 - def source; end -end - -# Ripper doesn't include the rest of the token in the event, so we need to -# trim it down to just the content on the first line when comparing. -# -# source://yarp//lib/yarp/lex_compat.rb#205 -class YARP::LexCompat::EndContentToken < ::YARP::LexCompat::Token - # source://yarp//lib/yarp/lex_compat.rb#206 - def ==(other); end -end - -# A heredoc in this case is a list of tokens that belong to the body of the -# heredoc that should be appended onto the list of tokens when the heredoc -# closes. -# -# source://yarp//lib/yarp/lex_compat.rb#266 -module YARP::LexCompat::Heredoc - class << self - # Here we will split between the two types of heredocs and return the - # object that will store their tokens. - # - # source://yarp//lib/yarp/lex_compat.rb#540 - def build(opening); end - end -end - -# Dash heredocs are a little more complicated. They are a list of tokens -# that need to be split on "\\\n" to mimic Ripper's behavior. We also need -# to keep track of the state that the heredoc was opened in. -# -# source://yarp//lib/yarp/lex_compat.rb#290 -class YARP::LexCompat::Heredoc::DashHeredoc - # @return [DashHeredoc] a new instance of DashHeredoc - # - # source://yarp//lib/yarp/lex_compat.rb#293 - def initialize(split); end - - # source://yarp//lib/yarp/lex_compat.rb#298 - def <<(token); end - - # Returns the value of attribute split. - # - # source://yarp//lib/yarp/lex_compat.rb#291 - def split; end - - # source://yarp//lib/yarp/lex_compat.rb#302 - def to_a; end - - # Returns the value of attribute tokens. - # - # source://yarp//lib/yarp/lex_compat.rb#291 - def tokens; end -end - -# Heredocs that are dedenting heredocs are a little more complicated. -# Ripper outputs on_ignored_sp tokens for the whitespace that is being -# removed from the output. YARP only modifies the node itself and keeps -# the token the same. This simplifies YARP, but makes comparing against -# Ripper much harder because there is a length mismatch. -# -# Fortunately, we already have to pull out the heredoc tokens in order to -# insert them into the stream in the correct order. As such, we can do -# some extra manipulation on the tokens to make them match Ripper's -# output by mirroring the dedent logic that Ripper uses. -# -# source://yarp//lib/yarp/lex_compat.rb#349 -class YARP::LexCompat::Heredoc::DedentingHeredoc - # @return [DedentingHeredoc] a new instance of DedentingHeredoc - # - # source://yarp//lib/yarp/lex_compat.rb#354 - def initialize; end - - # As tokens are coming in, we track the minimum amount of common leading - # whitespace on plain string content tokens. This allows us to later - # remove that amount of whitespace from the beginning of each line. - # - # source://yarp//lib/yarp/lex_compat.rb#364 - def <<(token); end - - # Returns the value of attribute dedent. - # - # source://yarp//lib/yarp/lex_compat.rb#352 - def dedent; end - - # Returns the value of attribute dedent_next. - # - # source://yarp//lib/yarp/lex_compat.rb#352 - def dedent_next; end - - # Returns the value of attribute embexpr_balance. - # - # source://yarp//lib/yarp/lex_compat.rb#352 - def embexpr_balance; end - - # source://yarp//lib/yarp/lex_compat.rb#396 - def to_a; end - - # Returns the value of attribute tokens. - # - # source://yarp//lib/yarp/lex_compat.rb#352 - def tokens; end -end - -# source://yarp//lib/yarp/lex_compat.rb#350 -YARP::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer) - -# Heredocs that are no dash or tilde heredocs are just a list of tokens. -# We need to keep them around so that we can insert them in the correct -# order back into the token stream and set the state of the last token to -# the state that the heredoc was opened in. -# -# source://yarp//lib/yarp/lex_compat.rb#271 -class YARP::LexCompat::Heredoc::PlainHeredoc - # @return [PlainHeredoc] a new instance of PlainHeredoc - # - # source://yarp//lib/yarp/lex_compat.rb#274 - def initialize; end - - # source://yarp//lib/yarp/lex_compat.rb#278 - def <<(token); end - - # source://yarp//lib/yarp/lex_compat.rb#282 - def to_a; end - - # Returns the value of attribute tokens. - # - # source://yarp//lib/yarp/lex_compat.rb#272 - def tokens; end -end - -# Ident tokens for the most part are exactly the same, except sometimes we -# know an ident is a local when ripper doesn't (when they are introduced -# through named captures in regular expressions). In that case we don't -# compare the state. -# -# source://yarp//lib/yarp/lex_compat.rb#223 -class YARP::LexCompat::IdentToken < ::YARP::LexCompat::Token - # source://yarp//lib/yarp/lex_compat.rb#224 - def ==(other); end -end - -# Tokens where state should be ignored -# used for :on_comment, :on_heredoc_end, :on_embexpr_end -# -# source://yarp//lib/yarp/lex_compat.rb#213 -class YARP::LexCompat::IgnoreStateToken < ::YARP::LexCompat::Token - # source://yarp//lib/yarp/lex_compat.rb#214 - def ==(other); end -end - -# Ignored newlines can occasionally have a LABEL state attached to them, so -# we compare the state differently here. -# -# source://yarp//lib/yarp/lex_compat.rb#234 -class YARP::LexCompat::IgnoredNewlineToken < ::YARP::LexCompat::Token - # source://yarp//lib/yarp/lex_compat.rb#235 - def ==(other); end -end - -# If we have an identifier that follows a method name like: -# -# def foo bar -# -# then Ripper will mark bar as END|LABEL if there is a local in a parent -# scope named bar because it hasn't pushed the local table yet. We do this -# more accurately, so we need to allow comparing against both END and -# END|LABEL. -# -# source://yarp//lib/yarp/lex_compat.rb#254 -class YARP::LexCompat::ParamToken < ::YARP::LexCompat::Token - # source://yarp//lib/yarp/lex_compat.rb#255 - def ==(other); end -end - -# This is a mapping of YARP token types to Ripper token types. This is a -# many-to-one mapping because we split up our token types, whereas Ripper -# tends to group them. -# -# source://yarp//lib/yarp/lex_compat.rb#15 -YARP::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash) - -# When we produce tokens, we produce the same arrays that Ripper does. -# However, we add a couple of convenience methods onto them to make them a -# little easier to work with. We delegate all other methods to the array. -# -# source://yarp//lib/yarp/lex_compat.rb#185 -class YARP::LexCompat::Token < ::SimpleDelegator - # source://yarp//lib/yarp/lex_compat.rb#190 - def event; end - - # source://yarp//lib/yarp/lex_compat.rb#186 - def location; end - - # source://yarp//lib/yarp/lex_compat.rb#198 - def state; end - - # source://yarp//lib/yarp/lex_compat.rb#194 - def value; end -end - -# Represents the use of the `&&=` operator for assignment to a local variable. -# -# target &&= value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6454 -class YARP::LocalVariableAndWriteNode < ::YARP::Node - # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void - # - # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#6471 - def initialize(name_loc, operator_loc, value, name, depth, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6481 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6486 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6491 - def comment_targets; end - - # def copy: (**params) -> LocalVariableAndWriteNode - # - # source://yarp//lib/yarp/node.rb#6496 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6486 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6511 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6468 - def depth; end - - # source://yarp//lib/yarp/node.rb#6520 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6465 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#6456 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6516 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6459 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6462 - def value; end -end - -# Represents assigning to a local variable using an operator that isn't `=`. -# -# target += value -# ^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6536 -class YARP::LocalVariableOperatorWriteNode < ::YARP::Node - # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void - # - # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#6556 - def initialize(name_loc, operator_loc, value, name, operator, depth, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6567 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6572 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6577 - def comment_targets; end - - # def copy: (**params) -> LocalVariableOperatorWriteNode - # - # source://yarp//lib/yarp/node.rb#6582 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6572 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6598 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6553 - def depth; end - - # source://yarp//lib/yarp/node.rb#6602 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6547 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#6538 - def name_loc; end - - # attr_reader operator: Symbol - # - # source://yarp//lib/yarp/node.rb#6550 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6541 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6544 - def value; end -end - -# Represents the use of the `||=` operator for assignment to a local variable. -# -# target ||= value -# ^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6619 -class YARP::LocalVariableOrWriteNode < ::YARP::Node - # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void - # - # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#6636 - def initialize(name_loc, operator_loc, value, name, depth, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6646 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6651 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6656 - def comment_targets; end - - # def copy: (**params) -> LocalVariableOrWriteNode - # - # source://yarp//lib/yarp/node.rb#6661 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6651 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6676 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6633 - def depth; end - - # source://yarp//lib/yarp/node.rb#6685 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6630 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#6621 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6681 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6624 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6627 - def value; end -end - -# Represents reading a local variable. Note that this requires that a local -# variable of the same name has already been written to in the same scope, -# otherwise it is parsed as a method call. -# -# foo -# ^^^ -# -# source://yarp//lib/yarp/node.rb#6703 -class YARP::LocalVariableReadNode < ::YARP::Node - # def initialize: (name: Symbol, depth: Integer, location: Location) -> void - # - # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode - # - # source://yarp//lib/yarp/node.rb#6711 - def initialize(name, depth, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6718 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6723 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6728 - def comment_targets; end - - # def copy: (**params) -> LocalVariableReadNode - # - # source://yarp//lib/yarp/node.rb#6733 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6723 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6745 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6708 - def depth; end - - # source://yarp//lib/yarp/node.rb#6749 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6705 - def name; end -end - -# Represents writing to a local variable in a context that doesn't have an explicit value. -# -# foo, bar = baz -# ^^^ ^^^ -# -# source://yarp//lib/yarp/node.rb#6761 -class YARP::LocalVariableTargetNode < ::YARP::Node - # def initialize: (name: Symbol, depth: Integer, location: Location) -> void - # - # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#6769 - def initialize(name, depth, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6776 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6781 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6786 - def comment_targets; end - - # def copy: (**params) -> LocalVariableTargetNode - # - # source://yarp//lib/yarp/node.rb#6791 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6781 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6803 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6766 - def depth; end - - # source://yarp//lib/yarp/node.rb#6807 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6763 - def name; end -end - -# Represents writing to a local variable. -# -# foo = 1 -# ^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6819 -class YARP::LocalVariableWriteNode < ::YARP::Node - # def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void - # - # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#6836 - def initialize(name, depth, name_loc, value, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6846 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6851 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6856 - def comment_targets; end - - # def copy: (**params) -> LocalVariableWriteNode - # - # source://yarp//lib/yarp/node.rb#6861 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6851 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6876 - def deconstruct_keys(keys); end - - # attr_reader depth: Integer - # - # source://yarp//lib/yarp/node.rb#6824 - def depth; end - - # source://yarp//lib/yarp/node.rb#6885 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#6821 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#6827 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6881 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6833 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6830 - def value; end -end - -# This represents a location in the source. -# -# source://yarp//lib/yarp.rb#41 -class YARP::Location - # @return [Location] a new instance of Location - # - # source://yarp//lib/yarp.rb#56 - def initialize(source, start_offset, length); end - - # source://yarp//lib/yarp.rb#123 - def ==(other); end - - # The list of comments attached to this location - # - # source://yarp//lib/yarp.rb#54 - def comments; end - - # Create a new location object with the given options. - # - # source://yarp//lib/yarp.rb#64 - def copy(**options); end - - # source://yarp//lib/yarp.rb#115 - def deconstruct_keys(keys); end - - # The column number in bytes where this location ends from the start of the - # line. - # - # source://yarp//lib/yarp.rb#111 - def end_column; end - - # The line number where this location ends. - # - # source://yarp//lib/yarp.rb#99 - def end_line; end - - # The byte offset from the beginning of the source where this location ends. - # - # source://yarp//lib/yarp.rb#83 - def end_offset; end - - # Returns a string representation of this location. - # - # source://yarp//lib/yarp.rb#73 - def inspect; end - - # Returns a new location that stretches from this location to the given - # other location. Raises an error if this location is not before the other - # location or if they don't share the same source. - # - # source://yarp//lib/yarp.rb#132 - def join(other); end - - # The length of this location in bytes. - # - # source://yarp//lib/yarp.rb#51 - def length; end - - # source://yarp//lib/yarp.rb#119 - def pretty_print(q); end - - # The source code that this location represents. - # - # source://yarp//lib/yarp.rb#78 - def slice; end - - # The column number in bytes where this location starts from the start of - # the line. - # - # source://yarp//lib/yarp.rb#105 - def start_column; end - - # The line number where this location starts. - # - # source://yarp//lib/yarp.rb#88 - def start_line; end - - # The content of the line where this location starts before this location. - # - # source://yarp//lib/yarp.rb#93 - def start_line_slice; end - - # The byte offset from the beginning of the source where this location - # starts. - # - # source://yarp//lib/yarp.rb#48 - def start_offset; end - - protected - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp.rb#44 - def source; end - - class << self - # source://yarp//lib/yarp.rb#139 - def null; end - end -end - -# source://yarp//lib/yarp/node.rb#10565 -module YARP::LoopFlags; end - -# a loop after a begin statement, so the body is executed first before the condition -# -# source://yarp//lib/yarp/node.rb#10567 -YARP::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer) - -# Represents the use of the modifier `in` operator. -# -# foo in bar -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6901 -class YARP::MatchPredicateNode < ::YARP::Node - # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void - # - # @return [MatchPredicateNode] a new instance of MatchPredicateNode - # - # source://yarp//lib/yarp/node.rb#6912 - def initialize(value, pattern, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6920 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6925 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#6930 - def comment_targets; end - - # def copy: (**params) -> MatchPredicateNode - # - # source://yarp//lib/yarp/node.rb#6935 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6925 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#6948 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#6957 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#6953 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6909 - def operator_loc; end - - # attr_reader pattern: Node - # - # source://yarp//lib/yarp/node.rb#6906 - def pattern; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6903 - def value; end -end - -# Represents the use of the `=>` operator. -# -# foo => bar -# ^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#6972 -class YARP::MatchRequiredNode < ::YARP::Node - # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void - # - # @return [MatchRequiredNode] a new instance of MatchRequiredNode - # - # source://yarp//lib/yarp/node.rb#6983 - def initialize(value, pattern, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#6991 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6996 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7001 - def comment_targets; end - - # def copy: (**params) -> MatchRequiredNode - # - # source://yarp//lib/yarp/node.rb#7006 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#6996 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7019 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7028 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7024 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#6980 - def operator_loc; end - - # attr_reader pattern: Node - # - # source://yarp//lib/yarp/node.rb#6977 - def pattern; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#6974 - def value; end -end - -# Represents a node that is missing from the source and results in a syntax -# error. -# -# source://yarp//lib/yarp/node.rb#7041 -class YARP::MissingNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [MissingNode] a new instance of MissingNode - # - # source://yarp//lib/yarp/node.rb#7043 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7048 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7053 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7058 - def comment_targets; end - - # def copy: (**params) -> MissingNode - # - # source://yarp//lib/yarp/node.rb#7063 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7053 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7073 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7077 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents a module declaration involving the `module` keyword. -# -# module Foo end -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7087 -class YARP::ModuleNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void - # - # @return [ModuleNode] a new instance of ModuleNode - # - # source://yarp//lib/yarp/node.rb#7107 - def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7118 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#7098 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7123 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7128 - def comment_targets; end - - # attr_reader constant_path: Node - # - # source://yarp//lib/yarp/node.rb#7095 - def constant_path; end - - # def copy: (**params) -> ModuleNode - # - # source://yarp//lib/yarp/node.rb#7133 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7123 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7149 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#7159 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#7101 - def end_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#7163 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#7089 - def locals; end - - # def module_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#7154 - def module_keyword; end - - # attr_reader module_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#7092 - def module_keyword_loc; end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#7104 - def name; end -end - -# Represents a multi-target expression. -# -# a, b, c = 1, 2, 3 -# ^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7185 -class YARP::MultiTargetNode < ::YARP::Node - # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void - # - # @return [MultiTargetNode] a new instance of MultiTargetNode - # - # source://yarp//lib/yarp/node.rb#7196 - def initialize(targets, lparen_loc, rparen_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7204 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7209 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7214 - def comment_targets; end - - # def copy: (**params) -> MultiTargetNode - # - # source://yarp//lib/yarp/node.rb#7219 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7209 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7232 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7246 - def inspect(inspector = T.unsafe(nil)); end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#7237 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#7190 - def lparen_loc; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#7242 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#7193 - def rparen_loc; end - - # attr_reader targets: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7187 - def targets; end -end - -# Represents a write to a multi-target expression. -# -# a, b, c = 1, 2, 3 -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7259 -class YARP::MultiWriteNode < ::YARP::Node - # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [MultiWriteNode] a new instance of MultiWriteNode - # - # source://yarp//lib/yarp/node.rb#7276 - def initialize(targets, lparen_loc, rparen_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7286 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7291 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7296 - def comment_targets; end - - # def copy: (**params) -> MultiWriteNode - # - # source://yarp//lib/yarp/node.rb#7301 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7291 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7316 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7335 - def inspect(inspector = T.unsafe(nil)); end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#7321 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#7264 - def lparen_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7331 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#7270 - def operator_loc; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#7326 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#7267 - def rparen_loc; end - - # attr_reader targets: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7261 - def targets; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#7273 - def value; end -end - -# This visitor walks through the tree and copies each node as it is being -# visited. This is useful for consumers that want to mutate the tree, as you -# can change subtrees in place without effecting the rest of the tree. -# -# source://yarp//lib/yarp/mutation_visitor.rb#12 -class YARP::MutationVisitor < ::YARP::BasicVisitor - # Copy a AliasNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#14 - def visit_alias_node(node); end - - # Copy a AlternationPatternNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#19 - def visit_alternation_pattern_node(node); end - - # Copy a AndNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#24 - def visit_and_node(node); end - - # Copy a ArgumentsNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#29 - def visit_arguments_node(node); end - - # Copy a ArrayNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#34 - def visit_array_node(node); end - - # Copy a ArrayPatternNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#39 - def visit_array_pattern_node(node); end - - # Copy a AssocNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#44 - def visit_assoc_node(node); end - - # Copy a AssocSplatNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#49 - def visit_assoc_splat_node(node); end - - # Copy a BackReferenceReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#54 - def visit_back_reference_read_node(node); end - - # Copy a BeginNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#59 - def visit_begin_node(node); end - - # Copy a BlockArgumentNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#64 - def visit_block_argument_node(node); end - - # Copy a BlockLocalVariableNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#69 - def visit_block_local_variable_node(node); end - - # Copy a BlockNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#74 - def visit_block_node(node); end - - # Copy a BlockParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#79 - def visit_block_parameter_node(node); end - - # Copy a BlockParametersNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#84 - def visit_block_parameters_node(node); end - - # Copy a BreakNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#89 - def visit_break_node(node); end - - # Copy a CallAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#94 - def visit_call_and_write_node(node); end - - # Copy a CallNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#99 - def visit_call_node(node); end - - # Copy a CallOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#104 - def visit_call_operator_write_node(node); end - - # Copy a CallOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#109 - def visit_call_or_write_node(node); end - - # Copy a CapturePatternNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#114 - def visit_capture_pattern_node(node); end - - # Copy a CaseNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#119 - def visit_case_node(node); end - - # Copy a ClassNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#124 - def visit_class_node(node); end - - # Copy a ClassVariableAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#129 - def visit_class_variable_and_write_node(node); end - - # Copy a ClassVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#134 - def visit_class_variable_operator_write_node(node); end - - # Copy a ClassVariableOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#139 - def visit_class_variable_or_write_node(node); end - - # Copy a ClassVariableReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#144 - def visit_class_variable_read_node(node); end - - # Copy a ClassVariableTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#149 - def visit_class_variable_target_node(node); end - - # Copy a ClassVariableWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#154 - def visit_class_variable_write_node(node); end - - # Copy a ConstantAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#159 - def visit_constant_and_write_node(node); end - - # Copy a ConstantOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#164 - def visit_constant_operator_write_node(node); end - - # Copy a ConstantOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#169 - def visit_constant_or_write_node(node); end - - # Copy a ConstantPathAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#174 - def visit_constant_path_and_write_node(node); end - - # Copy a ConstantPathNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#179 - def visit_constant_path_node(node); end - - # Copy a ConstantPathOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#184 - def visit_constant_path_operator_write_node(node); end - - # Copy a ConstantPathOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#189 - def visit_constant_path_or_write_node(node); end - - # Copy a ConstantPathTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#194 - def visit_constant_path_target_node(node); end - - # Copy a ConstantPathWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#199 - def visit_constant_path_write_node(node); end - - # Copy a ConstantReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#204 - def visit_constant_read_node(node); end - - # Copy a ConstantTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#209 - def visit_constant_target_node(node); end - - # Copy a ConstantWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#214 - def visit_constant_write_node(node); end - - # Copy a DefNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#219 - def visit_def_node(node); end - - # Copy a DefinedNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#224 - def visit_defined_node(node); end - - # Copy a ElseNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#229 - def visit_else_node(node); end - - # Copy a EmbeddedStatementsNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#234 - def visit_embedded_statements_node(node); end - - # Copy a EmbeddedVariableNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#239 - def visit_embedded_variable_node(node); end - - # Copy a EnsureNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#244 - def visit_ensure_node(node); end - - # Copy a FalseNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#249 - def visit_false_node(node); end - - # Copy a FindPatternNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#254 - def visit_find_pattern_node(node); end - - # Copy a FlipFlopNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#259 - def visit_flip_flop_node(node); end - - # Copy a FloatNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#264 - def visit_float_node(node); end - - # Copy a ForNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#269 - def visit_for_node(node); end - - # Copy a ForwardingArgumentsNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#274 - def visit_forwarding_arguments_node(node); end - - # Copy a ForwardingParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#279 - def visit_forwarding_parameter_node(node); end - - # Copy a ForwardingSuperNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#284 - def visit_forwarding_super_node(node); end - - # Copy a GlobalVariableAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#289 - def visit_global_variable_and_write_node(node); end - - # Copy a GlobalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#294 - def visit_global_variable_operator_write_node(node); end - - # Copy a GlobalVariableOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#299 - def visit_global_variable_or_write_node(node); end - - # Copy a GlobalVariableReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#304 - def visit_global_variable_read_node(node); end - - # Copy a GlobalVariableTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#309 - def visit_global_variable_target_node(node); end - - # Copy a GlobalVariableWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#314 - def visit_global_variable_write_node(node); end - - # Copy a HashNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#319 - def visit_hash_node(node); end - - # Copy a HashPatternNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#324 - def visit_hash_pattern_node(node); end - - # Copy a IfNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#329 - def visit_if_node(node); end - - # Copy a ImaginaryNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#334 - def visit_imaginary_node(node); end - - # Copy a InNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#339 - def visit_in_node(node); end - - # Copy a InstanceVariableAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#344 - def visit_instance_variable_and_write_node(node); end - - # Copy a InstanceVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#349 - def visit_instance_variable_operator_write_node(node); end - - # Copy a InstanceVariableOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#354 - def visit_instance_variable_or_write_node(node); end - - # Copy a InstanceVariableReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#359 - def visit_instance_variable_read_node(node); end - - # Copy a InstanceVariableTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#364 - def visit_instance_variable_target_node(node); end - - # Copy a InstanceVariableWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#369 - def visit_instance_variable_write_node(node); end - - # Copy a IntegerNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#374 - def visit_integer_node(node); end - - # Copy a InterpolatedRegularExpressionNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#379 - def visit_interpolated_regular_expression_node(node); end - - # Copy a InterpolatedStringNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#384 - def visit_interpolated_string_node(node); end - - # Copy a InterpolatedSymbolNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#389 - def visit_interpolated_symbol_node(node); end - - # Copy a InterpolatedXStringNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#394 - def visit_interpolated_x_string_node(node); end - - # Copy a KeywordHashNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#399 - def visit_keyword_hash_node(node); end - - # Copy a KeywordParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#404 - def visit_keyword_parameter_node(node); end - - # Copy a KeywordRestParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#409 - def visit_keyword_rest_parameter_node(node); end - - # Copy a LambdaNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#414 - def visit_lambda_node(node); end - - # Copy a LocalVariableAndWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#419 - def visit_local_variable_and_write_node(node); end - - # Copy a LocalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#424 - def visit_local_variable_operator_write_node(node); end - - # Copy a LocalVariableOrWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#429 - def visit_local_variable_or_write_node(node); end - - # Copy a LocalVariableReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#434 - def visit_local_variable_read_node(node); end - - # Copy a LocalVariableTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#439 - def visit_local_variable_target_node(node); end - - # Copy a LocalVariableWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#444 - def visit_local_variable_write_node(node); end - - # Copy a MatchPredicateNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#449 - def visit_match_predicate_node(node); end - - # Copy a MatchRequiredNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#454 - def visit_match_required_node(node); end - - # Copy a MissingNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#459 - def visit_missing_node(node); end - - # Copy a ModuleNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#464 - def visit_module_node(node); end - - # Copy a MultiTargetNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#469 - def visit_multi_target_node(node); end - - # Copy a MultiWriteNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#474 - def visit_multi_write_node(node); end - - # Copy a NextNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#479 - def visit_next_node(node); end - - # Copy a NilNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#484 - def visit_nil_node(node); end - - # Copy a NoKeywordsParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#489 - def visit_no_keywords_parameter_node(node); end - - # Copy a NumberedReferenceReadNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#494 - def visit_numbered_reference_read_node(node); end - - # Copy a OptionalParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#499 - def visit_optional_parameter_node(node); end - - # Copy a OrNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#504 - def visit_or_node(node); end - - # Copy a ParametersNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#509 - def visit_parameters_node(node); end - - # Copy a ParenthesesNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#514 - def visit_parentheses_node(node); end - - # Copy a PinnedExpressionNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#519 - def visit_pinned_expression_node(node); end - - # Copy a PinnedVariableNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#524 - def visit_pinned_variable_node(node); end - - # Copy a PostExecutionNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#529 - def visit_post_execution_node(node); end - - # Copy a PreExecutionNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#534 - def visit_pre_execution_node(node); end - - # Copy a ProgramNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#539 - def visit_program_node(node); end - - # Copy a RangeNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#544 - def visit_range_node(node); end - - # Copy a RationalNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#549 - def visit_rational_node(node); end - - # Copy a RedoNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#554 - def visit_redo_node(node); end - - # Copy a RegularExpressionNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#559 - def visit_regular_expression_node(node); end - - # Copy a RequiredDestructuredParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#564 - def visit_required_destructured_parameter_node(node); end - - # Copy a RequiredParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#569 - def visit_required_parameter_node(node); end - - # Copy a RescueModifierNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#574 - def visit_rescue_modifier_node(node); end - - # Copy a RescueNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#579 - def visit_rescue_node(node); end - - # Copy a RestParameterNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#584 - def visit_rest_parameter_node(node); end - - # Copy a RetryNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#589 - def visit_retry_node(node); end - - # Copy a ReturnNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#594 - def visit_return_node(node); end - - # Copy a SelfNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#599 - def visit_self_node(node); end - - # Copy a SingletonClassNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#604 - def visit_singleton_class_node(node); end - - # Copy a SourceEncodingNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#609 - def visit_source_encoding_node(node); end - - # Copy a SourceFileNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#614 - def visit_source_file_node(node); end - - # Copy a SourceLineNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#619 - def visit_source_line_node(node); end - - # Copy a SplatNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#624 - def visit_splat_node(node); end - - # Copy a StatementsNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#629 - def visit_statements_node(node); end - - # Copy a StringConcatNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#634 - def visit_string_concat_node(node); end - - # Copy a StringNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#639 - def visit_string_node(node); end - - # Copy a SuperNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#644 - def visit_super_node(node); end - - # Copy a SymbolNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#649 - def visit_symbol_node(node); end - - # Copy a TrueNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#654 - def visit_true_node(node); end - - # Copy a UndefNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#659 - def visit_undef_node(node); end - - # Copy a UnlessNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#664 - def visit_unless_node(node); end - - # Copy a UntilNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#669 - def visit_until_node(node); end - - # Copy a WhenNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#674 - def visit_when_node(node); end - - # Copy a WhileNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#679 - def visit_while_node(node); end - - # Copy a XStringNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#684 - def visit_x_string_node(node); end - - # Copy a YieldNode node - # - # source://yarp//lib/yarp/mutation_visitor.rb#689 - def visit_yield_node(node); end -end - -# Represents the use of the `next` keyword. -# -# next 1 -# ^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7351 -class YARP::NextNode < ::YARP::Node - # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void - # - # @return [NextNode] a new instance of NextNode - # - # source://yarp//lib/yarp/node.rb#7359 - def initialize(arguments, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7366 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#7353 - def arguments; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7371 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7376 - def comment_targets; end - - # def copy: (**params) -> NextNode - # - # source://yarp//lib/yarp/node.rb#7381 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7371 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7393 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7402 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#7398 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#7356 - def keyword_loc; end -end - -# Represents the use of the `nil` keyword. -# -# nil -# ^^^ -# -# source://yarp//lib/yarp/node.rb#7419 -class YARP::NilNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [NilNode] a new instance of NilNode - # - # source://yarp//lib/yarp/node.rb#7421 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7426 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7431 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7436 - def comment_targets; end - - # def copy: (**params) -> NilNode - # - # source://yarp//lib/yarp/node.rb#7441 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7431 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7451 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7455 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of `**nil` inside method arguments. -# -# def a(**nil) -# ^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#7466 -class YARP::NoKeywordsParameterNode < ::YARP::Node - # def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void - # - # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode - # - # source://yarp//lib/yarp/node.rb#7474 - def initialize(operator_loc, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7481 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7486 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7491 - def comment_targets; end - - # def copy: (**params) -> NoKeywordsParameterNode - # - # source://yarp//lib/yarp/node.rb#7496 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7486 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7508 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7522 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#7518 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#7471 - def keyword_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7513 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#7468 - def operator_loc; end -end - -# This represents a node in the tree. -# -# source://yarp//lib/yarp.rb#289 -class YARP::Node - # Returns the value of attribute location. - # - # source://yarp//lib/yarp.rb#290 - def location; end - - # @return [Boolean] - # - # source://yarp//lib/yarp.rb#292 - def newline?; end - - # source://yarp//lib/yarp.rb#309 - def pretty_print(q); end - - # source://yarp//lib/yarp.rb#296 - def set_newline_flag(newline_marked); end - - # Slice the location of the node from the source. - # - # source://yarp//lib/yarp.rb#305 - def slice; end -end - -# This object is responsible for generating the output for the inspect method -# implementations of child nodes. -# -# source://yarp//lib/yarp.rb#329 -class YARP::NodeInspector - # @return [NodeInspector] a new instance of NodeInspector - # - # source://yarp//lib/yarp.rb#332 - def initialize(prefix = T.unsafe(nil)); end - - # Appends a line to the output with the current prefix. - # - # source://yarp//lib/yarp.rb#338 - def <<(line); end - - # Returns a new inspector that can be used to inspect a child node. - # - # source://yarp//lib/yarp.rb#382 - def child_inspector(append); end - - # Generates a string that represents a child node. - # - # source://yarp//lib/yarp.rb#377 - def child_node(node, append); end - - # This generates a string that is used as the header of the inspect output - # for any given node. - # - # source://yarp//lib/yarp.rb#344 - def header(node); end - - # Generates a string that represents a list of nodes. It handles properly - # using the box drawing characters to make the output look nice. - # - # source://yarp//lib/yarp.rb#354 - def list(prefix, nodes); end - - # Generates a string that represents a location field on a node. - # - # source://yarp//lib/yarp.rb#368 - def location(value); end - - # Returns the value of attribute output. - # - # source://yarp//lib/yarp.rb#330 - def output; end - - # Returns the value of attribute prefix. - # - # source://yarp//lib/yarp.rb#330 - def prefix; end - - # Returns the output as a string. - # - # source://yarp//lib/yarp.rb#387 - def to_str; end -end - -# Represents reading a numbered reference to a capture in the previous match. -# -# $1 -# ^^ -# -# source://yarp//lib/yarp/node.rb#7534 -class YARP::NumberedReferenceReadNode < ::YARP::Node - # def initialize: (number: Integer, location: Location) -> void - # - # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode - # - # source://yarp//lib/yarp/node.rb#7539 - def initialize(number, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7545 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7550 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7555 - def comment_targets; end - - # def copy: (**params) -> NumberedReferenceReadNode - # - # source://yarp//lib/yarp/node.rb#7560 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7550 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7571 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7575 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader number: Integer - # - # source://yarp//lib/yarp/node.rb#7536 - def number; end -end - -# Represents an optional parameter to a method, block, or lambda definition. -# -# def a(b = 1) -# ^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#7587 -class YARP::OptionalParameterNode < ::YARP::Node - # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void - # - # @return [OptionalParameterNode] a new instance of OptionalParameterNode - # - # source://yarp//lib/yarp/node.rb#7601 - def initialize(name, name_loc, operator_loc, value, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7610 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7615 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7620 - def comment_targets; end - - # def copy: (**params) -> OptionalParameterNode - # - # source://yarp//lib/yarp/node.rb#7625 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7615 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7639 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7648 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#7589 - def name; end - - # attr_reader name_loc: Location - # - # source://yarp//lib/yarp/node.rb#7592 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7644 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#7595 - def operator_loc; end - - # attr_reader value: Node - # - # source://yarp//lib/yarp/node.rb#7598 - def value; end -end - -# Represents the use of the `||` operator or the `or` keyword. -# -# left or right -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7663 -class YARP::OrNode < ::YARP::Node - # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void - # - # @return [OrNode] a new instance of OrNode - # - # source://yarp//lib/yarp/node.rb#7674 - def initialize(left, right, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7682 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7687 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7692 - def comment_targets; end - - # def copy: (**params) -> OrNode - # - # source://yarp//lib/yarp/node.rb#7697 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7687 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7710 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7719 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node - # - # source://yarp//lib/yarp/node.rb#7665 - def left; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7715 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#7671 - def operator_loc; end - - # attr_reader right: Node - # - # source://yarp//lib/yarp/node.rb#7668 - def right; end -end - -# source://yarp//lib/yarp/pack.rb#4 -module YARP::Pack - class << self - def parse(_arg0, _arg1, _arg2); end - end -end - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::BACK = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::BER = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::COMMENT = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#57 -class YARP::Pack::Directive - # @return [Directive] a new instance of Directive - # - # source://yarp//lib/yarp/pack.rb#60 - def initialize(version, variant, source, type, signed, endian, size, length_type, length); end - - # source://yarp//lib/yarp/pack.rb#98 - def describe; end - - # Returns the value of attribute endian. - # - # source://yarp//lib/yarp/pack.rb#58 - def endian; end - - # Returns the value of attribute length. - # - # source://yarp//lib/yarp/pack.rb#58 - def length; end - - # Returns the value of attribute length_type. - # - # source://yarp//lib/yarp/pack.rb#58 - def length_type; end - - # Returns the value of attribute signed. - # - # source://yarp//lib/yarp/pack.rb#58 - def signed; end - - # Returns the value of attribute size. - # - # source://yarp//lib/yarp/pack.rb#58 - def size; end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp/pack.rb#58 - def source; end - - # Returns the value of attribute type. - # - # source://yarp//lib/yarp/pack.rb#58 - def type; end - - # Returns the value of attribute variant. - # - # source://yarp//lib/yarp/pack.rb#58 - def variant; end - - # Returns the value of attribute version. - # - # source://yarp//lib/yarp/pack.rb#58 - def version; end -end - -# source://yarp//lib/yarp/pack.rb#72 -YARP::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) - -# source://yarp//lib/yarp/pack.rb#80 -YARP::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) - -# source://yarp//lib/yarp/pack.rb#86 -YARP::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::FLOAT = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#162 -class YARP::Pack::Format - # @return [Format] a new instance of Format - # - # source://yarp//lib/yarp/pack.rb#165 - def initialize(directives, encoding); end - - # source://yarp//lib/yarp/pack.rb#170 - def describe; end - - # Returns the value of attribute directives. - # - # source://yarp//lib/yarp/pack.rb#163 - def directives; end - - # Returns the value of attribute encoding. - # - # source://yarp//lib/yarp/pack.rb#163 - def encoding; end -end - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::INTEGER = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::MOVE = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::NULL = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIGNED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::SPACE = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol) - -# source://yarp//lib/yarp/pack.rb#54 -YARP::Pack::UTF8 = T.let(T.unsafe(nil), Symbol) - -# Represents the list of parameters on a method, block, or lambda definition. -# -# def a(b, c, d) -# ^^^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#7735 -class YARP::ParametersNode < ::YARP::Node - # def initialize: (requireds: Array[Node], optionals: Array[Node], posts: Array[Node], rest: RestParameterNode?, keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void - # - # @return [ParametersNode] a new instance of ParametersNode - # - # source://yarp//lib/yarp/node.rb#7758 - def initialize(requireds, optionals, posts, rest, keywords, keyword_rest, block, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7770 - def accept(visitor); end - - # attr_reader block: BlockParameterNode? - # - # source://yarp//lib/yarp/node.rb#7755 - def block; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7775 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7780 - def comment_targets; end - - # def copy: (**params) -> ParametersNode - # - # source://yarp//lib/yarp/node.rb#7785 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7775 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7802 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7806 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader keyword_rest: Node? - # - # source://yarp//lib/yarp/node.rb#7752 - def keyword_rest; end - - # attr_reader keywords: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7749 - def keywords; end - - # attr_reader optionals: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7740 - def optionals; end - - # attr_reader posts: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7743 - def posts; end - - # attr_reader requireds: Array[Node] - # - # source://yarp//lib/yarp/node.rb#7737 - def requireds; end - - # attr_reader rest: RestParameterNode? - # - # source://yarp//lib/yarp/node.rb#7746 - def rest; end -end - -# Represents a parenthesized expression -# -# (10 + 34) -# ^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7838 -class YARP::ParenthesesNode < ::YARP::Node - # def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void - # - # @return [ParenthesesNode] a new instance of ParenthesesNode - # - # source://yarp//lib/yarp/node.rb#7849 - def initialize(body, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7857 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#7840 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7866 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#7899 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#7846 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7871 - def comment_targets; end - - # def copy: (**params) -> ParenthesesNode - # - # source://yarp//lib/yarp/node.rb#7876 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7866 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7889 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#7903 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#7894 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#7843 - def opening_loc; end - - # source://yarp//lib/yarp/node.rb#7861 - def set_newline_flag(newline_marked); end -end - -# This represents an error that was encountered during parsing. -# -# source://yarp//lib/yarp.rb#170 -class YARP::ParseError - # @return [ParseError] a new instance of ParseError - # - # source://yarp//lib/yarp.rb#173 - def initialize(message, location); end - - # source://yarp//lib/yarp.rb#178 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp.rb#182 - def inspect; end - - # Returns the value of attribute location. - # - # source://yarp//lib/yarp.rb#171 - def location; end - - # Returns the value of attribute message. - # - # source://yarp//lib/yarp.rb#171 - def message; end -end - -# This represents the result of a call to ::parse or ::parse_file. It contains -# the AST, any comments that were encounters, and any errors that were -# encountered. -# -# source://yarp//lib/yarp.rb#229 -class YARP::ParseResult - # @return [ParseResult] a new instance of ParseResult - # - # source://yarp//lib/yarp.rb#232 - def initialize(value, comments, errors, warnings, source); end - - # Attach the list of comments to their respective locations in the tree. - # - # source://yarp//lib/yarp/parse_result/comments.rb#168 - def attach_comments!; end - - # Returns the value of attribute comments. - # - # source://yarp//lib/yarp.rb#230 - def comments; end - - # source://yarp//lib/yarp.rb#240 - def deconstruct_keys(keys); end - - # Returns the value of attribute errors. - # - # source://yarp//lib/yarp.rb#230 - def errors; end - - # @return [Boolean] - # - # source://yarp//lib/yarp.rb#248 - def failure?; end - - # Walk the tree and mark nodes that are on a new line. - # - # source://yarp//lib/yarp/parse_result/newlines.rb#56 - def mark_newlines!; end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp.rb#230 - def source; end - - # @return [Boolean] - # - # source://yarp//lib/yarp.rb#244 - def success?; end - - # Returns the value of attribute value. - # - # source://yarp//lib/yarp.rb#230 - def value; end - - # Returns the value of attribute warnings. - # - # source://yarp//lib/yarp.rb#230 - def warnings; end -end - -# When we've parsed the source, we have both the syntax tree and the list of -# comments that we found in the source. This class is responsible for -# walking the tree and finding the nearest location to attach each comment. -# -# It does this by first finding the nearest locations to each comment. -# Locations can either come from nodes directly or from location fields on -# nodes. For example, a `ClassNode` has an overall location encompassing the -# entire class, but it also has a location for the `class` keyword. -# -# Once the nearest locations are found, it determines which one to attach -# to. If it's a trailing comment (a comment on the same line as other source -# code), it will favor attaching to the nearest location that occurs before -# the comment. Otherwise it will favor attaching to the nearest location -# that is after the comment. -# -# source://yarp//lib/yarp/parse_result/comments.rb#19 -class YARP::ParseResult::Comments - # @return [Comments] a new instance of Comments - # - # source://yarp//lib/yarp/parse_result/comments.rb#75 - def initialize(parse_result); end - - # source://yarp//lib/yarp/parse_result/comments.rb#79 - def attach!; end - - # Returns the value of attribute parse_result. - # - # source://yarp//lib/yarp/parse_result/comments.rb#73 - def parse_result; end - - private - - # Responsible for finding the nearest targets to the given comment within - # the context of the given encapsulating node. - # - # source://yarp//lib/yarp/parse_result/comments.rb#98 - def nearest_targets(node, comment); end -end - -# A target for attaching comments that is based on a location field on a -# node. For example, the `end` token of a ClassNode. -# -# source://yarp//lib/yarp/parse_result/comments.rb#49 -class YARP::ParseResult::Comments::LocationTarget - # @return [LocationTarget] a new instance of LocationTarget - # - # source://yarp//lib/yarp/parse_result/comments.rb#52 - def initialize(location); end - - # source://yarp//lib/yarp/parse_result/comments.rb#68 - def <<(comment); end - - # @return [Boolean] - # - # source://yarp//lib/yarp/parse_result/comments.rb#64 - def encloses?(comment); end - - # source://yarp//lib/yarp/parse_result/comments.rb#60 - def end_offset; end - - # Returns the value of attribute location. - # - # source://yarp//lib/yarp/parse_result/comments.rb#50 - def location; end - - # source://yarp//lib/yarp/parse_result/comments.rb#56 - def start_offset; end -end - -# A target for attaching comments that is based on a specific node's -# location. -# -# source://yarp//lib/yarp/parse_result/comments.rb#22 -class YARP::ParseResult::Comments::NodeTarget - # @return [NodeTarget] a new instance of NodeTarget - # - # source://yarp//lib/yarp/parse_result/comments.rb#25 - def initialize(node); end - - # source://yarp//lib/yarp/parse_result/comments.rb#42 - def <<(comment); end - - # @return [Boolean] - # - # source://yarp//lib/yarp/parse_result/comments.rb#37 - def encloses?(comment); end - - # source://yarp//lib/yarp/parse_result/comments.rb#33 - def end_offset; end - - # Returns the value of attribute node. - # - # source://yarp//lib/yarp/parse_result/comments.rb#23 - def node; end - - # source://yarp//lib/yarp/parse_result/comments.rb#29 - def start_offset; end -end - -# The :line tracepoint event gets fired whenever the Ruby VM encounters an -# expression on a new line. The types of expressions that can trigger this -# event are: -# -# * if statements -# * unless statements -# * nodes that are children of statements lists -# -# In order to keep track of the newlines, we have a list of offsets that -# come back from the parser. We assign these offsets to the first nodes that -# we find in the tree that are on those lines. -# -# Note that the logic in this file should be kept in sync with the Java -# MarkNewlinesVisitor, since that visitor is responsible for marking the -# newlines for JRuby/TruffleRuby. -# -# source://yarp//lib/yarp/parse_result/newlines.rb#20 -class YARP::ParseResult::Newlines < ::YARP::Visitor - # @return [Newlines] a new instance of Newlines - # - # source://yarp//lib/yarp/parse_result/newlines.rb#21 - def initialize(newline_marked); end - - # source://yarp//lib/yarp/parse_result/newlines.rb#25 - def visit_block_node(node); end - - # source://yarp//lib/yarp/parse_result/newlines.rb#38 - def visit_if_node(node); end - - # source://yarp//lib/yarp/parse_result/newlines.rb#25 - def visit_lambda_node(node); end - - # source://yarp//lib/yarp/parse_result/newlines.rb#45 - def visit_statements_node(node); end - - # source://yarp//lib/yarp/parse_result/newlines.rb#38 - def visit_unless_node(node); end -end - -# This represents a warning that was encountered during parsing. -# -# source://yarp//lib/yarp.rb#188 -class YARP::ParseWarning - # @return [ParseWarning] a new instance of ParseWarning - # - # source://yarp//lib/yarp.rb#191 - def initialize(message, location); end - - # source://yarp//lib/yarp.rb#196 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp.rb#200 - def inspect; end - - # Returns the value of attribute location. - # - # source://yarp//lib/yarp.rb#189 - def location; end - - # Returns the value of attribute message. - # - # source://yarp//lib/yarp.rb#189 - def message; end -end - -# A pattern is an object that wraps a Ruby pattern matching expression. The -# expression would normally be passed to an `in` clause within a `case` -# expression or a rightward assignment expression. For example, in the -# following snippet: -# -# case node -# in ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]] -# end -# -# the pattern is the `ConstantPathNode[...]` expression. -# -# The pattern gets compiled into an object that responds to #call by running -# the #compile method. This method itself will run back through YARP to -# parse the expression into a tree, then walk the tree to generate the -# necessary callable objects. For example, if you wanted to compile the -# expression above into a callable, you would: -# -# callable = YARP::Pattern.new("ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]]").compile -# callable.call(node) -# -# The callable object returned by #compile is guaranteed to respond to #call -# with a single argument, which is the node to match against. It also is -# guaranteed to respond to #===, which means it itself can be used in a `case` -# expression, as in: -# -# case node -# when callable -# end -# -# If the query given to the initializer cannot be compiled into a valid -# matcher (either because of a syntax error or because it is using syntax we -# do not yet support) then a YARP::Pattern::CompilationError will be -# raised. -# -# source://yarp//lib/yarp/pattern.rb#37 -class YARP::Pattern - # @return [Pattern] a new instance of Pattern - # - # source://yarp//lib/yarp/pattern.rb#58 - def initialize(query); end - - # source://yarp//lib/yarp/pattern.rb#63 - def compile; end - - # Returns the value of attribute query. - # - # source://yarp//lib/yarp/pattern.rb#56 - def query; end - - # source://yarp//lib/yarp/pattern.rb#68 - def scan(root); end - - private - - # Shortcut for combining two procs into one that returns true if both return - # true. - # - # source://yarp//lib/yarp/pattern.rb#84 - def combine_and(left, right); end - - # Shortcut for combining two procs into one that returns true if either - # returns true. - # - # source://yarp//lib/yarp/pattern.rb#90 - def combine_or(left, right); end - - # in foo | bar - # - # source://yarp//lib/yarp/pattern.rb#125 - def compile_alternation_pattern_node(node); end - - # in [foo, bar, baz] - # - # source://yarp//lib/yarp/pattern.rb#100 - def compile_array_pattern_node(node); end - - # in YARP::ConstantReadNode - # - # source://yarp//lib/yarp/pattern.rb#130 - def compile_constant_path_node(node); end - - # in ConstantReadNode - # in String - # - # source://yarp//lib/yarp/pattern.rb#142 - def compile_constant_read_node(node); end - - # Raise an error because the given node is not supported. - # - # @raise [CompilationError] - # - # source://yarp//lib/yarp/pattern.rb#95 - def compile_error(node); end - - # in InstanceVariableReadNode[name: Symbol] - # in { name: Symbol } - # - # source://yarp//lib/yarp/pattern.rb#160 - def compile_hash_pattern_node(node); end - - # in nil - # - # source://yarp//lib/yarp/pattern.rb#185 - def compile_nil_node(node); end - - # Compile any kind of node. Dispatch out to the individual compilation - # methods based on the type of node. - # - # source://yarp//lib/yarp/pattern.rb#214 - def compile_node(node); end - - # in /foo/ - # - # source://yarp//lib/yarp/pattern.rb#190 - def compile_regular_expression_node(node); end - - # in "" - # in "foo" - # - # source://yarp//lib/yarp/pattern.rb#198 - def compile_string_node(node); end - - # in :+ - # in :foo - # - # source://yarp//lib/yarp/pattern.rb#206 - def compile_symbol_node(node); end -end - -# Raised when the query given to a pattern is either invalid Ruby syntax or -# is using syntax that we don't yet support. -# -# source://yarp//lib/yarp/pattern.rb#40 -class YARP::Pattern::CompilationError < ::StandardError - # @return [CompilationError] a new instance of CompilationError - # - # source://yarp//lib/yarp/pattern.rb#41 - def initialize(repr); end -end - -# Represents the use of the `^` operator for pinning an expression in a -# pattern matching expression. -# -# foo in ^(bar) -# ^^^^^^ -# -# source://yarp//lib/yarp/node.rb#7922 -class YARP::PinnedExpressionNode < ::YARP::Node - # def initialize: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> void - # - # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode - # - # source://yarp//lib/yarp/node.rb#7936 - def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#7945 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7950 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#7955 - def comment_targets; end - - # def copy: (**params) -> PinnedExpressionNode - # - # source://yarp//lib/yarp/node.rb#7960 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#7950 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#7974 - def deconstruct_keys(keys); end - - # attr_reader expression: Node - # - # source://yarp//lib/yarp/node.rb#7924 - def expression; end - - # source://yarp//lib/yarp/node.rb#7993 - def inspect(inspector = T.unsafe(nil)); end - - # def lparen: () -> String - # - # source://yarp//lib/yarp/node.rb#7984 - def lparen; end - - # attr_reader lparen_loc: Location - # - # source://yarp//lib/yarp/node.rb#7930 - def lparen_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#7979 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#7927 - def operator_loc; end - - # def rparen: () -> String - # - # source://yarp//lib/yarp/node.rb#7989 - def rparen; end - - # attr_reader rparen_loc: Location - # - # source://yarp//lib/yarp/node.rb#7933 - def rparen_loc; end -end - -# Represents the use of the `^` operator for pinning a variable in a pattern -# matching expression. -# -# foo in ^bar -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#8009 -class YARP::PinnedVariableNode < ::YARP::Node - # def initialize: (variable: Node, operator_loc: Location, location: Location) -> void - # - # @return [PinnedVariableNode] a new instance of PinnedVariableNode - # - # source://yarp//lib/yarp/node.rb#8017 - def initialize(variable, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8024 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8029 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8034 - def comment_targets; end - - # def copy: (**params) -> PinnedVariableNode - # - # source://yarp//lib/yarp/node.rb#8039 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8029 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8051 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8060 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#8056 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#8014 - def operator_loc; end - - # attr_reader variable: Node - # - # source://yarp//lib/yarp/node.rb#8011 - def variable; end -end - -# Represents the use of the `END` keyword. -# -# END { foo } -# ^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#8073 -class YARP::PostExecutionNode < ::YARP::Node - # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void - # - # @return [PostExecutionNode] a new instance of PostExecutionNode - # - # source://yarp//lib/yarp/node.rb#8087 - def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8096 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8101 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#8140 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#8084 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8106 - def comment_targets; end - - # def copy: (**params) -> PostExecutionNode - # - # source://yarp//lib/yarp/node.rb#8111 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8101 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8125 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8144 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#8130 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#8078 - def keyword_loc; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#8135 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#8081 - def opening_loc; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#8075 - def statements; end -end - -# Represents the use of the `BEGIN` keyword. -# -# BEGIN { foo } -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#8163 -class YARP::PreExecutionNode < ::YARP::Node - # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void - # - # @return [PreExecutionNode] a new instance of PreExecutionNode - # - # source://yarp//lib/yarp/node.rb#8177 - def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8186 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8191 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#8230 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#8174 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8196 - def comment_targets; end - - # def copy: (**params) -> PreExecutionNode - # - # source://yarp//lib/yarp/node.rb#8201 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8191 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8215 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8234 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#8220 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#8168 - def keyword_loc; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#8225 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#8171 - def opening_loc; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#8165 - def statements; end -end - -# The top level node of any parse tree. -# -# source://yarp//lib/yarp/node.rb#8250 -class YARP::ProgramNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void - # - # @return [ProgramNode] a new instance of ProgramNode - # - # source://yarp//lib/yarp/node.rb#8258 - def initialize(locals, statements, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8265 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8270 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8275 - def comment_targets; end - - # def copy: (**params) -> ProgramNode - # - # source://yarp//lib/yarp/node.rb#8280 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8270 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8292 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8296 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#8252 - def locals; end - - # attr_reader statements: StatementsNode - # - # source://yarp//lib/yarp/node.rb#8255 - def statements; end -end - -# source://yarp//lib/yarp/node.rb#10570 -module YARP::RangeFlags; end - -# ... operator -# -# source://yarp//lib/yarp/node.rb#10572 -YARP::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) - -# Represents the use of the `..` or `...` operators. -# -# 1..2 -# ^^^^ -# -# c if a =~ /left/ ... b =~ /right/ -# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#8312 -class YARP::RangeNode < ::YARP::Node - # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void - # - # @return [RangeNode] a new instance of RangeNode - # - # source://yarp//lib/yarp/node.rb#8326 - def initialize(left, right, operator_loc, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8335 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8340 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8345 - def comment_targets; end - - # def copy: (**params) -> RangeNode - # - # source://yarp//lib/yarp/node.rb#8350 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8340 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8364 - def deconstruct_keys(keys); end - - # def exclude_end?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8374 - def exclude_end?; end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#8323 - def flags; end - - # source://yarp//lib/yarp/node.rb#8378 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node? - # - # source://yarp//lib/yarp/node.rb#8314 - def left; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#8369 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#8320 - def operator_loc; end - - # attr_reader right: Node? - # - # source://yarp//lib/yarp/node.rb#8317 - def right; end -end - -# Represents a rational number literal. -# -# 1.0r -# ^^^^ -# -# source://yarp//lib/yarp.rb#410 -class YARP::RationalNode < ::YARP::Node - # def initialize: (numeric: Node, location: Location) -> void - # - # @return [RationalNode] a new instance of RationalNode - # - # source://yarp//lib/yarp/node.rb#8407 - def initialize(numeric, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8413 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8418 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8423 - def comment_targets; end - - # def copy: (**params) -> RationalNode - # - # source://yarp//lib/yarp/node.rb#8428 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8418 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8439 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8443 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader numeric: Node - # - # source://yarp//lib/yarp/node.rb#8404 - def numeric; end - - # source://yarp//lib/yarp.rb#411 - def value; end -end - -# Represents the use of the `redo` keyword. -# -# redo -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#8455 -class YARP::RedoNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [RedoNode] a new instance of RedoNode - # - # source://yarp//lib/yarp/node.rb#8457 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8462 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8467 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8472 - def comment_targets; end - - # def copy: (**params) -> RedoNode - # - # source://yarp//lib/yarp/node.rb#8477 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8467 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8487 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8491 - def inspect(inspector = T.unsafe(nil)); end -end - -# source://yarp//lib/yarp/node.rb#10575 -module YARP::RegularExpressionFlags; end - -# n - forces the ASCII-8BIT encoding -# -# source://yarp//lib/yarp/node.rb#10589 -YARP::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer) - -# e - forces the EUC-JP encoding -# -# source://yarp//lib/yarp/node.rb#10586 -YARP::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer) - -# x - ignores whitespace and allows comments in regular expressions -# -# source://yarp//lib/yarp/node.rb#10583 -YARP::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer) - -# i - ignores the case of characters when matching -# -# source://yarp//lib/yarp/node.rb#10577 -YARP::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer) - -# m - allows $ to match the end of lines within strings -# -# source://yarp//lib/yarp/node.rb#10580 -YARP::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer) - -# o - only interpolates values into the regular expression once -# -# source://yarp//lib/yarp/node.rb#10598 -YARP::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer) - -# u - forces the UTF-8 encoding -# -# source://yarp//lib/yarp/node.rb#10595 -YARP::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer) - -# s - forces the Windows-31J encoding -# -# source://yarp//lib/yarp/node.rb#10592 -YARP::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) - -# Represents a regular expression literal with no interpolation. -# -# /foo/i -# ^^^^^^ -# -# source://yarp//lib/yarp/node.rb#8501 -class YARP::RegularExpressionNode < ::YARP::Node - # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void - # - # @return [RegularExpressionNode] a new instance of RegularExpressionNode - # - # source://yarp//lib/yarp/node.rb#8518 - def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8528 - def accept(visitor); end - - # def ascii_8bit?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8598 - def ascii_8bit?; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8533 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#8573 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#8509 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8538 - def comment_targets; end - - # def content: () -> String - # - # source://yarp//lib/yarp/node.rb#8568 - def content; end - - # attr_reader content_loc: Location - # - # source://yarp//lib/yarp/node.rb#8506 - def content_loc; end - - # def copy: (**params) -> RegularExpressionNode - # - # source://yarp//lib/yarp/node.rb#8543 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8533 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8558 - def deconstruct_keys(keys); end - - # def euc_jp?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8593 - def euc_jp?; end - - # def extended?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8588 - def extended?; end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#8515 - def flags; end - - # def ignore_case?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8578 - def ignore_case?; end - - # source://yarp//lib/yarp/node.rb#8617 - def inspect(inspector = T.unsafe(nil)); end - - # def multi_line?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8583 - def multi_line?; end - - # def once?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8613 - def once?; end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#8563 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#8503 - def opening_loc; end - - # attr_reader unescaped: String - # - # source://yarp//lib/yarp/node.rb#8512 - def unescaped; end - - # def utf_8?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8608 - def utf_8?; end - - # def windows_31j?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#8603 - def windows_31j?; end -end - -# Represents a destructured required parameter node. -# -# def foo((bar, baz)) -# ^^^^^^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#8633 -class YARP::RequiredDestructuredParameterNode < ::YARP::Node - # def initialize: (parameters: Array[Node], opening_loc: Location, closing_loc: Location, location: Location) -> void - # - # @return [RequiredDestructuredParameterNode] a new instance of RequiredDestructuredParameterNode - # - # source://yarp//lib/yarp/node.rb#8644 - def initialize(parameters, opening_loc, closing_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8652 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8657 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#8690 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#8641 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8662 - def comment_targets; end - - # def copy: (**params) -> RequiredDestructuredParameterNode - # - # source://yarp//lib/yarp/node.rb#8667 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8657 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8680 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8694 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#8685 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#8638 - def opening_loc; end - - # attr_reader parameters: Array[Node] - # - # source://yarp//lib/yarp/node.rb#8635 - def parameters; end -end - -# Represents a required parameter to a method, block, or lambda definition. -# -# def a(b) -# ^ -# end -# -# source://yarp//lib/yarp/node.rb#8708 -class YARP::RequiredParameterNode < ::YARP::Node - # def initialize: (name: Symbol, location: Location) -> void - # - # @return [RequiredParameterNode] a new instance of RequiredParameterNode - # - # source://yarp//lib/yarp/node.rb#8713 - def initialize(name, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8719 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8724 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8729 - def comment_targets; end - - # def copy: (**params) -> RequiredParameterNode - # - # source://yarp//lib/yarp/node.rb#8734 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8724 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8745 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#8749 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol - # - # source://yarp//lib/yarp/node.rb#8710 - def name; end -end - -# Represents an expression modified with a rescue. -# -# foo rescue nil -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#8760 -class YARP::RescueModifierNode < ::YARP::Node - # def initialize: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> void - # - # @return [RescueModifierNode] a new instance of RescueModifierNode - # - # source://yarp//lib/yarp/node.rb#8771 - def initialize(expression, keyword_loc, rescue_expression, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8779 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8788 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8793 - def comment_targets; end - - # def copy: (**params) -> RescueModifierNode - # - # source://yarp//lib/yarp/node.rb#8798 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8788 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8811 - def deconstruct_keys(keys); end - - # attr_reader expression: Node - # - # source://yarp//lib/yarp/node.rb#8762 - def expression; end - - # source://yarp//lib/yarp/node.rb#8820 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#8816 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#8765 - def keyword_loc; end - - # attr_reader rescue_expression: Node - # - # source://yarp//lib/yarp/node.rb#8768 - def rescue_expression; end - - # source://yarp//lib/yarp/node.rb#8783 - def set_newline_flag(newline_marked); end -end - -# Represents a rescue statement. -# -# begin -# rescue Foo, *splat, Bar => ex -# ^^^^^^ -# foo -# end -# -# `Foo, *splat, Bar` are in the `exceptions` field. -# `ex` is in the `exception` field. -# -# source://yarp//lib/yarp/node.rb#8841 -class YARP::RescueNode < ::YARP::Node - # def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void - # - # @return [RescueNode] a new instance of RescueNode - # - # source://yarp//lib/yarp/node.rb#8861 - def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8872 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8877 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8882 - def comment_targets; end - - # attr_reader consequent: RescueNode? - # - # source://yarp//lib/yarp/node.rb#8858 - def consequent; end - - # def copy: (**params) -> RescueNode - # - # source://yarp//lib/yarp/node.rb#8887 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8877 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8903 - def deconstruct_keys(keys); end - - # attr_reader exceptions: Array[Node] - # - # source://yarp//lib/yarp/node.rb#8846 - def exceptions; end - - # source://yarp//lib/yarp/node.rb#8917 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#8908 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#8843 - def keyword_loc; end - - # def operator: () -> String? - # - # source://yarp//lib/yarp/node.rb#8913 - def operator; end - - # attr_reader operator_loc: Location? - # - # source://yarp//lib/yarp/node.rb#8849 - def operator_loc; end - - # attr_reader reference: Node? - # - # source://yarp//lib/yarp/node.rb#8852 - def reference; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#8855 - def statements; end -end - -# Represents a rest parameter to a method, block, or lambda definition. -# -# def a(*b) -# ^^ -# end -# -# source://yarp//lib/yarp/node.rb#8949 -class YARP::RestParameterNode < ::YARP::Node - # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void - # - # @return [RestParameterNode] a new instance of RestParameterNode - # - # source://yarp//lib/yarp/node.rb#8960 - def initialize(name, name_loc, operator_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#8968 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8973 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#8978 - def comment_targets; end - - # def copy: (**params) -> RestParameterNode - # - # source://yarp//lib/yarp/node.rb#8983 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#8973 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#8996 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9005 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader name: Symbol? - # - # source://yarp//lib/yarp/node.rb#8951 - def name; end - - # attr_reader name_loc: Location? - # - # source://yarp//lib/yarp/node.rb#8954 - def name_loc; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#9001 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#8957 - def operator_loc; end -end - -# Represents the use of the `retry` keyword. -# -# retry -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#9018 -class YARP::RetryNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [RetryNode] a new instance of RetryNode - # - # source://yarp//lib/yarp/node.rb#9020 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9025 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9030 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9035 - def comment_targets; end - - # def copy: (**params) -> RetryNode - # - # source://yarp//lib/yarp/node.rb#9040 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9030 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9050 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9054 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `return` keyword. -# -# return 1 -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9064 -class YARP::ReturnNode < ::YARP::Node - # def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void - # - # @return [ReturnNode] a new instance of ReturnNode - # - # source://yarp//lib/yarp/node.rb#9072 - def initialize(keyword_loc, arguments, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9079 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#9069 - def arguments; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9084 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9089 - def comment_targets; end - - # def copy: (**params) -> ReturnNode - # - # source://yarp//lib/yarp/node.rb#9094 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9084 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9106 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9115 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#9111 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#9066 - def keyword_loc; end -end - -# This class is meant to provide a compatibility layer between YARP and -# Ripper. It functions by parsing the entire tree first and then walking it -# and executing each of the Ripper callbacks as it goes. -# -# This class is going to necessarily be slower than the native Ripper API. It -# is meant as a stopgap until developers migrate to using YARP. It is also -# meant as a test harness for the YARP parser. -# -# source://yarp//lib/yarp/ripper_compat.rb#13 -class YARP::RipperCompat - # @return [RipperCompat] a new instance of RipperCompat - # - # source://yarp//lib/yarp/ripper_compat.rb#59 - def initialize(source); end - - # Returns the value of attribute column. - # - # source://yarp//lib/yarp/ripper_compat.rb#57 - def column; end - - # Public interface - # - # @return [Boolean] - # - # source://yarp//lib/yarp/ripper_compat.rb#70 - def error?; end - - # Returns the value of attribute lineno. - # - # source://yarp//lib/yarp/ripper_compat.rb#57 - def lineno; end - - # source://yarp//lib/yarp/ripper_compat.rb#74 - def parse; end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp/ripper_compat.rb#57 - def source; end - - # Visitor methods - # - # source://yarp//lib/yarp/ripper_compat.rb#82 - def visit(node); end - - # source://yarp//lib/yarp/ripper_compat.rb#86 - def visit_call_node(node); end - - # source://yarp//lib/yarp/ripper_compat.rb#100 - def visit_integer_node(node); end - - # source://yarp//lib/yarp/ripper_compat.rb#125 - def visit_program_node(node); end - - # source://yarp//lib/yarp/ripper_compat.rb#105 - def visit_statements_node(node); end - - # source://yarp//lib/yarp/ripper_compat.rb#112 - def visit_token(node); end - - private - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def _dispatch0; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def _dispatch1(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def _dispatch2(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def _dispatch3(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def _dispatch4(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#167 - def _dispatch5(_, _, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#168 - def _dispatch7(_, _, _, _, _, _, _); end - - # This method is responsible for updating lineno and column information - # to reflect the current node. - # - # This method could be drastically improved with some caching on the start - # of every line, but for now it's good enough. - # - # source://yarp//lib/yarp/ripper_compat.rb#151 - def bounds(location); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_BEGIN(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_CHAR(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_END(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on___end__(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_alias(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_alias_error(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_aref(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_aref_field(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_arg_ambiguous(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_arg_paren(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_args_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_args_add_block(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_args_add_star(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_args_forward; end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_args_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_array(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def on_aryptn(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_assign(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_assign_error(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_assoc_new(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_assoc_splat(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_assoclist_from_args(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_backref(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_backtick(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_bare_assoc_hash(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_begin(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_binary(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_block_var(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_blockarg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def on_bodystmt(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_brace_block(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_break(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_call(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_case(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_class(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_class_name_error(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_comma(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_command(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def on_command_call(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_comment(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_const(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_const_path_field(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_const_path_ref(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_const_ref(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_cvar(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_def(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_defined(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#167 - def on_defs(_, _, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_do_block(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_dot2(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_dot3(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_dyna_symbol(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_else(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_elsif(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embdoc(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embdoc_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embdoc_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embexpr_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embexpr_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_embvar(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_ensure(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_excessed_comma; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_fcall(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_field(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_float(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def on_fndptn(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_for(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_gvar(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_hash(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_heredoc_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_heredoc_dedent(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_heredoc_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_hshptn(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_ident(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_if(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_if_mod(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_ifop(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_ignored_nl(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_ignored_sp(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_imaginary(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_in(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_int(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_ivar(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_kw(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_kwrest_param(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_label(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_label_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_lambda(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_lbrace(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_lbracket(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_lparen(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_magic_comment(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_massign(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_method_add_arg(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_method_add_block(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_mlhs_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_mlhs_add_post(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_mlhs_add_star(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_mlhs_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_mlhs_paren(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_module(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_mrhs_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_mrhs_add_star(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_mrhs_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_mrhs_new_from_args(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_next(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_nl(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_nokw_param(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_op(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_opassign(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_operator_ambiguous(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_param_error(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#168 - def on_params(_, _, _, _, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_paren(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_parse_error(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_period(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_program(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_qsymbols_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_qsymbols_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_qsymbols_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_qwords_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_qwords_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_qwords_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_rational(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_rbrace(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_rbracket(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_redo; end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_regexp_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_regexp_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_regexp_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_regexp_literal(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_regexp_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#166 - def on_rescue(_, _, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_rescue_mod(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_rest_param(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_retry; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_return(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_return0; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_rparen(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_sclass(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_semicolon(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_sp(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_stmts_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_stmts_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_string_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_string_concat(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_string_content; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_string_dvar(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_string_embexpr(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_string_literal(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_super(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_symbeg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_symbol(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_symbol_literal(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_symbols_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_symbols_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_symbols_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_tlambda(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_tlambeg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_top_const_field(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_top_const_ref(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_tstring_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_tstring_content(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_tstring_end(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_unary(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_undef(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_unless(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_unless_mod(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_until(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_until_mod(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_var_alias(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_var_field(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_var_ref(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_vcall(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_void_stmt; end - - # source://yarp//lib/yarp/ripper_compat.rb#165 - def on_when(_, _, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_while(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_while_mod(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_word_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_word_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_words_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_words_beg(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_words_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_words_sep(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#164 - def on_xstring_add(_, _); end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_xstring_literal(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_xstring_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#163 - def on_yield(_); end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_yield0; end - - # source://yarp//lib/yarp/ripper_compat.rb#162 - def on_zsuper; end - - # source://yarp//lib/yarp/ripper_compat.rb#158 - def result; end - - class << self - # This is a convenience method that runs the SexpBuilderPP subclass parser. - # - # source://yarp//lib/yarp/ripper_compat.rb#140 - def sexp(source); end - - # This is a convenience method that runs the SexpBuilder subclass parser. - # - # source://yarp//lib/yarp/ripper_compat.rb#135 - def sexp_raw(source); end - end -end - -# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that -# returns the arrays of [type, *children]. -# -# source://yarp//lib/yarp/ripper_compat.rb#16 -class YARP::RipperCompat::SexpBuilder < ::YARP::RipperCompat - private - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_BEGIN(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_CHAR(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_END(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on___end__(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_alias(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_alias_error(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_aref(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_aref_field(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_arg_ambiguous(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_arg_paren(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_args_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_args_add_block(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_args_add_star(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_args_forward(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_args_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_array(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_aryptn(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_assign(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_assign_error(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_assoc_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_assoc_splat(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_assoclist_from_args(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_backref(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_backtick(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_bare_assoc_hash(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_begin(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_binary(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_block_var(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_blockarg(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_bodystmt(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_brace_block(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_break(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_call(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_case(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_class(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_class_name_error(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_comma(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_command(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_command_call(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_comment(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_const(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_const_path_field(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_const_path_ref(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_const_ref(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_cvar(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_def(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_defined(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_defs(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_do_block(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_dot2(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_dot3(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_dyna_symbol(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_else(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_elsif(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embdoc(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embdoc_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embdoc_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embexpr_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embexpr_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_embvar(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_ensure(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_excessed_comma(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_fcall(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_field(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_float(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_fndptn(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_for(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_gvar(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_hash(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_heredoc_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_heredoc_dedent(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_heredoc_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_hshptn(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_ident(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_if(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_if_mod(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_ifop(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_ignored_nl(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_ignored_sp(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_imaginary(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_in(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_int(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_ivar(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_kw(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_kwrest_param(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_label(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_label_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_lambda(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_lbrace(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_lbracket(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_lparen(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_magic_comment(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_massign(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_method_add_arg(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_method_add_block(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mlhs_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mlhs_add_post(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mlhs_add_star(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mlhs_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mlhs_paren(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_module(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mrhs_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mrhs_add_star(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mrhs_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_mrhs_new_from_args(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_next(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_nl(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_nokw_param(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_op(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_opassign(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_operator_ambiguous(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_param_error(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_params(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_paren(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_parse_error(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_period(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_program(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_qsymbols_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_qsymbols_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_qsymbols_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_qwords_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_qwords_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_qwords_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_rational(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_rbrace(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_rbracket(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_redo(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_regexp_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_regexp_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_regexp_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_regexp_literal(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_regexp_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_rescue(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_rescue_mod(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_rest_param(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_retry(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_return(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_return0(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_rparen(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_sclass(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_semicolon(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_sp(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_stmts_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_stmts_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_concat(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_content(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_dvar(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_embexpr(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_string_literal(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_super(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_symbeg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_symbol(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_symbol_literal(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_symbols_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_symbols_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_symbols_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_tlambda(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_tlambeg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_top_const_field(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_top_const_ref(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_tstring_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_tstring_content(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_tstring_end(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_unary(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_undef(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_unless(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_unless_mod(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_until(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_until_mod(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_var_alias(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_var_field(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_var_ref(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_vcall(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_void_stmt(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_when(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_while(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_while_mod(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_word_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_word_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_words_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_words_beg(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_words_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#26 - def on_words_sep(value); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_xstring_add(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_xstring_literal(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_xstring_new(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_yield(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_yield0(*args); end - - # source://yarp//lib/yarp/ripper_compat.rb#20 - def on_zsuper(*args); end -end - -# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that -# returns the same values as ::Ripper::SexpBuilder except with a couple of -# niceties that flatten linked lists into arrays. -# -# source://yarp//lib/yarp/ripper_compat.rb#35 -class YARP::RipperCompat::SexpBuilderPP < ::YARP::RipperCompat::SexpBuilder - private - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def _dispatch_event_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def _dispatch_event_push(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_args_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_args_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_mlhs_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_mlhs_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_mrhs_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_mrhs_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_qsymbols_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_qsymbols_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_qwords_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_qwords_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_regexp_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_regexp_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_stmts_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_stmts_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_string_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_symbols_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_symbols_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_word_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_word_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_words_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_words_new; end - - # source://yarp//lib/yarp/ripper_compat.rb#42 - def on_xstring_add(list, item); end - - # source://yarp//lib/yarp/ripper_compat.rb#38 - def on_xstring_new; end -end - -# Represents the `self` keyword. -# -# self -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#9132 -class YARP::SelfNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [SelfNode] a new instance of SelfNode - # - # source://yarp//lib/yarp/node.rb#9134 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9139 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9144 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9149 - def comment_targets; end - - # def copy: (**params) -> SelfNode - # - # source://yarp//lib/yarp/node.rb#9154 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9144 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9164 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9168 - def inspect(inspector = T.unsafe(nil)); end -end - -# source://yarp//lib/yarp/serialize.rb#22 -module YARP::Serialize - class << self - # source://yarp//lib/yarp/serialize.rb#27 - def load(input, serialized); end - - # source://yarp//lib/yarp/serialize.rb#37 - def load_tokens(source, serialized); end - end -end - -# source://yarp//lib/yarp/serialize.rb#41 -class YARP::Serialize::Loader - # @return [Loader] a new instance of Loader - # - # source://yarp//lib/yarp/serialize.rb#45 - def initialize(source, serialized); end - - # Returns the value of attribute constant_pool. - # - # source://yarp//lib/yarp/serialize.rb#43 - def constant_pool; end - - # Returns the value of attribute constant_pool_offset. - # - # source://yarp//lib/yarp/serialize.rb#43 - def constant_pool_offset; end - - # Returns the value of attribute encoding. - # - # source://yarp//lib/yarp/serialize.rb#42 - def encoding; end - - # Returns the value of attribute input. - # - # source://yarp//lib/yarp/serialize.rb#42 - def input; end - - # Returns the value of attribute io. - # - # source://yarp//lib/yarp/serialize.rb#42 - def io; end - - # source://yarp//lib/yarp/serialize.rb#59 - def load_encoding; end - - # source://yarp//lib/yarp/serialize.rb#63 - def load_metadata; end - - # source://yarp//lib/yarp/serialize.rb#96 - def load_nodes; end - - # source://yarp//lib/yarp/serialize.rb#111 - def load_result; end - - # source://yarp//lib/yarp/serialize.rb#70 - def load_tokens; end - - # source://yarp//lib/yarp/serialize.rb#83 - def load_tokens_result; end - - # Returns the value of attribute serialized. - # - # source://yarp//lib/yarp/serialize.rb#42 - def serialized; end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp/serialize.rb#43 - def source; end - - private - - # source://yarp//lib/yarp/serialize.rb#168 - def load_constant(index); end - - # source://yarp//lib/yarp/serialize.rb#145 - def load_embedded_string; end - - # source://yarp//lib/yarp/serialize.rb#160 - def load_location; end - - # source://yarp//lib/yarp/serialize.rb#198 - def load_node; end - - # source://yarp//lib/yarp/serialize.rb#193 - def load_optional_constant; end - - # source://yarp//lib/yarp/serialize.rb#164 - def load_optional_location; end - - # source://yarp//lib/yarp/serialize.rb#138 - def load_optional_node; end - - # source://yarp//lib/yarp/serialize.rb#189 - def load_required_constant; end - - # source://yarp//lib/yarp/serialize.rb#134 - def load_serialized_length; end - - # source://yarp//lib/yarp/serialize.rb#149 - def load_string; end - - # variable-length integer using https://en.wikipedia.org/wiki/LEB128 - # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints - # - # source://yarp//lib/yarp/serialize.rb#120 - def load_varint; end -end - -# source://yarp//lib/yarp/serialize.rb#23 -YARP::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer) - -# source://yarp//lib/yarp/serialize.rb#24 -YARP::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer) - -# source://yarp//lib/yarp/serialize.rb#25 -YARP::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer) - -# source://yarp//lib/yarp/serialize.rb#480 -YARP::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array) - -# Represents a singleton class declaration involving the `class` keyword. -# -# class << self end -# ^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9178 -class YARP::SingletonClassNode < ::YARP::Node - # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void - # - # @return [SingletonClassNode] a new instance of SingletonClassNode - # - # source://yarp//lib/yarp/node.rb#9198 - def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9209 - def accept(visitor); end - - # attr_reader body: Node? - # - # source://yarp//lib/yarp/node.rb#9192 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9214 - def child_nodes; end - - # def class_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#9245 - def class_keyword; end - - # attr_reader class_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#9183 - def class_keyword_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9219 - def comment_targets; end - - # def copy: (**params) -> SingletonClassNode - # - # source://yarp//lib/yarp/node.rb#9224 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9214 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9240 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#9255 - def end_keyword; end - - # attr_reader end_keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#9195 - def end_keyword_loc; end - - # attr_reader expression: Node - # - # source://yarp//lib/yarp/node.rb#9189 - def expression; end - - # source://yarp//lib/yarp/node.rb#9259 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader locals: Array[Symbol] - # - # source://yarp//lib/yarp/node.rb#9180 - def locals; end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#9250 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#9186 - def operator_loc; end -end - -# This represents a source of Ruby code that has been parsed. It is used in -# conjunction with locations to allow them to resolve line numbers and source -# ranges. -# -# source://yarp//lib/yarp.rb#7 -class YARP::Source - # @return [Source] a new instance of Source - # - # source://yarp//lib/yarp.rb#10 - def initialize(source, offsets = T.unsafe(nil)); end - - # source://yarp//lib/yarp.rb#27 - def column(value); end - - # source://yarp//lib/yarp.rb#19 - def line(value); end - - # source://yarp//lib/yarp.rb#23 - def line_offset(value); end - - # Returns the value of attribute offsets. - # - # source://yarp//lib/yarp.rb#8 - def offsets; end - - # source://yarp//lib/yarp.rb#15 - def slice(offset, length); end - - # Returns the value of attribute source. - # - # source://yarp//lib/yarp.rb#8 - def source; end - - private - - # source://yarp//lib/yarp.rb#33 - def compute_offsets(code); end -end - -# Represents the use of the `__ENCODING__` keyword. -# -# __ENCODING__ -# ^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9281 -class YARP::SourceEncodingNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [SourceEncodingNode] a new instance of SourceEncodingNode - # - # source://yarp//lib/yarp/node.rb#9283 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9288 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9293 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9298 - def comment_targets; end - - # def copy: (**params) -> SourceEncodingNode - # - # source://yarp//lib/yarp/node.rb#9303 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9293 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9313 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9317 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `__FILE__` keyword. -# -# __FILE__ -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9327 -class YARP::SourceFileNode < ::YARP::Node - # def initialize: (filepath: String, location: Location) -> void - # - # @return [SourceFileNode] a new instance of SourceFileNode - # - # source://yarp//lib/yarp/node.rb#9332 - def initialize(filepath, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9338 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9343 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9348 - def comment_targets; end - - # def copy: (**params) -> SourceFileNode - # - # source://yarp//lib/yarp/node.rb#9353 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9343 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9364 - def deconstruct_keys(keys); end - - # attr_reader filepath: String - # - # source://yarp//lib/yarp/node.rb#9329 - def filepath; end - - # source://yarp//lib/yarp/node.rb#9368 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `__LINE__` keyword. -# -# __LINE__ -# ^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9379 -class YARP::SourceLineNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [SourceLineNode] a new instance of SourceLineNode - # - # source://yarp//lib/yarp/node.rb#9381 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9386 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9391 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9396 - def comment_targets; end - - # def copy: (**params) -> SourceLineNode - # - # source://yarp//lib/yarp/node.rb#9401 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9391 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9411 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9415 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the splat operator. -# -# [*a] -# ^^ -# -# source://yarp//lib/yarp/node.rb#9425 -class YARP::SplatNode < ::YARP::Node - # def initialize: (operator_loc: Location, expression: Node?, location: Location) -> void - # - # @return [SplatNode] a new instance of SplatNode - # - # source://yarp//lib/yarp/node.rb#9433 - def initialize(operator_loc, expression, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9440 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9445 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9450 - def comment_targets; end - - # def copy: (**params) -> SplatNode - # - # source://yarp//lib/yarp/node.rb#9455 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9445 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9467 - def deconstruct_keys(keys); end - - # attr_reader expression: Node? - # - # source://yarp//lib/yarp/node.rb#9430 - def expression; end - - # source://yarp//lib/yarp/node.rb#9476 - def inspect(inspector = T.unsafe(nil)); end - - # def operator: () -> String - # - # source://yarp//lib/yarp/node.rb#9472 - def operator; end - - # attr_reader operator_loc: Location - # - # source://yarp//lib/yarp/node.rb#9427 - def operator_loc; end -end - -# Represents a set of statements contained within some scope. -# -# foo; bar; baz -# ^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9493 -class YARP::StatementsNode < ::YARP::Node - # def initialize: (body: Array[Node], location: Location) -> void - # - # @return [StatementsNode] a new instance of StatementsNode - # - # source://yarp//lib/yarp/node.rb#9498 - def initialize(body, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9504 - def accept(visitor); end - - # attr_reader body: Array[Node] - # - # source://yarp//lib/yarp/node.rb#9495 - def body; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9509 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9514 - def comment_targets; end - - # def copy: (**params) -> StatementsNode - # - # source://yarp//lib/yarp/node.rb#9519 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9509 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9530 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9534 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of compile-time string concatenation. -# -# "foo" "bar" -# ^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9545 -class YARP::StringConcatNode < ::YARP::Node - # def initialize: (left: Node, right: Node, location: Location) -> void - # - # @return [StringConcatNode] a new instance of StringConcatNode - # - # source://yarp//lib/yarp/node.rb#9553 - def initialize(left, right, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9560 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9565 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9570 - def comment_targets; end - - # def copy: (**params) -> StringConcatNode - # - # source://yarp//lib/yarp/node.rb#9575 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9565 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9587 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9591 - def inspect(inspector = T.unsafe(nil)); end - - # attr_reader left: Node - # - # source://yarp//lib/yarp/node.rb#9547 - def left; end - - # attr_reader right: Node - # - # source://yarp//lib/yarp/node.rb#9550 - def right; end -end - -# Represents a string literal, a string contained within a `%w` list, or -# plain string content within an interpolated string. -# -# "foo" -# ^^^^^ -# -# %w[foo] -# ^^^ -# -# "foo #{bar} baz" -# ^^^^ ^^^^ -# -# source://yarp//lib/yarp/node.rb#9612 -class YARP::StringNode < ::YARP::Node - # def initialize: (opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void - # - # @return [StringNode] a new instance of StringNode - # - # source://yarp//lib/yarp/node.rb#9626 - def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9635 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9640 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#9679 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9620 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9645 - def comment_targets; end - - # def content: () -> String - # - # source://yarp//lib/yarp/node.rb#9674 - def content; end - - # attr_reader content_loc: Location - # - # source://yarp//lib/yarp/node.rb#9617 - def content_loc; end - - # def copy: (**params) -> StringNode - # - # source://yarp//lib/yarp/node.rb#9650 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9640 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9664 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9683 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#9669 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9614 - def opening_loc; end - - # attr_reader unescaped: String - # - # source://yarp//lib/yarp/node.rb#9623 - def unescaped; end -end - -# Represents the use of the `super` keyword with parentheses or arguments. -# -# super() -# ^^^^^^^ -# -# super foo, bar -# ^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9700 -class YARP::SuperNode < ::YARP::Node - # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode?, location: Location) -> void - # - # @return [SuperNode] a new instance of SuperNode - # - # source://yarp//lib/yarp/node.rb#9717 - def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9727 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#9708 - def arguments; end - - # attr_reader block: BlockNode? - # - # source://yarp//lib/yarp/node.rb#9714 - def block; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9732 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9737 - def comment_targets; end - - # def copy: (**params) -> SuperNode - # - # source://yarp//lib/yarp/node.rb#9742 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9732 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9757 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9776 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#9762 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#9702 - def keyword_loc; end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#9767 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9705 - def lparen_loc; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#9772 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9711 - def rparen_loc; end -end - -# Represents a symbol literal or a symbol contained within a `%i` list. -# -# :foo -# ^^^^ -# -# %i[foo] -# ^^^ -# -# source://yarp//lib/yarp/node.rb#9804 -class YARP::SymbolNode < ::YARP::Node - # def initialize: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void - # - # @return [SymbolNode] a new instance of SymbolNode - # - # source://yarp//lib/yarp/node.rb#9818 - def initialize(opening_loc, value_loc, closing_loc, unescaped, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9827 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9832 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#9871 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9812 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9837 - def comment_targets; end - - # def copy: (**params) -> SymbolNode - # - # source://yarp//lib/yarp/node.rb#9842 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9832 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9856 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9875 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String? - # - # source://yarp//lib/yarp/node.rb#9861 - def opening; end - - # attr_reader opening_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9806 - def opening_loc; end - - # attr_reader unescaped: String - # - # source://yarp//lib/yarp/node.rb#9815 - def unescaped; end - - # def value: () -> String? - # - # source://yarp//lib/yarp/node.rb#9866 - def value; end - - # attr_reader value_loc: Location? - # - # source://yarp//lib/yarp/node.rb#9809 - def value_loc; end -end - -# This represents a token from the Ruby source. -# -# source://yarp//lib/yarp.rb#254 -class YARP::Token - # @return [Token] a new instance of Token - # - # source://yarp//lib/yarp.rb#257 - def initialize(type, value, location); end - - # source://yarp//lib/yarp.rb#281 - def ==(other); end - - # source://yarp//lib/yarp.rb#263 - def deconstruct_keys(keys); end - - # Returns the value of attribute location. - # - # source://yarp//lib/yarp.rb#255 - def location; end - - # source://yarp//lib/yarp.rb#267 - def pretty_print(q); end - - # Returns the value of attribute type. - # - # source://yarp//lib/yarp.rb#255 - def type; end - - # Returns the value of attribute value. - # - # source://yarp//lib/yarp.rb#255 - def value; end -end - -# Represents the use of the literal `true` keyword. -# -# true -# ^^^^ -# -# source://yarp//lib/yarp/node.rb#9889 -class YARP::TrueNode < ::YARP::Node - # def initialize: (location: Location) -> void - # - # @return [TrueNode] a new instance of TrueNode - # - # source://yarp//lib/yarp/node.rb#9891 - def initialize(location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9896 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9901 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9906 - def comment_targets; end - - # def copy: (**params) -> TrueNode - # - # source://yarp//lib/yarp/node.rb#9911 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9901 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9921 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9925 - def inspect(inspector = T.unsafe(nil)); end -end - -# Represents the use of the `undef` keyword. -# -# undef :foo, :bar, :baz -# ^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#9935 -class YARP::UndefNode < ::YARP::Node - # def initialize: (names: Array[Node], keyword_loc: Location, location: Location) -> void - # - # @return [UndefNode] a new instance of UndefNode - # - # source://yarp//lib/yarp/node.rb#9943 - def initialize(names, keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#9950 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9955 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#9960 - def comment_targets; end - - # def copy: (**params) -> UndefNode - # - # source://yarp//lib/yarp/node.rb#9965 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#9955 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#9977 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#9986 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#9982 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#9940 - def keyword_loc; end - - # attr_reader names: Array[Node] - # - # source://yarp//lib/yarp/node.rb#9937 - def names; end -end - -# Represents the use of the `unless` keyword, either in the block form or the modifier form. -# -# bar unless foo -# ^^^^^^^^^^^^^^ -# -# unless foo then bar end -# ^^^^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#10001 -class YARP::UnlessNode < ::YARP::Node - # def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void - # - # @return [UnlessNode] a new instance of UnlessNode - # - # source://yarp//lib/yarp/node.rb#10018 - def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10028 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10037 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10042 - def comment_targets; end - - # attr_reader consequent: ElseNode? - # - # source://yarp//lib/yarp/node.rb#10012 - def consequent; end - - # def copy: (**params) -> UnlessNode - # - # source://yarp//lib/yarp/node.rb#10047 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10037 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10062 - def deconstruct_keys(keys); end - - # def end_keyword: () -> String? - # - # source://yarp//lib/yarp/node.rb#10072 - def end_keyword; end - - # attr_reader end_keyword_loc: Location? - # - # source://yarp//lib/yarp/node.rb#10015 - def end_keyword_loc; end - - # source://yarp//lib/yarp/node.rb#10076 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#10067 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#10003 - def keyword_loc; end - - # attr_reader predicate: Node - # - # source://yarp//lib/yarp/node.rb#10006 - def predicate; end - - # source://yarp//lib/yarp/node.rb#10032 - def set_newline_flag(newline_marked); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#10009 - def statements; end -end - -# Represents the use of the `until` keyword, either in the block form or the modifier form. -# -# bar until foo -# ^^^^^^^^^^^^^ -# -# until foo do bar end -# ^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#10105 -class YARP::UntilNode < ::YARP::Node - # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void - # - # @return [UntilNode] a new instance of UntilNode - # - # source://yarp//lib/yarp/node.rb#10122 - def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10132 - def accept(visitor); end - - # def begin_modifier?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#10181 - def begin_modifier?; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10141 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#10176 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#10110 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10146 - def comment_targets; end - - # def copy: (**params) -> UntilNode - # - # source://yarp//lib/yarp/node.rb#10151 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10141 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10166 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#10119 - def flags; end - - # source://yarp//lib/yarp/node.rb#10185 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#10171 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#10107 - def keyword_loc; end - - # attr_reader predicate: Node - # - # source://yarp//lib/yarp/node.rb#10113 - def predicate; end - - # source://yarp//lib/yarp/node.rb#10136 - def set_newline_flag(newline_marked); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#10116 - def statements; end -end - -# The version constant is set by reading the result of calling yp_version. -YARP::VERSION = T.let(T.unsafe(nil), String) - -# source://yarp//lib/yarp.rb#223 -class YARP::Visitor < ::YARP::BasicVisitor - # Visit a AliasNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_alias_node(node); end - - # Visit a AlternationPatternNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_alternation_pattern_node(node); end - - # Visit a AndNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_and_node(node); end - - # Visit a ArgumentsNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_arguments_node(node); end - - # Visit a ArrayNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_array_node(node); end - - # Visit a ArrayPatternNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_array_pattern_node(node); end - - # Visit a AssocNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_assoc_node(node); end - - # Visit a AssocSplatNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_assoc_splat_node(node); end - - # Visit a BackReferenceReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_back_reference_read_node(node); end - - # Visit a BeginNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_begin_node(node); end - - # Visit a BlockArgumentNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_block_argument_node(node); end - - # Visit a BlockLocalVariableNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_block_local_variable_node(node); end - - # Visit a BlockNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_block_node(node); end - - # Visit a BlockParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_block_parameter_node(node); end - - # Visit a BlockParametersNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_block_parameters_node(node); end - - # Visit a BreakNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_break_node(node); end - - # Visit a CallAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_call_and_write_node(node); end - - # Visit a CallNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_call_node(node); end - - # Visit a CallOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_call_operator_write_node(node); end - - # Visit a CallOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_call_or_write_node(node); end - - # Visit a CapturePatternNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_capture_pattern_node(node); end - - # Visit a CaseNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_case_node(node); end - - # Visit a ClassNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_node(node); end - - # Visit a ClassVariableAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_and_write_node(node); end - - # Visit a ClassVariableOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_operator_write_node(node); end - - # Visit a ClassVariableOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_or_write_node(node); end - - # Visit a ClassVariableReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_read_node(node); end - - # Visit a ClassVariableTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_target_node(node); end - - # Visit a ClassVariableWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_class_variable_write_node(node); end - - # Visit a ConstantAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_and_write_node(node); end - - # Visit a ConstantOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_operator_write_node(node); end - - # Visit a ConstantOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_or_write_node(node); end - - # Visit a ConstantPathAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_and_write_node(node); end - - # Visit a ConstantPathNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_node(node); end - - # Visit a ConstantPathOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_operator_write_node(node); end - - # Visit a ConstantPathOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_or_write_node(node); end - - # Visit a ConstantPathTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_target_node(node); end - - # Visit a ConstantPathWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_path_write_node(node); end - - # Visit a ConstantReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_read_node(node); end - - # Visit a ConstantTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_target_node(node); end - - # Visit a ConstantWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_constant_write_node(node); end - - # Visit a DefNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_def_node(node); end - - # Visit a DefinedNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_defined_node(node); end - - # Visit a ElseNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_else_node(node); end - - # Visit a EmbeddedStatementsNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_embedded_statements_node(node); end - - # Visit a EmbeddedVariableNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_embedded_variable_node(node); end - - # Visit a EnsureNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_ensure_node(node); end - - # Visit a FalseNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_false_node(node); end - - # Visit a FindPatternNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_find_pattern_node(node); end - - # Visit a FlipFlopNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_flip_flop_node(node); end - - # Visit a FloatNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_float_node(node); end - - # Visit a ForNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_for_node(node); end - - # Visit a ForwardingArgumentsNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_forwarding_arguments_node(node); end - - # Visit a ForwardingParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_forwarding_parameter_node(node); end - - # Visit a ForwardingSuperNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_forwarding_super_node(node); end - - # Visit a GlobalVariableAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_and_write_node(node); end - - # Visit a GlobalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_operator_write_node(node); end - - # Visit a GlobalVariableOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_or_write_node(node); end - - # Visit a GlobalVariableReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_read_node(node); end - - # Visit a GlobalVariableTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_target_node(node); end - - # Visit a GlobalVariableWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_global_variable_write_node(node); end - - # Visit a HashNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_hash_node(node); end - - # Visit a HashPatternNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_hash_pattern_node(node); end - - # Visit a IfNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_if_node(node); end - - # Visit a ImaginaryNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_imaginary_node(node); end - - # Visit a InNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_in_node(node); end - - # Visit a InstanceVariableAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_and_write_node(node); end - - # Visit a InstanceVariableOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_operator_write_node(node); end - - # Visit a InstanceVariableOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_or_write_node(node); end - - # Visit a InstanceVariableReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_read_node(node); end - - # Visit a InstanceVariableTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_target_node(node); end - - # Visit a InstanceVariableWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_instance_variable_write_node(node); end - - # Visit a IntegerNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_integer_node(node); end - - # Visit a InterpolatedRegularExpressionNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_interpolated_regular_expression_node(node); end - - # Visit a InterpolatedStringNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_interpolated_string_node(node); end - - # Visit a InterpolatedSymbolNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_interpolated_symbol_node(node); end - - # Visit a InterpolatedXStringNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_interpolated_x_string_node(node); end - - # Visit a KeywordHashNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_keyword_hash_node(node); end - - # Visit a KeywordParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_keyword_parameter_node(node); end - - # Visit a KeywordRestParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_keyword_rest_parameter_node(node); end - - # Visit a LambdaNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_lambda_node(node); end - - # Visit a LocalVariableAndWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_and_write_node(node); end - - # Visit a LocalVariableOperatorWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_operator_write_node(node); end - - # Visit a LocalVariableOrWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_or_write_node(node); end - - # Visit a LocalVariableReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_read_node(node); end - - # Visit a LocalVariableTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_target_node(node); end - - # Visit a LocalVariableWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_local_variable_write_node(node); end - - # Visit a MatchPredicateNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_match_predicate_node(node); end - - # Visit a MatchRequiredNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_match_required_node(node); end - - # Visit a MissingNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_missing_node(node); end - - # Visit a ModuleNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_module_node(node); end - - # Visit a MultiTargetNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_multi_target_node(node); end - - # Visit a MultiWriteNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_multi_write_node(node); end - - # Visit a NextNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_next_node(node); end - - # Visit a NilNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_nil_node(node); end - - # Visit a NoKeywordsParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_no_keywords_parameter_node(node); end - - # Visit a NumberedReferenceReadNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_numbered_reference_read_node(node); end - - # Visit a OptionalParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_optional_parameter_node(node); end - - # Visit a OrNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_or_node(node); end - - # Visit a ParametersNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_parameters_node(node); end - - # Visit a ParenthesesNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_parentheses_node(node); end - - # Visit a PinnedExpressionNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_pinned_expression_node(node); end - - # Visit a PinnedVariableNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_pinned_variable_node(node); end - - # Visit a PostExecutionNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_post_execution_node(node); end - - # Visit a PreExecutionNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_pre_execution_node(node); end - - # Visit a ProgramNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_program_node(node); end - - # Visit a RangeNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_range_node(node); end - - # Visit a RationalNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_rational_node(node); end - - # Visit a RedoNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_redo_node(node); end - - # Visit a RegularExpressionNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_regular_expression_node(node); end - - # Visit a RequiredDestructuredParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_required_destructured_parameter_node(node); end - - # Visit a RequiredParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_required_parameter_node(node); end - - # Visit a RescueModifierNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_rescue_modifier_node(node); end - - # Visit a RescueNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_rescue_node(node); end - - # Visit a RestParameterNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_rest_parameter_node(node); end - - # Visit a RetryNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_retry_node(node); end - - # Visit a ReturnNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_return_node(node); end - - # Visit a SelfNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_self_node(node); end - - # Visit a SingletonClassNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_singleton_class_node(node); end - - # Visit a SourceEncodingNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_source_encoding_node(node); end - - # Visit a SourceFileNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_source_file_node(node); end - - # Visit a SourceLineNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_source_line_node(node); end - - # Visit a SplatNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_splat_node(node); end - - # Visit a StatementsNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_statements_node(node); end - - # Visit a StringConcatNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_string_concat_node(node); end - - # Visit a StringNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_string_node(node); end - - # Visit a SuperNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_super_node(node); end - - # Visit a SymbolNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_symbol_node(node); end - - # Visit a TrueNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_true_node(node); end - - # Visit a UndefNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_undef_node(node); end - - # Visit a UnlessNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_unless_node(node); end - - # Visit a UntilNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_until_node(node); end - - # Visit a WhenNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_when_node(node); end - - # Visit a WhileNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_while_node(node); end - - # Visit a XStringNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_x_string_node(node); end - - # Visit a YieldNode node - # - # source://yarp//lib/yarp.rb#218 - def visit_yield_node(node); end -end - -# Represents the use of the `when` keyword within a case statement. -# -# case true -# when true -# ^^^^^^^^^ -# end -# -# source://yarp//lib/yarp/node.rb#10208 -class YARP::WhenNode < ::YARP::Node - # def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void - # - # @return [WhenNode] a new instance of WhenNode - # - # source://yarp//lib/yarp/node.rb#10219 - def initialize(keyword_loc, conditions, statements, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10227 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10232 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10237 - def comment_targets; end - - # attr_reader conditions: Array[Node] - # - # source://yarp//lib/yarp/node.rb#10213 - def conditions; end - - # def copy: (**params) -> WhenNode - # - # source://yarp//lib/yarp/node.rb#10242 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10232 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10255 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#10264 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#10260 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#10210 - def keyword_loc; end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#10216 - def statements; end -end - -# Represents the use of the `while` keyword, either in the block form or the modifier form. -# -# bar while foo -# ^^^^^^^^^^^^^ -# -# while foo do bar end -# ^^^^^^^^^^^^^^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#10285 -class YARP::WhileNode < ::YARP::Node - # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void - # - # @return [WhileNode] a new instance of WhileNode - # - # source://yarp//lib/yarp/node.rb#10302 - def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10312 - def accept(visitor); end - - # def begin_modifier?: () -> bool - # - # @return [Boolean] - # - # source://yarp//lib/yarp/node.rb#10361 - def begin_modifier?; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10321 - def child_nodes; end - - # def closing: () -> String? - # - # source://yarp//lib/yarp/node.rb#10356 - def closing; end - - # attr_reader closing_loc: Location? - # - # source://yarp//lib/yarp/node.rb#10290 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10326 - def comment_targets; end - - # def copy: (**params) -> WhileNode - # - # source://yarp//lib/yarp/node.rb#10331 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10321 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10346 - def deconstruct_keys(keys); end - - # attr_reader flags: Integer - # - # source://yarp//lib/yarp/node.rb#10299 - def flags; end - - # source://yarp//lib/yarp/node.rb#10365 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#10351 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#10287 - def keyword_loc; end - - # attr_reader predicate: Node - # - # source://yarp//lib/yarp/node.rb#10293 - def predicate; end - - # source://yarp//lib/yarp/node.rb#10316 - def set_newline_flag(newline_marked); end - - # attr_reader statements: StatementsNode? - # - # source://yarp//lib/yarp/node.rb#10296 - def statements; end -end - -# Represents an xstring literal with no interpolation. -# -# `foo` -# ^^^^^ -# -# source://yarp//lib/yarp/node.rb#10386 -class YARP::XStringNode < ::YARP::Node - # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void - # - # @return [XStringNode] a new instance of XStringNode - # - # source://yarp//lib/yarp/node.rb#10400 - def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10409 - def accept(visitor); end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10414 - def child_nodes; end - - # def closing: () -> String - # - # source://yarp//lib/yarp/node.rb#10453 - def closing; end - - # attr_reader closing_loc: Location - # - # source://yarp//lib/yarp/node.rb#10394 - def closing_loc; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10419 - def comment_targets; end - - # def content: () -> String - # - # source://yarp//lib/yarp/node.rb#10448 - def content; end - - # attr_reader content_loc: Location - # - # source://yarp//lib/yarp/node.rb#10391 - def content_loc; end - - # def copy: (**params) -> XStringNode - # - # source://yarp//lib/yarp/node.rb#10424 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10414 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10438 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#10457 - def inspect(inspector = T.unsafe(nil)); end - - # def opening: () -> String - # - # source://yarp//lib/yarp/node.rb#10443 - def opening; end - - # attr_reader opening_loc: Location - # - # source://yarp//lib/yarp/node.rb#10388 - def opening_loc; end - - # attr_reader unescaped: String - # - # source://yarp//lib/yarp/node.rb#10397 - def unescaped; end -end - -# Represents the use of the `yield` keyword. -# -# yield 1 -# ^^^^^^^ -# -# source://yarp//lib/yarp/node.rb#10471 -class YARP::YieldNode < ::YARP::Node - # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void - # - # @return [YieldNode] a new instance of YieldNode - # - # source://yarp//lib/yarp/node.rb#10485 - def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end - - # def accept: (visitor: Visitor) -> void - # - # source://yarp//lib/yarp/node.rb#10494 - def accept(visitor); end - - # attr_reader arguments: ArgumentsNode? - # - # source://yarp//lib/yarp/node.rb#10479 - def arguments; end - - # def child_nodes: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10499 - def child_nodes; end - - # def comment_targets: () -> Array[Node | Location] - # - # source://yarp//lib/yarp/node.rb#10504 - def comment_targets; end - - # def copy: (**params) -> YieldNode - # - # source://yarp//lib/yarp/node.rb#10509 - def copy(**params); end - - # def child_nodes: () -> Array[nil | Node] - # def deconstruct: () -> Array[nil | Node] - # - # source://yarp//lib/yarp/node.rb#10499 - def deconstruct; end - - # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] - # - # source://yarp//lib/yarp/node.rb#10523 - def deconstruct_keys(keys); end - - # source://yarp//lib/yarp/node.rb#10542 - def inspect(inspector = T.unsafe(nil)); end - - # def keyword: () -> String - # - # source://yarp//lib/yarp/node.rb#10528 - def keyword; end - - # attr_reader keyword_loc: Location - # - # source://yarp//lib/yarp/node.rb#10473 - def keyword_loc; end - - # def lparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#10533 - def lparen; end - - # attr_reader lparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#10476 - def lparen_loc; end - - # def rparen: () -> String? - # - # source://yarp//lib/yarp/node.rb#10538 - def rparen; end - - # attr_reader rparen_loc: Location? - # - # source://yarp//lib/yarp/node.rb#10482 - def rparen_loc; end -end