tapioca 0.6.4 → 0.7.0

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

@@ -7,15 +7,18 @@ module Tapioca
   module Helpers
     module Test
       module Template
-        include Kernel
         extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { Kernel }
+
         ERB_SUPPORTS_KVARGS = T.let(
           ::ERB.instance_method(:initialize).parameters.assoc(:key), T.nilable([Symbol, Symbol])
         )
 
         sig { params(selector: String).returns(T::Boolean) }
         def ruby_version(selector)
-          Gem::Requirement.new(selector).satisfied_by?(Gem::Version.new(RUBY_VERSION))
+          ::Gem::Requirement.new(selector).satisfied_by?(::Gem::Version.new(RUBY_VERSION))
         end
 
         sig { params(src: String).returns(String) }
@@ -28,6 +31,14 @@ module Tapioca
 
           erb.result(binding)
         end
+
+        sig { params(str: String, indent: Integer).returns(String) }
+        def indented(str, indent)
+          str.lines.map! do |line|
+            next line if line.chomp.empty?
+            (" " * indent) + line
+          end.join
+        end
       end
     end
   end

data/lib/tapioca/internal.rb

@@ -2,20 +2,27 @@
 # frozen_string_literal: true
 
 require "tapioca"
-require "tapioca/loader"
+require "tapioca/runtime/reflection"
+require "tapioca/runtime/trackers"
+require "tapioca/runtime/dynamic_mixin_compiler"
+require "tapioca/runtime/loader"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/fixed_hash_patch"
-require "tapioca/generic_type_registry"
+require "tapioca/runtime/generic_type_registry"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
-require "tapioca/generators"
+require "tapioca/helpers/rbi_helper"
+require "tapioca/helpers/shims_helper"
+require "tapioca/helpers/sorbet_helper"
+require "tapioca/commands"
 require "tapioca/cli"
 require "tapioca/gemfile"
 require "tapioca/executor"
-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/static/symbol_table_parser"
+require "tapioca/static/symbol_loader"
+require "tapioca/gem/events"
+require "tapioca/gem/listeners"
+require "tapioca/gem/pipeline"
+require "tapioca/dsl/compiler"
+require "tapioca/dsl/pipeline"
+require "tapioca/static/requires_compiler"

data/lib/tapioca/rbi_ext/model.rb

@@ -1,59 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "rbi"
-
 module RBI
-  class File
-    extend T::Sig
-
-    sig { returns(String) }
-    def transformed_string
-      transform_rbi!
-      string
-    end
-
-    sig { void }
-    def transform_rbi!
-      root.nest_singleton_methods!
-      root.nest_non_public_methods!
-      root.group_nodes!
-      root.sort_nodes!
-    end
-
-    sig do
-      params(
-        command: String,
-        reason: T.nilable(String),
-        display_heading: T::Boolean
-      ).void
-    end
-    def set_file_header(command, reason: nil, display_heading: true)
-      return unless display_heading
-      comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
-      comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
-      comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
-    end
-
-    sig { void }
-    def set_empty_body_content
-      comments << RBI::BlankLine.new unless comments.empty?
-      comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
-      comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
-    end
-
-    sig { returns(T::Boolean) }
-    def empty?
-      root.empty?
-    end
-  end
-
   class Tree
     extend T::Sig
 
     sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).void }
     def create_path(constant, &block)
-      constant_name = Tapioca::Reflection.name_of(constant)
+      constant_name = Tapioca::Runtime::Reflection.name_of(constant)
       raise "given constant does not have a name" unless constant_name
 
       instance = ::Module.const_get(constant_name)
