tapioca 0.6.4 → 0.7.0

data/lib/tapioca/{compilers/dsl_compiler.rb → dsl/pipeline.rb}

@@ -1,15 +1,15 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "tapioca/compilers/dsl/base"
+require "tapioca/dsl/compilers"
 
 module Tapioca
-  module Compilers
-    class DslCompiler
+  module Dsl
+    class Pipeline
       extend T::Sig
 
-      sig { returns(T::Enumerable[Dsl::Base]) }
-      attr_reader :generators
+      sig { returns(T::Enumerable[T.class_of(Compiler)]) }
+      attr_reader :compilers
 
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
@@ -17,29 +17,33 @@ module Tapioca
       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_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)],
+          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_generators: [],
-        excluded_generators: [],
+        requested_compilers: [],
+        excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
         number_of_workers: nil
       )
-        @generators = T.let(
-          gather_generators(requested_generators, excluded_generators),
-          T::Enumerable[Dsl::Base]
+        @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
@@ -49,8 +53,8 @@ module Tapioca
       end
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
-          .select { |c| Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
-          .sort_by! { |c| T.must(Reflection.name_of(c)) }
+          .select { |c| Runtime::Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
+          .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
         if constants_to_process.empty?
           report_error(<<~ERROR)
@@ -69,42 +73,45 @@ module Tapioca
           blk.call(constant, rbi)
         end
 
-        generators.flat_map(&:errors).each do |msg|
+        errors.each do |msg|
           report_error(msg)
         end
 
         result.compact
       end
 
-      sig { params(generator_name: String).returns(T::Boolean) }
-      def generator_enabled?(generator_name)
-        generator = Dsl::Base.resolve(generator_name)
+      sig { params(error: String).void }
+      def add_error(error)
+        @errors << error
+      end
 
-        return false unless generator
+      sig { params(compiler_name: String).returns(T::Boolean) }
+      def compiler_enabled?(compiler_name)
+        potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
 
-        @generators.any?(generator)
+        @compilers.any? do |compiler|
+          potential_names.any?(compiler.name)
+        end
       end
 
       private
 
       sig do
         params(
-          requested_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)]
-        ).returns(T::Enumerable[Dsl::Base])
+          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_generators(requested_generators, excluded_generators)
-        generator_klasses = ::Tapioca::Reflection.descendants_of(Dsl::Base).select do |klass|
-          (requested_generators.empty? || requested_generators.include?(klass)) &&
-            !excluded_generators.include?(klass)
+      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) }
-
-        generator_klasses.map { |generator_klass| generator_klass.new(self) }
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
       def gather_constants(requested_constants)
-        constants = generators.map(&:processable_constants).reduce(Set.new, :union)
+        constants = compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants &= requested_constants unless requested_constants.empty?
         constants
       end
@@ -113,9 +120,10 @@ module Tapioca
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
-        generators.each do |generator|
-          next unless generator.handles?(constant)
-          generator.decorate(file.root, constant)
+        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?

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

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

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetEnums < Base
+        extend T::Sig
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          return unless T::Enum > event.constant
+
+          enums = T.unsafe(constant).values.map do |enum_type|
+            enum_type.instance_variable_get(:@const_name).to_s
+          end
+
+          event.node << RBI::TEnumBlock.new(enums)
+        end
+      end
+    end
+  end
+end