tapioca 0.19.0 → 0.19.2

data/lib/tapioca/runtime/reflection.rb

@@ -20,7 +20,7 @@ module Tapioca
       PROTECTED_INSTANCE_METHODS_METHOD = Module.instance_method(:protected_instance_methods) #: UnboundMethod
       PRIVATE_INSTANCE_METHODS_METHOD = Module.instance_method(:private_instance_methods) #: UnboundMethod
       METHOD_METHOD = Kernel.instance_method(:method) #: UnboundMethod
-      UNDEFINED_CONSTANT = Module.new.freeze #: T::Module[top]
+      UNDEFINED_CONSTANT = Module.new.freeze #: Module[top]
 
       REQUIRED_FROM_LABELS = ["<top (required)>", "<main>", "<compiled>"].freeze #: Array[String]
 
@@ -31,7 +31,7 @@ module Tapioca
       end
 
       # @without_runtime
-      #: (String symbol, ?inherit: bool, ?namespace: T::Module[top]) -> BasicObject
+      #: (String symbol, ?inherit: bool, ?namespace: Module[top]) -> BasicObject
       def constantize(symbol, inherit: false, namespace: Object)
         namespace.const_get(symbol, inherit)
       rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
@@ -43,23 +43,23 @@ module Tapioca
         CLASS_METHOD.bind_call(object)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def constants_of(constant)
         CONSTANTS_METHOD.bind_call(constant, false)
       end
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def name_of(constant)
         name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
-      #: (T::Module[top] constant) -> Class[top]
+      #: (Module[top] constant) -> Class[top]
       def singleton_class_of(constant)
         SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[T::Module[top]]
+      #: (Module[top] constant) -> Array[Module[top]]
       def ancestors_of(constant)
         ANCESTORS_METHOD.bind_call(constant)
       end
@@ -69,7 +69,7 @@ module Tapioca
         SUPERCLASS_METHOD.bind_call(constant)
       end
 
-      #: (Class[top] singleton_class) -> T::Module[top]?
+      #: (Class[top] singleton_class) -> Module[top]?
       def attached_class_of(singleton_class)
         result = singleton_class.attached_object
         Module === result ? result : nil
@@ -85,22 +85,22 @@ module Tapioca
         EQUAL_METHOD.bind_call(object, other)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def public_instance_methods_of(constant)
         PUBLIC_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def protected_instance_methods_of(constant)
         PROTECTED_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[Symbol]
+      #: (Module[top] constant) -> Array[Symbol]
       def private_instance_methods_of(constant)
         PRIVATE_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (T::Module[top] constant) -> Array[T::Module[top]]
+      #: (Module[top] constant) -> Array[Module[top]]
       def inherited_ancestors_of(constant)
         if Class === constant
           ancestors_of(superclass_of(constant) || Object)
@@ -109,7 +109,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def qualified_name_of(constant)
         name = name_of(constant)
         return if name.nil?
@@ -142,7 +142,7 @@ module Tapioca
         type.to_s
       end
 
-      #: (T::Module[top] constant, Symbol method) -> Method
+      #: (Module[top] constant, Symbol method) -> Method
       def method_of(constant, method)
         METHOD_METHOD.bind_call(constant, method)
       end
@@ -211,7 +211,7 @@ module Tapioca
         SourceLocation.from_loc([file, resolved_loc.lineno])
       end
 
-      #: (T::Module[top] constant) -> Set[String]
+      #: (Module[top] constant) -> Set[String]
       def file_candidates_for(constant)
         # Grab all source files for (relevant) methods defined on the constant
         candidates = relevant_methods_for(constant).filter_map do |method|
@@ -225,25 +225,25 @@ module Tapioca
         candidates
       end
 
-      #: (T::Module[top] constant) -> untyped
+      #: (Module[top] constant) -> untyped
       def abstract_type_of(constant)
         T::Private::Abstract::Data.get(constant, :abstract_type) ||
           T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
       end
 
-      #: (T::Module[top] constant) -> bool
+      #: (Module[top] constant) -> bool
       def final_module?(constant)
         T::Private::Final.final_module?(constant)
       end
 
-      #: (T::Module[top] constant) -> bool
+      #: (Module[top] constant) -> bool
       def sealed_module?(constant)
         T::Private::Sealed.sealed_module?(constant)
       end
 
       private
 
-      #: (T::Module[top] constant) -> Array[UnboundMethod]
+      #: (Module[top] constant) -> Array[UnboundMethod]
       def relevant_methods_for(constant)
         methods = methods_for(constant).select(&:source_location)
           .reject { |x| method_defined_by_forwardable_module?(x) }
@@ -259,7 +259,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> Array[UnboundMethod]
+      #: (Module[top] constant) -> Array[UnboundMethod]
       def methods_for(constant)
         modules = [constant, singleton_class_of(constant)]
         method_list_methods = [
@@ -273,7 +273,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] parent, String name) -> T::Module[top]?
+      #: (Module[top] parent, String name) -> Module[top]?
       def child_module_for_parent_with_name(parent, name)
         return if parent.autoload?(name)
 

