tapioca 0.4.17 → 0.4.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9293078ee1614e88f45586904e3d90cc556cab3218340699325902e224d94aed
-  data.tar.gz: d14050953a3de23bfc4830b6b27282331dcac745090695cd2552a5e7a1ee6296
+  metadata.gz: b3709ab7f54589bdf97715ffc2cc7c3a98ad703a6e318a264db70429078cdf26
+  data.tar.gz: 3e38366a54f9b3286de28a2b6d557762b2cf564848b8184a76aadc75504a41fb
 SHA512:
-  metadata.gz: bd3bbcbc3a7d5448e7ace8472258e96c654d8854f1c4ec3ffe498a5b06e136f46df526f5a83d4b7814bf1ed57eec24cb3694c8fce686dd2df02a6d6af6de8414
-  data.tar.gz: 641e472a327784295d117481c9676b7fc92c320a764d06449ed9c5d65e1f5cc76cb63b0446e4269d85fd606df8ec19e519ce42cfe503403a1cf2197c042ad494
+  metadata.gz: 4ef5e31a85a71607340ad54e2fff59b1a5bd0d3f81b1481bd4830ca5e73e5ea9ed1504d38808d8bf49a9686276685167a35103769fdb30d66b61362c4d9c072b
+  data.tar.gz: e0b1daab32f024cc5f3f1fc019b5c1dcd040ce0657e59b81d736702e3cb380a9e7265397f108f4787163e50d9b31e793b960cd33f875cf45a061cee17fa1857e

data/README.md

