tapioca 0.4.27 → 0.5.3

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -1,48 +1,56 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require 'pathname'
+require "pathname"
 
 module Tapioca
   module Compilers
     module SymbolTable
       class SymbolGenerator
         extend(T::Sig)
-
-        IGNORED_SYMBOLS = %w{
-          YAML
-          MiniTest
-          Mutex
-        }
-
-        attr_reader(:gem, :indent)
-
-        sig { params(gem: Gemfile::GemSpec, indent: Integer).void }
-        def initialize(gem, indent = 0)
+        include(Reflection)
+
+        IGNORED_SYMBOLS = T.let(["YAML", "MiniTest", "Mutex"], T::Array[String])
+        IGNORED_COMMENTS = T.let([
+          ":doc:",
+          ":nodoc:",
+          "typed:",
+          "frozen_string_literal:",
+          "encoding:",
+          "warn_indent:",
+          "shareable_constant_value:",
+          "rubocop:",
+        ], T::Array[String])
+
+        sig { returns(Gemfile::GemSpec) }
+        attr_reader :gem
+
+        sig { returns(Integer) }
+        attr_reader :indent
+
+        sig { params(gem: Gemfile::GemSpec, indent: Integer, include_doc: T::Boolean).void }
+        def initialize(gem, indent = 0, include_doc = false)
           @gem = gem
           @indent = indent
-          @seen = Set.new
-          @alias_namespace ||= Set.new
+          @seen = T.let(Set.new, T::Set[String])
+          @alias_namespace = T.let(Set.new, T::Set[String])
           @symbol_queue = T.let(symbols.sort.dup, T::Array[String])
-        end
+          @symbols = T.let(nil, T.nilable(T::Set[String]))
+          @include_doc = include_doc
 
-        sig { returns(String) }
-        def generate
-          rbi = RBI::Tree.new
-
-          generate_from_symbol(rbi, T.must(@symbol_queue.shift)) until @symbol_queue.empty?
+          gem.parse_yard_docs if include_doc
+        end
 
-          rbi.nest_singleton_methods!
-          rbi.nest_non_public_methods!
-          rbi.group_nodes!
-          rbi.sort_nodes!
-          rbi.string
+        sig { params(rbi: RBI::File).void }
+        def generate(rbi)
+          generate_from_symbol(rbi.root, T.must(@symbol_queue.shift)) until @symbol_queue.empty?
         end
 
         private
 
+        sig { params(name: T.nilable(String)).void }
         def add_to_symbol_queue(name)
-          @symbol_queue << name unless symbols.include?(name) || symbol_ignored?(name)
+          @symbol_queue << name unless name.nil? || symbols.include?(name) || symbol_ignored?(name)
         end
 
         sig { returns(T::Set[String]) }
@@ -57,8 +65,8 @@ module Tapioca
         def engine_symbols(symbols)
           return Set.new unless Object.const_defined?("Rails::Engine")
 
-          engine = Object.const_get("Rails::Engine")
-            .descendants.reject(&:abstract_railtie?)
+          engine = descendants_of(Object.const_get("Rails::Engine"))
+            .reject(&:abstract_railtie?)
             .find do |klass|
               name = name_of(klass)
               !name.nil? && symbols.include?(name)
@@ -102,7 +110,7 @@ module Tapioca
           return unless constant
           return unless name
           return if name.strip.empty?
-          return if name.start_with?('#<')
+          return if name.start_with?("#<")
           return if name.downcase == name
           return if alias_namespaced?(name)
           return if seen?(name)
@@ -144,7 +152,9 @@ module Tapioca
         sig { params(tree: RBI::Tree, name: String, value: BasicObject).void.checked(:never) }
         def compile_object(tree, name, value)
           return if symbol_ignored?(name)
+
           klass = class_of(value)
+          return if klass == TypeMember || klass == TypeTemplate
 
           klass_name = if klass == ObjectSpace::WeakMap
             # WeakMap is an implicit generic with one type variable
