tapioca 0.6.1 → 0.7.0

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

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

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetHelpers < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          node = event.node
+
+          abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type) ||
+            T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
+
+          node << RBI::Helper.new(abstract_type.to_s) if abstract_type
+          node << RBI::Helper.new("final") if T::Private::Final.final_module?(constant)
+          node << RBI::Helper.new("sealed") if T::Private::Sealed.sealed_module?(constant)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetProps < Base
+        extend T::Sig
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          node = event.node
+
+          return unless T::Props::ClassMethods === constant
+
+          constant.props.map do |name, prop|
+            type = prop.fetch(:type_object, "T.untyped").to_s.gsub(".returns(<VOID>)", ".void")
+
+            default = prop.key?(:default) ? "T.unsafe(nil)" : nil
+            node << if prop.fetch(:immutable, false)
+              RBI::TStructConst.new(name.to_s, type, default: default)
+            else
+              RBI::TStructProp.new(name.to_s, type, default: default)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetRequiredAncestors < Base
+        extend T::Sig
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          ancestors = Runtime::Trackers::RequiredAncestor.required_ancestors_by(event.constant)
+          ancestors.each do |ancestor|
+            next unless ancestor # TODO: We should have a way to warn from here
+            event.node << RBI::RequiresAncestor.new(ancestor.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetSignatures < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+        include RBIHelper
+
+        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
+
+        private
+
+        sig { override.params(event: MethodNodeAdded).void }
+        def on_method(event)
+          signature = event.signature
+          return unless signature
+
+          event.node.sigs << compile_signature(signature, event.parameters)
+        end
+
+        sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(RBI::Sig) }
+        def compile_signature(signature, parameters)
+          parameter_types = T.let(signature.arg_types.to_h, T::Hash[Symbol, T::Types::Base])
+          parameter_types.merge!(signature.kwarg_types)
+          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
+          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
+          parameter_types[signature.block_name] = signature.block_type if signature.block_name
+
+          sig = RBI::Sig.new
+
+          parameters.each do |_, name|
+            type = sanitize_signature_types(parameter_types[name.to_sym].to_s)
+            @pipeline.push_symbol(type)
+            sig << RBI::SigParam.new(name, type)
+          end
+
+          return_type = name_of_type(signature.return_type)
+          return_type = sanitize_signature_types(return_type)
+          sig.return_type = return_type
+          @pipeline.push_symbol(return_type)
+
+          parameter_types.values.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq.each do |k, _|
+            sig.type_params << k
+          end
+
+          case signature.mode
+          when "abstract"
+            sig.is_abstract = true
+          when "override"
+            sig.is_override = true
+          when "overridable_override"
+            sig.is_overridable = true
+            sig.is_override = true
+          when "overridable"
+            sig.is_overridable = true
+          end
+
+          sig.is_final = signature_final?(signature)
+
+          sig
+        end
+
+        sig { params(signature: T.untyped).returns(T::Boolean) }
+        def signature_final?(signature)
+          modules_with_final = T::Private::Methods.instance_variable_get(:@modules_with_final)
+          final_methods = modules_with_final[signature.owner.object_id]
+
+          return false unless final_methods
+
+          final_methods.include?(signature.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class SorbetTypeVariables < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          node = event.node
+
+          compile_type_variable_declarations(node, constant)
+
+          sclass = RBI::SingletonClass.new
+          compile_type_variable_declarations(sclass, singleton_class_of(constant))
+          node << sclass if sclass.nodes.length > 1
+        end
+
+        sig { params(tree: RBI::Tree, constant: Module).void }
+        def compile_type_variable_declarations(tree, constant)
+          # Try to find the type variables defined on this constant, bail if we can't
+          type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)
+          return unless type_variables
+
+          # Map each type variable to its string representation.
+          #
+          # Each entry of `type_variables` maps a Module to a String,
+          # and the order they are inserted into the hash is the order they should be
+          # defined in the source code.
+          type_variable_declarations = type_variables.map do |type_variable|
+            type_variable_name = type_variable.name
+            next unless type_variable_name
+
+            tree << RBI::TypeMember.new(type_variable_name, type_variable.serialize)
+          end
+
+          return if type_variable_declarations.empty?
+
+          tree << RBI::Extend.new("T::Generic")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Subconstants < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          symbol = event.symbol
+          return if @pipeline.symbol_in_payload?(symbol) && event.node.empty?
+
+          prefix = symbol == "Object" ? "" : symbol
+
+          constant = event.constant
+          constants_of(constant).sort.uniq.map do |constant_name|
+            name = "#{prefix}::#{constant_name}"
+            subconstant = constantize(name)
+
+            # Don't compile modules of Object because Object::Foo == Foo
+            # Don't compile modules of BasicObject because BasicObject::BasicObject == BasicObject
+            next if (Object == constant || BasicObject == constant) && Module === subconstant
+            next unless subconstant
+
+            @pipeline.push_constant(name, subconstant)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class YardDoc < Base
+        extend T::Sig
+
+        IGNORED_COMMENTS = T.let([
+          ":doc:",
+          ":nodoc:",
+          "typed:",
+          "frozen_string_literal:",
+          "encoding:",
+          "warn_indent:",
+          "shareable_constant_value:",
+          "rubocop:",
+        ], T::Array[String])
+
+        IGNORED_SIG_TAGS = T.let(["param", "return"], T::Array[String])
+
+        sig { params(pipeline: Pipeline).void }
+        def initialize(pipeline)
+          super(pipeline)
+          pipeline.gem.parse_yard_docs
+        end
+
+        private
+
+        sig { override.params(event: ConstNodeAdded).void }
+        def on_const(event)
+          event.node.comments = documentation_comments(event.symbol)
+        end
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          event.node.comments = documentation_comments(event.symbol)
+        end
+
+        sig { override.params(event: MethodNodeAdded).void }
+        def on_method(event)
+          separator = event.constant.singleton_class? ? "." : "#"
+          event.node.comments = documentation_comments(
+            "#{event.symbol}#{separator}#{event.node.name}",
+            sigs: event.node.sigs
+          )
+        end
+
+        sig { params(name: String, sigs: T::Array[RBI::Sig]).returns(T::Array[RBI::Comment]) }
+        def documentation_comments(name, sigs: [])
+          yard_docs = YARD::Registry.at(name)
+          return [] unless yard_docs
+
+          docstring = yard_docs.docstring
+          return [] if /(copyright|license)/i.match?(docstring)
+
+          comments = docstring.lines
+            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } }
+            .map! { |line| RBI::Comment.new(line) }
+
+          tags = yard_docs.tags
+          tags.reject! { |tag| IGNORED_SIG_TAGS.include?(tag.tag_name) } unless sigs.empty?
+
+          comments << RBI::Comment.new("") if comments.any? && tags.any?
+
+          tags.sort_by(&:tag_name).each do |tag|
+            line = +"@#{tag.tag_name}"
+
+            tag_name = tag.name
+            line << " #{tag_name}" if tag_name
+
+            tag_types = tag.types
+            line << " [#{tag_types.join(", ")}]" if tag_types&.any?
+
+            tag_text = tag.text
+            if tag_text && !tag_text.empty?
+              text_lines = tag_text.lines
+
+              # Example are a special case because we want the text to start on the next line
+              line << " #{text_lines.shift&.strip}" unless tag.tag_name == "example"
+
+              text_lines.each do |text_line|
+                line << "\n  #{text_line.strip}"
+              end
+            end
+
+            comments << RBI::Comment.new(line)
+          end
+
+          comments
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/gem/listeners/base"
+require "tapioca/gem/listeners/dynamic_mixins"
+require "tapioca/gem/listeners/methods"
+require "tapioca/gem/listeners/mixins"
+require "tapioca/gem/listeners/remove_empty_payload_scopes"
+require "tapioca/gem/listeners/sorbet_enums"
+require "tapioca/gem/listeners/sorbet_helpers"
+require "tapioca/gem/listeners/sorbet_props"
+require "tapioca/gem/listeners/sorbet_required_ancestors"
+require "tapioca/gem/listeners/sorbet_signatures"
+require "tapioca/gem/listeners/sorbet_type_variables"
+require "tapioca/gem/listeners/subconstants"
+require "tapioca/gem/listeners/yard_doc"