tapioca 0.7.0 → 0.8.0

data/lib/tapioca/helpers/rbi_helper.rb

@@ -4,14 +4,121 @@
 module Tapioca
   module RBIHelper
     extend T::Sig
+    extend T::Helpers
 
-    sig { params(sig_string: String).returns(String) }
-    def sanitize_signature_types(sig_string)
-      sig_string
-        .gsub(".returns(<VOID>)", ".void")
-        .gsub("<VOID>", "void")
-        .gsub("<NOT-TYPED>", "T.untyped")
-        .gsub(".params()", "")
+    requires_ancestor { Thor::Shell }
+    requires_ancestor { SorbetHelper }
+
+    sig do
+      params(
+        command: String,
+        gem_dir: String,
+        dsl_dir: String,
+        auto_strictness: T::Boolean,
+        gems: T::Array[Gemfile::GemSpec],
+        compilers: T::Enumerable[Class]
+      ).void
+    end
+    def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
+      error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+
+      say("Checking generated RBI files... ")
+      res = sorbet(
+        "--no-config",
+        "--error-url-base=#{error_url_base}",
+        "--stop-after namer",
+        dsl_dir,
+        gem_dir
+      )
+      say(" Done", :green)
+
+      errors = Spoom::Sorbet::Errors::Parser.parse_string(res.err)
+
+      if errors.empty?
+        say("  No errors found\n\n", [:green, :bold])
+        return
+      end
+
+      parse_errors = errors.select { |error| error.code < 4000 }
+
+      if parse_errors.any?
+        say_error(<<~ERR, :red)
+
+          ##### INTERNAL ERROR #####
+
+          There are parse errors in the generated RBI files.
+
+          This seems related to a bug in Tapioca.
+          Please open an issue at https://github.com/Shopify/tapioca/issues/new with the following information:
+
+          Tapioca v#{Tapioca::VERSION}
+
+          Command:
+            #{command}
+
+        ERR
+
+        say_error(<<~ERR, :red) if gems.any?
+          Gems:
+          #{gems.map { |gem| "  #{gem.name} (#{gem.version})" }.join("\n")}
+
+        ERR
+
+        say_error(<<~ERR, :red) if compilers.any?
+          Compilers:
+          #{compilers.map { |compiler| "  #{compiler.name}" }.join("\n")}
+
+        ERR
+
+        say_error(<<~ERR, :red)
+          Errors:
+          #{parse_errors.map { |error| "  #{error}" }.join("\n")}
+
+          ##########################
+
+        ERR
+      end
+
+      if auto_strictness
+        redef_errors = errors.select { |error| error.code == 4010 }
+        update_gem_rbis_strictnesses(redef_errors, gem_dir)
+      end
+
+      Kernel.exit(1) if parse_errors.any?
+    end
+
+    private
+
+    sig { params(errors: T::Array[Spoom::Sorbet::Errors::Error], gem_dir: String).void }
+    def update_gem_rbis_strictnesses(errors, gem_dir)
+      files = []
+
+      errors.each do |error|
+        # Collect the file with error
+        files << error.file
+        error.more.each do |line|
+          # Also collect the conflicting definition file paths
+          next unless line.include?("Previous definition")
+
+          files << line.split(":").first&.strip
+        end
+      end
+
+      files
+        .uniq
+        .sort
+        .select { |file| file.start_with?(gem_dir) }
+        .each do |file|
+          Spoom::Sorbet::Sigils.change_sigil_in_file(file, "false")
+          say("\n  Changed strictness of #{file} to `typed: false` (conflicting with DSL files)", [:yellow, :bold])
+        end
+
+      say("\n")
+    end
+
+    sig { params(path: String).returns(String) }
+    def gem_name_from_rbi_path(path)
+      T.must(File.basename(path, ".rbi").split("@").first)
     end
   end
 end

data/lib/tapioca/helpers/shims_helper.rb