@@ -1,3 +1,5 @@
+> :warning: **Note**: This software is currently under active development. The API and interface should be considered unstable until a v1.0.0 release.
+
 # Tapioca
 
 ![Build Status](https://github.com/Shopify/tapioca/workflows/CI/badge.svg)
@@ -14,7 +16,7 @@ For gems that have a normal default `require` and load all of their constants th
 
 For example, suppose you are using the class `BetterHtml::Parser` exported from the `better_html` gem. Just doing a `require "better_html"` (which is the default require) does not load that type:
 
-```ruby
+```shell
 $ bundle exec pry
 [1] pry(main)> require 'better_html'
 => true
@@ -110,7 +112,7 @@ This will generate DSL RBIs for specified constants (or for all handled constant
 - `--prerequire [file]`: A file to be required before `Bundler.require` is called.
 - `--postrequire [file]`: A file to be required after `Bundler.require` is called.
 - `--out [directory]`: The output directory for generated RBI files, default to `sorbet/rbi/gems`.
-- `--generate-command [command]`: The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
+- `--generate-command [command]`: **[DEPRECATED]** The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
 - `--typed-overrides [gem:level]`: Overrides typed sigils for generated gem RBIs for gem `gem` to level `level` (`level` can be one of `ignore`, `false`, `true`, `strict`, or `strong`, see [the Sorbet docs](https://sorbet.org/docs/static#file-level-granularity-strictness-levels) for more details).
 
 ## Contributing

data/exe/tapioca

@@ -1,6 +1,21 @@
 #! /usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative "../lib/tapioca"
+require 'sorbet-runtime'
 
-Tapioca::Cli.start(ARGV)
+begin
+  T::Configuration.default_checked_level = :never
+  # Suppresses errors caused by T.cast, T.let, T.must, etc.
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  # Suppresses errors caused by incorrect parameter ordering
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  # Need this rescue so that if another gem has
+  # already set the checked level by the time we
+  # get to it, we don't fail outright.
+  nil
+end
+
+require_relative "../lib/tapioca/internal"
+
+Tapioca::Cli::Main.start(ARGV)

data/lib/tapioca.rb

@@ -17,31 +17,5 @@ module Tapioca
   class Error < StandardError; end
 end
 
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
-
-require "tapioca/loader"
-require "tapioca/constant_locator"
-require "tapioca/config"
-require "tapioca/config_builder"
-require "tapioca/generator"
-require "tapioca/cli"
-require "tapioca/gemfile"
-require "tapioca/compilers/sorbet"
-require "tapioca/compilers/requires_compiler"
-require "tapioca/compilers/symbol_table_compiler"
-require "tapioca/compilers/symbol_table/symbol_generator"
-require "tapioca/compilers/symbol_table/symbol_loader"
-require "tapioca/compilers/todos_compiler"
-require "tapioca/compilers/dsl_compiler"
+require "tapioca/compilers/dsl/base"
 require "tapioca/version"

data/lib/tapioca/cli.rb

@@ -4,112 +4,5 @@
 require 'thor'
 
 module Tapioca
-  class Cli < Thor
-    include(Thor::Actions)
-
-    class_option :prerequire,
-                  aliases: ["--pre", "-b"],
-                  banner: "file",
-                  desc: "A file to be required before Bundler.require is called"
-    class_option :postrequire,
-                  aliases: ["--post", "-a"],
-                  banner: "file",
-                  desc: "A file to be required after Bundler.require is called"
-    class_option :outdir,
-                  aliases: ["--out", "-o"],
-                  banner: "directory",
-                  desc: "The output directory for generated RBI files"
-    class_option :generate_command,
-                  aliases: ["--cmd", "-c"],
-                  banner: "command",
-                  desc: "The command to run to regenerate RBI files"
-    class_option :exclude,
-                  aliases: ["-x"],
-                  type: :array,
-                  banner: "gem [gem ...]",
-                  desc: "Excludes the given gem(s) from RBI generation"
-    class_option :typed_overrides,
-                  aliases: ["--typed", "-t"],
-                  type: :hash,
-                  banner: "gem:level [gem:level ...]",
-                  desc: "Overrides for typed sigils for generated gem RBIs"
-
-    map T.unsafe(%w[--version -v] => :__print_version)
-
-    desc "init", "initializes folder structure"
-    def init
-      create_file(Config::SORBET_CONFIG, skip: true) do
-        <<~CONTENT
-          --dir
-          .
-        CONTENT
-      end
-      create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
-        <<~CONTENT
-          # typed: false
-          # frozen_string_literal: true
-
-          # Add your extra requires here
-        CONTENT
-      end
-    end
-
-    desc "require", "generate the list of files to be required by tapioca"
-    def require
-      Tapioca.silence_warnings do
-        generator.build_requires
-      end
-    end
-
-    desc "todo", "generate the list of unresolved constants"
-    def todo
-      Tapioca.silence_warnings do
-        generator.build_todos
-      end
-    end
-
-    desc "dsl [constant...]", "generate RBIs for dynamic methods"
-    option :generators,
-      type: :array,
-      aliases: ["--gen", "-g"],
-      banner: "generator [generator ...]",
-      desc: "Only run supplied DSL generators"
-    def dsl(*constants)
-      Tapioca.silence_warnings do
-        generator.build_dsl(constants)
-      end
-    end
-
-    desc "generate [gem...]", "generate RBIs from gems"
-    def generate(*gems)
-      Tapioca.silence_warnings do
-        generator.build_gem_rbis(gems)
-      end
-    end
-
-    desc "sync", "sync RBIs to Gemfile"
-    def sync
-      Tapioca.silence_warnings do
-        generator.sync_rbis_with_gemfile
-      end
-    end
-
-    desc "--version, -v", "show version"
-    def __print_version
-      puts "Tapioca v#{Tapioca::VERSION}"
-    end
-
-    no_commands do
-      def self.exit_on_failure?
-        true
-      end
-
-      def generator
-        current_command = T.must(current_command_chain.first)
-        @generator ||= Generator.new(
-          ConfigBuilder.from_options(current_command, options)
-        )
-      end
-    end
-  end
+  module Cli; end
 end

data/lib/tapioca/cli/main.rb

@@ -0,0 +1,136 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Cli
+    class Main < Thor
+      include(Thor::Actions)
+
+      class_option :prerequire,
+                    aliases: ["--pre", "-b"],
+                    banner: "file",
+                    desc: "A file to be required before Bundler.require is called"
+      class_option :postrequire,
+                    aliases: ["--post", "-a"],
+                    banner: "file",
+                    desc: "A file to be required after Bundler.require is called"
+      class_option :outdir,
+                    aliases: ["--out", "-o"],
+                    banner: "directory",
+                    desc: "The output directory for generated RBI files"
+      class_option :generate_command,
+                    aliases: ["--cmd", "-c"],
+                    banner: "command",
+                    desc: "The command to run to regenerate RBI files"
+      class_option :exclude,
+                    aliases: ["-x"],
+                    type: :array,
+                    banner: "gem [gem ...]",
+                    desc: "Excludes the given gem(s) from RBI generation"
+      class_option :typed_overrides,
+                    aliases: ["--typed", "-t"],
+                    type: :hash,
+                    banner: "gem:level [gem:level ...]",
+                    desc: "Overrides for typed sigils for generated gem RBIs"
+
+      map T.unsafe(%w[--version -v] => :__print_version)
+
+      desc "init", "initializes folder structure"
+      def init
+        create_config
+        create_post_require
+        generate_binstub
+      end
+
+      desc "require", "generate the list of files to be required by tapioca"
+      def require
+        Tapioca.silence_warnings do
+          generator.build_requires
+        end
+      end
+
+      desc "todo", "generate the list of unresolved constants"
+      def todo
+        Tapioca.silence_warnings do
+          generator.build_todos
+        end
+      end
+
+      desc "dsl [constant...]", "generate RBIs for dynamic methods"
+      option :generators,
+        type: :array,
+        aliases: ["--gen", "-g"],
+        banner: "generator [generator ...]",
+        desc: "Only run supplied DSL generators"
+      option :verify,
+        type: :boolean,
+        default: false,
+        desc: "Verifies RBIs are up-to-date"
+      def dsl(*constants)
+        Tapioca.silence_warnings do
+          generator.build_dsl(constants, should_verify: options[:verify])
+        end
+      end
+
+      desc "generate [gem...]", "generate RBIs from gems"
+      def generate(*gems)
+        Tapioca.silence_warnings do
+          generator.build_gem_rbis(gems)
+        end
+      end
+
+      desc "sync", "sync RBIs to Gemfile"
+      def sync
+        Tapioca.silence_warnings do
+          generator.sync_rbis_with_gemfile
+        end
+      end
+
+      desc "--version, -v", "show version"
+      def __print_version
+        puts "Tapioca v#{Tapioca::VERSION}"
+      end
+
+      private
+
+      def create_config
+        create_file(Config::SORBET_CONFIG, skip: true) do
+          <<~CONTENT
+            --dir
+            .
+          CONTENT
+        end
+      end
+
+      def create_post_require
+        create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
+          <<~CONTENT
+            # typed: false
+            # frozen_string_literal: true
+
+            # Add your extra requires here
+          CONTENT
+        end
+      end
+
+      def generate_binstub
+        installer = Bundler::Installer.new(Bundler.root, Bundler.definition)
+        spec = Bundler.definition.specs.find { |s| s.name == "tapioca" }
+        installer.generate_bundler_executable_stubs(spec, { force: true })
+      end
+
+      no_commands do
+        def self.exit_on_failure?
+          true
+        end
+
+        def generator
+          current_command = T.must(current_command_chain.first)
+          @generator ||= Generator.new(
+            ConfigBuilder.from_options(current_command, options)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl/active_record_columns.rb

@@ -371,7 +371,6 @@ module Tapioca
           return unless signature
 
           return_type = signature.return_type
-          return if T::Types::Simple === return_type && T::Generic === return_type.raw_type
           return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
 
           return_type.to_s
@@ -382,10 +381,11 @@ module Tapioca
           signature = T::Private::Methods.signature_for_method(column_type.method(method))
           return unless signature
 
-          arg_type = signature.arg_types.first.last
-          return if T::Types::Simple === arg_type && T::Generic === arg_type.raw_type
+          # Arg types is an array [name, type] entries, so we desctructure the type of
+          # first argument to get the first argument type
+          _, first_argument_type = signature.arg_types.first
 
-          arg_type.to_s
+          first_argument_type.to_s
         end
 
         sig { params(type: String).returns(String) }

data/lib/tapioca/compilers/dsl/active_record_scope.rb

@@ -60,7 +60,7 @@ module Tapioca
 
             model.create_module(module_name) do |mod|
               scope_method_names.each do |scope_method|
-                generate_scope_method(scope_method, mod)
+                generate_scope_method(scope_method.to_s, mod)
               end
             end
 

data/lib/tapioca/compilers/dsl/base.rb

@@ -123,7 +123,7 @@ module Tapioca
         # Compile a Ruby method return type into a Parlour type
         sig do
           params(method_def: T.any(Method, UnboundMethod))
-            .returns(String)
+            .returns(T.nilable(String))
         end
         def compile_method_return_type_to_parlour(method_def)
           signature = T::Private::Methods.signature_for_method(method_def)

data/lib/tapioca/compilers/dsl/url_helpers.rb

@@ -89,7 +89,7 @@ module Tapioca
       class UrlHelpers < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def decorate(root, constant)
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
@@ -127,7 +127,7 @@ module Tapioca
 
         private
 
-        sig { params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -143,7 +143,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module), helper_module: Module).void }
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: Module, helper_module: Module).void }
         def create_mixins_for(mod, constant, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -74,9 +74,15 @@ module Tapioca
           compile(symbol, constant)
         end
 
-        sig { params(symbol: String, inherit: T::Boolean).returns(BasicObject).checked(:never) }
-        def resolve_constant(symbol, inherit: false)
-          Object.const_get(symbol, inherit)
+        sig do
+          params(
+            symbol: String,
+            inherit: T::Boolean,
+            namespace: Module
+          ).returns(BasicObject).checked(:never)
+        end
+        def resolve_constant(symbol, inherit: false, namespace: Object)
+          namespace.const_get(symbol, inherit)
         rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
           nil
         end
@@ -142,9 +148,11 @@ module Tapioca
         def compile_object(name, value)
           return if symbol_ignored?(name)
           klass = class_of(value)
-          return if name_of(klass)&.start_with?("T::Types::", "T::Private::")
+          klass_name = name_of(klass)
+
+          return if klass_name&.start_with?("T::Types::", "T::Private::")
 
-          type_name = public_module?(klass) && name_of(klass) || "T.untyped"
+          type_name = public_module?(klass) && klass_name || "T.untyped"
           indented("#{name} = T.let(T.unsafe(nil), #{type_name})")
         end
 
@@ -181,16 +189,17 @@ module Tapioca
 
             [
               compile_module_helpers(constant),
+              compile_type_variables(constant),
               compile_mixins(constant),
               compile_mixes_in_class_methods(constant),
               compile_props(constant),
               compile_enums(constant),
               methods,
-            ].select { |b| b != "" }.join("\n\n")
+            ].select { |b| b && !b.empty? }.join("\n\n")
           end
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_module_helpers(constant)
           abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type)
 
