rbs 4.1.0.pre.2-java

data/schema/types.json

@@ -0,0 +1,317 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "definitions": {
+    "base": {
+      "title": "Base types",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": [
+            "bool",
+            "void",
+            "untyped",
+            "nil",
+            "top",
+            "bot",
+            "self",
+            "instance",
+            "class"
+          ]
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "location"]
+    },
+    "variable": {
+      "title": "Type variables: `X`, `Y`, `Elem`, `Key`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["variable"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "name", "location"]
+    },
+    "classSingleton": {
+      "title": "Class singleton type: `singleton(Object)`, `singleton(::Kernel)`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["class_singleton"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "name", "location"]
+    },
+    "classInstance": {
+      "title": "Class instance type: `String`, `::Enumerable`, `Array[::Symbol]`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["class_instance"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "name", "args", "location"]
+    },
+    "interface": {
+      "title": "Interface type: `_Each[String, void]`, `_ToStr`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["interface"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "name", "args", "location"]
+    },
+    "alias": {
+      "title": "Type alias: `u`, `ty`, `json`, `list[Integer]`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["alias"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "name", "args", "location"]
+    },
+    "tuple": {
+      "title": "Tuple type: `[Foo, bar]`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["tuple"]
+        },
+        "types": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "types", "location"]
+    },
+    "record": {
+      "title": "Record type: `{ id: Integer, email: String }`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["record"]
+        },
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "fields", "location"]
+    },
+    "optional": {
+      "title": "Optional types: `Integer?`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["optional"]
+        },
+        "type": {
+          "$ref": "#"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "type", "location"]
+    },
+    "union": {
+      "title": "Union types: `Integer | String`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["union"]
+        },
+        "types": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "types", "location"]
+    },
+    "intersection": {
+      "title": "Intersection types: `Integer & String`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["intersection"]
+        },
+        "types": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "types", "location"]
+    },
+    "proc": {
+      "title": "Proc types: `^() -> void`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["proc"]
+        },
+        "type": {
+          "$ref": "function.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        },
+        "block": {
+          "oneOf": [
+            { "$ref": "methodType.json#/definitions/block" },
+            { "type": "null" }
+          ]
+        },
+        "self_type": {
+          "oneOf": [
+            { "$ref": "#" },
+            { "type": "null" }
+          ]
+        }
+      },
+      "required": ["class", "type", "location", "block", "self_type"]
+    },
+    "literal": {
+      "title": "Literal types: `1`, `:foo`, `\"foo\"`, ...",
+      "type": "object",
+      "properties": {
+        "class": {
+          "type": "string",
+          "enum": ["literal"]
+        },
+        "literal": {
+          "type": "string"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["class", "literal", "location"]
+    }
+  },
+  "title": "Type",
+  "oneOf": [
+    {
+      "$ref": "#/definitions/base"
+    },
+    {
+      "$ref": "#/definitions/variable"
+    },
+    {
+      "$ref": "#/definitions/classInstance"
+    },
+    {
+      "$ref": "#/definitions/classSingleton"
+    },
+    {
+      "$ref": "#/definitions/interface"
+    },
+    {
+      "$ref": "#/definitions/alias"
+    },
+    {
+      "$ref": "#/definitions/tuple"
+    },
+    {
+      "$ref": "#/definitions/record"
+    },
+    {
+      "$ref": "#/definitions/union"
+    },
+    {
+      "$ref": "#/definitions/intersection"
+    },
+    {
+      "$ref": "#/definitions/optional"
+    },
+    {
+      "$ref": "#/definitions/proc"
+    },
+    {
+      "$ref": "#/definitions/literal"
+    }
+  ]
+}

data/sig/ancestor_builder.rbs