@@ -8,20 +8,25 @@ module Tapioca
 
     requires_ancestor { Thor::Shell }
 
+    SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
+
+    sig { params(index: RBI::Index, dir: String).void }
+    def index_payload(index, dir)
+      return unless Dir.exist?(dir)
+
+      say("Loading Sorbet payload... ")
+      files = Dir.glob("#{dir}/**/*.rbi").sort
+      parse_and_index_files(index, files)
+      say(" Done", :green)
+    end
+
     sig { params(index: RBI::Index, kind: String, dir: String).void }
     def index_rbis(index, kind, dir)
       return unless Dir.exist?(dir) && !Dir.empty?(dir)
 
       say("Loading #{kind} RBIs from #{dir}... ")
       files = Dir.glob("#{dir}/**/*.rbi").sort
-
-      trees = files.map do |file|
-        RBI::Parser.parse_file(file)
-      rescue RBI::ParseError => e
-        say_error("\nWarning: #{e} (#{e.location})", :yellow)
-      end.compact
-
-      index.visit_all(trees)
+      parse_and_index_files(index, files)
       say(" Done", :green)
     end
 
@@ -32,14 +37,37 @@ module Tapioca
       index.keys.each do |key|
         nodes = index[key]
         next unless shims_have_duplicates?(nodes, shim_rbi_dir)
+
         duplicates[key] = nodes
       end
       say(" Done", :green)
       duplicates
     end
 
+    sig { params(loc: RBI::Loc, path_prefix: T.nilable(String)).returns(String) }
+    def location_to_payload_url(loc, path_prefix:)
+      return loc.to_s unless path_prefix
+
+      url = loc.file || ""
+      return loc.to_s unless url.start_with?(path_prefix)
+
+      url = url.sub(path_prefix, SORBET_PAYLOAD_URL)
+      url = "#{url}#L#{loc.begin_line}"
+      url
+    end
+
     private
 
+    sig { params(index: RBI::Index, files: T::Array[String]).void }
+    def parse_and_index_files(index, files)
+      trees = files.map do |file|
+        RBI::Parser.parse_file(file)
+      rescue RBI::ParseError => e
+        say_error("\nWarning: #{e} (#{e.location})", :yellow)
+      end.compact
+      index.visit_all(trees)
+    end
+
     sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String).returns(T::Boolean) }
     def shims_have_duplicates?(nodes, shim_rbi_dir)
       return false if nodes.size == 1

data/lib/tapioca/helpers/signatures_helper.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module SignaturesHelper
+    extend T::Sig
+
+    sig { params(sig_string: String).returns(String) }
+    def sanitize_signature_types(sig_string)
+      sig_string
+        .gsub(".returns(<VOID>)", ".void")
+        .gsub("<VOID>", "void")
+        .gsub("<NOT-TYPED>", "T.untyped")
+        .gsub(".params()", "")
+    end
+  end
+end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -21,20 +21,14 @@ module Tapioca
     SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
     FEATURE_REQUIREMENTS = T.let({
-      # First tag that includes https://github.com/sorbet/sorbet/pull/4706
-      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),
+      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),         # https://github.com/sorbet/sorbet/pull/4706
+      print_payload_sources: ::Gem::Requirement.new(">= 0.5.9818"),      # https://github.com/sorbet/sorbet/pull/5504
+      type_variable_block_syntax: ::Gem::Requirement.new(">= 0.5.9892"), # https://github.com/sorbet/sorbet/pull/5639
     }.freeze, T::Hash[Symbol, ::Gem::Requirement])
 
-    class CmdResult < T::Struct
-      const :out, String
-      const :err, String
-      const :status, T::Boolean
-    end
-
-    sig { params(sorbet_args: String).returns(CmdResult) }
+    sig { params(sorbet_args: String).returns(Spoom::ExecResult) }
     def sorbet(*sorbet_args)