@@ -199,12 +208,14 @@ module Tapioca
           helpers << indented("final!") if T::Private::Final.final_module?(constant)
           helpers << indented("sealed!") if T::Private::Sealed.sealed_module?(constant)
 
+          return if helpers.empty?
+
           helpers.join("\n")
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_props(constant)
-          return "" unless T::Props::ClassMethods === constant
+          return unless T::Props::ClassMethods === constant
 
           constant.props.map do |name, prop|
             method = "prop"
@@ -219,11 +230,11 @@ module Tapioca
           end.join("\n")
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_enums(constant)
-          return "" unless T::Enum > constant
+          return unless T::Enum > constant
 
-          enums = T.cast(constant, T::Enum).values.map do |enum_type|
+          enums = T.unsafe(constant).values.map do |enum_type|
             enum_type.instance_variable_get(:@const_name).to_s
           end
 
@@ -250,11 +261,71 @@ module Tapioca
             compile(symbol, subconstant)
           end.compact
 
-          return "" if output.empty?
+          return if output.empty?
 
           "\n" + output.join("\n\n")
         end
 
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variables(constant)
+          type_variables = compile_type_variable_declarations(constant)
+          singleton_class_type_variables = compile_type_variable_declarations(singleton_class_of(constant))
+
+          return if !type_variables && !singleton_class_type_variables
+
+          type_variables += "\n" if type_variables
+          singleton_class_type_variables += "\n" if singleton_class_type_variables
+
+          [
+            type_variables,
+            singleton_class_type_variables,
+          ].compact.join("\n").rstrip
+        end
+
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variable_declarations(constant)
+          with_indentation_for_constant(constant) do
+            # Try to find the type variables defined on this constant, bail if we can't
+            type_variables = GenericTypeRegistry.lookup_type_variables(constant)
+            return unless type_variables
+
+            # Create a map of subconstants (via their object ids) to their names.
+            # We need this later when we want to lookup the name of the registered type
+            # variable via the value of the type variable constant.
+            subconstant_to_name_lookup = constants_of(constant).map do |constant_name|
+              [
+                object_id_of(resolve_constant(constant_name.to_s, namespace: constant)),
+                constant_name,
+              ]
+            end.to_h
+
+            # Map each type variable to its string representation.
+            #
+            # Each entry of `type_variables` maps an object_id to a String,
+            # and the order they are inserted into the hash is the order they should be
+            # defined in the source code.
+            #
+            # By looping over these entries and then getting the actual constant name
+            # from the `subconstant_to_name_lookup` we defined above, gives us all the
+            # information we need to serialize type variable definitions.
+            type_variable_declarations = type_variables.map do |type_variable_id, serialized_type_variable|
+              constant_name = subconstant_to_name_lookup[type_variable_id]
+              # Here, we know that constant_value will be an instance of
+              # T::Types::CustomTypeVariable, which knows how to serialize
+              # itself to a type_member/type_template
+              indented("#{constant_name} = #{serialized_type_variable}")
+            end.compact
+
+            return if type_variable_declarations.empty?
+
+            [
+              indented("extend T::Generic"),
+              "",
+              *type_variable_declarations,
+            ].compact.join("\n")
+          end
+        end
+
         sig { params(constant: Class).returns(String) }
         def compile_superclass(constant)
           superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
