Merge pull request #1173 from dleavitt/rbs-2-standalone

Support rbs 2.x under ruby 3.1

Author: kddnewton

.github/workflows/main.yml

@@ -16,6 +16,7 @@ jobs:
           - "2.6"
           - "2.7"
           - "3.0"
+          - "3.1"
     runs-on: ${{ matrix.platform }}
     env:
       PLUGIN_RUBY_CI: true

src/rbs/parser.rb

@@ -98,6 +98,47 @@ def to_json(*a)
   end
 end
 
+if defined?(RBS::AST::Declarations::ModuleTypeParams)
+  # This class was removed in rbs 2.0. Monkeypatch < 2.0 to give the same json
+  # output
+  class RBS::AST::Declarations::ModuleTypeParams
+    def to_json(*a)
+      params.to_json(*a)
+    end
+  end
+
+  # make this look like the new AST::TypeParam json
+  class RBS::AST::Declarations::ModuleTypeParams::TypeParam
+    def to_json(*a)
+      { name: name, variance: variance, unchecked: skip_validation }.to_json(*a)
+    end
+  end
+
+  # https://github.com/ruby/rbs/commit/3ccdcb1f3ac5dcb866280f745866a852658195e6
+  class RBS::MethodType
+    # promote the array of symbols into TypeParam looking-things
+    def to_json(*a)
+      type_param_objects =
+        type_params.map do |name|
+          {
+            name: name,
+            variance: 'invariant',
+            unchecked: 'false',
+            upper_bound: nil
+            # location - harder to get this but not needed
+          }
+        end
+
+      {
+        type_params: type_param_objects,
+        type: type,
+        block: block,
+        location: location
+      }.to_json(*a)
+    end
+  end
+end
+
 # The main parser interface.
 module Prettier
   class RBSParser

src/rbs/printer.ts

