rbs-relaxed 3.9.0.1

data/sig/variance_calculator.rbs

@@ -0,0 +1,87 @@
+module RBS
+  # Calculate the use variances of type variables in declaration.
+  #
+  # ```rb
+  # calculator = VarianceCalculator.new(builder: builder)
+  #
+  # # Calculates variances in a method type
+  # result = calculator.in_method_type(method_type: method_type, variables: variables)
+  #
+  # # Calculates variances in a inheritance/mixin/...
+  # result = calculator.in_inherit(name: name, args: args, variables: variables)
+  #
+  # # Calculates variances in a type alias
+  # result = calculator.in_type_alias(name: name, args: args, variables: variables)
+  # ```
+  #
+  # See `RBS::VarianceCalculator::Result` for information recorded in the `Result` object.
+  #
+  class VarianceCalculator
+    type variance = :unused | :covariant | :contravariant | :invariant
+
+    # Result contains the set of type variables and it's variance in a occurrence.
+    #
+    # ```rb
+    # # Enumerates recorded type variables
+    # result.each do |name, variance|
+    #   # name is the name of a type variable
+    #   # variance is one of :unused | :covariant | :contravariant | :invariant
+    # end
+    # ```
+    #
+    # You can test with `compatible?` method if the type variable occurrences are compatible with specified (annotated) variance.
+    #
+    # ```rb
+    # # When T is declared as `out T`
+    # result.compatible?(:T, with_annotation: :covariant)
+    #
+    # # When T is declared as `in T`
+    # result.compatible?(:T, with_annotation: :contravariant)
+    #
+    # # When T is declared as `T`
+    # result.compatible?(:T, with_annotation: :invariant)
+    # ```
+    #
+    class Result
+      attr_reader result: Hash[Symbol, variance]
+
+      def initialize: (variables: Array[Symbol]) -> void
+
+      def covariant: (Symbol) -> void
+
+      def contravariant: (Symbol) -> void
+
+      def invariant: (Symbol) -> void
+
+      def each: () { ([Symbol, variance]) -> void } -> void
+
+      def include?: (Symbol) -> bool
+
+      def compatible?: (Symbol, with_annotation: variance) -> bool
+
+      def incompatible?: (Array[AST::TypeParam]) -> Set[Symbol]?
+    end
+
+    attr_reader builder: DefinitionBuilder
+
+    def initialize: (builder: DefinitionBuilder) -> void
+
+    def env: () -> Environment
+
+    def in_method_type: (method_type: MethodType, variables: Array[Symbol]) -> Result
+
+    def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
+
+    # The type name must be normalized
+    #
+    def in_type_alias: (name: TypeName) -> Result
+
+    private
+
+    def type: (Types::t, result: Result, context: variance) -> void
+
+    def function: (Types::function, result: Result, context: variance) -> void
+
+    def negate: (variance) -> variance
+  end
+end

data/sig/vendorer.rbs

@@ -0,0 +1,51 @@
+module RBS
+  # Copies RBS files loaded through `loader` under `vendor_dir`.
+  #
+  # Core libraries and library RBS files will be copied.
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new()
+  #
+  # loader.add(library: set)               # Libraries will be copied.
+  # loader.add(library: "minitest", version: "1.2.3")
+  #
+  # loader.add(path: Pathname("sig"))      # Dirs will be ignored.
+  #
+  # vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
+  # vendorer.clean!
+  # vendorer.copy!
+  # ```
+  #
+  # The result will be:
+  #
+  # ```
+  # vendor/rbs/core            => Will include core RBSs
+  # vendor/rbs/set-0           => Will include `set` library RBSs.
+  # vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
+  # ```
+  #
+  # The vendored RBSs will be loaded through :dir source.
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
+  # loader.add(path: Pathname("vendor/rbs"))
+  # loader.add(path: Pathname("sig"))
+  # ```
+  #
+  class Vendorer
+    attr_reader vendor_dir: Pathname
+    attr_reader loader: EnvironmentLoader
+
+    def initialize: (vendor_dir: Pathname, loader: EnvironmentLoader) -> void
+
+    # Copy RBS files into `vendor_dir`.
+    # Ensures the `vendor_dir` exists.
+    def copy!: () -> void
+
+    # Deletes `vendor_dir` and its content if exists.
+    #
+    def clean!: () -> void
+
+    def ensure_dir: [A] () { () -> A } -> A
+  end
+end