@@ -431,29 +502,19 @@ module Tapioca
           instance_methods = compile_directly_owned_methods(name, constant)
           singleton_methods = compile_directly_owned_methods(name, singleton_class_of(constant))
 
-          return if symbol_ignored?(name) && instance_methods.empty? && singleton_methods.empty?
+          return if symbol_ignored?(name) && !instance_methods && !singleton_methods
 
           [
-            initialize_method || "",
+            initialize_method,
             instance_methods,
             singleton_methods,
-          ].select { |b| b.strip != "" }.join("\n\n")
+          ].select { |b| b && !b.strip.empty? }.join("\n\n")
         end
 
-        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(String) }
+        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(T.nilable(String)) }
         def compile_directly_owned_methods(module_name, mod, for_visibility = [:public, :protected, :private])
-          indent_step = 0
-          preamble = nil
-          postamble = nil
-
-          if mod.singleton_class?
-            indent_step = 1
-            preamble = indented("class << self")
-            postamble = indented("end")
-          end
-
-          methods = with_indentation(indent_step) do
-            method_names_by_visibility(mod)
+          with_indentation_for_constant(mod) do
+            methods = method_names_by_visibility(mod)
               .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
               .flat_map do |visibility, method_list|
                 compiled = method_list.sort!.map do |name|
