tapioca 0.6.4 → 0.7.0

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"