data/sig/version.rbs

@@ -0,0 +1,3 @@
+module RBS
+  VERSION: String
+end

data/sig/visitor.rbs

@@ -0,0 +1,47 @@
+module RBS
+  module AST
+    class Visitor
+      def visit_all: (Enumerable[(Members::Base | Declarations::Base)] nodes) -> void
+
+      def visit: ((Members::Base | Declarations::Base) node) -> void
+
+      def visit_declaration_global: (Declarations::Global node) -> void
+
+      def visit_declaration_class: (Declarations::Class node) -> void
+
+      def visit_declaration_module: (Declarations::Module node) -> void
+
+      def visit_declaration_constant: (Declarations::Constant node) -> void
+
+      def visit_declaration_type_alias: (Declarations::TypeAlias node) -> void
+
+      def visit_declaration_interface: (Declarations::Interface node) -> void
+
+      def visit_member_alias: (Members::Alias node) -> void
+
+      def visit_member_class_instance_variable: (Members::ClassInstanceVariable node) -> void
+
+      def visit_member_class_variable: (Members::ClassVariable node) -> void
+
+      def visit_member_instance_variable: (Members::InstanceVariable node) -> void
+
+      def visit_member_private: (Members::Private node) -> void
+
+      def visit_member_public: (Members::Public node) -> void
+
+      def visit_member_method_definition: (Members::MethodDefinition node) -> void
+
+      def visit_member_attr_reader: (Members::AttrReader node) -> void
+
+      def visit_member_attr_writer: (Members::AttrWriter node) -> void
+
+      def visit_member_attr_accessor: (Members::AttrAccessor node) -> void
+
+      def visit_member_include: (Members::Include node) -> void
+
+      def visit_member_prepend: (Members::Prepend node) -> void
+
+      def visit_member_extend: (Members::Extend node) -> void
+    end
+  end
+end

data/sig/writer.rbs

@@ -0,0 +1,127 @@
+module RBS
+  # Writer prints RBS AST to String.
+  #
+  class Writer
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    # Channel to output the result.
+    #
+    attr_reader out: _IO
+
+    # Array of indentations.
+    #
+    attr_reader indentation: Array[String]
+
+    def initialize: (out: _IO) -> void
+
+    # Output the array of declarations.
+    # It automatically inserts empty lines between the declarations.
+    #
+    def write: (Array[AST::Declarations::t | AST::Directives::t]) -> void
+
+    def preserve?: () -> bool
+
+    def preserve!: (?preserve: bool) -> self
+
+    private
+
+    @preserve: bool
+
+    # Increases the indentation and yields the block.
+    #
+    def indent: (?Integer size) { () -> void } -> void
+
+    # Returns the current indentation of lines.
+    #
+    def prefix: () -> String
+
+    # Prints a string.
+    # Automatically appends the `#prefix` and newline at the end.
+    #
+    def puts: (?String) -> void
+
+    # Prints a (possibly) multi-line string.
+    #
+    # Drops `leading_spaces` of spaces at the beginning of each line.
+    #
+    # ```ruby
+    # put_lines(<<TEXT, leading_spaces: 0)
+    # Hello
+    #   world!
+    # TEXT
+    #
+    # # Outputs
+    # # Hello
+    # #   world!
+    #
+    # put_lines(<<TEXT, leading_spaces: 2)
+    # Hello
+    #   world!
+    # TEXT
+    #
+    # # Outputs
+    # # Hello
+    # # world!
+    # ```
+    #
+    # This is for `Location#source`.
+    # The `#source` returns the text spans from the beginning to end of the element.
+    # It will look like the following.
+    #
+    # ```rbs
+    # module Foo
+    #   type t = Integer     # the definition of `t` starts from line=2, column=2
+    #          | String
+    #          | :false      # the definition of `t` ends from line=4, column=17
+    # end
+    # ```
+    #
+    # The expected output will be something like:
+    #
+    # ```rbs
+    # type t = Integer       # Extracted from `Foo` definition and keeps the line breaks
+    #        | String
+    #        | :false
+    # ```
+    #
+    # And it can be done with a `#put_lines(source, leading_spaces: 2)` call.
+    #
+    def put_lines: (String, leading_spaces: Integer) -> void
+
+    def write_loc_source: (_Located) { () -> void } -> void
+
+    def format_annotation: (AST::Annotation) -> String
+
+    def write_use_directive: (AST::Directives::Use) -> void
+
+    def write_annotation: (Array[AST::Annotation]) -> void
+
+    def write_comment: (AST::Comment?) -> void
+
+    def write_decl: (AST::Declarations::t) -> void
+
+    def write_member: (AST::Declarations::Module::member) -> void
+
+    def name_and_params: (TypeName, Array[AST::TypeParam]) -> String?
+
+    def name_and_args: (TypeName, Array[Types::t]) -> String?
+
+    def write_alias: (AST::Declarations::TypeAlias) -> void
+
+    def method_name: (Symbol) -> String
+
+    def write_def: (AST::Members::MethodDefinition) -> void
+
+    def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
+
+    interface _Located
+      def location: () -> Location[untyped, untyped]?
+    end
+
+    def preserve_empty_line: (_Located?, _Located) -> void
+  end
+end