@@ -470,16 +531,11 @@ module Tapioca
                 compiled
               end
               .compact
-              .join("\n")
-          end
 
-          return "" if methods.strip == ""
+            return if methods.empty?
 
-          [
-            preamble,
-            methods,
-            postamble,
-          ].compact.join("\n")
+            methods.join("\n")
+          end
         end
 
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
@@ -659,6 +715,33 @@ module Tapioca
           @indent -= 2 * step
         end
 
+        sig do
+          params(
+            constant: Module,
+            blk: T.proc
+              .returns(T.nilable(String))
+          )
+            .returns(T.nilable(String))
+        end
+        def with_indentation_for_constant(constant, &blk)
+          step = if constant.singleton_class?
+            1
+          else
+            0
+          end
+
+          result = with_indentation(step, &blk)
+
+          return result unless result
+          return result unless constant.singleton_class?
+
+          [
+            indented("class << self"),
+            result,
+            indented("end"),
+          ].compact.join("\n")
+        end
+
         sig { params(str: String).returns(String) }
         def indented(str)
           " " * @indent + str
@@ -859,12 +942,12 @@ module Tapioca
           nil
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: T::Types::Base).returns(String) }
         def type_of(constant)
           constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
         end
 
-        sig { params(object: Object).returns(T::Boolean).checked(:never) }
+        sig { params(object: BasicObject).returns(Integer).checked(:never) }
         def object_id_of(object)
           Object.instance_method(:object_id).bind(object).call
         end

data/lib/tapioca/config.rb

@@ -8,7 +8,6 @@ module Tapioca
     const(:outdir, String)
     const(:prerequire, T.nilable(String))
     const(:postrequire, String)
-    const(:generate_command, String)
     const(:exclude, T::Array[String])
     const(:typed_overrides, T::Hash[String, String])
     const(:todos_path, String)
@@ -27,6 +26,7 @@ module Tapioca
     TAPIOCA_PATH = T.let("#{SORBET_PATH}/tapioca", String)
     TAPIOCA_CONFIG = T.let("#{TAPIOCA_PATH}/config.yml", String)
 
+    DEFAULT_COMMAND = T.let("bin/tapioca", String)
     DEFAULT_POSTREQUIRE = T.let("#{TAPIOCA_PATH}/require.rb", String)
     DEFAULT_RBIDIR = T.let("#{SORBET_PATH}/rbi", String)
     DEFAULT_DSLDIR = T.let("#{DEFAULT_RBIDIR}/dsl", String)

data/lib/tapioca/config_builder.rb

@@ -10,9 +10,13 @@ module Tapioca
 
       sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Config) }
       def from_options(command, options)
-        Config.from_hash(
-          merge_options(default_options(command), config_options, options)
-        )
+        merged_options = merge_options(default_options(command), config_options, options)
+
+        puts(<<~MSG) if merged_options.include?("generate_command")
+          DEPRECATION: The `-c` and `--cmd` flags will be removed in a future release.
+        MSG
+
+        Config.from_hash(merged_options)
       end
 
       private
@@ -40,14 +44,6 @@ module Tapioca
         DEFAULT_OPTIONS.merge("outdir" => default_outdir)
       end
 
-      sig { returns(String) }
-      def default_command
-        command = File.basename($PROGRAM_NAME)
-        args = ARGV.join(" ")
-
-        "#{command} #{args}".strip
-      end
-
       sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
       def merge_options(*options)
         options.each_with_object({}) do |option, result|
@@ -65,7 +61,6 @@ module Tapioca
     DEFAULT_OPTIONS = T.let({
       "postrequire" => Config::DEFAULT_POSTREQUIRE,
       "outdir" => nil,
-      "generate_command" => default_command,
       "exclude" => [],
       "typed_overrides" => Config::DEFAULT_OVERRIDES,
       "todos_path" => Config::DEFAULT_TODOSPATH,

data/lib/tapioca/generator.rb

@@ -63,7 +63,7 @@ module Tapioca
 
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} require",
         reason: "explicit gem requires",
         strictness: "false"
       )
@@ -76,8 +76,8 @@ module Tapioca
       say("Done", :green)
 
       say("All requires from this application have been written to #{name}.", [:green, :bold])