-      out, err, status = Open3.capture3([sorbet_path, *sorbet_args].join(" "))
-      CmdResult.new(out: out, err: err, status: status.success? || false)
+      Spoom::Sorbet.srb(sorbet_args.join(" "), sorbet_bin: sorbet_path, capture_err: true)
     end
 
     sig { returns(String) }

data/lib/tapioca/helpers/test/content.rb

@@ -41,6 +41,7 @@ module Tapioca
         def add_content_file(name, content)
           file_name = tmp_path("lib/#{name}")
           raise ArgumentError, "a file named '#{name}' was already added; cannot overwrite." if File.exist?(file_name)
+
           FileUtils.mkdir_p(File.dirname(file_name))
           File.write(file_name, content)
           file_name

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -46,6 +46,7 @@ module Tapioca
         sig { returns(CompilerContext) }
         def context
           raise "Please call `use_dsl_compiler` before" unless @context
+
           @context
         end
 

data/lib/tapioca/helpers/test/template.rb

@@ -36,6 +36,7 @@ module Tapioca
         def indented(str, indent)
           str.lines.map! do |line|
             next line if line.chomp.empty?
+
             (" " * indent) + line
           end.join
         end

data/lib/tapioca/helpers/type_variable_helper.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module TypeVariableHelper
+    extend T::Sig
+    extend SorbetHelper
+
+    sig do
+      params(
+        type: String,
+        variance: Symbol,
+        fixed: T.nilable(String),
+        upper: T.nilable(String),
+        lower: T.nilable(String)
+      ).returns(String)
+    end
+    def self.serialize_type_variable(type, variance, fixed, upper, lower)
+      variance = nil if variance == :invariant
+
+      bounds = []
+      bounds << "fixed: #{fixed}" if fixed
+      bounds << "lower: #{lower}" if lower
+      bounds << "upper: #{upper}" if upper
+
+      parameters = []
+      block = []
+
+      parameters << ":#{variance}" if variance
+
+      if sorbet_supports?(:type_variable_block_syntax)
+        block = bounds
+      else
+        parameters.concat(bounds)
+      end
+
+      serialized = type.dup
+      serialized << "(#{parameters.join(", ")})" unless parameters.empty?
+      serialized << " { { #{block.join(", ")} } }" unless block.empty?
+      serialized
+    end
+  end
+end

data/lib/tapioca/internal.rb

@@ -6,14 +6,17 @@ require "tapioca/runtime/reflection"
 require "tapioca/runtime/trackers"
 require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/runtime/loader"
+require "tapioca/helpers/sorbet_helper"
+require "tapioca/helpers/type_variable_helper"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/runtime/generic_type_registry"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
+require "tapioca/helpers/signatures_helper"
 require "tapioca/helpers/rbi_helper"
 require "tapioca/helpers/shims_helper"
-require "tapioca/helpers/sorbet_helper"
+require "tapioca/repo_index"
 require "tapioca/commands"
 require "tapioca/cli"
 require "tapioca/gemfile"

data/lib/tapioca/rbi_ext/model.rb

@@ -61,8 +61,18 @@ module RBI
       create_node(RBI::MixesInClassMethods.new(name))
     end
 
-    sig { params(name: String, value: String).void }
-    def create_type_member(name, value: "type_member")
+    sig do
+      params(
+        name: String,
+        type: String,
+        variance: Symbol,
+        fixed: T.nilable(String),
+        upper: T.nilable(String),
+        lower: T.nilable(String)
+      ).void
+    end
+    def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: nil, lower: nil)
+      value = Tapioca::TypeVariableHelper.serialize_type_variable(type, variance, fixed, upper, lower)
       create_node(RBI::TypeMember.new(name, value))
     end
 
@@ -98,6 +108,7 @@ module RBI
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
       return true if SPECIAL_METHOD_NAMES.include?(name)
+
       !!name.match(/^[a-zA-Z_][[:word:]]*[?!=]?$/)
     end
 