data/src/constants.c

@@ -0,0 +1,153 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually.                                                      */
+/* To change the template see                                                 */
+/* templates/src/constants.c.erb                                              */
+/*----------------------------------------------------------------------------*/
+
+#include "rbs_extension.h"
+
+VALUE RBS_Parser;
+
+VALUE RBS;
+VALUE RBS_AST;
+VALUE RBS_AST_Declarations;
+VALUE RBS_AST_Directives;
+VALUE RBS_AST_Members;
+VALUE RBS_Parser;
+VALUE RBS_Types;
+VALUE RBS_Types_Bases;
+
+VALUE RBS_AST_Annotation;
+VALUE RBS_AST_Comment;
+VALUE RBS_AST_Declarations_Class;
+VALUE RBS_AST_Declarations_Class_Super;
+VALUE RBS_AST_Declarations_ClassAlias;
+VALUE RBS_AST_Declarations_Constant;
+VALUE RBS_AST_Declarations_Global;
+VALUE RBS_AST_Declarations_Interface;
+VALUE RBS_AST_Declarations_Module;
+VALUE RBS_AST_Declarations_Module_Self;
+VALUE RBS_AST_Declarations_ModuleAlias;
+VALUE RBS_AST_Declarations_TypeAlias;
+VALUE RBS_AST_Directives_Use;
+VALUE RBS_AST_Directives_Use_SingleClause;
+VALUE RBS_AST_Directives_Use_WildcardClause;
+VALUE RBS_AST_Members_Alias;
+VALUE RBS_AST_Members_AttrAccessor;
+VALUE RBS_AST_Members_AttrReader;
+VALUE RBS_AST_Members_AttrWriter;
+VALUE RBS_AST_Members_ClassInstanceVariable;
+VALUE RBS_AST_Members_ClassVariable;
+VALUE RBS_AST_Members_Extend;
+VALUE RBS_AST_Members_Include;
+VALUE RBS_AST_Members_InstanceVariable;
+VALUE RBS_AST_Members_MethodDefinition;
+VALUE RBS_AST_Members_MethodDefinition_Overload;
+VALUE RBS_AST_Members_Prepend;
+VALUE RBS_AST_Members_Private;
+VALUE RBS_AST_Members_Public;
+VALUE RBS_AST_TypeParam;
+VALUE RBS_MethodType;
+VALUE RBS_Namespace;
+VALUE RBS_TypeName;
+VALUE RBS_Types_Alias;
+VALUE RBS_Types_Bases_Any;
+VALUE RBS_Types_Bases_Bool;
+VALUE RBS_Types_Bases_Bottom;
+VALUE RBS_Types_Bases_Class;
+VALUE RBS_Types_Bases_Instance;
+VALUE RBS_Types_Bases_Nil;
+VALUE RBS_Types_Bases_Self;
+VALUE RBS_Types_Bases_Top;
+VALUE RBS_Types_Bases_Void;
+VALUE RBS_Types_Block;
+VALUE RBS_Types_ClassInstance;
+VALUE RBS_Types_ClassSingleton;
+VALUE RBS_Types_Function;
+VALUE RBS_Types_Function_Param;
+VALUE RBS_Types_Interface;
+VALUE RBS_Types_Intersection;
+VALUE RBS_Types_Literal;
+VALUE RBS_Types_Optional;
+VALUE RBS_Types_Proc;
+VALUE RBS_Types_Record;
+VALUE RBS_Types_Tuple;
+VALUE RBS_Types_Union;
+VALUE RBS_Types_UntypedFunction;
+VALUE RBS_Types_Variable;
+
+VALUE RBS_ParsingError;
+
+#define IMPORT_CONSTANT(var, parent, name) { var = rb_const_get(parent, rb_intern(name)); rb_gc_register_mark_object(var); }
+
+void rbs__init_constants(void) {
+  IMPORT_CONSTANT(RBS, rb_cObject, "RBS");
+  IMPORT_CONSTANT(RBS_ParsingError, RBS, "ParsingError");
+
+  IMPORT_CONSTANT(RBS_AST, RBS, "AST");
+  IMPORT_CONSTANT(RBS_AST_Declarations, RBS_AST, "Declarations");
+  IMPORT_CONSTANT(RBS_AST_Directives, RBS_AST, "Directives");
+  IMPORT_CONSTANT(RBS_AST_Members, RBS_AST, "Members");
+  IMPORT_CONSTANT(RBS_Types, RBS, "Types");
+  IMPORT_CONSTANT(RBS_Types_Bases, RBS_Types, "Bases");
+
+  IMPORT_CONSTANT(RBS_AST_Annotation, RBS_AST, "Annotation");
+  IMPORT_CONSTANT(RBS_AST_Comment, RBS_AST, "Comment");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Class, RBS_AST_Declarations, "Class");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Class_Super, RBS_AST_Declarations_Class, "Super");
+  IMPORT_CONSTANT(RBS_AST_Declarations_ClassAlias, RBS_AST_Declarations, "ClassAlias");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Constant, RBS_AST_Declarations, "Constant");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Global, RBS_AST_Declarations, "Global");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Interface, RBS_AST_Declarations, "Interface");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Module, RBS_AST_Declarations, "Module");
+  IMPORT_CONSTANT(RBS_AST_Declarations_Module_Self, RBS_AST_Declarations_Module, "Self");
+  IMPORT_CONSTANT(RBS_AST_Declarations_ModuleAlias, RBS_AST_Declarations, "ModuleAlias");
+  IMPORT_CONSTANT(RBS_AST_Declarations_TypeAlias, RBS_AST_Declarations, "TypeAlias");
+  IMPORT_CONSTANT(RBS_AST_Directives_Use, RBS_AST_Directives, "Use");
+  IMPORT_CONSTANT(RBS_AST_Directives_Use_SingleClause, RBS_AST_Directives_Use, "SingleClause");
+  IMPORT_CONSTANT(RBS_AST_Directives_Use_WildcardClause, RBS_AST_Directives_Use, "WildcardClause");
+  IMPORT_CONSTANT(RBS_AST_Members_Alias, RBS_AST_Members, "Alias");
+  IMPORT_CONSTANT(RBS_AST_Members_AttrAccessor, RBS_AST_Members, "AttrAccessor");
+  IMPORT_CONSTANT(RBS_AST_Members_AttrReader, RBS_AST_Members, "AttrReader");
+  IMPORT_CONSTANT(RBS_AST_Members_AttrWriter, RBS_AST_Members, "AttrWriter");
+  IMPORT_CONSTANT(RBS_AST_Members_ClassInstanceVariable, RBS_AST_Members, "ClassInstanceVariable");
+  IMPORT_CONSTANT(RBS_AST_Members_ClassVariable, RBS_AST_Members, "ClassVariable");
+  IMPORT_CONSTANT(RBS_AST_Members_Extend, RBS_AST_Members, "Extend");
+  IMPORT_CONSTANT(RBS_AST_Members_Include, RBS_AST_Members, "Include");
+  IMPORT_CONSTANT(RBS_AST_Members_InstanceVariable, RBS_AST_Members, "InstanceVariable");
+  IMPORT_CONSTANT(RBS_AST_Members_MethodDefinition, RBS_AST_Members, "MethodDefinition");
+  IMPORT_CONSTANT(RBS_AST_Members_MethodDefinition_Overload, RBS_AST_Members_MethodDefinition, "Overload");
+  IMPORT_CONSTANT(RBS_AST_Members_Prepend, RBS_AST_Members, "Prepend");
+  IMPORT_CONSTANT(RBS_AST_Members_Private, RBS_AST_Members, "Private");
+  IMPORT_CONSTANT(RBS_AST_Members_Public, RBS_AST_Members, "Public");
+  IMPORT_CONSTANT(RBS_AST_TypeParam, RBS_AST, "TypeParam");
+  IMPORT_CONSTANT(RBS_MethodType, RBS, "MethodType");
+  IMPORT_CONSTANT(RBS_Namespace, RBS, "Namespace");
+  IMPORT_CONSTANT(RBS_TypeName, RBS, "TypeName");
+  IMPORT_CONSTANT(RBS_Types_Alias, RBS_Types, "Alias");
+  IMPORT_CONSTANT(RBS_Types_Bases_Any, RBS_Types_Bases, "Any");
+  IMPORT_CONSTANT(RBS_Types_Bases_Bool, RBS_Types_Bases, "Bool");
+  IMPORT_CONSTANT(RBS_Types_Bases_Bottom, RBS_Types_Bases, "Bottom");
+  IMPORT_CONSTANT(RBS_Types_Bases_Class, RBS_Types_Bases, "Class");
+  IMPORT_CONSTANT(RBS_Types_Bases_Instance, RBS_Types_Bases, "Instance");
+  IMPORT_CONSTANT(RBS_Types_Bases_Nil, RBS_Types_Bases, "Nil");
+  IMPORT_CONSTANT(RBS_Types_Bases_Self, RBS_Types_Bases, "Self");
+  IMPORT_CONSTANT(RBS_Types_Bases_Top, RBS_Types_Bases, "Top");
+  IMPORT_CONSTANT(RBS_Types_Bases_Void, RBS_Types_Bases, "Void");
+  IMPORT_CONSTANT(RBS_Types_Block, RBS_Types, "Block");
+  IMPORT_CONSTANT(RBS_Types_ClassInstance, RBS_Types, "ClassInstance");
+  IMPORT_CONSTANT(RBS_Types_ClassSingleton, RBS_Types, "ClassSingleton");
+  IMPORT_CONSTANT(RBS_Types_Function, RBS_Types, "Function");
+  IMPORT_CONSTANT(RBS_Types_Function_Param, RBS_Types_Function, "Param");
+  IMPORT_CONSTANT(RBS_Types_Interface, RBS_Types, "Interface");
+  IMPORT_CONSTANT(RBS_Types_Intersection, RBS_Types, "Intersection");
+  IMPORT_CONSTANT(RBS_Types_Literal, RBS_Types, "Literal");
+  IMPORT_CONSTANT(RBS_Types_Optional, RBS_Types, "Optional");
+  IMPORT_CONSTANT(RBS_Types_Proc, RBS_Types, "Proc");
+  IMPORT_CONSTANT(RBS_Types_Record, RBS_Types, "Record");
+  IMPORT_CONSTANT(RBS_Types_Tuple, RBS_Types, "Tuple");
+  IMPORT_CONSTANT(RBS_Types_Union, RBS_Types, "Union");
+  IMPORT_CONSTANT(RBS_Types_UntypedFunction, RBS_Types, "UntypedFunction");
+  IMPORT_CONSTANT(RBS_Types_Variable, RBS_Types, "Variable");
+}