-      cmd = set_color("tapioca sync", :yellow, :bold)
-      say("Please review changes and commit them, then run #{cmd}.", [:green, :bold])
+      cmd = set_color("#{Config::DEFAULT_COMMAND} sync", :yellow, :bold)
+      say("Please review changes and commit them, then run `#{cmd}`.", [:green, :bold])
     end
 
     sig { void }
@@ -99,7 +99,7 @@ module Tapioca
 
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} todo",
         reason: "unresolved constants",
         strictness: "false"
       )
@@ -116,16 +116,26 @@ module Tapioca
       say("Please review changes and commit them.", [:green, :bold])
     end
 
-    sig { params(requested_constants: T::Array[String]).void }
-    def build_dsl(requested_constants)
+    sig do
+      params(
+        requested_constants: T::Array[String],
+        should_verify: T::Boolean,
+      ).void
+    end
+    def build_dsl(requested_constants, should_verify: false)
       load_application(eager_load: requested_constants.empty?)
       load_dsl_generators
 
-      rbi_files_to_purge = existing_rbi_filenames(requested_constants)
-
-      say("Compiling DSL RBI files...")
+      if should_verify
+        say("Checking for out-of-date RBIs...")
+      else
+        say("Compiling DSL RBI files...")
+      end
       say("")
 
+      outpath = should_verify ? Dir.mktmpdir : config.outpath
+      rbi_files_to_purge = existing_rbi_filenames(requested_constants)
+
       compiler = Compilers::DslCompiler.new(
         requested_constants: constantize(requested_constants),
         requested_generators: config.generators,
@@ -135,24 +145,21 @@ module Tapioca
       )
 
       compiler.run do |constant, contents|
-        filename = compile_dsl_rbi(constant, contents)
+        filename = compile_dsl_rbi(constant, contents, outpath: Pathname.new(outpath))
         rbi_files_to_purge.delete(filename) if filename
       end
+      say("")
 
-      unless rbi_files_to_purge.empty?
-        say("")
-        say("Removing stale RBI files...")
-
-        rbi_files_to_purge.sort.each do |filename|
-          remove(filename)
-        end
-      end
+      if should_verify
+        perform_dsl_verification(outpath)
+      else
+        purge_stale_dsl_rbi_files(rbi_files_to_purge)
 
-      say("")
-      say("Done", :green)
+        say("Done", :green)
 
-      say("All operations performed in working directory.", [:green, :bold])
-      say("Please review changes and commit them.", [:green, :bold])
+        say("All operations performed in working directory.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
     end
 
     sig { void }
@@ -218,7 +225,7 @@ module Tapioca
       say_error("If you populated ", :yellow)
       say_error("#{file} ", :bold, :blue)
       say_error("with ", :yellow)
-      say_error("tapioca require", :bold, :blue)
+      say_error("`#{Config::DEFAULT_COMMAND} require`", :bold, :blue)
       say_error("you should probably review it and remove the faulty line.", :yellow)
     end
 
@@ -286,10 +293,10 @@ module Tapioca
       constant_map.values
     end
 
-    sig { params(requested_constants: T::Array[String]).returns(T::Set[Pathname]) }
-    def existing_rbi_filenames(requested_constants)
+    sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+    def existing_rbi_filenames(requested_constants, path: config.outpath)
       filenames = if requested_constants.empty?
-        Pathname.glob(config.outpath / "**/*.rbi")
+        Pathname.glob(path / "**/*.rbi")
       else
         requested_constants.map do |constant_name|
           dsl_rbi_filename(constant_name)
@@ -477,7 +484,7 @@ module Tapioca
       rbi_body_content = compiler.compile(gem)
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} sync",
         reason: "types exported from the `#{gem.name}` gem",
         strictness: strictness
       )
@@ -494,23 +501,22 @@ module Tapioca
       end
       File.write(filename.to_s, content)
 
-      Pathname.glob((config.outpath / "#{gem.name}@*.rbi").to_s) do |file|
+      T.unsafe(Pathname).glob((config.outpath / "#{gem.name}@*.rbi").to_s) do |file|
         remove(file) unless file.basename.to_s == gem.rbi_file_name
       end
     end
 
-    sig { params(constant: Module, contents: String).returns(T.nilable(Pathname)) }
-    def compile_dsl_rbi(constant, contents)
+    sig { params(constant: Module, contents: String, outpath: Pathname).returns(T.nilable(Pathname)) }
+    def compile_dsl_rbi(constant, contents, outpath: config.outpath)
       return if contents.nil?
 
-      command = format(config.generate_command, constant.name)
       constant_name = Module.instance_method(:name).bind(constant).call
       rbi_name = constant_name.underscore + ".rbi"
-      filename = config.outpath / rbi_name
+      filename = outpath / rbi_name
 
       out = String.new
       out << rbi_header(
-        command,
+        "#{Config::DEFAULT_COMMAND} dsl #{constant_name}",
         reason: "dynamic methods in `#{constant.name}`"
       )
       out << contents
