rbi 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3ec679e5a50e9325d794c32a93ca12eb08aff102e12b21e6476a172b8001cba
-  data.tar.gz: 5abffaaba601923ebe58dd49e5c59aba2faf41a73ee4571b15e157c5f220297f
+  metadata.gz: f74d8bfd9f52c65d39357d68e286e247a48d53779397c11f310b50ca37b3b925
+  data.tar.gz: 0a924a9c84c508cbb70b307a1b8770f00b1c855d68c41c57e0dd74dfd1f75d86
 SHA512:
-  metadata.gz: dfebab9782d4817841ec80c87d81ff9919df026de13614fe056bc4ca0cd9ab4546f861c230172023d8f3c185b60b1155e076c7ef22ef420421bd1203879f15b0
-  data.tar.gz: bae1339fd94ad30d5d6997611b1ac14fc36d9119607a32f954ab2361112c5ec5c31181636409df223c190348477917cf2e27da3d2bae0551295836273e59fcbb
+  metadata.gz: 303c4606968022e24e65f0d9a54732431ee7c6cc315dffe592e0196e5c449a5842319d32897231f046ca8266ccaf3dc9743fd7229582988b5a590c381cf4473b
+  data.tar.gz: 955d836aea51639220440f984fa0a8c595c763521b84ddca73dfdd08b8b546bc5b61e3fc48a19ddd04e50a7824377cc25960816a9ac2d65454ab8821259acda8

data/Gemfile

@@ -5,9 +5,12 @@ source "https://rubygems.org"
 
 gemspec
 
-group(:development) do
-  gem('rubocop-shopify', require: false)
-  gem('rubocop-sorbet', require: false)
-  gem('byebug')
-  gem('pry-byebug')
+group(:development, :test) do
+  gem("byebug")
+  gem("minitest")
+  gem("rubocop", "~> 1.7", require: false)
+  gem("rubocop-shopify", require: false)
+  gem("rubocop-sorbet", require: false)
+  gem("sorbet", require: false)
+  gem("tapioca", require: false, github: "Shopify/tapioca", branch: "master")
 end

data/README.md