@@ -0,0 +1,163 @@
+module RBS
+  class DefinitionBuilder
+    # AncestorBuilder calculates the ancestors of a class or module.
+    #
+    class AncestorBuilder
+      # OneAncestors represents a list of _direct_ ancestors of a type name
+      #
+      # _Direct_ ancestors is defined as follows:
+      #
+      # * Super class is a direct ancestor
+      # * Self type constraints are direct ancestors
+      # * Mixin modules are direct ancestors
+      # * Mixin interfaces are direct ancestors
+      #
+      # The optional attributes are defined by the type of the ancestors object, one of the following five groups:
+      #
+      # 1. Instance of a class -- with super_class, included_modules, included_interfaces, and prepended_modules
+      # 2. Instance of a module -- with self_types, included_modules, included_interfaces, and prepended_modules
+      # 3. Singleton of a class or module -- with super_class, extended_modules, and extended_interfaces
+      # 4. Interface -- with included_interfaces
+      #
+      class OneAncestors
+        attr_reader type_name: TypeName
+        attr_reader params: Array[Symbol]?
+
+        # Returns super_class ancestor if specified
+        #
+        # * Always `nil` if this is not a class.
+        #
+        attr_reader super_class: Definition::Ancestor::t?
+
+        # Returns list of _self type constraints_ of a module
+        #
+        # * Returns `nil` if it is not a module instance.
+        #
+        attr_reader self_types: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of included modules
+        #
+        # * Returns `nil` if it is an interface or it is a singleton.
+        #
+        attr_reader included_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of included interfaces
+        #
+        # * Returns `nil` it it is a singleton.
+        #
+        attr_reader included_interfaces: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of prepended modules
+        #
+        # * Returns `nil` if it is an interface or it is a singleton.
+        #
+        attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of extended modules
+        #
+        # * Returns `nil` if it is an interface or it is an instance.
+        #
+        attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of extended interfaces
+        #
+        # * Returns `nil` if it is an interface or it is an instance.
+        #
+        attr_reader extended_interfaces: Array[Definition::Ancestor::Instance]?
+
+        def initialize: (type_name: TypeName,
+                            params: Array[Symbol]?,
+                       super_class: Definition::Ancestor::t?,
+                        self_types: Array[Definition::Ancestor::Instance]?,
+                  included_modules: Array[Definition::Ancestor::Instance]?,
+               included_interfaces: Array[Definition::Ancestor::Instance]?,
+                 prepended_modules: Array[Definition::Ancestor::Instance]?,
+                  extended_modules: Array[Definition::Ancestor::Instance]?,
+               extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+        def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
+                         | -> Enumerator[Definition::Ancestor::t, void]
+
+        # Returns a OneAncestors object for class instance
+        def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
+
+        # Returns a OneAncestors object for module instance
+        def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        # Returns a OneAncestors object for class/module singleton
+        def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t) -> instance
+
+        # Returns a OneAncestors object for interface
+        def self.interface: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def each_included_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_included_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_prepended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                 | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_self_type: () { (Definition::Ancestor::Instance) -> void } -> void
+                          | () -> Enumerator[Definition::Ancestor::Instance, void]
+      end
+
+      attr_reader env: Environment
+
+      attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader singleton_ancestors_cache: Hash[TypeName, Definition::SingletonAncestors]
+
+      attr_reader one_interface_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader interface_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      def initialize: (env: Environment) -> void
+
+      def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
+
+      def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def one_instance_ancestors: (TypeName) -> OneAncestors
+
+      def one_singleton_ancestors: (TypeName) -> OneAncestors
+
+      def one_interface_ancestors: (TypeName) -> OneAncestors
+
+      private
+
+      def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+      def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
+                            TypeName,
+                            included_modules: Array[Definition::Ancestor::Instance]?,
+                         included_interfaces: Array[Definition::Ancestor::Instance]?,
+                           prepended_modules: Array[Definition::Ancestor::Instance]?,
+                            extended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface | AST::Ruby::Declarations::ClassDecl | AST::Ruby::Declarations::ModuleDecl,
+                             TypeName,
+                             align_params: Substitution?,
+                         included_modules: Array[Definition::Ancestor::Instance]?,
+                      included_interfaces: Array[Definition::Ancestor::Instance]?,
+                        prepended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_modules: Array[Definition::Ancestor::Instance]?,
+                      extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      # Fill `#source` of instance ancestor if `ancestor.name == name` and its `source` is `nil`
+      #
+      def fill_ancestor_source: (Definition::Ancestor::t, name: TypeName, source: Definition::Ancestor::Instance::source)  -> Definition::Ancestor::t
+    end
+  end
+end

data/sig/ancestor_graph.rbs