@@ -447,30 +447,32 @@ const printer: Plugin.PrinterConfig<RBS.AnyNode> = {
       path: Plugin.Path<RBS.NameAndTypeParams>,
       node: RBS.NameAndTypeParams
     ) {
-      if (node.type_params.params.length === 0) {
+      if (node.type_params.length === 0) {
         return node.name;
       }
 
-      const docs = path.map(
-        (paramPath) => {
-          const node = paramPath.getValue();
-          const parts = [];
+      const docs = path.map((paramPath) => {
+        const node = paramPath.getValue();
+        const parts = [];
 
-          if (node.skip_validation) {
-            parts.push("unchecked");
-          }
+        if (node.unchecked) {
+          parts.push("unchecked");
+        }
 
-          if (node.variance === "covariant") {
-            parts.push("out");
-          } else if (node.variance === "contravariant") {
-            parts.push("in");
-          }
+        if (node.variance === "covariant") {
+          parts.push("out");
+        } else if (node.variance === "contravariant") {
+          parts.push("in");
+        }
 
+        if (node.upper_bound) {
+          const path = paramPath as Plugin.Path<{ upper_bound: RBS.Type }>;
+          const upperBound = path.call(printType, "upper_bound");
+          return join(" ", [...parts, node.name, "<", upperBound]);
+        } else {
           return join(" ", [...parts, node.name]);
-        },
-        "type_params",
-        "params"
-      );
+        }
+      }, "type_params");
 
       return [node.name, "[", join(", ", docs), "]"];
     }
@@ -568,7 +570,9 @@ const printer: Plugin.PrinterConfig<RBS.AnyNode> = {
 
       // We won't have a type_params key if we're printing a block
       if (node.type_params && node.type_params.length > 0) {
-        parts.push("[", join(", ", node.type_params), "] ");
+        const typeParamNames = node.type_params.map((tp) => tp.name);
+
+        parts.push("[", join(", ", typeParamNames), "] ");
       }
 
       const params = path.call(printMethodParams, "type");

src/types/rbs.ts

@@ -18,7 +18,7 @@ export type MethodParams = {
 };
 
 export type MethodSignature = {
-  type_params: string[],
+  type_params: Param[],
   type: MethodParams & { return_type: Type },
   block: { required: boolean } & MethodSignature
 };
@@ -74,13 +74,14 @@ export type MethodDefinition = Member & { member: "method_definition" };
 
 export type Param = {
   name: string,
-  skip_validation: boolean,
+  unchecked: boolean,
   variance: "invariant" | "covariant" | "contravariant"
+  upper_bound?: Type, 
 };
 
 export type NameAndTypeParams = {
   name: string,
-  type_params: { params: Param[] }
+  type_params: Param[]
 };
 
 export type Class = { declaration: "class", super_class?: NameAndArgs, members: Member[] } & NameAndTypeParams;

test/js/rbs/rbs.test.ts

@@ -47,6 +47,26 @@ describe("rbs", () => {
       expect(content).toMatchFormat();
     });
 
+    if (atLeastVersion("3.1")) {
+      test("interface with bounded type param", () => {
+        const content = rbs(`
+          interface _Foo[A < B]
+          end
+        `);
+
+        expect(content).toMatchFormat();
+      });
+
+      test("interface with fancy bounded type params", () => {
+        const content = rbs(`
+          interface _Foo[U < singleton(::Hash), V < W[X, Y]]
+          end
+        `);
+
+        expect(content).toMatchFormat();
+      });
+    }
+
     test("class", () => {
       const content = rbs(`
         class Foo
@@ -74,6 +94,26 @@ describe("rbs", () => {
       expect(content).toMatchFormat();
     });
 
+    if (atLeastVersion("3.1")) {
+      test("class with bounded type param", () => {
+        const content = rbs(`
+          class Foo[A < B]
+          end
+        `);
+
+        expect(content).toMatchFormat();
+      });
+
+      test("class with fancy bounded type params", () => {
+        const content = rbs(`
+          class Foo[U < singleton(::Hash), V < W[X, Y]]
+          end
+        `);
+
+        expect(content).toMatchFormat();
+      });
+    }
+
     test("class with annotations", () => {
       const content = rbs(`
         %a{This is an annotation.}

test/rb/rbs_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class RBSTest < Minitest::Test
+  # https://github.com/ruby/rbs/commit/c5da467adacc75fe9294ec1630f1b7931d9d6871
+  def test_module_type_params_empty
+    actual = declaration_json("interface _Foo\nend")['type_params']
+    assert_instance_of Array, actual
+    assert_empty actual
+  end
+
+  def test_module_type_params_fancy
+    source = <<~SOURCE
+      class Foo[unchecked in A, B]
+      end
+    SOURCE
+
+    actual = declaration_json(source)['type_params']
+    assert_instance_of Array, actual
+    assert_equal 2, actual.length
+
+    type_a, type_b = actual
+
+    assert_equal 'A', type_a['name']
+    assert_equal 'contravariant', type_a['variance']
+    assert_equal true, type_a['unchecked']
+
+    assert_equal 'B', type_b['name']
+    assert_equal 'invariant', type_b['variance']
+    assert_equal false, type_b['unchecked']
+  end
+
+  # https://github.com/ruby/rbs/commit/3ccdcb1f3ac5dcb866280f745866a852658195e6
+  def test_generic_method
+    source = <<~SOURCE
+      class T
+        def t: [A, B] (A) -> B
+      end
+    SOURCE
+
+    actual = member_json(source)['types'].first['type_params']
+    assert_equal 2, actual.length
+
+    type_a, type_b = actual
+    assert_equal 'A', type_a['name']
+    assert_equal 'B', type_b['name']
+  end
+
+  private
+
+  def declaration_json(source)
+    JSON.parse(first_declaration(source).to_json)
+  end
+
+  def member_json(source)
+    JSON.parse(first_member(source).to_json)
+  end
+
+  def parse(source)
+    Prettier::RBSParser.parse(source)
+  end
+
+  def first_declaration(source)
+    parse(source)[:declarations].first
+  end
+
+  def first_member(source)
+    first_declaration(source).members.first
+  end
+end

test/rb/test_helper.rb

@@ -4,5 +4,6 @@
 
 require 'prettier'
 require_relative '../../src/ruby/parser'
+require_relative '../../src/rbs/parser'
 
 require 'minitest/autorun'