@@ -155,28 +165,33 @@ module Tapioca
             name_of(klass)
           end
 
+          comments = documentation_comments(name)
+
           if klass_name == "T::Private::Types::TypeAlias"
-            tree << RBI::Const.new(name, "T.type_alias { #{T.unsafe(value).aliased_type} }")
+            constant = RBI::Const.new(name, "T.type_alias { #{T.unsafe(value).aliased_type} }", comments: comments)
+            tree << constant
             return
           end
 
           return if klass_name&.start_with?("T::Types::", "T::Private::")
 
           type_name = klass_name || "T.untyped"
+          constant = RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})", comments: comments)
 
-          tree << RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})")
+          tree << constant
         end
 
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_module(tree, name, constant)
           return unless defined_in_gem?(constant, strict: false)
 
+          comments = documentation_comments(name)
           scope =
             if constant.is_a?(Class)
               superclass = compile_superclass(constant)
-              RBI::Class.new(name, superclass_name: superclass)
+              RBI::Class.new(name, superclass_name: superclass, comments: comments)
             else
-              RBI::Module.new(name)
+              RBI::Module.new(name, comments: comments)
             end
 
           compile_body(scope, name, constant)
@@ -189,13 +204,27 @@ module Tapioca
 
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_body(tree, name, constant)
+          # Compiling type variables must happen first to populate generic names
+          compile_type_variables(tree, constant)
           compile_methods(tree, name, constant)
           compile_module_helpers(tree, constant)
-          compile_type_variables(tree, constant)
           compile_mixins(tree, constant)
-          compile_mixes_in_class_methods(tree, constant)
           compile_props(tree, constant)
           compile_enums(tree, constant)
+          compile_dynamic_mixins(tree, constant)
+        end
+
+        sig { params(tree: RBI::Tree, constant: Module).void }
+        def compile_dynamic_mixins(tree, constant)
+          return if constant.is_a?(Class)
+
+          mixin_compiler = DynamicMixinCompiler.new(constant)
+          mixin_compiler.compile_class_attributes(tree)
+          dynamic_extends, dynamic_includes = mixin_compiler.compile_mixes_in_class_methods(tree)
+
+          (dynamic_includes + dynamic_extends).each do |mod|
+            add_to_symbol_queue(name_of(mod))
+          end
         end
 
         sig { params(tree: RBI::Tree, constant: Module).void }
@@ -267,12 +296,10 @@ module Tapioca
           # Create a map of subconstants (via their object ids) to their names.
           # We need this later when we want to lookup the name of the registered type
           # variable via the value of the type variable constant.
-          subconstant_to_name_lookup = constants_of(constant).map do |constant_name|
-            [
-              object_id_of(resolve_constant(constant_name.to_s, namespace: constant)),
-              constant_name,
-            ]
-          end.to_h
+          subconstant_to_name_lookup = constants_of(constant)
+            .each_with_object({}.compare_by_identity) do |constant_name, table|
+            table[resolve_constant(constant_name.to_s, namespace: constant)] = constant_name.to_s
+          end
 
           # Map each type variable to its string representation.
           #
@@ -283,12 +310,13 @@ module Tapioca
           # By looping over these entries and then getting the actual constant name
           # from the `subconstant_to_name_lookup` we defined above, gives us all the
           # information we need to serialize type variable definitions.
-          type_variable_declarations = type_variables.map do |type_variable_id, serialized_type_variable|
-            constant_name = subconstant_to_name_lookup[type_variable_id]
+          type_variable_declarations = type_variables.map do |type_variable, serialized_type_variable|
+            constant_name = subconstant_to_name_lookup[type_variable]
+            type_variable.name = constant_name
             # Here, we know that constant_value will be an instance of
             # T::Types::CustomTypeVariable, which knows how to serialize
             # itself to a type_member/type_template