@@ -110,6 +121,7 @@ module RBI
     def create_node(node)
       cached = nodes_cache[node.to_s]
       return cached if cached
+
       nodes_cache[node.to_s] = node
       self << node
       node

data/lib/tapioca/repo_index.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  class RepoIndex
+    extend T::Sig
+    extend T::Generic
+
+    sig { params(json: String).returns(RepoIndex) }
+    def self.from_json(json)
+      RepoIndex.from_hash(JSON.parse(json))
+    end
+
+    sig { params(hash: T::Hash[String, T::Hash[T.untyped, T.untyped]]).returns(RepoIndex) }
+    def self.from_hash(hash)
+      hash.each_with_object(RepoIndex.new) do |(name, _), index|
+        index << name
+      end
+    end
+
+    sig { void }
+    def initialize
+      @entries = T.let(Set.new, T::Set[String])
+    end
+
+    sig { params(gem_name: String).void }
+    def <<(gem_name)
+      @entries.add(gem_name)
+    end
+
+    sig { returns(T::Enumerable[String]) }
+    def gems
+      @entries.sort
+    end
+
+    sig { params(gem_name: String).returns(T::Boolean) }
+    def has_gem?(gem_name)
+      @entries.include?(gem_name)
+    end
+  end
+end

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -111,8 +111,10 @@ module Tapioca
             constant.clone
           end
 
-          # Let's set the `name` method to return the proper generic name
-          generic_type.define_singleton_method(:name) { name }
+          # Let's set the `name` and `to_s` methods to return the proper generic name
+          name_proc = -> { name }
+          generic_type.define_singleton_method(:name, name_proc)
+          generic_type.define_singleton_method(:to_s, name_proc)
 
           # We need to define a `<=` method on the cloned constant, so that Sorbet
           # can do covariance/contravariance checks on the type variables.

data/lib/tapioca/runtime/loader.rb

@@ -41,6 +41,7 @@ module Tapioca
       sig { params(file: T.nilable(String)).void }
       def require_helper(file)
         return unless file
+
         file = File.absolute_path(file)
         return unless File.exist?(file)
 
@@ -51,6 +52,8 @@ module Tapioca
       def rails_engines
         return [] unless Object.const_defined?("Rails::Engine")
 
+        safe_require("active_support/core_ext/class/subclasses")
+
         # We can use `Class#descendants` here, since we know Rails is loaded
         Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
       end

data/lib/tapioca/runtime/reflection.rb

@@ -35,58 +35,58 @@ module Tapioca
 
       sig { params(object: BasicObject).returns(Class).checked(:never) }
       def class_of(object)
-        CLASS_METHOD.bind(object).call
+        CLASS_METHOD.bind_call(object)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def constants_of(constant)
-        CONSTANTS_METHOD.bind(constant).call(false)
+        CONSTANTS_METHOD.bind_call(constant, false)
       end
 
       sig { params(constant: Module).returns(T.nilable(String)) }
       def name_of(constant)
-        name = NAME_METHOD.bind(constant).call
+        name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
       sig { params(constant: Module).returns(Class) }
       def singleton_class_of(constant)
-        SINGLETON_CLASS_METHOD.bind(constant).call
+        SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Module]) }
       def ancestors_of(constant)
-        ANCESTORS_METHOD.bind(constant).call
+        ANCESTORS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Class).returns(T.nilable(Class)) }
       def superclass_of(constant)
-        SUPERCLASS_METHOD.bind(constant).call
+        SUPERCLASS_METHOD.bind_call(constant)
       end
 
       sig { params(object: BasicObject).returns(Integer).checked(:never) }
       def object_id_of(object)
-        OBJECT_ID_METHOD.bind(object).call
+        OBJECT_ID_METHOD.bind_call(object)
       end
 
       sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean).checked(:never) }
       def are_equal?(object, other)
