tapioca 0.4.17 → 0.4.22

data/lib/tapioca/internal.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca"
+require "tapioca/loader"
+require "tapioca/constant_locator"
+require "tapioca/generic_type_registry"
+require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/config"
+require "tapioca/config_builder"
+require "tapioca/generator"
+require "tapioca/cli"
+require "tapioca/cli/main"
+require "tapioca/gemfile"
+require "tapioca/rbi/model"
+require "tapioca/rbi/visitor"
+require "tapioca/rbi/rewriters/nest_singleton_methods"
+require "tapioca/rbi/rewriters/nest_non_public_methods"
+require "tapioca/rbi/rewriters/group_nodes"
+require "tapioca/rbi/rewriters/sort_nodes"
+require "tapioca/rbi/printer"
+require "tapioca/compilers/sorbet"
+require "tapioca/compilers/requires_compiler"
+require "tapioca/compilers/symbol_table_compiler"
+require "tapioca/compilers/symbol_table/symbol_generator"
+require "tapioca/compilers/symbol_table/symbol_loader"
+require "tapioca/compilers/todos_compiler"
+require "tapioca/compilers/dsl_compiler"

data/lib/tapioca/rbi/model.rb

@@ -0,0 +1,405 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    class Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(T.nilable(Tree)) }
+      attr_accessor :parent_tree
+
+      sig { void }
+      def initialize
+        @parent_tree = nil
+      end
+
+      sig { void }
+      def detach
+        tree = parent_tree
+        return unless tree
+        tree.nodes.delete(self)
+        self.parent_tree = nil
+      end
+    end
+
+    class Tree < Node
+      extend T::Sig
+
+      sig { returns(T::Array[Node]) }
+      attr_reader :nodes
+
+      sig { void }
+      def initialize
+        super()
+        @nodes = T.let([], T::Array[Node])
+      end
+
+      sig { params(node: Node).void }
+      def <<(node)
+        node.parent_tree = self
+        @nodes << node
+      end
+
+      sig { returns(T::Boolean) }
+      def empty?
+        nodes.empty?
+      end
+    end
+
+    # Scopes
+
+    class Scope < Tree
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class Module < Scope
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class Class < Scope
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :superclass_name
+
+      sig { params(name: String, superclass_name: T.nilable(String)).void }
+      def initialize(name, superclass_name: nil)
+        super()
+        @name = name
+        @superclass_name = superclass_name
+      end
+    end
+
+    class SingletonClass < Scope
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super()
+      end
+    end
+
+    # Consts
+
+    class Const < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super()
+        @name = name
+        @value = value
+      end
+    end
+
+    # Methods and args
+
+    class Method < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T::Array[Param]) }
+      attr_reader :params
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_singleton
+
+      sig { returns(Visibility) }
+      attr_accessor :visibility
+
+      sig { returns(T::Array[Sig]) }
+      attr_accessor :sigs
+
+      sig do
+        params(
+          name: String,
+          params: T::Array[Param],
+          is_singleton: T::Boolean,
+          visibility: Visibility,
+          sigs: T::Array[Sig]
+        ).void
+      end
+      def initialize(name, params: [], is_singleton: false, visibility: Visibility::Public, sigs: [])
+        super()
+        @name = name
+        @params = params
+        @is_singleton = is_singleton
+        @visibility = visibility
+        @sigs = sigs
+      end
+
+      sig { params(param: Param).void }
+      def <<(param)
+        @params << param
+      end
+    end
+
+    class Param < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class OptParam < Param
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super(name)
+        @value = value
+      end
+    end
+
+    class RestParam < Param; end
+    class KwParam < Param; end
+    class KwOptParam < OptParam; end
+    class KwRestParam < Param; end
+    class BlockParam < Param; end
+
+    # Mixins
+
+    class Mixin < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class Include < Mixin; end
+    class Extend < Mixin; end
+
+    # Visibility
+
+    class Visibility < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(Symbol) }
+      attr_reader :visibility
+
+      sig { params(visibility: Symbol).void }
+      def initialize(visibility)
+        super()
+        @visibility = visibility
+      end
+
+      sig { returns(T::Boolean) }
+      def public?
+        visibility == :public
+      end
+
+      Public = T.let(Visibility.new(:public), Visibility)
+      Protected = T.let(Visibility.new(:protected), Visibility)
+      Private = T.let(Visibility.new(:private), Visibility)
+    end
+
+    # Sorbet's sigs
+
+    class Sig < Node
+      extend T::Sig
+
+      sig { returns(T::Array[SigParam]) }
+      attr_reader :params
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :return_type
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_abstract, :is_override, :is_overridable
+
+      sig { returns(T::Array[String]) }
+      attr_reader :type_params
+
+      sig do
+        params(
+          params: T::Array[SigParam],
+          return_type: T.nilable(String),
+          is_abstract: T::Boolean,
+          is_override: T::Boolean,
+          is_overridable: T::Boolean,
+          type_params: T::Array[String]
+        ).void
+      end
+      def initialize(
+        params: [],
+        return_type: nil,
+        is_abstract: false,
+        is_override: false,
+        is_overridable: false,
+        type_params: []
+      )
+        super()
+        @params = params
+        @return_type = return_type
+        @is_abstract = is_abstract
+        @is_override = is_override
+        @is_overridable = is_overridable
+        @type_params = type_params
+      end
+
+      sig { params(param: SigParam).void }
+      def <<(param)
+        @params << param
+      end
+    end
+
+    class SigParam < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :type
+
+      sig { params(name: String, type: String).void }
+      def initialize(name, type)
+        super()
+        @name = name
+        @type = type
+      end
+    end
+
+    # Sorbet's T::Struct
+
+    class TStruct < Class
+      extend T::Sig
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super(name, superclass_name: "::T::Struct")
+      end
+    end
+
+    class TStructField < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_accessor :name, :type
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :default
+
+      sig do
+        params(
+          name: String,
+          type: String,
+          default: T.nilable(String)
+        ).void
+      end
+      def initialize(name, type, default: nil)
+        super()
+        @name = name
+        @type = type
+        @default = default
+      end
+    end
+
+    class TStructProp < TStructField; end
+    class TStructConst < TStructField; end
+
+    # Sorbet's T::Enum
+
+    class TEnum < Class
+      extend T::Sig
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super(name, superclass_name: "::T::Enum")
+      end
+    end
+
+    class TEnumBlock < Node
+      extend T::Sig
+
+      sig { returns(T::Array[String]) }
+      attr_reader :names
+
+      sig { params(names: T::Array[String]).void }
+      def initialize(names = [])
+        super()
+        @names = names
+      end
+
+      sig { returns(T::Boolean) }
+      def empty?
+        names.empty?
+      end
+    end
+
+    # Sorbet's misc.
+
+    class Helper < Node
+      extend T::Helpers
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class TypeMember < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super()
+        @name = name
+        @value = value
+      end
+    end
+
+    class MixesInClassMethods < Mixin; end
+  end
+end