-            tree << RBI::TypeMember.new(constant_name.to_s, serialized_type_variable)
+            tree << RBI::TypeMember.new(constant_name, serialized_type_variable)
           end
 
           return if type_variable_declarations.empty?
@@ -392,71 +420,6 @@ module Tapioca
             end
         end
 
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_mixes_in_class_methods(tree, constant)
-          return if constant.is_a?(Class)
-
-          mixins_from_modules = {}
-
-          Class.new do
-            # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
-            def method_missing(symbol, *args)
-            end
-
-            define_singleton_method(:include) do |mod|
-              begin
-                before = singleton_class.ancestors
-                super(mod).tap do
-                  mixins_from_modules[mod] = singleton_class.ancestors - before
-                end
-              rescue Exception # rubocop:disable Lint/RescueException
-                # this is a best effort, bail if we can't perform this
-              end
-            end
-
-            class << self
-              def method_missing(symbol, *args)
-              end
-            end
-            # rubocop:enable Style/MethodMissingSuper, Style/MissingRespondToMissing
-          end.include(constant)
-
-          all_dynamic_extends = mixins_from_modules.delete(constant)
-          all_dynamic_includes = mixins_from_modules.keys
-          dynamic_extends_from_dynamic_includes = mixins_from_modules.values.flatten
-          dynamic_extends = all_dynamic_extends - dynamic_extends_from_dynamic_includes
-
-          all_dynamic_includes
-            .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
-            .map do |mod|
-              add_to_symbol_queue(name_of(mod))
-
-              qname = qualified_name_of(mod)
-              tree << RBI::Include.new(T.must(qname))
-            end.join("\n")
-
-          ancestors = singleton_class_of(constant).ancestors
-          extends_as_concern = ancestors.any? do |mod|
-            qualified_name_of(mod) == "::ActiveSupport::Concern"
-          end
-          class_methods_module = resolve_constant("#{name_of(constant)}::ClassMethods")
-
-          mixed_in_module = if extends_as_concern && Module === class_methods_module
-            class_methods_module
-          else
-            dynamic_extends.find { |mod| mod != constant }
-          end
-
-          return if mixed_in_module.nil?
-
-          qualified_name = qualified_name_of(mixed_in_module)
-          return if qualified_name.nil? || qualified_name == ""
-
-          tree << RBI::MixesInClassMethods.new(qualified_name)
-        rescue
-          nil # silence errors
-        end
-
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_methods(tree, name, constant)
           compile_method(
@@ -486,11 +449,11 @@ module Tapioca
                 next if name == :initialize
                 vis = case visibility
                 when :protected
-                  RBI::Visibility::Protected
+                  RBI::Protected.new
                 when :private
-                  RBI::Visibility::Private
+                  RBI::Private.new
                 else
-                  RBI::Visibility::Public
+                  RBI::Public.new
                 end
                 compile_method(tree, module_name, mod, mod.instance_method(name), vis)
               end
@@ -500,9 +463,9 @@ module Tapioca
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
         def method_names_by_visibility(mod)
           {
-            public: Module.instance_method(:public_instance_methods).bind(mod).call,
-            protected: Module.instance_method(:protected_instance_methods).bind(mod).call,
-            private: Module.instance_method(:private_instance_methods).bind(mod).call,
+            public: public_instance_methods_of(mod),
+            protected: protected_instance_methods_of(mod),
+            private: private_instance_methods_of(mod),
           }
         end
 
@@ -513,7 +476,7 @@ module Tapioca
           constant
             .props
             .keys
-            .include?(method_name.gsub(/=$/, '').to_sym)
+            .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
         sig do
@@ -525,7 +488,7 @@ module Tapioca
             visibility: RBI::Visibility
           ).void
         end
-        def compile_method(tree, symbol_name, constant, method, visibility = RBI::Visibility::Public)
+        def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
           return unless method
           return unless method.owner == constant
           return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
