tapioca 0.6.4 → 0.7.2

data/lib/tapioca/{compilers/dsl → dsl/helpers}/param_helper.rb

@@ -1,11 +1,14 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/helpers/signatures_helper"
+
 module Tapioca
-  module Compilers
-    module Dsl
+  module Dsl
+    module Helpers
       module ParamHelper
         extend T::Sig
+        include SignaturesHelper
 
         sig { params(name: String, type: String).returns(RBI::TypedParam) }
         def create_param(name, type:)
@@ -44,7 +47,7 @@ module Tapioca
 
         sig { params(param: RBI::Param, type: String).returns(RBI::TypedParam) }
         def create_typed_param(param, type)
-          RBI::TypedParam.new(param: param, type: type)
+          RBI::TypedParam.new(param: param, type: sanitize_signature_types(type))
         end
       end
     end

data/lib/tapioca/dsl/pipeline.rb

@@ -0,0 +1,169 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/dsl/compilers"
+
+module Tapioca
+  module Dsl
+    class Pipeline
+      extend T::Sig
+
+      sig { returns(T::Enumerable[T.class_of(Compiler)]) }
+      attr_reader :compilers
+
+      sig { returns(T::Array[Module]) }
+      attr_reader :requested_constants
+
+      sig { returns(T.proc.params(error: String).void) }
+      attr_reader :error_handler
+
+      sig { returns(T::Array[String]) }
+      attr_reader :errors
+
+      sig do
+        params(
+          requested_constants: T::Array[Module],
+          requested_compilers: T::Array[T.class_of(Compiler)],
+          excluded_compilers: T::Array[T.class_of(Compiler)],
+          error_handler: T.proc.params(error: String).void,
+          number_of_workers: T.nilable(Integer),
+        ).void
+      end
+      def initialize(
+        requested_constants:,
+        requested_compilers: [],
+        excluded_compilers: [],
+        error_handler: $stderr.method(:puts).to_proc,
+        number_of_workers: nil
+      )
+        @compilers = T.let(
+          gather_compilers(requested_compilers, excluded_compilers),
+          T::Enumerable[T.class_of(Compiler)]
+        )
+        @requested_constants = requested_constants
+        @error_handler = error_handler
+        @number_of_workers = number_of_workers
+        @errors = T.let([], T::Array[String])
+      end
+
+      sig do
+        type_parameters(:T).params(
+          blk: T.proc.params(constant: Module, rbi: RBI::File).returns(T.type_parameter(:T))
+        ).returns(T::Array[T.type_parameter(:T)])
+      end
+      def run(&blk)
+        constants_to_process = gather_constants(requested_constants)
+          .select { |c| Module === c } # Filter value constants out
+          .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
+
+        if constants_to_process.empty?
+          report_error(<<~ERROR)
+            No classes/modules can be matched for RBI generation.
+            Please check that the requested classes/modules include processable DSL methods.
+          ERROR
+        end
+
+        result = Executor.new(
+          constants_to_process,
+          number_of_workers: @number_of_workers
+        ).run_in_parallel do |constant|
+          rbi = rbi_for_constant(constant)
+          next if rbi.nil?
+
+          blk.call(constant, rbi)
+        end
+
+        errors.each do |msg|
+          report_error(msg)
+        end
+
+        result.compact
+      end
+
+      sig { params(error: String).void }
+      def add_error(error)
+        @errors << error
+      end
+
+      sig { params(compiler_name: String).returns(T::Boolean) }
+      def compiler_enabled?(compiler_name)
+        potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
+
+        @compilers.any? do |compiler|
+          potential_names.any?(compiler.name)
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          requested_compilers: T::Array[T.class_of(Compiler)],
+          excluded_compilers: T::Array[T.class_of(Compiler)]
+        ).returns(T::Enumerable[T.class_of(Compiler)])
+      end
+      def gather_compilers(requested_compilers, excluded_compilers)
+        Runtime::Reflection.descendants_of(Compiler).select do |klass|
+          (requested_compilers.empty? || requested_compilers.include?(klass)) &&
+            !excluded_compilers.include?(klass)
+        end.sort_by { |klass| T.must(klass.name) }
+      end
+
+      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
+      def gather_constants(requested_constants)
+        constants = compilers.map(&:processable_constants).reduce(Set.new, :union)
+        constants = filter_anonymous_and_reloaded_constants(constants)
+
+        constants &= requested_constants unless requested_constants.empty?
+        constants
+      end
+
+      sig { params(constants: T::Set[Module]).returns(T::Set[Module]) }
+      def filter_anonymous_and_reloaded_constants(constants)
+        # Group constants by their names
+        constants_by_name = constants
+          .group_by { |c| T.must(Runtime::Reflection.name_of(c)) }
+          .select { |name, _| !name.nil? }
+
+        # Find the constants that have been reloaded
+        reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
+
+        unless reloaded_constants.empty?
+          reloaded_constant_names = reloaded_constants.map { |name| "`#{name}`" }.join(", ")
+
+          $stderr.puts("WARNING: Multiple constants with the same name: #{reloaded_constant_names}")
+          $stderr.puts("Make sure some object is not holding onto these constants during an app reload.")
+        end
+
+        # Look up all the constants back from their names. The resulting constant set will be the
+        # set of constants that are actually in memory with those names.
+        constants_by_name
+          .keys
+          .map { |name| T.cast(Runtime::Reflection.constantize(name), Module) }
+          .to_set
+      end
+
+      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
+      def rbi_for_constant(constant)
+        file = RBI::File.new(strictness: "true")
+
+        compilers.each do |compiler_class|
+          next unless compiler_class.handles?(constant)
+          compiler = compiler_class.new(self, file.root, constant)
+          compiler.decorate
+        end
+
+        return if file.root.empty?
+
+        file
+      end
+
+      sig { params(error: String).returns(T.noreturn) }
+      def report_error(error)
+        handler = error_handler
+        handler.call(error)
+        exit(1)
+      end
+    end
+  end
+end