-        EQUAL_METHOD.bind(object).call(other)
+        EQUAL_METHOD.bind_call(object, other)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def public_instance_methods_of(constant)
-        PUBLIC_INSTANCE_METHODS_METHOD.bind(constant).call
+        PUBLIC_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def protected_instance_methods_of(constant)
-        PROTECTED_INSTANCE_METHODS_METHOD.bind(constant).call
+        PROTECTED_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def private_instance_methods_of(constant)
-        PRIVATE_INSTANCE_METHODS_METHOD.bind(constant).call
+        PRIVATE_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Module]) }
@@ -124,7 +124,7 @@ module Tapioca
 
       sig { params(constant: Module, method: Symbol).returns(Method) }
       def method_of(constant, method)
-        METHOD_METHOD.bind(constant).call(method)
+        METHOD_METHOD.bind_call(constant, method)
       end
 
       # Returns an array with all classes that are < than the supplied class.
@@ -140,7 +140,11 @@ module Tapioca
       #
       #   class D < C; end
       #   descendants_of(C) # => [B, A, D]
-      sig { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
+      sig do
+        type_parameters(:U)
+          .params(klass: T.all(Class, T.type_parameter(:U)))
+          .returns(T::Array[T.type_parameter(:U)])
+      end
       def descendants_of(klass)
         result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
           T.cast(k, Module).singleton_class? || T.unsafe(k) == klass

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "tapioca/sorbet_ext/name_patch"
+require "tapioca/helpers/sorbet_helper"
 
 module T
   module Generic
@@ -20,31 +21,47 @@ module T
         Tapioca::Runtime::GenericTypeRegistry.register_type(constant, types)
       end
 
-      def type_member(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+      def type_member(variance = :invariant, fixed: nil, lower: nil, upper: nil, &blk)
         # `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.
+        hash = if blk
+          blk.call
+        else
+          {
+            fixed: fixed,
+            lower: lower,
+            upper: upper,
+          }
+        end
+
         Tapioca::TypeVariableModule.new(
           T.cast(self, Module),
           Tapioca::TypeVariableModule::Type::Member,
           variance,
-          fixed,
-          lower,
-          upper
+          **hash,
         ).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)
+      def type_template(variance = :invariant, fixed: nil, lower: nil, upper: nil, &blk)
         # `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.
+        hash = if blk
+          blk.call
+        else
+          {
+            fixed: fixed,
+            lower: lower,
+            upper: upper,
+          }
+        end
+
         Tapioca::TypeVariableModule.new(
           T.cast(self, Module),
           Tapioca::TypeVariableModule::Type::Template,
           variance,
-          fixed,
-          lower,
-          upper
+          **hash,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
@@ -122,7 +139,7 @@ module Tapioca
     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
+    def initialize(context, type, variance, fixed: nil, lower: nil, upper: nil)
       @context = context
       @type = type
       @variance = variance
@@ -137,7 +154,7 @@ module Tapioca
       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
+      # names in 2.7: https://bugs.ruby-lang.org/issues/14895
       #
       # This happens when a type variable is declared under `class << self`, for
       # example.
@@ -153,17 +170,17 @@ module Tapioca
 
     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.serialize.dup
-      serialized << "(#{parameters})" unless parameters.empty?
-      serialized
+      fixed = @fixed.to_s if @fixed
+      upper = @upper.to_s if @upper
+      lower = @lower.to_s if @lower
+
+      TypeVariableHelper.serialize_type_variable(
+        @type.serialize,
+        @variance,
+        fixed,
+        upper,
+        lower
+      )
     end
 
     sig { returns(Tapioca::TypeVariable) }

data/lib/tapioca/static/symbol_table_parser.rb

@@ -16,6 +16,8 @@ module Tapioca
         parser = SymbolTableParser.new
         parser.parse_object(obj)
         parser.symbols
+      rescue JSON::ParserError
+        Set.new
       end
 
       sig { returns(T::Set[String]) }

data/lib/tapioca/version.rb

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