@@ -137,7 +91,7 @@ module RBI
 
     SPECIAL_METHOD_NAMES = T.let(
       ["!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^", "<", "<=", "=>", ">", ">=",
-       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"].freeze,
+       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",].freeze,
       T::Array[String]
     )
 

data/lib/tapioca/rbi_formatter.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  class RBIFormatter < RBI::Formatter
+    extend T::Sig
+
+    sig do
+      params(
+        file: RBI::File,
+        command: String,
+        reason: T.nilable(String)
+      ).void
+    end
+    def write_header!(file, command, reason: nil)
+      file.comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
+      file.comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
+      file.comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+    end
+
+    sig { params(file: RBI::File).void }
+    def write_empty_body_comment!(file)
+      file.comments << RBI::BlankLine.new unless file.comments.empty?
+      file.comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
+      file.comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
+    end
+  end
+
+  DEFAULT_RBI_FORMATTER = T.let(RBIFormatter.new(
+    add_sig_templates: false,
+    group_nodes: true,
+    max_line_length: nil,
+    nest_singleton_methods: true,
+    nest_non_public_methods: true,
+    sort_nodes: true
+  ), RBIFormatter)
+end

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -0,0 +1,227 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    class DynamicMixinCompiler
+      extend T::Sig
+      include Runtime::Reflection
+
+      sig { returns(T::Array[Module]) }
+      attr_reader :dynamic_extends, :dynamic_includes
+
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :class_attribute_readers, :class_attribute_writers, :class_attribute_predicates
+
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
+
+      sig { params(constant: Module).void }
+      def initialize(constant)
+        @constant = constant
+        mixins_from_modules = {}.compare_by_identity
+        class_attribute_readers = T.let([], T::Array[Symbol])
+        class_attribute_writers = T.let([], T::Array[Symbol])
+        class_attribute_predicates = T.let([], T::Array[Symbol])
+
+        instance_attribute_readers = T.let([], T::Array[Symbol])
+        instance_attribute_writers = T.let([], T::Array[Symbol])
+        instance_attribute_predicates = T.let([], T::Array[Symbol])
+
+        Class.new do
+          # Override the `self.include` method
+          define_singleton_method(:include) do |mod|
+            # Take a snapshot of the list of singleton class ancestors
+            # before the actual include
+            before = singleton_class.ancestors
+            # Call the actual `include` method with the supplied module
+            super(mod).tap do
+              # Take a snapshot of the list of singleton class ancestors
+              # after the actual include
+              after = singleton_class.ancestors
+              # The difference is the modules that are added to the list
+              # of ancestors of the singleton class. Those are all the
+              # modules that were `extend`ed due to the `include` call.
+              #
+              # We record those modules on our lookup table keyed by
+              # the included module with the values being all the modules
+              # that that module pulls into the singleton class.
+              #
+              # We need to reverse the order, since the extend order should
+              # be the inverse of the ancestor order. That is, earlier
+              # extended modules would be later in the ancestor chain.
+              mixins_from_modules[mod] = (after - before).reverse!
+            end
+          rescue Exception # rubocop:disable Lint/RescueException
+            # this is a best effort, bail if we can't perform this
+          end
+
+          define_singleton_method(:class_attribute) do |*attrs, **kwargs|
+            class_attribute_readers.concat(attrs)
+            class_attribute_writers.concat(attrs)
+
+            instance_predicate = kwargs.fetch(:instance_predicate, true)
+            instance_accessor = kwargs.fetch(:instance_accessor, true)
+            instance_reader = kwargs.fetch(:instance_reader, instance_accessor)
+            instance_writer = kwargs.fetch(:instance_writer, instance_accessor)
+
+            if instance_reader
+              instance_attribute_readers.concat(attrs)
+            end
+
+            if instance_writer
+              instance_attribute_writers.concat(attrs)
+            end
+
+            if instance_predicate
+              class_attribute_predicates.concat(attrs)
+
+              if instance_reader
+                instance_attribute_predicates.concat(attrs)
+              end
+            end
+
+            super(*attrs, **kwargs) if defined?(super)
+          end
+
+          # rubocop:disable Style/MissingRespondToMissing
+          T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+          def method_missing(symbol, *args)
+            # We need this here so that we can handle any random instance
+            # method calls on the fake including class that may be done by
+            # the included module during the `self.included` hook.
+          end
+
+          class << self
+            extend T::Sig
+
+            T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+            def method_missing(symbol, *args)
+              # Similarly, we need this here so that we can handle any
+              # random class method calls on the fake including class
+              # that may be done by the included module during the
+              # `self.included` hook.
+            end
+          end
+          # rubocop:enable Style/MissingRespondToMissing
+        end.include(constant)
+
+        # The value that corresponds to the original included constant
+        # is the list of all dynamically extended modules because of that
+        # constant. We grab that value by deleting the key for the original
+        # constant.
+        @dynamic_extends = T.let(mixins_from_modules.delete(constant) || [], T::Array[Module])
+
+        # Since we deleted the original constant from the list of keys, all
+        # the keys that remain are the ones that are dynamically included modules
+        # during the include of the original constant.
+        @dynamic_includes = T.let(mixins_from_modules.keys, T::Array[Module])
+
+        @class_attribute_readers = T.let(class_attribute_readers, T::Array[Symbol])
+        @class_attribute_writers = T.let(class_attribute_writers, T::Array[Symbol])
+        @class_attribute_predicates = T.let(class_attribute_predicates, T::Array[Symbol])
+
+        @instance_attribute_readers = T.let(instance_attribute_readers, T::Array[Symbol])
+        @instance_attribute_writers = T.let(instance_attribute_writers, T::Array[Symbol])
+        @instance_attribute_predicates = T.let(instance_attribute_predicates, T::Array[Symbol])
+      end
+
+      sig { returns(T::Boolean) }
+      def empty_attributes?
+        @class_attribute_readers.empty? && @class_attribute_writers.empty?
+      end
+
+      sig { params(tree: RBI::Tree).void }
+      def compile_class_attributes(tree)
+        return if empty_attributes?
+
+        # Create a synthetic module to hold the generated class methods
+        tree << RBI::Module.new("GeneratedClassMethods") do |mod|
+          class_attribute_readers.each do |attribute|
+            mod << RBI::Method.new(attribute.to_s)
+          end
+
+          class_attribute_writers.each do |attribute|
+            mod << RBI::Method.new("#{attribute}=") do |method|
+              method << RBI::Param.new("value")
+            end
+          end
+
+          class_attribute_predicates.each do |attribute|
+            mod << RBI::Method.new("#{attribute}?")
+          end
+        end
+
+        # Create a synthetic module to hold the generated instance methods
+        tree << RBI::Module.new("GeneratedInstanceMethods") do |mod|
+          instance_attribute_readers.each do |attribute|
+            mod << RBI::Method.new(attribute.to_s)
+          end
+
+          instance_attribute_writers.each do |attribute|
+            mod << RBI::Method.new("#{attribute}=") do |method|
+              method << RBI::Param.new("value")
+            end
+          end
+
+          instance_attribute_predicates.each do |attribute|
+            mod << RBI::Method.new("#{attribute}?")
+          end
+        end
+
+        # Add a mixes_in_class_methods and include for the generated modules
+        tree << RBI::MixesInClassMethods.new("GeneratedClassMethods")
+        tree << RBI::Include.new("GeneratedInstanceMethods")
+      end
+
+      sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+      def compile_mixes_in_class_methods(tree)
+        includes = dynamic_includes.map do |mod|
+          qname = qualified_name_of(mod)
+
+          next if qname.nil? || qname.empty?
+          next if filtered_mixin?(qname)
+
+          tree << RBI::Include.new(qname)
+
+          mod
+        end.compact
+
+        # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
+        # constant itself
+        mixed_in_class_methods = dynamic_extends.select do |mod|
+          mod != @constant && !module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+        end
+
+        return [[], []] if mixed_in_class_methods.empty?
+
+        mixed_in_class_methods.each do |mod|
+          qualified_name = qualified_name_of(mod)
+
+          next if qualified_name.nil? || qualified_name.empty?
+          next if filtered_mixin?(qualified_name)
+
+          tree << RBI::MixesInClassMethods.new(qualified_name)
+        end
+
+        [mixed_in_class_methods, includes]
+      rescue
+        [[], []] # silence errors
+      end
+
+      sig { params(mod: Module, dynamic_extends: T::Array[Module]).returns(T::Boolean) }
+      def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+        dynamic_extends.any? do |dynamic_extend|
+          mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)
+        end
+      end
+
+      sig { params(qualified_mixin_name: String).returns(T::Boolean) }
+      def filtered_mixin?(qualified_mixin_name)
+        # filter T:: namespace mixins that aren't T::Props
+        # T::Props and subconstants have semantic value
+        qualified_mixin_name.start_with?("::T::") && !qualified_mixin_name.start_with?("::T::Props")
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -0,0 +1,166 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    # 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(
+        {}.compare_by_identity,
+        T::Hash[Module, T::Array[TypeVariableModule]]
+      )
+
+      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 = "#{Reflection.name_of(constant)}[#{type_list}]"
+
+          # Create a generic type with an overridden `name`
+          # method that returns the name we constructed above.
+          #
+          # Also, we try to memoize the generic type based on the name, so that
+          # we don't have to keep recreating them all the time.
+          @generic_instances[name] ||= create_generic_type(constant, name)
+        end
+
+        sig { params(instance: Object).returns(T::Boolean) }
+        def generic_type_instance?(instance)
+          @generic_instances.values.any? { |generic_type| generic_type === instance }
+        end
+
+        sig { params(constant: Module).returns(T.nilable(T::Array[TypeVariableModule])) }
+        def lookup_type_variables(constant)
+          @type_variables[constant]
+        end
+
+        # 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: TypeVariableModule,
+          ).void
+        end
+        def register_type_variable(constant, type_variable)
+          type_variables = lookup_or_initialize_type_variables(constant)
+
+          type_variables << type_variable
+        end
+
+        private
+
+        sig { params(constant: Module, name: String).returns(Module) }
+        def create_generic_type(constant, name)
+          generic_type = case constant
+          when Class
+            # For classes, we want to create a subclass, so that an instance of
+            # the generic class `Foo[Bar]` is still a `Foo`. That is:
+            # `Foo[Bar].new.is_a?(Foo)` should be true, which isn't the case
+            # if we just clone the class. But subclassing works just fine.
+            create_safe_subclass(constant)
+          else
+            # This can only be a module and it is fine to just clone modules
+            # since they can't have instances and will not have `is_a?` relationships.
+            # Moreover, we never `include`/`extend` any generic modules into the
+            # ancestor tree, so this doesn't become a problem with checking the
+            # instance of a class being `is_a?` of a module type.
+            constant.clone
+          end
+
+          # Let's set the `name` method to return the proper generic name
+          generic_type.define_singleton_method(:name) { name }
+
+          # We need to define a `<=` method on the cloned constant, so that Sorbet
+          # can do covariance/contravariance checks on the type variables.
+          #
+          # Normally, we would be doing proper covariance/contravariance checks here, but
+          # that is not necessary, since we are not implementing a runtime type checker
+          # here. It is just enough for the checks to pass, so that we can serialize the
+          # signatures, assuming the sigs were well-formed.
+          #
+          # So we act like all subtype checks pass.
+          generic_type.define_singleton_method(:<=) { |_| true }
+
+          # Return the generic type we created
+          generic_type
+        end
+
+        sig { params(constant: Class).returns(Class) }
+        def create_safe_subclass(constant)
+          # Lookup the "inherited" class method
+          inherited_method = constant.method(:inherited)
+          # and the module that defines it
+          owner = inherited_method.owner
+
+          # If no one has overriden the inherited method yet, just subclass
+          return Class.new(constant) if Class == owner
+
+          begin
+            # Otherwise, some inherited method could be preventing us
+            # from creating subclasses, so let's override it and rescue
+            owner.send(:define_method, :inherited) do |s|
+              inherited_method.call(s)
+            rescue
+              # Ignoring errors
+            end
+
+            # return a subclass
+            Class.new(constant)
+          ensure
+            # Reinstate the original inherited method back.
+            owner.send(:define_method, :inherited, inherited_method)
+          end
+        end
+
+        sig { params(constant: Module).returns(T::Array[TypeVariableModule]) }
+        def lookup_or_initialize_type_variables(constant)
+          @type_variables[constant] ||= []
+        end
+      end
+    end
+  end
+end