@@ -1,8 +1,6 @@
-# Rbi
+# RBI generation framework
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rbi`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+`RBI` provides a Ruby API to compose Ruby interface files consumed by Sorbet.
 
 ## Installation
 
@@ -14,7 +12,7 @@ gem 'rbi'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -22,17 +20,47 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```rb
+require "rbi"
+
+rbi = RBI::File.new(strictness: "true") do |file|
+  file << RBI::Module.new("Foo") do |mod|
+    mod << RBI::Method.new("foo")
+  end
+end
+
+puts rbi.string
+```
+
+will produce:
+
+```rb
+# typed: true
+
+module Foo
+  def foo; end
+end
+```
+
+## Features
+
+* RBI generation API
+* RBI parsing with Whitequark
+* RBI formatting
+* RBI validation
+* RBI merging
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+This repo uses itself (`rbi`) to retrieve and generate gem RBIs. You can run `dev rbi` to update local gem RBIs with RBIs from the central repo.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rbi/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -40,4 +68,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Rbi project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rbi/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Rbi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rbi/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,7 +1,9 @@
 # typed: true
 # frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "rubocop/rake_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"

data/lib/rbi.rb

@@ -1,11 +1,22 @@
-# typed: true
+# typed: strict
+# frozen_string_literal: true
 
 require "sorbet-runtime"
-require "thor"
-
-require "rbi/version"
-require "rbi/cli"
+require "stringio"
 
 module RBI
   class Error < StandardError; end
 end
+
+require "rbi/loc"
+require "rbi/model"
+require "rbi/visitor"
+require "rbi/index"
+require "rbi/rewriters/merge_trees"
+require "rbi/rewriters/nest_singleton_methods"
+require "rbi/rewriters/nest_non_public_methods"
+require "rbi/rewriters/group_nodes"
+require "rbi/rewriters/sort_nodes"
+require "rbi/parser"
+require "rbi/printer"
+require "rbi/version"

data/lib/rbi/index.rb

@@ -0,0 +1,186 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Index < Visitor
+    extend T::Sig
+    include T::Enumerable
+
+    sig { params(node: Node).returns(Index) }
+    def self.index(*node)
+      index = Index.new
+      index.visit_all(node)
+      index
+    end
+
+    sig { void }
+    def initialize
+      super()
+      @index = T.let({}, T::Hash[String, T::Array[Node]])
+    end
+
+    sig { returns(T::Array[String]) }
+    def keys
+      @index.keys
+    end
+
+    sig { params(id: String).returns(T::Array[Node]) }
+    def [](id)
+      @index[id] ||= []
+    end
+
+    sig { params(node: T.all(Indexable, Node)).void }
+    def index(node)
+      node.index_ids.each { |id| self[id] << node }
+    end
+
+    sig { override.params(node: T.nilable(Node)).void }
+    def visit(node)
+      return unless node
+
+      case node
+      when Scope
+        index(node)
+        visit_all(node.nodes)
+      when Tree
+        visit_all(node.nodes)
+      when Indexable
+        index(node)
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { returns(Index) }
+    def index
+      Index.index(self)
+    end
+  end
+
+  # A Node that can be refered to by a unique ID inside an index
+  module Indexable
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    # Unique IDs that refer to this node.
+    #
+    # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the
+    # getter and the setter.
+    sig { abstract.returns(T::Array[String]) }
+    def index_ids; end
+  end
+
+  class Scope
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [fully_qualified_name]
+    end
+  end
+
+  class Const
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [fully_qualified_name]
+    end
+  end
+
+  class Attr
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      fully_qualified_names
+    end
+  end
+
+  class Method
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [fully_qualified_name]
+    end
+  end
+
+  class Include
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      names.map { |name| "#{parent_scope&.fully_qualified_name}.include(#{name})" }
+    end
+  end
+
+  class Extend
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      names.map { |name| "#{parent_scope&.fully_qualified_name}.extend(#{name})" }
+    end
+  end
+
+  class MixesInClassMethods
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      names.map { |name| "#{parent_scope&.fully_qualified_name}.mixes_in_class_method(#{name})" }
+    end
+  end
+
+  class Helper
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [to_s]
+    end
+  end
+
+  class TStructConst
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      fully_qualified_names
+    end
+  end
+
+  class TStructProp
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      fully_qualified_names
+    end
+  end
+
+  class TEnumBlock
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [to_s]
+    end
+  end
+end

data/lib/rbi/loc.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Loc
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :file
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :begin_line, :end_line, :begin_column, :end_column
+
+    sig do
+      params(
+        file: T.nilable(String),
+        begin_line: T.nilable(Integer),
+        end_line: T.nilable(Integer),
+        begin_column: T.nilable(Integer),
+        end_column: T.nilable(Integer)
+      ).void
+    end
+    def initialize(file: nil, begin_line: nil, end_line: nil, begin_column: nil, end_column: nil)
+      @file = file
+      @begin_line = begin_line
+      @end_line = end_line
+      @begin_column = begin_column
+      @end_column = end_column
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{file}:#{begin_line}:#{begin_column}-#{end_line}:#{end_column}"
+    end
+  end
+end

data/lib/rbi/model.rb

@@ -0,0 +1,879 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Node
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T.nilable(Tree)) }
+    attr_accessor :parent_tree
+
+    sig { returns(T.nilable(Loc)) }
+    attr_accessor :loc
+
+    sig { params(loc: T.nilable(Loc)).void }
+    def initialize(loc: nil)
+      @parent_tree = nil
+      @loc = loc
+    end
+
+    sig { void }
+    def detach
+      tree = parent_tree
+      return unless tree
+      tree.nodes.delete(self)
+      self.parent_tree = nil
+    end
+
+    sig { params(node: Node).void }
+    def replace(node)
+      tree = parent_tree
+      raise unless tree
+      index = tree.nodes.index(self)
+      raise unless index
+      tree.nodes[index] = node
+      node.parent_tree = tree
+      self.parent_tree = nil
+    end
+
+    sig { returns(T.nilable(Scope)) }
+    def parent_scope
+      parent = T.let(parent_tree, T.nilable(Tree))
+      parent = parent.parent_tree until parent.is_a?(Scope) || parent.nil?
+      parent
+    end
+  end
+
+  class Comment < Node
+    extend T::Helpers
+
+    sig { returns(String) }
+    attr_accessor :text
+
+    sig { params(text: String, loc: T.nilable(Loc)).void }
+    def initialize(text, loc: nil)
+      super(loc: loc)
+      @text = text
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Comment)
+      text == other.text
+    end
+  end
+
+  class NodeWithComments < Node
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T::Array[Comment]) }
+    attr_accessor :comments
+
+    sig { params(loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(loc: nil, comments: [])
+      super(loc: loc)
+      @comments = comments
+    end
+  end
+
+  class Tree < NodeWithComments
+    extend T::Sig
+
+    sig { returns(T::Array[Node]) }
+    attr_reader :nodes
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(tree: Tree).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments)
+      @nodes = T.let([], T::Array[Node])
+      block&.call(self)
+    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
+
+  class File
+    extend T::Sig
+
+    sig { returns(Tree) }
+    attr_reader :root
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :strictness
+
+    sig { returns(T::Array[Comment]) }
+    attr_accessor :comments
+
+    sig do
+      params(
+        strictness: T.nilable(String),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(mod: File).void)
+      ).void
+    end
+    def initialize(strictness: nil, comments: [], &block)
+      @root = T.let(Tree.new, Tree)
+      @strictness = strictness
+      @comments = comments
+      block&.call(self)
+    end
+
+    sig { params(node: Node).void }
+    def <<(node)
+      @root << node
+    end
+  end
+
+  # Scopes
+
+  class Scope < Tree
+    extend T::Helpers
+
+    abstract!
+
+    sig { abstract.returns(String) }
+    def fully_qualified_name; end
+
+    sig { override.returns(String) }
+    def to_s
+      fully_qualified_name
+    end
+  end
+
+  class Module < Scope
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_accessor :name
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(mod: Module).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments) {}
+      @name = name
+      block&.call(self)
+    end
+
+    sig { override.returns(String) }
+    def fully_qualified_name
+      return name if name.start_with?("::")
+      "#{parent_scope&.fully_qualified_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 do
+      params(
+        name: String,
+        superclass_name: T.nilable(String),
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(klass: Class).void)
+      ).void
+    end
+    def initialize(name, superclass_name: nil, loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments) {}
+      @name = name
+      @superclass_name = superclass_name
+      block&.call(self)
+    end
+
+    sig { override.returns(String) }
+    def fully_qualified_name
+      return name if name.start_with?("::")
+      "#{parent_scope&.fully_qualified_name}::#{name}"
+    end
+  end
+
+  class SingletonClass < Scope
+    extend T::Sig
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(klass: SingletonClass).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments) {}
+      block&.call(self)
+    end
+
+    sig { override.returns(String) }
+    def fully_qualified_name
+      "#{parent_scope&.fully_qualified_name}::<self>"
+    end
+  end
+
+  # Consts
+
+  class Const < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name, :value
+
+    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, value, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+      @value = value
+    end
+
+    sig { returns(String) }
+    def fully_qualified_name
+      return name if name.start_with?("::")
+      "#{parent_scope&.fully_qualified_name}::#{name}"
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      fully_qualified_name
+    end
+  end
+
+  # Attributes
+
+  class Attr < NodeWithComments
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T::Array[Symbol]) }
+    attr_accessor :names
+
+    sig { returns(Visibility) }
+    attr_accessor :visibility
+
+    sig { returns(T::Array[Sig]) }
+    attr_reader :sigs
+
+    sig do
+      params(
+        name: Symbol,
+        names: Symbol,
+        visibility: Visibility,
+        sigs: T::Array[Sig],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment]
+      ).void
+    end
+    def initialize(name, *names, visibility: Visibility::Public, sigs: [], loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @names = T.let([name, *names], T::Array[Symbol])
+      @visibility = visibility
+      @sigs = sigs
+    end
+
+    sig { abstract.returns(T::Array[String]) }
+    def fully_qualified_names; end
+  end
+
+  class AttrAccessor < Attr
+    extend T::Sig
+
+    sig { override.returns(T::Array[String]) }
+    def fully_qualified_names
+      parent_name = parent_scope&.fully_qualified_name
+      names.flat_map { |name| ["#{parent_name}##{name}", "#{parent_name}##{name}="] }
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      symbols = names.map { |name| ":#{name}" }.join(", ")
+      "#{parent_scope&.fully_qualified_name}.attr_accessor(#{symbols})"
+    end
+  end
+
+  class AttrReader < Attr
+    extend T::Sig
+
+    sig { override.returns(T::Array[String]) }
+    def fully_qualified_names
+      parent_name = parent_scope&.fully_qualified_name
+      names.map { |name| "#{parent_name}##{name}" }
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      symbols = names.map { |name| ":#{name}" }.join(", ")
+      "#{parent_scope&.fully_qualified_name}.attr_reader(#{symbols})"
+    end
+  end
+
+  class AttrWriter < Attr
+    extend T::Sig
+
+    sig { override.returns(T::Array[String]) }
+    def fully_qualified_names
+      parent_name = parent_scope&.fully_qualified_name
+      names.map { |name| "#{parent_name}##{name}=" }
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      symbols = names.map { |name| ":#{name}" }.join(", ")
+      "#{parent_scope&.fully_qualified_name}.attr_writer(#{symbols})"
+    end
+  end
+
+  # Methods and args
+
+  class Method < NodeWithComments
+    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],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(mod: Method).void)
+      ).void
+    end
+    def initialize(
+      name,
+      params: [],
+      is_singleton: false,
+      visibility: Visibility::Public,
+      sigs: [],
+      loc: nil,
+      comments: [],
+      &block
+    )
+      super(loc: loc, comments: comments)
+      @name = name
+      @params = params
+      @is_singleton = is_singleton
+      @visibility = visibility
+      @sigs = sigs
+      block&.call(self)
+    end
+
+    sig { params(param: Param).void }
+    def <<(param)
+      @params << param
+    end
+
+    sig { returns(String) }
+    def fully_qualified_name
+      if is_singleton
+        "#{parent_scope&.fully_qualified_name}::#{name}"
+      else
+        "#{parent_scope&.fully_qualified_name}##{name}"
+      end
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{fully_qualified_name}(#{params.join(", ")})"
+    end
+  end
+
+  class Param < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { params(name: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      name
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(Param)
+      name == T.cast(other, Param).name
+    end
+  end
+
+  class OptParam < Param
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :value
+
+    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, value, loc: nil, comments: [])
+      super(name, loc: loc, comments: comments)
+      @value = value
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(OptParam)
+      other = T.cast(other, OptParam)
+      return false unless name == other.name
+      value == other.value
+    end
+  end
+
+  class RestParam < Param
+    extend T::Sig
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(RestParam)
+      name == T.cast(other, RestParam).name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "*#{name}"
+    end
+  end
+
+  class KwParam < Param
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "#{name}:"
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(KwParam)
+      name == T.cast(other, KwParam).name
+    end
+  end
+
+  class KwOptParam < OptParam
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "#{name}:"
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(KwOptParam)
+      other = T.cast(other, KwOptParam)
+      return false unless name == other.name
+      value == other.value
+    end
+  end
+
+  class KwRestParam < Param
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "**#{name}:"
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(KwRestParam)
+      name == T.cast(other, KwRestParam).name
+    end
+  end
+
+  class BlockParam < Param
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "&#{name}"
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.instance_of?(BlockParam)
+      name == T.cast(other, BlockParam).name
+    end
+  end
+
+  # Mixins
+
+  class Mixin < NodeWithComments
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T::Array[String]) }
+    attr_accessor :names
+
+    sig { params(name: String, names: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, *names, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @names = T.let([name, *names], T::Array[String])
+    end
+  end
+
+  class Include < Mixin
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.include(#{names.join(", ")})"
+    end
+  end
+
+  class Extend < Mixin
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.extend(#{names.join(", ")})"
+    end
+  end
+
+  # Visibility
+
+  class Visibility < Node
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(Symbol) }
+    attr_reader :visibility
+
+    sig { params(visibility: Symbol, loc: T.nilable(Loc)).void }
+    def initialize(visibility, loc: nil)
+      super(loc: loc)
+      @visibility = visibility
+    end
+
+    sig { params(other: Visibility).returns(T::Boolean) }
+    def ==(other)
+      visibility == other.visibility
+    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 { returns(T.nilable(Symbol)) }
+    attr_accessor :checked
+
+    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],
+        checked: T.nilable(Symbol),
+        loc: T.nilable(Loc)
+      ).void
+    end
+    def initialize(
+      params: [],
+      return_type: nil,
+      is_abstract: false,
+      is_override: false,
+      is_overridable: false,
+      type_params: [],
+      checked: nil,
+      loc: nil
+    )
+      super(loc: loc)
+      @params = params
+      @return_type = return_type
+      @is_abstract = is_abstract
+      @is_override = is_override
+      @is_overridable = is_overridable
+      @type_params = type_params
+      @checked = checked
+    end
+
+    sig { params(param: SigParam).void }
+    def <<(param)
+      @params << param
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Sig)
+      params == other.params && return_type == other.return_type && is_abstract == other.is_abstract &&
+        is_override == other.is_override && is_overridable == other.is_overridable &&
+        type_params == other.type_params && checked == other.checked
+    end
+  end
+
+  class SigParam < Node
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name, :type
+
+    sig { params(name: String, type: String, loc: T.nilable(Loc)).void }
+    def initialize(name, type, loc: nil)
+      super(loc: loc)
+      @name = name
+      @type = type
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      other.is_a?(SigParam) && name == other.name && type == other.type
+    end
+  end
+
+  # Sorbet's T::Struct
+
+  class TStruct < Class
+    extend T::Sig
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(klass: TStruct).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, superclass_name: "::T::Struct", loc: loc, comments: comments) {}
+      block&.call(self)
+    end
+  end
+
+  class TStructField < NodeWithComments
+    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),
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment]
+      ).void
+    end
+    def initialize(name, type, default: nil, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+      @type = type
+      @default = default
+    end
+
+    sig { abstract.returns(T::Array[String]) }
+    def fully_qualified_names; end
+  end
+
+  class TStructConst < TStructField
+    extend T::Sig
+
+    sig { override.returns(T::Array[String]) }
+    def fully_qualified_names
+      parent_name = parent_scope&.fully_qualified_name
+      ["#{parent_name}##{name}"]
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.const(:#{name})"
+    end
+  end
+
+  class TStructProp < TStructField
+    extend T::Sig
+
+    sig { override.returns(T::Array[String]) }
+    def fully_qualified_names
+      parent_name = parent_scope&.fully_qualified_name
+      ["#{parent_name}##{name}", "#{parent_name}##{name}="]
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.prop(:#{name})"
+    end
+  end
+
+  # Sorbet's T::Enum
+
+  class TEnum < Class
+    extend T::Sig
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(klass: TEnum).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, superclass_name: "::T::Enum", loc: loc, comments: comments) {}
+      block&.call(self)
+    end
+  end
+
+  class TEnumBlock < NodeWithComments
+    extend T::Sig
+
+    sig { returns(T::Array[String]) }
+    attr_reader :names
+
+    sig { params(names: T::Array[String], loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(names = [], loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @names = names
+    end
+
+    sig { returns(T::Boolean) }
+    def empty?
+      names.empty?
+    end
+
+    sig { params(name: String).void }
+    def <<(name)
+      @names << name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.enums"
+    end
+  end
+
+  # Sorbet's misc.
+
+  class Helper < NodeWithComments
+    extend T::Helpers
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { params(name: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.#{name}!"
+    end
+  end
+
+  class TypeMember < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name, :value
+
+    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(name, value, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+      @value = value
+    end
+
+    sig { returns(String) }
+    def fully_qualified_name
+      return name if name.start_with?("::")
+      "#{parent_scope&.fully_qualified_name}::#{name}"
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      fully_qualified_name
+    end
+  end
+
+  class MixesInClassMethods < Mixin
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.mixes_in_class_methods(#{names.join(", ")})"
+    end
+  end
+end