@@ -0,0 +1,60 @@
+module RBS
+  # AncestorGraph is a utility class that helps iterating through ancestors and descendants of a class/module
+  #
+  # ```ruby
+  # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
+  #
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  #
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # ```
+  #
+  # Note that the class works for class/module declarations.
+  # All of the *alias* classes/modules are ignored.
+  #
+  # * Alias classes/modules doesn't count as a parent nor child
+  # * Passing alias classes/modules to the method doesn't yield anything
+  #
+  class AncestorGraph
+    class InstanceNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class SingletonNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    type node = InstanceNode | SingletonNode
+
+    attr_reader env: Environment
+    attr_reader ancestor_builder: DefinitionBuilder::AncestorBuilder
+    attr_reader parents: Hash[node, Set[node]]
+    attr_reader children: Hash[node, Set[node]]
+
+    def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
+
+    def each_parent: (node) { (node) -> void } -> void
+                   | (node) -> Enumerator[node, void]
+
+    def each_ancestor: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                     | (node) -> Enumerator[node, void]
+
+    def each_child: (node) { (node) -> void } -> void
+                  | (node) -> Enumerator[node, void]
+
+    def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                       | (node) -> Enumerator[node, void]
+
+    private
+
+    def build: () -> void
+
+    def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
+
+    def register: (parent: node, child: node) -> void
+  end
+end

data/sig/annotate/annotations.rbs

@@ -0,0 +1,102 @@
+module RBS
+  module Annotate
+    class Annotations
+      type t = Skip | Source | Copy
+
+      def self.parse: (AST::Annotation) -> t?
+
+      attr_reader items: Array[t]
+
+      def initialize: (Array[t]) -> void
+
+      def skip?: () -> bool
+
+      def skip_all?: () -> bool
+
+      def test_path: (String path) -> bool
+
+      def test_path_string: (String pattern, String path) -> bool
+
+      def copy_annotation: -> Copy?
+
+      # Skip annotation allows skipping generating annotation of a subject.
+      #
+      #     %a{annotate:rdoc:skip}
+      #     %a{annotate:rdoc:skip:all}
+      #
+      class Skip
+        attr_reader annotation: AST::Annotation
+
+        attr_reader skip_children: bool
+
+        def initialize: (annotation: AST::Annotation, skip_children: bool) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Source annotation allows where the documents are copied from.
+      #
+      # It allows specifying two directions: the source to read from, and the source to skip.
+      #
+      #     %a{annotate:rdoc:source:from=ext/pathname}
+      #     %a{annotate:rdoc:source:skip=ext/pathname/doc}
+      #
+      # When you want to specify several paths, repeat writing the Source annotation.
+      #
+      class Source
+        attr_reader annotation: AST::Annotation
+
+        attr_reader include_source: String?
+        attr_reader skip_source: String?
+
+        def initialize: (annotation: AST::Annotation, include: String) -> void
+                      | (annotation: AST::Annotation, skip: String) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Copy annotation allows copying the doc from another subject.
+      # This helps working with incorrect RDoc annotations.
+      #
+      #     %a{annotate:rdoc:copy:Bar#baz}
+      #     %a{annotate:rdoc:copy:Bar.baz}
+      #     %a{annotate:rdoc:copy:Bar::Baz}
+      #
+      class Copy
+        attr_reader annotation: AST::Annotation
+
+        attr_reader source: String
+
+        def initialize: (annotation: AST::Annotation, source: String) -> void
+
+        # Returns a tuple of:
+        #
+        # - Type name
+        # - A pair of:
+        #   - Boolean which holds if it is singleton
+        #   - Name of method
+        def partition: () -> [TypeName, [bool, Symbol]?]
+
+        def type_name: () -> TypeName
+
+        def method_name: () -> Symbol?
+
+        def singleton?: () -> bool
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+    end
+  end
+end

data/sig/annotate/formatter.rbs

@@ -0,0 +1,24 @@
+module RBS
+  module Annotate
+    class Formatter
+      attr_reader buffer: String
+
+      @pending_separator: String?
+
+      def initialize: () -> void
+
+      def <<: (String | RDoc::Markup::Document | nil) -> self
+
+      def margin: (?separator: String) -> self
+
+      def empty?: () -> bool
+
+      def format: (newline_at_end: bool) -> String
+
+      def self.translate: (RDoc::Markup::Document) -> String?
+
+      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
+    end
+  end
+end