Remove misleading upstream.rbi, enable types in on_system

Library/Homebrew/cask/config.rb

@@ -169,10 +169,12 @@ def languages=(languages)
 
     DEFAULT_DIRS.each_key do |dir|
       define_method(dir) do
+        T.bind(self, Config)
         explicit.fetch(dir, env.fetch(dir, default.fetch(dir)))
       end
 
       define_method(:"#{dir}=") do |path|
+        T.bind(self, Config)
         explicit[dir] = Pathname(path).expand_path
       end
     end

Library/Homebrew/cask/dsl.rb

@@ -339,6 +339,7 @@ def livecheckable?
 
     ORDINARY_ARTIFACT_CLASSES.each do |klass|
       define_method(klass.dsl_key) do |*args, **kwargs|
+        T.bind(self, DSL)
         if [*artifacts.map(&:class), klass].include?(Artifact::StageOnly) &&
            (artifacts.map(&:class) & ACTIVATABLE_ARTIFACT_CLASSES).any?
           raise CaskInvalidError.new(cask, "'stage_only' must be the only activatable artifact.")
@@ -355,6 +356,7 @@ def livecheckable?
     ARTIFACT_BLOCK_CLASSES.each do |klass|
       [klass.dsl_key, klass.uninstall_dsl_key].each do |dsl_key|
         define_method(dsl_key) do |&block|
+          T.bind(self, DSL)
           artifacts.add(klass.new(cask, dsl_key => block))
         end
       end

Library/Homebrew/cask/dsl/version.rb

@@ -32,6 +32,7 @@ def define_divider_methods(divider)
         def define_divider_deletion_method(divider)
           method_name = deletion_method_name(divider)
           define_method(method_name) do
+            T.bind(self, Version)
             version { delete(divider) }
           end
         end
@@ -49,6 +50,7 @@ def define_divider_conversion_methods(left_divider)
         def define_divider_conversion_method(left_divider, right_divider)
           method_name = conversion_method_name(left_divider, right_divider)
           define_method(method_name) do
+            T.bind(self, Version)
             version { gsub(left_divider, right_divider) }
           end
         end

Library/Homebrew/extend/on_system.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 require "simulate_system"
@@ -9,17 +9,15 @@ module OnSystem
   ARCH_OPTIONS = [:intel, :arm].freeze
   BASE_OS_OPTIONS = [:macos, :linux].freeze
 
-  module_function
-
   sig { params(arch: Symbol).returns(T::Boolean) }
-  def arch_condition_met?(arch)
+  def self.arch_condition_met?(arch)
     raise ArgumentError, "Invalid arch condition: #{arch.inspect}" if ARCH_OPTIONS.exclude?(arch)
 
     arch == Homebrew::SimulateSystem.current_arch
   end
 
   sig { params(os_name: Symbol, or_condition: T.nilable(Symbol)).returns(T::Boolean) }
-  def os_condition_met?(os_name, or_condition = nil)
+  def self.os_condition_met?(os_name, or_condition = nil)
     return Homebrew::SimulateSystem.send("simulating_or_running_on_#{os_name}?") if BASE_OS_OPTIONS.include?(os_name)
 
     raise ArgumentError, "Invalid OS condition: #{os_name.inspect}" unless MacOSVersions::SYMBOLS.key?(os_name)
@@ -46,17 +44,17 @@ def os_condition_met?(os_name, or_condition = nil)
   end
 
   sig { params(method_name: Symbol).returns(Symbol) }
-  def condition_from_method_name(method_name)
+  def self.condition_from_method_name(method_name)
     method_name.to_s.sub(/^on_/, "").to_sym
   end
 
   sig { params(base: Class).void }
-  def setup_arch_methods(base)
+  def self.setup_arch_methods(base)
     ARCH_OPTIONS.each do |arch|
       base.define_method("on_#{arch}") do |&block|
         @on_system_blocks_exist = true
 
-        return unless OnSystem.arch_condition_met? OnSystem.condition_from_method_name(__method__)
+        return unless OnSystem.arch_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
         @called_in_on_system_block = true
         result = block.call
@@ -75,12 +73,12 @@ def setup_arch_methods(base)
   end
 
   sig { params(base: Class).void }
-  def setup_base_os_methods(base)
+  def self.setup_base_os_methods(base)
     BASE_OS_OPTIONS.each do |base_os|
       base.define_method("on_#{base_os}") do |&block|
         @on_system_blocks_exist = true
 
-        return unless OnSystem.os_condition_met? OnSystem.condition_from_method_name(__method__)
+        return unless OnSystem.os_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
         @called_in_on_system_block = true
         result = block.call
@@ -118,12 +116,12 @@ def setup_base_os_methods(base)
   end
 
   sig { params(base: Class).void }
-  def setup_macos_methods(base)
+  def self.setup_macos_methods(base)
     MacOSVersions::SYMBOLS.each_key do |os_name|
       base.define_method("on_#{os_name}") do |or_condition = nil, &block|
         @on_system_blocks_exist = true
 
-        os_condition = OnSystem.condition_from_method_name __method__
+        os_condition = OnSystem.condition_from_method_name T.must(__method__)
         return unless OnSystem.os_condition_met? os_condition, or_condition
 
         @called_in_on_system_block = true