@@ -572,7 +535,15 @@ module Tapioca
             [type, name]
           end
 
-          rbi_method = RBI::Method.new(method_name, is_singleton: constant.singleton_class?, visibility: visibility)
+          separator = constant.singleton_class? ? "." : "#"
+          comments = documentation_comments("#{symbol_name}#{separator}#{method_name}")
+          rbi_method = RBI::Method.new(
+            method_name,
+            is_singleton: constant.singleton_class?,
+            visibility: visibility,
+            comments: comments
+          )
+
           rbi_method.sigs << compile_signature(signature, sanitized_parameters) if signature
 
           sanitized_parameters.each do |type, name|
@@ -615,7 +586,7 @@ module Tapioca
             sig << RBI::SigParam.new(name, type)
           end
 
-          return_type = type_of(signature.return_type)
+          return_type = name_of_type(signature.return_type)
           sig.return_type = sanitize_signature_types(return_type)
           add_to_symbol_queue(sig.return_type)
 
@@ -638,12 +609,24 @@ module Tapioca
           sig
         end
 
+        sig { params(sig_string: String).returns(String) }
+        def sanitize_signature_types(sig_string)
+          sig_string
+            .gsub(".returns(<VOID>)", ".void")
+            .gsub("<VOID>", "void")
+            .gsub("<NOT-TYPED>", "T.untyped")
+            .gsub(".params()", "")
+        end
+
         sig { params(symbol_name: String).returns(T::Boolean) }
         def symbol_ignored?(symbol_name)
           SymbolLoader.ignore_symbol?(symbol_name)
         end
 