data/lib/tapioca/rbi/printer.rb

@@ -0,0 +1,410 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    class Printer < Visitor
+      extend T::Sig
+
+      sig { returns(T::Boolean) }
+      attr_accessor :in_visibility_group
+
+      sig { returns(T.nilable(Node)) }
+      attr_reader :previous_node
+
+      sig { params(out: T.any(IO, StringIO), indent: Integer).void }
+      def initialize(out: $stdout, indent: 0)
+        super()
+        @out = out
+        @current_indent = indent
+        @in_visibility_group = T.let(false, T::Boolean)
+        @previous_node = T.let(nil, T.nilable(Node))
+      end
+
+      # Printing
+
+      sig { void }
+      def indent
+        @current_indent += 2
+      end
+
+      sig { void }
+      def dedent
+        @current_indent -= 2
+      end
+
+      # Print a string without indentation nor `\n` at the end.
+      sig { params(string: String).void }
+      def print(string)
+        @out.print(string)
+      end
+
+      # Print a string without indentation but with a `\n` at the end.
+      sig { params(string: T.nilable(String)).void }
+      def printn(string = nil)
+        print(string) if string
+        print("\n")
+      end
+
+      # Print a string with indentation but without a `\n` at the end.
+      sig { params(string: T.nilable(String)).void }
+      def printt(string = nil)
+        print(" " * @current_indent)
+        print(string) if string
+      end
+
+      # Print a string with indentation and `\n` at the end.
+      sig { params(string: String).void }
+      def printl(string)
+        printt
+        printn(string)
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+        node.accept_printer(self)
+      end
+
+      sig { override.params(nodes: T::Array[Node]).void }
+      def visit_all(nodes)
+        previous_node = @previous_node
+        @previous_node = nil
+        nodes.each do |node|
+          visit(node)
+          @previous_node = node
+        end
+        @previous_node = previous_node
+      end
+    end
+
+    class Node
+      extend T::Sig
+
+      sig { abstract.params(v: Printer).void }
+      def accept_printer(v); end
+
+      sig { params(out: T.any(IO, StringIO), indent: Integer).void }
+      def print(out: $stdout, indent: 0)
+        p = Printer.new(out: out, indent: indent)
+        p.visit(self)
+      end
+
+      sig { params(indent: Integer).returns(String) }
+      def string(indent: 0)
+        out = StringIO.new
+        print(out: out, indent: indent)
+        out.string
+      end
+
+      sig { returns(T::Boolean) }
+      def oneline?
+        true
+      end
+    end
+
+    class Tree
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.visit_all(nodes)
+      end
+
+      sig { override.returns(T::Boolean) }
+      def oneline?
+        empty?
+      end
+    end
+
+    class Scope
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        previous_node = v.previous_node
+        v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+        case self
+        when Module
+          v.printt("module #{name}")
+        when Class
+          v.printt("class #{name}")
+          superclass = superclass_name
+          v.print(" < #{superclass}") if superclass
+        when SingletonClass
+          v.printt("class << self")
+        end
+        if empty?
+          v.printn("; end")
+        else
+          v.printn
+          v.indent
+          v.visit_all(nodes)
+          v.dedent
+          v.printl("end")
+        end
+      end
+    end
+
+    class Const
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        previous_node = v.previous_node
+        v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+        v.printl("#{name} = #{value}")
+      end
+    end
+
+    class Method
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        previous_node = v.previous_node
+        v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+        v.visit_all(sigs)
+        v.printt
+        unless v.in_visibility_group || visibility == Visibility::Public
+          v.print(visibility.visibility.to_s)
+          v.print(" ")
+        end
+        v.print("def ")
+        v.print("self.") if is_singleton
+        v.print(name)
+        unless params.empty?
+          v.print("(")
+          params.each_with_index do |param, index|
+            v.print(", ") if index > 0
+            v.visit(param)
+          end
+          v.print(")")
+        end
+        v.print("; end")
+        v.printn
+      end
+
+      sig { override.returns(T::Boolean) }
+      def oneline?
+        sigs.empty?
+      end
+    end
+
+    class Param
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print(name.to_s)
+      end
+    end
+
+    class OptParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("#{name} = #{value}")
+      end
+    end
+
+    class RestParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("*#{name}")
+      end
+    end
+
+    class KwParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("#{name}:")
+      end
+    end
+
+    class KwOptParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("#{name}: #{value}")
+      end
+    end
+
+    class KwRestParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("**#{name}")
+      end
+    end
+
+    class BlockParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("&#{name}")
+      end
+    end
+
+    class Mixin
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        case self
+        when Include
+          v.printt("include")
+        when Extend
+          v.printt("extend")
+        when MixesInClassMethods
+          v.printt("mixes_in_class_methods")
+        end
+        v.printn(" #{name}")
+      end
+    end
+
+    class Visibility
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.printl(visibility.to_s)
+      end
+    end
+
+    class Sig
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.printt("sig { ")
+        v.print("abstract.") if is_abstract
+        v.print("override.") if is_override
+        v.print("overridable.") if is_overridable
+        unless type_params.empty?
+          v.print("type_parameters(")
+          type_params.each_with_index do |param, index|
+            v.print(":#{param}")
+            v.print(", ") if index < type_params.length - 1
+          end
+          v.print(").")
+        end
+        unless params.empty?
+          v.print("params(")
+          params.each_with_index do |param, index|
+            v.visit(param)
+            v.print(", ") if index < params.length - 1
+          end
+          v.print(").")
+        end
+        if return_type && return_type != "void"
+          v.print("returns(#{return_type})")
+        else
+          v.print("void")
+        end
+        v.printn(" }")
+      end
+    end
+
+    class SigParam
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.print("#{name}: #{type}")
+      end
+    end
+
+    class TStructField
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        case self
+        when TStructProp
+          v.printt("prop")
+        when TStructConst
+          v.printt("const")
+        end
+        v.print(" :#{name}, #{type}")
+        default = self.default
+        v.print(", default: #{default}") if default
+        v.printn
+      end
+    end
+
+    class TEnumBlock
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.printl("enums do")
+        v.indent
+        names.each do |name|
+          v.printl("#{name} = new")
+        end
+        v.dedent
+        v.printl("end")
+      end
+    end
+
+    class TypeMember
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        previous_node = v.previous_node
+        v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+        v.printl("#{name} = #{value}")
+      end
+    end
+
+    class Helper
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.printl("#{name}!")
+      end
+    end
+
+    class Group
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.printn unless v.previous_node.nil?
+        v.visit_all(nodes)
+      end
+    end
+
+    class VisibilityGroup
+      extend T::Sig
+
+      sig { override.params(v: Printer).void }
+      def accept_printer(v)
+        v.in_visibility_group = true
+        v.printn unless v.previous_node.nil?
+        case visibility
+        when Visibility::Protected, Visibility::Private
+          v.visit(visibility)
+          v.printn
+        end
+        v.visit_all(nodes)
+        v.in_visibility_group = false
+      end
+    end
+  end
+end