feat: add TypeScript-style array shorthand syntax T[] (#36)

* feat: add TypeScript-style array shorthand syntax `T[]`

- Add `String[]` as alternative to `Array<String>`
- Support nested arrays: `Integer[][]` → `Array[Array[Integer]]`
- Support nullable arrays: `String[]?` → `(Array[String] | nil)`
- Support arrays of nullable elements: `String?[]` → `Array[String?]`
- Support union type arrays: `(String | Integer)[]`
- Both syntaxes produce identical IR and RBS output
- Add parse_postfix_type_operators for `[]` and `?` suffix handling
- Add comprehensive unit tests (15 cases) and E2E tests (14 cases)
- Update README examples to show new syntax

* Update Gemfile.lock

* fix: restore Gemfile.lock with listen gem for CI compatibility

Ruby 4.0 skips listen gem installation, but CI runs on Ruby 3.x which
requires it. Restore the original Gemfile.lock from main branch.

* refactor: remove unused legacy type parsing code from IR::Builder

TypeParser now handles all type parsing including:
- Simple types, generics, array shorthand, union, intersection, function types

Remove legacy fallback code that was never executed, improving code coverage.

Author: yhk1038

README.ja.md

@@ -238,7 +238,7 @@ watch:
 
 - **型アノテーション** — パラメータと戻り値の型、コンパイル時に削除
 - **ユニオン型** — `String | Integer | nil`
-- **ジェネリクス** — `Array<User>`, `Hash<String, Integer>`
+- **ジェネリクス** — `User[]`, `Array<User>`, `Hash<String, Integer>`
 - **インターフェース** — オブジェクト間の契約を定義
 - **型エイリアス** — `type UserID = Integer`
 - **RBS 生成** — Steep、Ruby LSP、Sorbet と連携

README.ko.md

@@ -238,7 +238,7 @@ watch:
 
 - **타입 어노테이션** — 파라미터와 리턴 타입, 컴파일 시 제거됨
 - **유니온 타입** — `String | Integer | nil`
-- **제네릭** — `Array<User>`, `Hash<String, Integer>`
+- **제네릭** — `User[]`, `Array<User>`, `Hash<String, Integer>`
 - **인터페이스** — 객체 간 계약 정의
 - **타입 별칭** — `type UserID = Integer`
 - **RBS 생성** — Steep, Ruby LSP, Sorbet과 연동

README.md

@@ -243,7 +243,7 @@ watch:
 
 - **Type annotations** — Parameter and return types, erased at compile time
 - **Union types** — `String | Integer | nil`
-- **Generics** — `Array<User>`, `Hash<String, Integer>`
+- **Generics** — `User[]`, `Array<User>`, `Hash<String, Integer>`
 - **Interfaces** — Define contracts between objects
 - **Type aliases** — `type UserID = Integer`
 - **RBS generation** — Works with Steep, Ruby LSP, Sorbet

lib/t_ruby/ir.rb

@@ -646,7 +646,13 @@ def initialize(inner_type:, **opts)
       end
 
       def to_rbs
-        "#{@inner_type.to_rbs}?"
+        inner_rbs = @inner_type.to_rbs
+        # Simple types can use ? suffix, complex types need (Type | nil) form
+        if @inner_type.is_a?(SimpleType)
+          "#{inner_rbs}?"
+        else
+          "(#{inner_rbs} | nil)"
+        end
       end
 
       def to_trb
@@ -829,77 +835,17 @@ def parse_type(type_str)
         return nil unless type_str
 
         type_str = type_str.strip
+        return nil if type_str.empty?
 
-        # Union type
-        if type_str.include?("|")
-          types = type_str.split("|").map { |t| parse_type(t.strip) }
-          return UnionType.new(types: types)
-        end
-
-        # Intersection type
-        if type_str.include?("&")
-          types = type_str.split("&").map { |t| parse_type(t.strip) }
-          return IntersectionType.new(types: types)
-        end
+        # Use ParserCombinator::TypeParser for all type parsing
+        # Supports: simple types, generics, array shorthand, union, intersection, function types
+        @type_parser ||= TRuby::ParserCombinator::TypeParser.new
+        result = @type_parser.parse(type_str)
+        return result[:type] if result[:success]
 
-        # Nullable type
-        if type_str.end_with?("?")
-          inner = parse_type(type_str[0..-2])
-          return NullableType.new(inner_type: inner)
-        end
-
-        # Generic type
-        if type_str.include?("<") && type_str.include?(">")
-          match = type_str.match(/^(\w+)<(.+)>$/)
-          if match
-            base = match[1]
-            args = parse_generic_args(match[2])
-            return GenericType.new(base: base, type_args: args)
-          end
-        end
-
-        # Function type
-        if type_str.include?("->")
-          match = type_str.match(/^\((.*)?\)\s*->\s*(.+)$/)
-          if match
-            param_types = match[1] ? match[1].split(",").map { |t| parse_type(t.strip) } : []
-            return_type = parse_type(match[2])
-            return FunctionType.new(param_types: param_types, return_type: return_type)
-          end
-        end
-
-        # Simple type
+        # Fallback for unparseable types - return as SimpleType
         SimpleType.new(name: type_str)
       end
-
-      def parse_generic_args(args_str)
-        args = []
-        current = ""
-        depth = 0
-
-        args_str.each_char do |char|
-          case char
-          when "<"
-            depth += 1
-            current += char
-          when ">"
-            depth -= 1
-            current += char
-          when ","
-            if depth.zero?
-              args << parse_type(current.strip)
-              current = ""
-            else
-              current += char
-            end
-          else
-            current += char
-          end
-        end
-
-        args << parse_type(current.strip) unless current.empty?
-        args
-      end
     end
 
     #==========================================================================

lib/t_ruby/parser_combinator/token/token_declaration_parser.rb

@@ -781,6 +781,7 @@ def parse_primary_type(tokens, position)
         end
 
         # Check for tuple type: (Type, Type) -> ReturnType
+        # or parenthesized type: (String | Integer)[]
         if tokens[position].type == :lparen
           position += 1
           param_types = []
@@ -811,6 +812,11 @@ def parse_primary_type(tokens, position)
 
             node = IR::FunctionType.new(param_types: param_types, return_type: return_result.value)
             return TokenParseResult.success(node, tokens, return_result.position)
+          elsif param_types.length == 1
+            # Single type in parentheses: (String | Integer)
+            # Check for postfix operators like [] or ?
+            type = param_types[0]
+            return parse_postfix_type_operators(tokens, position, type)
           else
             node = IR::TupleType.new(element_types: param_types)
             return TokenParseResult.success(node, tokens, position)
@@ -826,6 +832,13 @@ def parse_primary_type(tokens, position)
         type_name = tokens[position].value
         position += 1
 
+        # Handle type names ending with ? (e.g., "String?" scanned as single token)
+        # This happens because Ruby allows ? in method/identifier names
+        is_nullable_from_name = type_name.end_with?("?")
+        if is_nullable_from_name
+          type_name = type_name.chomp("?")
+        end
+
         # Check for generic arguments: Type<Args>
         if position < tokens.length && tokens[position].type == :lt
           position += 1
@@ -848,17 +861,46 @@ def parse_primary_type(tokens, position)
           position += 1
 
           node = IR::GenericType.new(base: type_name, type_args: type_args)
-          TokenParseResult.success(node, tokens, position)
-        elsif position < tokens.length && tokens[position].type == :question
-          # Check for nullable: Type?
-          position += 1
-          inner = IR::SimpleType.new(name: type_name)
-          node = IR::NullableType.new(inner_type: inner)
-          TokenParseResult.success(node, tokens, position)
+          # Wrap in NullableType if the original type name ended with ?
+          node = IR::NullableType.new(inner_type: node) if is_nullable_from_name
+          # Apply postfix operators ([] or ?) to generic types too
+          parse_postfix_type_operators(tokens, position, node)
         else
+          # Simple type - apply postfix operators
           node = IR::SimpleType.new(name: type_name)
-          TokenParseResult.success(node, tokens, position)
+          # Wrap in NullableType if the original type name ended with ?
+          node = IR::NullableType.new(inner_type: node) if is_nullable_from_name
+          parse_postfix_type_operators(tokens, position, node)
+        end
+      end
+
+      # Parse postfix type operators: [] (array shorthand) and ? (nullable)
+      # Handles patterns like:
+      #   String[]     => Array<String>
+      #   Integer[][]  => Array<Array<Integer>>
+      #   String[]?    => NullableType(Array<String>)
+      #   String?[]    => Array<NullableType(String)>
+      #   (A | B)[]    => Array<UnionType(A, B)>
+      def parse_postfix_type_operators(tokens, position, type)
+        loop do
+          break if position >= tokens.length
+
+          case tokens[position].type
+          when :lbracket
+            # Check for [] (empty brackets for array shorthand)
+            break unless tokens[position + 1]&.type == :rbracket
+
+            position += 2
+            type = IR::GenericType.new(base: "Array", type_args: [type])
+          when :question
+            position += 1
+            type = IR::NullableType.new(inner_type: type)
+          else
+            break
+          end
         end
+
+        TokenParseResult.success(type, tokens, position)
       end
 
       # Parse hash literal type: { key: Type, key2: Type }

lib/t_ruby/parser_combinator/type_parser.rb

@@ -81,9 +81,24 @@ def build_parsers
           generic_type
         )
 
-        # With optional nullable suffix
-        base_type = (primary_type >> nullable_suffix.optional).map do |(type, nullable)|
-          nullable ? IR::NullableType.new(inner_type: type) : type
+        # Array shorthand suffix: [] (can be repeated for nested arrays)
+        array_suffix = string("[]")
+
+        # Postfix operators: ([] | ?)*
+        # Handles: String[], Integer[][], String[]?, String?[], etc.
+        postfix_op = array_suffix | nullable_suffix
+
+        base_type = (primary_type >> postfix_op.many).map do |(initial_type, ops)|
+          ops.reduce(initial_type) do |type, op|
+            case op
+            when "[]"
+              IR::GenericType.new(base: "Array", type_args: [type])
+            when "?"
+              IR::NullableType.new(inner_type: type)
+            else
+              type
+            end
+          end
         end
 
         # Union type: Type | Type | ...