-        SPECIAL_METHOD_NAMES = %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `]
+        SPECIAL_METHOD_NAMES = T.let([
+          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"
+        ], T::Array[String])
 
         sig { params(name: String).returns(T::Boolean) }
         def valid_method_name?(name)
@@ -702,46 +685,13 @@ module Tapioca
           @seen.include?(name)
         end
 
+        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue
           nil
         end
 
-        sig { params(constant: BasicObject).returns(Class).checked(:never) }
-        def class_of(constant)
-          Kernel.instance_method(:class).bind(constant).call
-        end
-
-        sig { params(constant: Module).returns(T::Array[Symbol]) }
-        def constants_of(constant)
-          Module.instance_method(:constants).bind(constant).call(false)
-        end
-
-        sig { params(constant: Module).returns(T.nilable(String)) }
-        def raw_name_of(constant)
-          Module.instance_method(:name).bind(constant).call
-        end
-
-        sig { params(constant: Module).returns(Class) }
-        def singleton_class_of(constant)
-          Object.instance_method(:singleton_class).bind(constant).call
-        end
-
-        sig { params(constant: Module).returns(T::Array[Module]) }
-        def ancestors_of(constant)
-          Module.instance_method(:ancestors).bind(constant).call
-        end
-
-        sig { params(constant: Module).returns(T::Array[Module]) }
-        def inherited_ancestors_of(constant)
-          if Class === constant
-            ancestors_of(superclass_of(constant) || Object)
-          else
-            Module.ancestors
-          end
-        end
-
         sig { params(constant: Module).returns(T::Array[Module]) }
         def interesting_ancestors_of(constant)
           inherited_ancestors_ids = Set.new(
@@ -771,9 +721,9 @@ module Tapioca
 
         sig { params(constant: Module).returns(T.nilable(String)) }
         def name_of(constant)
-          name = name_of_proxy_target(constant)
+          name = name_of_proxy_target(constant, super(class_of(constant)))
           return name if name
-          name = raw_name_of(constant)
+          name = super(constant)
           return if name.nil?
           return unless are_equal?(constant, resolve_constant(name, inherit: true))
           name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
@@ -793,67 +743,33 @@ module Tapioca
           "#{type_name}[#{type_variable_names}]"
         end
 
-        sig { params(constant: Module).returns(T.nilable(String)) }
-        def name_of_proxy_target(constant)
-          klass = class_of(constant)
-          return unless raw_name_of(klass) == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
+        sig { params(constant: Module, class_name: T.nilable(String)).returns(T.nilable(String)) }
+        def name_of_proxy_target(constant, class_name)
+          return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
           # We are dealing with a ActiveSupport::Deprecation::DeprecatedConstantProxy
           # so try to get the name of the target class
           begin
-            target = Kernel.instance_method(:send).bind(constant).call(:target)
+            target = constant.__send__(:target)
           rescue NoMethodError
             return
           end
 
-          raw_name_of(target)
+          name_of(target)
         end
 
-        sig { params(constant: Module).returns(T.nilable(String)) }
-        def qualified_name_of(constant)
-          name = name_of(constant)
-          return if name.nil?
+        sig { params(name: String).returns(T::Array[RBI::Comment]) }
+        def documentation_comments(name)
+          return [] unless @include_doc
 
-          if name.start_with?("::")
-            name
-          else
-            "::#{name}"
-          end
-        end
-
-        sig { params(constant: Class).returns(T.nilable(Class)) }
-        def superclass_of(constant)
-          Class.instance_method(:superclass).bind(constant).call
-        end
-
-        sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
-        def signature_of(method)
-          T::Private::Methods.signature_for_method(method)
-        rescue LoadError, StandardError
-          nil
-        end
+          yard_docs = YARD::Registry.at(name)
+          return [] unless yard_docs
 
-        sig { params(sig_string: String).returns(String) }
-        def sanitize_signature_types(sig_string)
-          sig_string
-            .gsub(".returns(<VOID>)", ".void")
-            .gsub("<VOID>", "void")
-            .gsub("<NOT-TYPED>", "T.untyped")
-            .gsub(".params()", "")
-        end
-
-        sig { params(constant: T::Types::Base).returns(String) }
-        def type_of(constant)
-          constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
-        end
-
-        sig { params(object: BasicObject).returns(Integer).checked(:never) }
-        def object_id_of(object)
-          Object.instance_method(:object_id).bind(object).call
-        end
+          docstring = yard_docs.docstring
+          return [] if /(copyright|license)/i.match?(docstring)
 
-        sig { params(constant: Module, other: BasicObject).returns(T::Boolean).checked(:never) }
-        def are_equal?(constant, other)
-          BasicObject.instance_method(:equal?).bind(constant).call(other)
+          docstring.lines
+            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } }
+            .map! { |line| RBI::Comment.new(line) }
         end
       end
     end

data/lib/tapioca/compilers/symbol_table/symbol_loader.rb

@@ -1,8 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'json'
-require 'tempfile'
+require "json"
+require "tempfile"
 
 module Tapioca
   module Compilers
@@ -25,7 +25,7 @@ module Tapioca
 
           sig { params(paths: T::Array[String]).returns(T::Set[String]) }
           def load_symbols(paths)
-            output = T.cast(Tempfile.create('sorbet') do |file|
+            output = T.cast(Tempfile.create("sorbet") do |file|
               file.write(Array(paths).join("\n"))
               file.flush
 
@@ -69,7 +69,7 @@ module Tapioca
               # TODO: CLASS is removed since v0.4.4730 of Sorbet
               # but keeping here for backward compatibility. Remove
               # once the minimum version is moved past that.
-              next unless %w[CLASS CLASS_OR_MODULE STATIC_FIELD].include?(kind)
+              next unless ["CLASS", "CLASS_OR_MODULE", "STATIC_FIELD"].include?(kind)
               next if name =~ /[<>()$]/
               next if name =~ /^[0-9]+$/
               next if name == "T::Helpers"

data/lib/tapioca/compilers/symbol_table_compiler.rb

@@ -6,17 +6,11 @@ module Tapioca
     class SymbolTableCompiler
       extend(T::Sig)
 
-      sig do
-        params(
-          gem: Gemfile::GemSpec,
-          indent: Integer
-        ).returns(String)
-      end
-      def compile(
-        gem,
-        indent = 0
-      )
-        Tapioca::Compilers::SymbolTable::SymbolGenerator.new(gem, indent).generate
+      sig { params(gem: Gemfile::GemSpec, rbi: RBI::File, indent: Integer, include_docs: T::Boolean).void }
+      def compile(gem, rbi, indent = 0, include_docs = false)
+        Tapioca::Compilers::SymbolTable::SymbolGenerator
+          .new(gem, indent, include_docs)
+          .generate(rbi)
       end
     end
   end

data/lib/tapioca/compilers/todos_compiler.rb

@@ -13,7 +13,7 @@ module Tapioca
       def compile
         list_todos.each_line.map do |line|
           next if line.include?("<") || line.include?("class_of")
-          "module #{line.strip.gsub('T.untyped::', '')}; end"
+          "module #{line.strip.gsub("T.untyped::", "")}; end"
         end.compact.join("\n")
       end
 

data/lib/tapioca/config.rb

@@ -9,9 +9,12 @@ module Tapioca
     const(:prerequire, T.nilable(String))
     const(:postrequire, String)
     const(:exclude, T::Array[String])
+    const(:exclude_generators, T::Array[String])
     const(:typed_overrides, T::Hash[String, String])
     const(:todos_path, String)
     const(:generators, T::Array[String])
+    const(:file_header, T::Boolean, default: true)
+    const(:doc, T::Boolean, default: false)
 
     sig { returns(Pathname) }
     def outpath

data/lib/tapioca/config_builder.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'yaml'
+require "yaml"
 
 module Tapioca
   class ConfigBuilder
@@ -33,7 +33,7 @@ module Tapioca
       sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
       def default_options(command)
         default_outdir = case command
-        when :sync, :generate
+        when :sync, :generate, :gem
           Config::DEFAULT_GEMDIR
         when :dsl
           Config::DEFAULT_DSLDIR
@@ -62,9 +62,12 @@ module Tapioca
       "postrequire" => Config::DEFAULT_POSTREQUIRE,
       "outdir" => nil,
       "exclude" => [],
+      "exclude_generators" => [],
       "typed_overrides" => Config::DEFAULT_OVERRIDES,
       "todos_path" => Config::DEFAULT_TODOSPATH,
       "generators" => [],
+      "file_header" => true,
+      "doc" => false,
     }.freeze, T::Hash[String, T.untyped])
   end
 end

data/lib/tapioca/constant_locator.rb

@@ -1,7 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module Tapioca
   # Registers a TracePoint immediately upon load to track points at which
@@ -9,15 +9,14 @@ module Tapioca
   # correspondence between classes/modules and files, as this information isn't
   # available in the ruby runtime without extra accounting.
   module ConstantLocator
-    @class_files = {}
+    extend Reflection
 
-    NAME = Module.instance_method(:name)
-    private_constant :NAME
+    @class_files = {}
 
     # Immediately activated upon load. Observes class/module definition.
     TracePoint.trace(:class) do |tp|
       unless tp.self.singleton_class?
-        key = NAME.bind(tp.self).call
+        key = name_of(tp.self)
         @class_files[key] ||= Set.new
         @class_files[key] << tp.path
       end
@@ -26,11 +25,10 @@ module Tapioca
     # Returns the files in which this class or module was opened. Doesn't know
     # about situations where the class was opened prior to +require+ing,
     # or where metaprogramming was used via +eval+, etc.
-    def files_for(klass)
-      name = String === klass ? klass : NAME.bind(klass).call
+    def self.files_for(klass)
+      name = String === klass ? klass : name_of(klass)
       files = @class_files[name]
       files || Set.new
     end
-    module_function :files_for
   end
 end