tapioca 0.6.1 → 0.7.0

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -17,23 +17,37 @@ module T
         constant = super
         # `register_type` method builds and returns an instantiated clone of the generic type
         # so, we just return that from this method as well.
-        Tapioca::GenericTypeRegistry.register_type(constant, types)
+        Tapioca::Runtime::GenericTypeRegistry.register_type(constant, types)
       end
 
       def type_member(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
         # `T::Generic#type_member` just instantiates a `T::Type::TypeMember` instance and returns it.
         # We use that when registering the type member and then later return it from this method.
-        type_member = Tapioca::TypeMember.new(variance, fixed, lower, upper)
-        Tapioca::GenericTypeRegistry.register_type_variable(self, type_member)
-        type_member
+        Tapioca::TypeVariableModule.new(
+          T.cast(self, Module),
+          Tapioca::TypeVariableModule::Type::Member,
+          variance,
+          fixed,
+          lower,
+          upper
+        ).tap do |type_variable|
+          Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
+        end
       end
 
       def type_template(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
         # `T::Generic#type_template` just instantiates a `T::Type::TypeTemplate` instance and returns it.
         # We use that when registering the type template and then later return it from this method.
-        type_template = Tapioca::TypeTemplate.new(variance, fixed, lower, upper)
-        Tapioca::GenericTypeRegistry.register_type_variable(self, type_template)
-        type_template
+        Tapioca::TypeVariableModule.new(
+          T.cast(self, Module),
+          Tapioca::TypeVariableModule::Type::Template,
+          variance,
+          fixed,
+          lower,
+          upper
+        ).tap do |type_variable|
+          Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
+        end
       end
     end
 
@@ -42,15 +56,14 @@ module T
 
   module Types
     class Simple
-      # This module intercepts calls to the `name` method for
-      # simple types, so that it can ask the name to the type if
-      # the type is generic, since, by this point, we've created
-      # a clone of that type with the `name` method returning the
-      # appropriate name for that specific concrete type.
-      module GenericNamePatch
+      module GenericPatch
+        # This method intercepts calls to the `name` method for simple types, so that
+        # it can ask the name to the type if the type is generic, since, by this point,
+        # we've created a clone of that type with the `name` method returning the
+        # appropriate name for that specific concrete type.
         def name
-          if T::Generic === @raw_type
-            # for types that are generic, use the name
+          if T::Generic === @raw_type || Tapioca::TypeVariableModule === @raw_type
+            # for types that are generic or are type variables, use the name
             # returned by the "name" method of this instance
             @name ||= T.unsafe(@raw_type).name.freeze
           else
@@ -60,60 +73,82 @@ module T
         end
       end
 
-      prepend GenericNamePatch
+      prepend GenericPatch
     end
   end
-end
-
-module Tapioca
-  class TypeMember < T::Types::TypeMember
-    extend T::Sig
 
-    sig { returns(T.nilable(String)) }
-    attr_accessor :name
+  module Utils
+    module CoercePatch
+      def coerce(val)
+        if val.is_a?(Tapioca::TypeVariableModule)
+          val.coerce_to_type_variable
+        else
+          super
+        end
+      end
+    end
 
-    sig { returns(T.untyped) }
-    attr_reader :fixed, :lower, :upper
+    class << self
+      prepend(CoercePatch)
+    end
+  end
+end
 
-    sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def initialize(variance, fixed, lower, upper)
+module Tapioca
+  class TypeVariable < ::T::Types::TypeVariable
+    def initialize(name, variance)
+      @name = name
       super(variance)
-      @fixed = fixed
-      @lower = lower
-      @upper = upper
     end
 
-    sig { returns(String) }
-    def serialize
-      parts = []
-      parts << ":#{@variance}" unless @variance == :invariant
-      parts << "fixed: #{@fixed}" if @fixed
-      parts << "lower: #{@lower}" unless @lower == T.untyped
-      parts << "upper: #{@upper}" unless @upper == BasicObject
-
-      parameters = parts.join(", ")
-
-      serialized = +"type_member"
-      serialized << "(#{parameters})" unless parameters.empty?
-      serialized
-    end
+    attr_reader :name
   end
 
-  class TypeTemplate < T::Types::TypeTemplate
+  # This is subclassing from `Module` so that instances of this type will be modules.
+  # The reason why we want that is because that means those instances will automatically
+  # get bound to the constant names they are assigned to by Ruby. As a result, we don't
+  # need to do any matching of constants to type variables to bind their names, Ruby will
+  # do that automatically for us and we get the `name` method for free from `Module`.
+  class TypeVariableModule < Module
     extend T::Sig
 
-    sig { returns(T.nilable(String)) }
-    attr_accessor :name
-
-    sig { returns(T.untyped) }
-    attr_reader :fixed, :lower, :upper
+    class Type < T::Enum
+      enums do
+        Member = new("type_member")
+        Template = new("type_template")
+      end
+    end
 
-    sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def initialize(variance, fixed, lower, upper)
-      super(variance)
+    sig do
+      params(context: Module, type: Type, variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void
+    end
+    def initialize(context, type, variance, fixed, lower, upper) # rubocop:disable Metrics/ParameterLists
+      @context = context
+      @type = type
+      @variance = variance
       @fixed = fixed
       @lower = lower
       @upper = upper
+      super()
+    end
+
+    sig { returns(T.nilable(String)) }
+    def name
+      constant_name = super
+
+      # This is a hack to work around modules under anonymous modules not having
+      # names in 2.6 and 2.7: https://bugs.ruby-lang.org/issues/14895
+      #
+      # This happens when a type variable is declared under `class << self`, for
+      # example.
+      #
+      # The workaround is to give the parent context a name, at which point, our
+      # module gets bound to a name under that name, as well.
+      unless constant_name
+        constant_name = with_bound_name_pre_3_0 { super }
+      end
+
+      constant_name&.split("::")&.last
     end
 
     sig { returns(String) }
@@ -126,9 +161,30 @@ module Tapioca
 
       parameters = parts.join(", ")
 
-      serialized = +"type_template"
+      serialized = @type.serialize.dup
       serialized << "(#{parameters})" unless parameters.empty?
       serialized
     end
+
+    sig { returns(Tapioca::TypeVariable) }
+    def coerce_to_type_variable
+      TypeVariable.new(name, @variance)
+    end
+
+    private
+
+    sig do
+      type_parameters(:Result)
+        .params(block: T.proc.returns(T.type_parameter(:Result)))
+        .returns(T.type_parameter(:Result))
+    end
+    def with_bound_name_pre_3_0(&block)
+      require "securerandom"
+      temp_name = "TYPE_VARIABLE_TRACKING_#{SecureRandom.hex}"
+      self.class.const_set(temp_name, @context)
+      block.call
+    ensure
+      self.class.send(:remove_const, temp_name) if temp_name
+    end
   end
 end

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -1,12 +1,18 @@
 # typed: true
 # frozen_string_literal: true
 
+# We need sorbet to compile the signature for `qualified_name_of` before applying
+# the patch to avoid an infinite loop.
+T::Utils.signature_for_method(::Tapioca::Runtime::Reflection.method(:qualified_name_of))
+
 module T
   module Types
     class Simple
       module NamePatch
         def name
-          @name ||= ::Tapioca::Reflection.name_of(@raw_type).freeze
+          # Sorbet memoizes this method into the `@name` instance variable but
+          # doing so means that types get memoized before this patch is applied
+          ::Tapioca::Runtime::Reflection.qualified_name_of(@raw_type)
         end
       end
 

data/lib/tapioca/{compilers → static}/requires_compiler.rb

@@ -4,7 +4,7 @@
 require "spoom"
 
 module Tapioca
-  module Compilers
+  module Static
     class RequiresCompiler
       extend T::Sig
 
@@ -17,10 +17,9 @@ module Tapioca
       def compile
         config = Spoom::Sorbet::Config.parse_file(@sorbet_path)
         files = collect_files(config)
+        names_in_project = files.to_h { |file| [File.basename(file, ".rb"), true] }
         files.flat_map do |file|
-          collect_requires(file).reject do |req|
-            name_in_project?(files, req)
-          end
+          collect_requires(file).reject { |req| names_in_project[req] }
         end.sort.uniq.map do |name|
           "require \"#{name}\"\n"
         end.join
@@ -45,9 +44,10 @@ module Tapioca
 
       sig { params(file_path: String).returns(T::Enumerable[String]) }
       def collect_requires(file_path)
-        File.read(file_path).lines.map do |line|
+        File.binread(file_path).lines.map do |line|
           /^\s*require\s*(\(\s*)?['"](?<name>[^'"]+)['"](\s*\))?/.match(line) { |m| m["name"] }
         end.compact
+          .reject { |require| require.include?('#{') } # ignore interpolation
       end
 
       sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
@@ -83,13 +83,6 @@ module Tapioca
       def path_parts(path)
         T.unsafe(path).descend.map { |part| part.basename.to_s }
       end
-
-      sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
-      def name_in_project?(files, name)
-        files.any? do |file|
-          File.basename(file, ".rb") == name
-        end
-      end
     end
   end
 end

data/lib/tapioca/static/symbol_loader.rb

@@ -0,0 +1,83 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "tempfile"
+
+module Tapioca
+  module Static
+    module SymbolLoader
+      class << self
+        extend T::Sig
+        include SorbetHelper
+        include Runtime::Reflection
+
+        sig { returns(T::Set[String]) }
+        def payload_symbols
+          unless @payload_symbols
+            output = symbol_table_json_from("-e ''", table_type: "symbol-table-full-json")
+            @payload_symbols = T.let(SymbolTableParser.parse_json(output), T.nilable(T::Set[String]))
+          end
+
+          T.must(@payload_symbols)
+        end
+
+        sig { returns(T::Set[String]) }
+        def engine_symbols
+          unless @engine_symbols
+            @engine_symbols = T.let(load_engine_symbols, T.nilable(T::Set[String]))
+          end
+          T.must(@engine_symbols)
+        end
+
+        sig { params(gem: Gemfile::GemSpec).returns(T::Set[String]) }
+        def gem_symbols(gem)
+          symbols_from_paths(gem.files)
+        end
+
+        private
+
+        sig { params(input: String, table_type: String).returns(String) }
+        def symbol_table_json_from(input, table_type: "symbol-table-json")
+          sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
+        end
+
+        sig { returns(T::Set[String]) }
+        def load_engine_symbols
+          return Set.new unless Object.const_defined?("Rails::Engine")
+
+          engine = descendants_of(Object.const_get("Rails::Engine"))
+            .reject(&:abstract_railtie?)
+            .find do |klass|
+              name = name_of(klass)
+              !name.nil? && payload_symbols.include?(name)
+            end
+
+          return Set.new unless engine
+
+          paths = engine.config.eager_load_paths.flat_map do |load_path|
+            Pathname.glob("#{load_path}/**/*.rb")
+          end
+
+          symbols_from_paths(paths)
+        rescue
+          Set.new
+        end
+
+        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+        def symbols_from_paths(paths)
+          output = T.cast(Tempfile.create("sorbet") do |file|
+            file.write(Array(paths).join("\n"))
+            file.flush
+
+            symbol_table_json_from("@#{file.path.shellescape}")
+          end, T.nilable(String))
+
+          return Set.new if output.nil? || output.empty?
+
+          SymbolTableParser.parse_json(output)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/static/symbol_table_parser.rb

@@ -0,0 +1,63 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "tempfile"
+
+module Tapioca
+  module Static
+    class SymbolTableParser
+      extend T::Sig
+
+      sig { params(json_string: String).returns(T::Set[String]) }
+      def self.parse_json(json_string)
+        obj = JSON.parse(json_string)
+
+        parser = SymbolTableParser.new
+        parser.parse_object(obj)
+        parser.symbols
+      end
+
+      sig { returns(T::Set[String]) }
+      attr_reader :symbols
+
+      sig { void }
+      def initialize
+        @symbols = T.let(Set.new, T::Set[String])
+        @parents = T.let([], T::Array[String])
+      end
+
+      sig { params(object: T::Hash[String, T.untyped]).void }
+      def parse_object(object)
+        children = object.fetch("children", [])
+
+        children.each do |child|
+          kind = child.fetch("kind")
+          name = child.fetch("name")
+          name = name.fetch("name") if name.is_a?(Hash)
+
+          next if kind.nil? || name.nil?
+
+          # TODO: CLASS is removed since v0.4.4730 of Sorbet
+          # but keeping here for backward compatibility. Remove
+          # once the minimum version is moved past that.
+          next unless ["CLASS", "CLASS_OR_MODULE", "STATIC_FIELD"].include?(kind)
+          next if name =~ /[<>()$]/
+          next if name =~ /^[0-9]+$/
+          next if name == "T::Helpers"
+
+          @symbols.add(fully_qualified_name(name))
+
+          @parents << name
+          parse_object(child)
+          @parents.pop
+        end
+      end
+
+      sig { params(name: String).returns(String) }
+      def fully_qualified_name(name)
+        [*@parents, name].join("::")
+      end
+    end
+  end
+end

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -14,7 +14,7 @@ module Tapioca
   def self.silence_warnings(&blk)
     original_verbosity = $VERBOSE
     $VERBOSE = nil
-    Gem::DefaultUserInteraction.use_ui(Gem::SilentUI.new) do
+    ::Gem::DefaultUserInteraction.use_ui(::Gem::SilentUI.new) do
       blk.call
     end
   ensure
@@ -28,7 +28,7 @@ module Tapioca
   TAPIOCA_DIR = T.let("#{SORBET_DIR}/tapioca", String)
   TAPIOCA_CONFIG_FILE = T.let("#{TAPIOCA_DIR}/config.yml", String)
 
-  DEFAULT_COMMAND = T.let("bin/tapioca", String)
+  BINARY_FILE = T.let("bin/tapioca", String)
   DEFAULT_POSTREQUIRE_FILE = T.let("#{TAPIOCA_DIR}/require.rb", String)
   DEFAULT_RBI_DIR = T.let("#{SORBET_DIR}/rbi", String)
   DEFAULT_DSL_DIR = T.let("#{DEFAULT_RBI_DIR}/dsl", String)
@@ -43,9 +43,4 @@ module Tapioca
   }.freeze, T::Hash[String, String])
 end
 
-require "tapioca/reflection"
-require "tapioca/trackers"
-require "tapioca/compilers/dsl/base"
-require "tapioca/compilers/dynamic_mixin_compiler"
-require "tapioca/helpers/active_record_column_type_helper"
 require "tapioca/version"