@@ -522,5 +528,53 @@ module Tapioca
 
       filename
     end
+
+    sig { params(tmp_dir: Pathname).returns(T.nilable(String)) }
+    def verify_dsl_rbi(tmp_dir:)
+      existing_rbis = existing_rbi_filenames([]).sort
+      new_rbis = existing_rbi_filenames([], path: tmp_dir).grep_v(/gem|shim/).sort
+
+      return "New file(s) introduced." if existing_rbis.length != new_rbis.length
+
+      desynced_files = []
+
+      (0..existing_rbis.length - 1).each do |i|
+        desynced_files << new_rbis[i] unless FileUtils.identical?(existing_rbis[i], new_rbis[i])
+      end
+
+      unless desynced_files.empty?
+        filenames = desynced_files.map { |f| f.to_s.sub!(tmp_dir.to_s, "sorbet/rbi/dsl") }.join("\n  - ")
+
+        return "File(s) updated:\n  - #{filenames}"
+      end
+
+      nil
+    end
+
+    sig { params(dir: String).void }
+    def perform_dsl_verification(dir)
+      if (error = verify_dsl_rbi(tmp_dir: Pathname.new(dir)))
+        say("RBI files are out-of-date, please run `#{Config::DEFAULT_COMMAND} dsl` to update.")
+        say("Reason: ", [:red])
+        say(error)
+        exit(1)
+      else
+        say("Nothing to do, all RBIs are up-to-date.")
+      end
+    ensure
+      FileUtils.remove_entry(dir)
+    end
+
+    sig { params(files: T::Set[Pathname]).void }
+    def purge_stale_dsl_rbi_files(files)
+      if files.any?
+        say("Removing stale RBI files...")
+
+        files.sort.each do |filename|
+          remove(filename)
+        end
+        say("")
+      end
+    end
   end
 end

data/lib/tapioca/generic_type_registry.rb