data/lib/tapioca/gem/events.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+
+module Tapioca
+  module Gem
+    class Event
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class SymbolFound < Event
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { params(symbol: String).void }
+      def initialize(symbol)
+        super()
+        @symbol = symbol
+      end
+    end
+
+    class ConstantFound < Event
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { returns(BasicObject).checked(:never) }
+      attr_reader :constant
+
+      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      def initialize(symbol, constant)
+        super()
+        @symbol = symbol
+        @constant = constant
+      end
+    end
+
+    class NodeAdded < Event
+      extend T::Helpers
+      extend T::Sig
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { returns(Module).checked(:never) }
+      attr_reader :constant
+
+      sig { params(symbol: String, constant: Module).void.checked(:never) }
+      def initialize(symbol, constant)
+        super()
+        @symbol = symbol
+        @constant = constant
+      end
+    end
+
+    class ConstNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Const) }
+      attr_reader :node
+
+      sig { params(symbol: String, constant: Module, node: RBI::Const).void.checked(:never) }
+      def initialize(symbol, constant, node)
+        super(symbol, constant)
+        @node = node
+      end
+    end
+
+    class ScopeNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Scope) }
+      attr_reader :node
+
+      sig { params(symbol: String, constant: Module, node: RBI::Scope).void.checked(:never) }
+      def initialize(symbol, constant, node)
+        super(symbol, constant)
+        @node = node
+      end
+    end
+
+    class MethodNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Method) }
+      attr_reader :node
+
+      sig { returns(T.untyped) }
+      attr_reader :signature
+
+      sig { returns(T::Array[[Symbol, String]]) }
+      attr_reader :parameters
+
+      sig do
+        params(
+          symbol: String,
+          constant: Module,
+          node: RBI::Method,
+          signature: T.untyped,
+          parameters: T::Array[[Symbol, String]]
+        ).void.checked(:never)
+      end
+      def initialize(symbol, constant, node, signature, parameters)
+        super(symbol, constant)
+        @node = node
+        @signature = signature
+        @parameters = parameters
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/base.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { params(pipeline: Pipeline).void }
+        def initialize(pipeline)
+          @pipeline = pipeline
+        end
+
+        sig { params(event: NodeAdded).void }
+        def dispatch(event)
+          case event
+          when ConstNodeAdded
+            on_const(event)
+          when ScopeNodeAdded
+            on_scope(event)
+          when MethodNodeAdded
+            on_method(event)
+          else
+            raise "Unsupported event #{event.class}"
+          end
+        end
+
+        private
+
+        sig { params(event: ConstNodeAdded).void }
+        def on_const(event)
+        end
+
+        sig { params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+        end
+
+        sig { params(event: MethodNodeAdded).void }
+        def on_method(event)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/dynamic_mixins.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class DynamicMixins < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          return if constant.is_a?(Class)
+
+          node = event.node
+          mixin_compiler = Runtime::DynamicMixinCompiler.new(constant)
+          mixin_compiler.compile_class_attributes(node)
+          dynamic_extends, dynamic_includes = mixin_compiler.compile_mixes_in_class_methods(node)
+
+          (dynamic_includes + dynamic_extends).each do |mod|
+            name = @pipeline.name_of(mod)
+            @pipeline.push_symbol(name) if name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/methods.rb

@@ -0,0 +1,183 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Methods < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        SPECIAL_METHOD_NAMES = T.let([
+          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
+        ], T::Array[String])
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          symbol = event.symbol
+          constant = event.constant
+          node = event.node
+
+          compile_method(node, symbol, constant, initialize_method_for(constant))
+          compile_directly_owned_methods(node, symbol, constant)
+          compile_directly_owned_methods(node, symbol, singleton_class_of(constant))
+        end
+
+        sig do
+          params(
+            tree: RBI::Tree,
+            module_name: String,
+            mod: Module,
+            for_visibility: T::Array[Symbol]
+          ).void
+        end
+        def compile_directly_owned_methods(tree, module_name, mod, for_visibility = [:public, :protected, :private])
+          method_names_by_visibility(mod)
+            .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
+            .each do |visibility, method_list|
+              method_list.sort!.map do |name|
+                next if name == :initialize
+                vis = case visibility
+                when :protected
+                  RBI::Protected.new
+                when :private
+                  RBI::Private.new
+                else
+                  RBI::Public.new
+                end
+                compile_method(tree, module_name, mod, mod.instance_method(name), vis)
+              end
+            end
+        end
+
+        sig do
+          params(
+            tree: RBI::Tree,
+            symbol_name: String,
+            constant: Module,
+            method: T.nilable(UnboundMethod),
+            visibility: RBI::Visibility
+          ).void
+        end
+        def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
+          return unless method
+          return unless method.owner == constant
+          return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
+
+          signature = signature_of(method)
+          method = T.let(signature.method, UnboundMethod) if signature
+
+          method_name = method.name.to_s
+          return unless valid_method_name?(method_name)
+          return if struct_method?(constant, method_name)
+          return if method_name.start_with?("__t_props_generated_")
+
+          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
+            fallback_arg_name = "_arg#{index}"
+
+            name = if name
+              name.to_s
+            else
+              # For attr_writer methods, Sorbet signatures have the name
+              # of the method (without the trailing = sign) as the name of
+              # the only parameter. So, if the parameter does not have a name
+              # then the replacement name should be the name of the method
+              # (minus trailing =) if and only if there is a signature for the
+              # method and the parameter is required and there is a single
+              # parameter and the signature also defines a single parameter and
+              # the name of the method ends with a = character.
+              writer_method_with_sig = (
+                signature && type == :req &&
+                parameters.size == 1 &&
+                signature.arg_types.size == 1 &&
+                method_name[-1] == "="
+              )
+
+              if writer_method_with_sig
+                method_name.delete_suffix("=")
+              else
+                fallback_arg_name
+              end
+            end
+
+            # Sanitize param names
+            name = fallback_arg_name unless valid_parameter_name?(name)
+
+            [type, name]
+          end
+
+          rbi_method = RBI::Method.new(
+            method_name,
+            is_singleton: constant.singleton_class?,
+            visibility: visibility
+          )
+
+          sanitized_parameters.each do |type, name|
+            case type
+            when :req
+              rbi_method << RBI::Param.new(name)
+            when :opt
+              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
+            when :rest
+              rbi_method << RBI::RestParam.new(name)
+            when :keyreq
+              rbi_method << RBI::KwParam.new(name)
+            when :key
+              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
+            when :keyrest
+              rbi_method << RBI::KwRestParam.new(name)
+            when :block
+              rbi_method << RBI::BlockParam.new(name)
+            end
+          end
+
+          @pipeline.push_method(symbol_name, constant, rbi_method, signature, sanitized_parameters)
+          tree << rbi_method
+        end
+
+        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+        def method_names_by_visibility(mod)
+          {
+            public: public_instance_methods_of(mod),
+            protected: protected_instance_methods_of(mod),
+            private: private_instance_methods_of(mod),
+          }
+        end
+
+        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+        def struct_method?(constant, method_name)
+          return false unless T::Props::ClassMethods === constant
+
+          constant
+            .props
+            .keys
+            .include?(method_name.gsub(/=$/, "").to_sym)
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_method_name?(name)
+          return true if SPECIAL_METHOD_NAMES.include?(name)
+          !!name.match(/^[[:word:]]+[?!=]?$/)
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
+
+        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
+        def initialize_method_for(constant)
+          constant.instance_method(:initialize)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/mixins.rb

@@ -0,0 +1,101 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Mixins < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          singleton_class = singleton_class_of(constant)
+
+          interesting_ancestors = interesting_ancestors_of(constant)
+          interesting_singleton_class_ancestors = interesting_ancestors_of(singleton_class)
+
+          prepends = interesting_ancestors.take_while { |c| !are_equal?(constant, c) }
+          includes = interesting_ancestors.drop(prepends.size + 1)
+          extends  = interesting_singleton_class_ancestors.reject do |mod|
+            Module != class_of(mod) || are_equal?(mod, singleton_class)
+          end
+
+          node = event.node
+          add_mixins(node, prepends.reverse, Runtime::Trackers::Mixin::Type::Prepend)
+          add_mixins(node, includes.reverse, Runtime::Trackers::Mixin::Type::Include)
+          add_mixins(node, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
+        end
+
+        sig do
+          params(
+            tree: RBI::Tree,
+            mods: T::Array[Module],
+            mixin_type: Runtime::Trackers::Mixin::Type
+          ).void
+        end
+        def add_mixins(tree, mods, mixin_type)
+          mods
+            .select do |mod|
+              name = @pipeline.name_of(mod)
+
+              name && !filtered_mixin?(name)
+            end
+            .map do |mod|
+              name = @pipeline.name_of(mod)
+              @pipeline.push_symbol(name) if name
+
+              qname = qualified_name_of(mod)
+              case mixin_type
+              # TODO: Sorbet currently does not handle prepend
+              # properly for method resolution, so we generate an
+              # include statement instead
+              when Runtime::Trackers::Mixin::Type::Include, Runtime::Trackers::Mixin::Type::Prepend
+                tree << RBI::Include.new(T.must(qname))
+              when Runtime::Trackers::Mixin::Type::Extend
+                tree << RBI::Extend.new(T.must(qname))
+              end
+            end
+        end
+
+        sig { params(mixin_name: String).returns(T::Boolean) }
+        def filtered_mixin?(mixin_name)
+          # filter T:: namespace mixins that aren't T::Props
+          # T::Props and subconstants have semantic value
+          mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
+        end
+
+        sig { params(constant: Module).returns(T::Array[Module]) }
+        def interesting_ancestors_of(constant)
+          inherited_ancestors_ids = Set.new(
+            inherited_ancestors_of(constant).map { |mod| object_id_of(mod) }
+          )
+          # TODO: There is actually a bug here where this will drop modules that
+          # may be included twice. For example:
+          #
+          # ```ruby
+          # class Foo
+          #   prepend Kernel
+          # end
+          # ````
+          # would give:
+          # ```ruby
+          # Foo.ancestors #=> [Kernel, Foo, Object, Kernel, BasicObject]
+          # ````
+          # but since we drop `Kernel` whenever we match it, we would miss
+          # the `prepend Kernel` in the output.
+          #
+          # Instead, we should only drop the tail matches of the ancestors and
+          # inherited ancestors, past the location of the constant itself.
+          constant.ancestors.reject do |mod|
+            inherited_ancestors_ids.include?(object_id_of(mod))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class RemoveEmptyPayloadScopes < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          event.node.detach if @pipeline.symbol_in_payload?(event.symbol) && event.node.empty?
+        end
+      end
+    end
+  end
+end