data/lib/tapioca/runtime/trackers/constant_definition.rb

@@ -12,7 +12,7 @@ module Tapioca
         extend Tracker
         extend Reflection
 
-        @class_files = {}.compare_by_identity #: Hash[T::Module[top], Set[SourceLocation]]
+        @class_files = {}.compare_by_identity #: Hash[Module[top], Set[SourceLocation]]
 
         # Immediately activated upon load. Observes class/module definition.
         @class_tracepoint = TracePoint.trace(:class) do |tp|
@@ -83,12 +83,12 @@ module Tapioca
           # Returns the files in which this class or module was opened. Doesn't know
           # about situations where the class was opened prior to +require+ing,
           # or where metaprogramming was used via +eval+, etc.
-          #: (T::Module[top] klass) -> Set[String]
+          #: (Module[top] klass) -> Set[String]
           def files_for(klass)
             locations_for(klass).map(&:file).to_set
           end
 
-          #: (T::Module[top] klass) -> Set[SourceLocation]
+          #: (Module[top] klass) -> Set[SourceLocation]
           def locations_for(klass)
             @class_files.fetch(klass, Set.new)
           end

data/lib/tapioca/runtime/trackers/method_definition.rb

@@ -7,10 +7,10 @@ module Tapioca
       module MethodDefinition
         extend Tracker
 
-        @method_definitions = {}.compare_by_identity #: Hash[T::Module[top], Hash[Symbol, Array[SourceLocation]]]
+        @method_definitions = {}.compare_by_identity #: Hash[Module[top], Hash[Symbol, Array[SourceLocation]]]
 
         class << self
-          #: (Symbol method_name, T::Module[top] owner, Array[Thread::Backtrace::Location] locations) -> void
+          #: (Symbol method_name, Module[top] owner, Array[Thread::Backtrace::Location] locations) -> void
           def register(method_name, owner, locations)
             return unless enabled?
             # If Sorbet runtime is redefining a method, it sets this to true.
@@ -24,7 +24,7 @@ module Tapioca
             registrations_for(method_name, owner) << loc
           end
 
-          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
+          #: (Symbol method_name, Module[top] owner) -> Array[SourceLocation]
           def method_definitions_for(method_name, owner)
             definitions = registrations_for(method_name, owner)
 
@@ -38,7 +38,7 @@ module Tapioca
 
           private
 
-          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
+          #: (Symbol method_name, Module[top] owner) -> Array[SourceLocation]
           def registrations_for(method_name, owner)
             owner_lookup = (@method_definitions[owner] ||= {})
             owner_lookup[method_name] ||= []

data/lib/tapioca/runtime/trackers/mixin.rb

@@ -24,7 +24,7 @@ module Tapioca
             with_disabled_tracker(&block)
           end
 
-          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type) -> void
+          #: (Module[top] constant, Module[top] mixin, Type mixin_type) -> void
           def register(constant, mixin, mixin_type)
             return unless enabled?
 
@@ -46,19 +46,19 @@ module Tapioca
             attached_class
           end
 
-          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
+          #: (Module[top] mixin) -> Hash[Type, Hash[Module[top], String]]
           def constants_with_mixin(mixin)
             find_or_initialize_mixin_lookup(mixin)
           end
 
-          #: (T::Module[top] mixin, Type mixin_type, T::Module[top] constant) -> String?
+          #: (Module[top] mixin, Type mixin_type, Module[top] constant) -> String?
           def mixin_location(mixin, mixin_type, constant)
             find_or_initialize_mixin_lookup(mixin).dig(mixin_type, constant)
           end
 
           private
 
-          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type, String location) -> void
+          #: (Module[top] constant, Module[top] mixin, Type mixin_type, String location) -> void
           def register_with_location(constant, mixin, mixin_type, location)
             return unless @enabled
 
@@ -66,7 +66,7 @@ module Tapioca
             constants.fetch(mixin_type).store(constant, location)
           end
 
-          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
+          #: (Module[top] mixin) -> Hash[Type, Hash[Module[top], String]]
           def find_or_initialize_mixin_lookup(mixin)
             @mixins_to_constants[mixin] ||= {
               Type::Prepend => {}.compare_by_identity,

data/lib/tapioca/runtime/trackers/required_ancestor.rb

@@ -17,12 +17,12 @@ module Tapioca
             ancestors << block
           end
 
-          #: (T::Module[top] mod) -> Array[^-> void]
+          #: (Module[top] mod) -> Array[^-> void]
           def required_ancestors_blocks_by(mod)
             @required_ancestors_map[mod] || []
           end
 
-          #: (T::Module[top] mod) -> Array[untyped]
+          #: (Module[top] mod) -> Array[untyped]
           def required_ancestors_by(mod)
             blocks = required_ancestors_blocks_by(mod)
             blocks.map do |block|

data/lib/tapioca/runtime/trackers/tracker.rb

@@ -7,7 +7,7 @@ module Tapioca
       # @abstract
       module Tracker
         class << self
-          #: ((Tracker & T::Module[top]) base) -> void
+          #: ((Tracker & Module[top]) base) -> void
           def extended(base)
             Trackers.register_tracker(base)
             base.instance_exec do

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -82,26 +82,6 @@ module T
       prepend GenericPatch
     end
   end
-
-  module Utils
-    module Private
-      module PrivateCoercePatch
-        def coerce_and_check_module_types(val, check_val, check_module_type)
-          if val.is_a?(Tapioca::TypeVariableModule)
-            val.coerce_to_type_variable
-          elsif val.respond_to?(:__tapioca_override_type)
-            val.__tapioca_override_type
-          else
-            super
-          end
-        end
-      end
-
-      class << self
-        prepend(PrivateCoercePatch)
-      end
-    end
-  end
 end
 
 module Tapioca
@@ -133,7 +113,7 @@ module Tapioca
     #: Type
     attr_reader :type
 
-    #: (T::Module[top] context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
+    #: (Module[top] context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
     def initialize(context, type, variance, bounds_proc)
       @context = context
       @type = type

data/lib/tapioca/sorbet_ext/generic_type_patch.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module T
+  module Utils
+    module Private
+      # Preserve Tapioca's generic type variables and instantiated generic
+      # names when Sorbet coerces them into runtime types.
+      module TapiocaGenericTypeCoercePatch
+        def coerce_and_check_module_types(val, check_val, check_module_type)
+          if val.is_a?(Tapioca::TypeVariableModule)
+            val.coerce_to_type_variable
+          elsif val.respond_to?(:__tapioca_override_type)
+            val.__tapioca_override_type
+          else
+            super
+          end
+        end
+      end
+
+      class << self
+        prepend(TapiocaGenericTypeCoercePatch)
+      end
+    end
+  end
+
+  module Private
+    module Casts
+      module TapiocaGenericTypeCastPatch
+        # https://github.com/sorbet/sorbet/commit/b8d64c7fd9a08e2b9159b5d592bc2de6d586b44a
+        # inlines the Module fast path in `T.let`, `T.cast`, `T.bind`, and
+        # `T.assert_type!`, so generic module clones can reach this cast path
+        # without going through `T::Utils::Private::TapiocaGenericTypeCoercePatch`.
+        def cast(value, type, cast_method)
+          if type.respond_to?(:__tapioca_override_type)
+            type = type.__tapioca_override_type
+          end
+
+          super(value, type, cast_method)
+        end
+      end
+
+      class << self
+        prepend(TapiocaGenericTypeCastPatch)
+      end
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/void_patch.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+# If Signature has `effective_return_type`, then `return_type` always returns the correct type.
+# Ref: https://github.com/sorbet/sorbet/pull/10121
+return if T::Private::Methods::Signature.method_defined?(:effective_return_type)
+
+module T
+  module Private
+    module Methods
+      module DeclBuilderPatch
+        def void
+          super.tap do
+            @_real_returns_is_void = true
+          end
+        end
+
+        def finalize!
+          super.tap do
+            #: self as untyped
+            decl.returns = T::Private::Types::Void::Private::INSTANCE if @_real_returns_is_void
+          end
+        end
+      end
+
+      DeclBuilder.prepend(DeclBuilderPatch)
+    end
+  end
+end

data/lib/tapioca/static/symbol_loader.rb

@@ -87,7 +87,25 @@ module Tapioca
 
         #: (String input, ?table_type: String) -> String
         def symbol_table_json_from(input, table_type: "symbol-table-json")
-          sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
+          supported_values = ["symbol-table-json", "symbol-table-full-json"]
+          unless supported_values.include?(table_type)
+            raise NotImplementedError, <<~MSG
+              Got an unsupported value for `table_type` (#{table_type.inspect}).
+              The only supported values are:
+                #{supported_values.map { |v| "- #{v}" }.join("\n")}
+
+              This is because we use `--stop-after=namer` as a performance optimization. Other print formats
+              may require running later stages of Sorbet's pipeline. Please adjust the `stop-after` accordingly.
+            MSG
+          end
+
+          sorbet(
+            "--no-config",
+            "--quiet",
+            "--print=#{table_type}",
+            "--stop-after=namer",
+            input,
+          ).out
         end
       end
     end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.19.0"
+  VERSION = "0.19.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.2
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -102,14 +102,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 0.6.12698
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 0.6.12698
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -144,14 +144,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.9
+        version: 1.7.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.9
+        version: 1.7.16
 - !ruby/object:Gem::Dependency
   name: tsort
   requirement: !ruby/object:Gem::Requirement
@@ -305,8 +305,10 @@ files:
 - lib/tapioca/runtime/trackers/tracker.rb
 - lib/tapioca/sorbet_ext/backcompat_patches.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
+- lib/tapioca/sorbet_ext/generic_type_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/sorbet_ext/proc_bind_patch.rb
+- lib/tapioca/sorbet_ext/void_patch.rb
 - lib/tapioca/static/requires_compiler.rb
 - lib/tapioca/static/symbol_loader.rb
 - lib/tapioca/static/symbol_table_parser.rb
@@ -330,7 +332,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard
   library