@@ -0,0 +1,170 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  # This class is responsible for storing and looking up information related to generic types.
+  #
+  # The class stores 2 different kinds of data, in two separate lookup tables:
+  #   1. a lookup of generic type instances by name: `@generic_instances`
+  #   2. a lookup of type variable serializer by constant and type variable
+  #      instance: `@type_variables`
+  #
+  # By storing the above data, we can cheaply query each constant against this registry
+  # to see if it declares any generic type variables. This becomes a simple lookup in the
+  # `@type_variables` hash table with the given constant.
+  #
+  # If there is no entry, then we can cheaply know that we can skip generic type
+  # information generation for this type.
+  #
+  # On the other hand, if we get a result, then the result will be a hash of type
+  # variable to type variable serializers. This allows us to associate type variables
+  # to the constant names that represent them, easily.
+  module GenericTypeRegistry
+    @generic_instances = T.let(
+      {},
+      T::Hash[String, Module]
+    )
+
+    @type_variables = T.let(
+      {},
+      T::Hash[Integer, T::Hash[Integer, String]]
+    )
+
+    class << self
+      extend T::Sig
+
+      # This method is responsible for building the name of the instantiated concrete type
+      # and cloning the given constant so that we can return a type that is the same
+      # as the current type but is a different instance and has a different name method.
+      #
+      # We cache those cloned instances by their name in `@generic_instances`, so that
+      # we don't keep instantiating a new type every single time it is referenced.
+      # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+      # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+      # 2 hash lookups (for the other two `Foo[Integer]`s).
+      #
+      # This method returns the created or cached clone of the constant.
+      sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
+      def register_type(constant, types)
+        # Build the name of the instantiated generic type,
+        # something like `"Foo[X, Y, Z]"`
+        type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
+        name = "#{name_of(constant)}[#{type_list}]"
+
+        # Create a clone of the constant with an overridden `name`
+        # method that returns the name we constructed above.
+        #
+        # Also, we try to memoize the clone based on the name, so that
+        # we don't have to keep recreating clones all the time.
+        @generic_instances[name] ||= constant.clone.tap do |clone|
+          clone.define_singleton_method(:name) { name }
+        end
+      end
+
+      sig do
+        params(
+          constant: T.untyped,
+          type_member: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      def register_type_member(constant, type_member, fixed, lower, upper)
+        register_type_variable(constant, :type_member, type_member, fixed, lower, upper)
+      end
+
+      sig do
+        params(
+          constant: T.untyped,
+          type_template: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      def register_type_template(constant, type_template, fixed, lower, upper)
+        register_type_variable(constant, :type_template, type_template, fixed, lower, upper)
+      end
+
+      sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
+      def lookup_type_variables(constant)
+        @type_variables[object_id_of(constant)]
+      end
+
+      private
+
+      # This method is called from intercepted calls to `type_member` and `type_template`.
+      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+      #
+      # This method creates a `String` with that data and stores it in the
+      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+      #
+      # Finally, the original `type_variable` is returned from this method, so that the caller
+      # can return it from the original methods as well.
+      sig do
+        params(
+          constant: T.untyped,
+          type_variable_type: T.enum([:type_member, :type_template]),
+          type_variable: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      # rubocop:disable Metrics/ParameterLists
+      def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper)
+        # rubocop:enable Metrics/ParameterLists
+        type_variables = lookup_or_initialize_type_variables(constant)
+
+        type_variables[object_id_of(type_variable)] = serialize_type_variable(
+          type_variable_type,
+          type_variable.variance,
+          fixed,
+          lower,
+          upper
+        )
+      end
+
+      sig { params(constant: Module).returns(T::Hash[Integer, String]) }
+      def lookup_or_initialize_type_variables(constant)
+        @type_variables[object_id_of(constant)] ||= {}
+      end
+
+      sig do
+        params(
+          type_variable_type: Symbol,
+          variance: Symbol,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).returns(String)
+      end
+      def serialize_type_variable(type_variable_type, variance, fixed, lower, upper)
+        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 = T.let(type_variable_type.to_s, String)
+        serialized += "(#{parameters})" unless parameters.empty?
+
+        serialized
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def name_of(constant)
+        Module.instance_method(:name).bind(constant).call
+      end
+
+      sig { params(object: BasicObject).returns(Integer) }
+      def object_id_of(object)
+        Object.instance_method(:object_id).bind(object).call
+      end
+    end
+  end
+end

data/lib/tapioca/internal.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca"
+require "tapioca/loader"
+require "tapioca/constant_locator"
+require "tapioca/generic_type_registry"
+require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/config"
+require "tapioca/config_builder"
+require "tapioca/generator"
+require "tapioca/cli"
+require "tapioca/cli/main"
+require "tapioca/gemfile"
+require "tapioca/compilers/sorbet"
+require "tapioca/compilers/requires_compiler"
+require "tapioca/compilers/symbol_table_compiler"
+require "tapioca/compilers/symbol_table/symbol_generator"
+require "tapioca/compilers/symbol_table/symbol_loader"
+require "tapioca/compilers/todos_compiler"
+require "tapioca/compilers/dsl_compiler"

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -0,0 +1,66 @@
+# typed: true
+# frozen_string_literal: true
+
+require "tapioca/sorbet_ext/name_patch"
+
+module T
+  module Generic
+    # This module intercepts calls to generic type instantiations and type variable definitions.
+    # Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
+    # to look up the original call details when we are trying to do code generation.
+    #
+    # We are interested in the data of the `[]`, `type_member` and `type_template` calls which
+    # are all needed to generate good generic information at runtime.
+    module TypeStoragePatch
+      def [](*types)
+        # `T::Generic#[]` just returns `self`, so let's call and store it.
+        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)
+      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 = super
+        Tapioca::GenericTypeRegistry.register_type_member(self, type_member, fixed, lower, upper)
+        type_member
+      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 = super
+        Tapioca::GenericTypeRegistry.register_type_template(self, type_template, fixed, lower, upper)
+        type_template
+      end
+    end
+
+    prepend TypeStoragePatch
+  end
+
+  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
+        def name
+          if T::Generic === @raw_type
+            # for types that are generic, use the name
+            # returned by the "name" method of this instance
+            @name ||= T.unsafe(@raw_type).name.freeze
+          else
+            # otherwise, fallback to the normal name lookup
+            super
+          end
+        end
+      end
+
+      prepend GenericNamePatch
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -0,0 +1,16 @@
+# typed: true
+# frozen_string_literal: true
+
+module T
+  module Types
+    class Simple
+      module NamePatch
+        def name
+          @name ||= Module.instance_method(:name).bind(@raw_type).call.freeze
+        end
+      end
+
+      prepend NamePatch
+    end
+  end
+end

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.17
+  version: 0.4.18
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2021-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,6 +125,7 @@ files:
 - exe/tapioca
 - lib/tapioca.rb
 - lib/tapioca/cli.rb
+- lib/tapioca/cli/main.rb
 - lib/tapioca/compilers/dsl/action_controller_helpers.rb
 - lib/tapioca/compilers/dsl/action_mailer.rb
 - lib/tapioca/compilers/dsl/active_record_associations.rb
@@ -155,7 +156,11 @@ files:
 - lib/tapioca/core_ext/class.rb
 - lib/tapioca/gemfile.rb
 - lib/tapioca/generator.rb
+- lib/tapioca/generic_type_registry.rb
+- lib/tapioca/internal.rb
 - lib/tapioca/loader.rb
+- lib/tapioca/sorbet_ext/generic_name_patch.rb
+- lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/version.rb
 homepage: https://github.com/Shopify/tapioca
 licenses: