kanayago 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c6e26071a97395c4f35c029908d78bba8a927f75129aa361367dc9cf549c3ca
-  data.tar.gz: be48eae66a3bc69256ff3a9dba5afa842b8b8876f7be66eb72d79774fb94d878
+  metadata.gz: f2ec99120dc51fa4605b265aa47d5474d7f9a3540e3d09e10f782eebebcced6f
+  data.tar.gz: 0c836dc8b6390755edbbe0a42fe5fc936bb788961c313c75e0c7c559cd61afc2
 SHA512:
-  metadata.gz: 5073effb4706b23b912a61f79a3bb40d2565e59f4d9805c6ba6f3006c613d8029340d2e164e67f94eb0341cc7b14d340ca5a9f862ee8c4fb84a2b8a86f1622b9
-  data.tar.gz: 5731b6e8463b384cbd3dfe7bd3bf67835ea0a4a8f51ac0ee84259f8fd04d414fd5b2e1ea38e79f6f3dfab83787207c86757dfa5bce0180bfbf6fbac1102665ef
+  metadata.gz: cd996926d976b0dc9e48f6ee8478d65dd0c02a48dfc81e1754a087a92e10c79f6ec174c34da2eade27c563c04b4c70a638e2ed501c0002c4d5b2e8988d8c1e48
+  data.tar.gz: f8bc6647c4daed8b6ed823c7f6e2dcb65646a735f9a9a5c6818e1a514463eb38c1bcf014d106621bbd81bf6de4f71e1b5385639dd4eeb64e727281d0d5ad1a68

data/CHANGELOG.md

@@ -7,6 +7,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0]
+
+### Added
+- Add LSP (Language Server Protocol) mode
+  - `kanayago --lsp` - Start LSP server for editor integration
+  - Provides real-time syntax error diagnostics via LSP protocol
+  - Supports `textDocument/didOpen`, `didChange`, `didClose` notifications
+  - Publishes diagnostics with `textDocument/publishDiagnostics`
+  - Compatible with LSP-compliant editors (VSCode, etc.)
+  - Add `language_server-protocol` gem dependency (~> 3.17.0)
+- Add CLI mode for syntax checking
+  - `kanayago check 'code'` - Check Ruby code syntax directly
+  - `kanayago check --file FILE` or `-f FILE` - Check syntax of Ruby file
+  - Output "Syntax valid" for valid syntax, "Syntax invalid" for invalid syntax
+  - Exit with code 0 for valid syntax, 1 for invalid syntax or errors
+- Add `ParseResult` class to wrap AST and error information
+  - `ParseResult#ast` - Returns the parsed AST (ScopeNode)
+  - `ParseResult#error` - Returns SyntaxError object if syntax error occurred, false otherwise
+  - `ParseResult#valid?` - Returns true if no syntax error occurred
+  - `ParseResult#invalid?` - Returns true if syntax error occurred
+  - `Kanayago.parse` now returns `ParseResult` instead of raw AST
+
+### Fixed
+- Fix parser crash on syntax errors by implementing `rb_syntax_error_append`
+  - Previously, `rb_syntax_error_append` was not available in UniversalParser, causing forced termination when syntax errors occurred during parsing
+  - Ported `err_vcatf`, `syntax_error_with_path`, and `rb_syntax_error_append` from Ruby's error.c
+  - Added proper copyright notice (Copyright (C) 1993-2007 Yukihiro Matsumoto) as the code is ported from Ruby's error.c
+  - Updated patch files for both Ruby 3.4 and head versions
+  - Syntax errors now display properly instead of crashing the parser
+- Implement error_tolerant mode to continue parsing despite syntax errors
+  - Enable `rb_ruby_parser_error_tolerant` flag for all parsing operations
+  - Parser now accumulates syntax errors in `error_buffer` instead of terminating
+  - Fixed Qfalse handling in `rb_syntax_error_append` (Qfalse is defined as 0, causing `!exc` to evaluate to true)
+  - Added OBJ_FROZEN checks to handle frozen default "compile error" messages in SyntaxError objects
+  - Both AST and error information are now available even when syntax errors occur
+
+### Changed
+- Migrate error_buffer accessor implementation from script to patch files
+  - Moved `rb_ruby_parser_error_buffer_get` accessor function from `script/setup_parser.rb` to patch files
+  - Added parse.c modifications to both `patch/3.4/kanayago.patch` and `patch/head/kanayago.patch`
+  - Improved maintainability and version compatibility by using patch-based approach instead of runtime script modifications
+  - Removed `add_error_buffer_accessor` function from `script/setup_parser.rb`
+- Update all test files to access AST through `ParseResult#ast`
+  - All 93 test files now use `result.ast` instead of direct result access
+  - Tests validate both successful parsing and error handling scenarios
+
+## [0.4.1]
+
+### Fixed
+- Fix segmentation fault when parsing dynamic symbols in complex hash structures
+- Fix segmentation fault when parsing nested modules with outer constant references
+- Fix `module_node_new` to use `RNODE_MODULE` instead of incorrect `RNODE_CLASS` macro
+- Add NULL pointer checks in `dynamic_string_node_new`, `dynamic_symbol_node_new`, `dynamic_execute_string_node_new`, and `dynamic_regexp_node_new`
+
+### Changed
+- Remove incorrect `@super` field access from `ModuleNode` (modules do not have superclasses)
+
 ## [0.4.0]
 
 ### Added

data/README.md

@@ -31,24 +31,105 @@ Finally, build `Kanayago` gem  and install it.
 
 ```console
 bundle exec rake build
-gem install pkg/kanayago-0.4.0.gem
+gem install pkg/kanayago-0.5.0.gem
 ```
 
 ## Usage
 
+### Language Server Protocol (LSP) Mode
+
+Kanayago provides LSP server support for real-time syntax checking in your editor:
+
+```bash
+# Start LSP server
+$ kanayago --lsp
+```
+
+This starts an LSP server that communicates via stdin/stdout. You can integrate it with LSP-compliant editors like VSCode, Vim, Emacs, etc.
+
+#### VSCode Integration Example
+
+Create or modify `.vscode/settings.json`:
+
+```json
+{
+  "ruby.lsp.enabled": false,
+  "ruby.languageServer": "kanayago-lsp",
+  "ruby.languageServerPath": "kanayago",
+  "ruby.languageServerArgs": ["--lsp"]
+}
+```
+
+Now VSCode will show syntax errors in real-time as you type Ruby code.
+
+#### Vim/Neovim with coc.nvim Integration Example
+
+Add the following to your `coc-settings.json` (`:CocConfig` in Vim):
+
+```json
+{
+  "languageserver": {
+    "kanayago": {
+      "command": "kanayago",
+      "args": ["--lsp"],
+      "filetypes": ["ruby"],
+      "rootPatterns": ["Gemfile", ".git"]
+    }
+  }
+}
+```
+
+Now Vim/Neovim with coc.nvim will show syntax errors in real-time as you edit Ruby files.
+
+### Command Line Interface
+
+Kanayago provides a CLI for syntax checking:
+
+```bash
+# Check Ruby code directly
+$ kanayago check 'p 117'
+Syntax valid
+
+# Check Ruby code with syntax error
+$ kanayago check 'def foo'
+Syntax invalid
+
+# Check a Ruby file
+$ kanayago check --file test.rb
+Syntax valid
+
+# Or use the short option
+$ kanayago check -f test.rb
+Syntax valid
+```
+
+The CLI exits with code 0 for valid syntax and code 1 for invalid syntax or errors.
+
+### Ruby API
+
 ```ruby
 require 'kanayago/kanayago'
 
 result = Kanayago.parse('117 + 117')
+# => #<Kanayago::ParseResult:0x00007f522199c5a8>
+
+p result.ast
 # => #<Kanayago::ScopeNode:0x00007f522199c5a8>
 
-p result.body
+p result.ast.body
 # => #<Kanayago::OperatorCallNode:0x00007f5221b06358>
 
-p result.body.recv
-p result.body.recv.val
+p result.ast.body.recv
+p result.ast.body.recv.val
 # => #<Kanayago::IntegerNode:0x00007f5221b06330>
 # => 117
+
+# Check for syntax errors
+result = Kanayago.parse('def foo')
+p result.valid?
+# => false
+p result.error
+# => #<SyntaxError: syntax error, unexpected end-of-input>
 ```
 
 ## Development

data/exe/kanayago

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'kanayago'
+require 'kanayago/cli'
+
+Kanayago::CLI.start(ARGV)

data/ext/kanayago/kanayago.c

@@ -193,9 +193,8 @@ module_node_new(const NODE *node)
 {
     VALUE obj = rb_class_new_instance(0, 0, rb_cModuleNode);
 
-    rb_ivar_set(obj, rb_intern("@cpath"), ast_to_node_instance(RNODE_CLASS(node)->nd_cpath));
-    rb_ivar_set(obj, rb_intern("@super"), ast_to_node_instance(RNODE_CLASS(node)->nd_super));
-    rb_ivar_set(obj, rb_intern("@body"), ast_to_node_instance(RNODE_CLASS(node)->nd_body));
+    rb_ivar_set(obj, rb_intern("@cpath"), ast_to_node_instance(RNODE_MODULE(node)->nd_cpath));
+    rb_ivar_set(obj, rb_intern("@body"), ast_to_node_instance(RNODE_MODULE(node)->nd_body));
 
     return obj;
 }
@@ -518,12 +517,22 @@ kanayago_parse(VALUE self, VALUE source)
                                          &ruby_parser_data_type, parser);
     parser->parser_params = parser_params;
 
+    // Enable error tolerant parser
+    rb_ruby_parser_error_tolerant(parser_params);
 
     VALUE vast = rb_parser_compile_string(vparser, "main", source, 0);
 
     rb_ast_t *ast = rb_ruby_ast_data_get(vast);
+    VALUE ast_node = ast_to_node_instance(ast->body.root);
+
+    // Get error_buffer from parser_params using accessor function
+    VALUE error_buffer = rb_ruby_parser_error_buffer_get(parser_params);
 
-    return ast_to_node_instance(ast->body.root);
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("ast")), ast_node);
+    rb_hash_aset(result, ID2SYM(rb_intern("error")), error_buffer);
+
+    return result;
 }
 
 RUBY_FUNC_EXPORTED void

data/ext/kanayago/kanayago.h

@@ -12,6 +12,7 @@ VALUE rb_node_rational_literal_val(const NODE *);
 VALUE rb_node_imaginary_literal_val(const NODE *);
 VALUE rb_node_str_string_val(const NODE *);
 VALUE rb_node_sym_string_val(const NODE *);
+VALUE rb_ruby_parser_error_buffer_get(rb_parser_t *);
 
 // Add extern for Kanayago
 extern const rb_data_type_t ruby_parser_data_type;

data/ext/kanayago/string_node.c

@@ -19,12 +19,22 @@ dynamic_string_node_new(const NODE *node)
 {
     VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicStringNode);
     rb_parser_string_t *str = RNODE_DSTR(node)->string;
-    rb_encoding *enc = str->enc;
-    char *ptr = str->ptr;
-    long len = str->len;
-
-    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
-    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DSTR(node)->nd_next));
+    const NODE *nd_next = (const NODE *)RNODE_DSTR(node)->nd_next;
+
+    if (str) {
+        rb_encoding *enc = str->enc;
+        char *ptr = str->ptr;
+        long len = str->len;
+        rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    } else {
+        rb_ivar_set(obj, rb_intern("@string"), rb_str_new("", 0));
+    }
+
+    if (nd_next && nd_next != (NODE *)-1) {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance(nd_next));
+    } else {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), Qnil);
+    }
 
     return obj;
 }
@@ -34,12 +44,22 @@ dynamic_symbol_node_new(const NODE *node)
 {
     VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicSymbolNode);
     rb_parser_string_t *str = RNODE_DSYM(node)->string;
-    rb_encoding *enc = str->enc;
-    char *ptr = str->ptr;
-    long len = str->len;
-
-    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
-    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DSYM(node)->nd_next));
+    const NODE *nd_next = (const NODE *)RNODE_DSYM(node)->nd_next;
+
+    if (str) {
+        rb_encoding *enc = str->enc;
+        char *ptr = str->ptr;
+        long len = str->len;
+        rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    } else {
+        rb_ivar_set(obj, rb_intern("@string"), rb_str_new("", 0));
+    }
+
+    if (nd_next && nd_next != (NODE *)-1) {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance(nd_next));
+    } else {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), Qnil);
+    }
 
     return obj;
 }
@@ -77,12 +97,22 @@ dynamic_execute_string_node_new(const NODE *node)
 {
     VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicExecuteStringNode);
     rb_parser_string_t *str = RNODE_DXSTR(node)->string;
-    rb_encoding *enc = str->enc;
-    char *ptr = str->ptr;
-    long len = str->len;
-
-    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
-    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DXSTR(node)->nd_next));
+    const NODE *nd_next = (const NODE *)RNODE_DXSTR(node)->nd_next;
+
+    if (str) {
+        rb_encoding *enc = str->enc;
+        char *ptr = str->ptr;
+        long len = str->len;
+        rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    } else {
+        rb_ivar_set(obj, rb_intern("@string"), rb_str_new("", 0));
+    }
+
+    if (nd_next && nd_next != (NODE *)-1) {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance(nd_next));
+    } else {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), Qnil);
+    }
 
     return obj;
 }
@@ -112,13 +142,24 @@ dynamic_regexp_node_new(const NODE *node)
 {
     VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicRegexpNode);
     rb_parser_string_t *str = RNODE_DREGX(node)->string;
-    rb_encoding *enc = str->enc;
-    char *ptr = str->ptr;
-    long len = str->len;
     long options = RNODE_DREGX(node)->as.nd_cflag;
+    const NODE *nd_next = (const NODE *)RNODE_DREGX(node)->nd_next;
+
+    if (str) {
+        rb_encoding *enc = str->enc;
+        char *ptr = str->ptr;
+        long len = str->len;
+        rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    } else {
+        rb_ivar_set(obj, rb_intern("@string"), rb_str_new("", 0));
+    }
+
+    if (nd_next && nd_next != (NODE *)-1) {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance(nd_next));
+    } else {
+        rb_ivar_set(obj, rb_intern("@next_nodes"), Qnil);
+    }
 
-    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
-    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DREGX(node)->nd_next));
     rb_ivar_set(obj, rb_intern("@options"), LONG2FIX(options));
 
     return obj;

data/lib/kanayago/cli.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Kanayago
+  class CLI
+    def self.start(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv
+      @file = nil
+      @lsp_mode = false
+    end
+
+    def run
+      # Check for --lsp flag first
+      parse_global_options
+
+      if @lsp_mode
+        start_lsp_server
+        return
+      end
+
+      if @argv.empty?
+        puts "Usage: kanayago check 'code' or kanayago check --file FILE"
+        puts '       kanayago --lsp (start LSP server)'
+        exit 1
+      end
+
+      command = @argv.shift
+
+      case command
+      when 'check'
+        check_command
+      else
+        puts "Unknown command: #{command}"
+        puts "Usage: kanayago check 'code' or kanayago check --file FILE"
+        puts '       kanayago --lsp (start LSP server)'
+        exit 1
+      end
+    end
+
+    private
+
+    def parse_global_options
+      # Check for --lsp flag without modifying @argv for other options
+      return unless @argv.include?('--lsp')
+
+      @lsp_mode = true
+      @argv.delete('--lsp')
+    end
+
+    def start_lsp_server
+      require_relative 'lsp'
+      server = Kanayago::LSP::Server.new
+      server.start
+    end
+
+    def check_command
+      parse_options
+
+      if @file
+        check_file(@file)
+      elsif @argv.empty?
+        puts 'Error: Please provide Ruby code or use --file option'
+        exit 1
+      else
+        code = @argv.join(' ')
+        check_code(code)
+      end
+    end
+
+    def parse_options
+      OptionParser.new do |opts|
+        opts.banner = "Usage: kanayago check [options] 'code'"
+
+        opts.on('-f FILE', '--file FILE', 'Check syntax of Ruby file') do |file|
+          @file = file
+        end
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end.parse!(@argv)
+    end
+
+    def check_code(code)
+      result = Kanayago.parse(code)
+
+      if result.valid?
+        puts 'Syntax valid'
+        exit 0
+      else
+        puts 'Syntax invalid'
+        exit 1
+      end
+    end
+
+    def check_file(file_path)
+      unless File.exist?(file_path)
+        puts "Error: File not found: #{file_path}"
+        exit 1
+      end
+
+      code = File.read(file_path)
+      check_code(code)
+    rescue StandardError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+  end
+end

data/lib/kanayago/lsp/diagnostics.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+
+module Kanayago
+  module LSP
+    # Provides diagnostics for Ruby source code using Kanayago parser
+    class DiagnosticsProvider
+      def analyze(source)
+        diagnostics = []
+
+        result = Kanayago.parse(source)
+
+        if result.invalid?
+          # Extract error information from SyntaxError
+          error = result.error
+          diagnostic = create_diagnostic(error)
+          diagnostics << diagnostic
+        end
+
+        diagnostics
+      end
+
+      private
+
+      def create_diagnostic(error)
+        # Try to extract line and column from error message
+        # SyntaxError message format: "syntax error, unexpected ..."
+        # or with location: "(eval):2: syntax error, unexpected ..."
+        range = extract_range_from_error(error)
+
+        {
+          range: range,
+          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          source: 'Kanayago',
+          message: error.message
+        }
+      end
+
+      def extract_range_from_error(error)
+        # Try to extract line number from error message
+        # Format: "(eval):LINE: message" or just "message"
+        message = error.message
+
+        if message =~ /\(eval\):(\d+):/
+          line = ::Regexp.last_match(1).to_i - 1 # Convert to 0-based
+          {
+            start: { line: line, character: 0 },
+            end: { line: line, character: 0 }
+          }
+        else
+          # Default to line 0 if we can't extract line number
+          {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kanayago/lsp/server.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative 'diagnostics'
+
+module Kanayago
+  module LSP
+    # Language Server Protocol server for Kanayago
+    class Server
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new(@output)
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new(@input)
+        @diagnostics = DiagnosticsProvider.new
+        @documents = {} # URI => content mapping
+      end
+
+      def start
+        @reader.read do |request|
+          handle_request(request)
+        end
+      end
+
+      private
+
+      def handle_request(request) # rubocop:disable Metrics/CyclomaticComplexity
+        case request[:method]
+        when 'initialize'
+          handle_initialize(request)
+        when 'initialized'
+          # Client notification, no response needed
+        when 'shutdown'
+          handle_shutdown(request)
+        when 'exit'
+          exit(0)
+        when 'textDocument/didOpen'
+          handle_did_open(request)
+        when 'textDocument/didChange'
+          handle_did_change(request)
+        when 'textDocument/didClose'
+          handle_did_close(request)
+        else
+          # Unsupported method
+          send_response(request[:id], nil) if request[:id]
+        end
+      end
+
+      def handle_initialize(request)
+        result = {
+          capabilities: {
+            textDocumentSync: {
+              openClose: true,
+              change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL
+            }
+          },
+          serverInfo: {
+            name: 'Kanayago LSP',
+            version: Kanayago::VERSION
+          }
+        }
+        send_response(request[:id], result)
+      end
+
+      def handle_shutdown(request)
+        send_response(request[:id], nil)
+      end
+
+      def handle_did_open(request)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+        text = params[:textDocument][:text]
+
+        @documents[uri] = text
+        publish_diagnostics(uri, text)
+      end
+
+      def handle_did_change(request)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+
+        # FULL sync: get entire content
+        text = params[:contentChanges][0][:text]
+
+        @documents[uri] = text
+        publish_diagnostics(uri, text)
+      end
+
+      def handle_did_close(request)
+        params = request[:params]
+        uri = params[:textDocument][:uri]
+
+        @documents.delete(uri)
+        # Clear diagnostics
+        publish_diagnostics(uri, nil)
+      end
+
+      def publish_diagnostics(uri, text)
+        diagnostics = text ? @diagnostics.analyze(text) : []
+
+        notification = {
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: uri,
+            diagnostics: diagnostics
+          }
+        }
+
+        send_notification(notification)
+      end
+
+      def send_response(id, result)
+        response = {
+          jsonrpc: '2.0',
+          id: id,
+          result: result
+        }
+        @writer.write(response)
+      end
+
+      def send_notification(notification)
+        message = {
+          jsonrpc: '2.0',
+          method: notification[:method],
+          params: notification[:params]
+        }
+        @writer.write(message)
+      end
+    end
+  end
+end

data/lib/kanayago/lsp.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'lsp/server'
+require_relative 'lsp/diagnostics'
+
+module Kanayago
+  # Language Server Protocol support for Kanayago
+  module LSP
+  end
+end

data/lib/kanayago/statement_node.rb

@@ -74,7 +74,7 @@ module Kanayago
   end
 
   class ModuleNode
-    attr_reader :cpath, :super, :body
+    attr_reader :cpath, :body
   end
 
   class SingletonClassNode

data/lib/kanayago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanayago
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/kanayago.rb

@@ -14,7 +14,26 @@ require_relative 'kanayago/constant_node'
 
 # Parse Ruby code with Ruby's Parser(Universal Parser)
 module Kanayago
+  class ParseResult
+    attr_reader :ast, :error
+
+    def initialize(ast, error)
+      @ast = ast
+      @error = error
+    end
+
+    def invalid?
+      @error.is_a?(SyntaxError)
+    end
+
+    def valid?
+      !invalid?
+    end
+  end
+
   def self.parse(source)
-    kanayago_parse(source)
+    kanayago_parse(source) in { ast:, error: }
+
+    ParseResult.new(ast, error)
   end
 end

data/patch/3.4/kanayago.patch

@@ -5,7 +5,7 @@ index 8e306d1..d420a02 100644
 @@ -15,6 +15,29 @@ struct lex_pointer_string {
      long ptr;
  };
- 
+
 +// Add Ruby's Parser struct and enum for Kanayago
 +enum lex_type {
 +    lex_type_str,
@@ -36,10 +36,111 @@ diff --git a/ext/kanayago/ruby_parser.c b/ext/kanayago/ruby_parser.c
 index 267f619..841db65 100644
 --- a/ext/kanayago/ruby_parser.c
 +++ b/ext/kanayago/ruby_parser.c
-@@ -314,6 +314,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
- 
+@@ -34,6 +34,100 @@
+
+ #define parser_encoding const void
+
++/*
++ * The following functions are ported from Ruby's error.c for Kanayago:
++ *   - err_vcatf
++ *   - syntax_error_with_path
++ *   - rb_syntax_error_append
++ *
++ * Copyright (C) 1993-2007 Yukihiro Matsumoto
++ *
++ * Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
++ * You can redistribute it and/or modify it under either the terms of the
++ * 2-clause BSDL (see the file BSDL), or the conditions below:
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++static VALUE
++err_vcatf(VALUE str, const char *pre, const char *file, int line,
++          const char *fmt, va_list args)
++{
++    if (file) {
++        rb_str_cat_cstr(str, file);
++        if (line) rb_str_catf(str, ":%d", line);
++        rb_str_cat_cstr(str, ": ");
++    }
++    if (pre) rb_str_cat_cstr(str, pre);
++    rb_str_vcatf(str, fmt, args);
++    return str;
++}
++
++static VALUE
++syntax_error_with_path(VALUE exc, VALUE file, VALUE *mesg, rb_encoding *enc)
++{
++    // Create new SyntaxError if exc is nil or Qfalse (for error_tolerant mode)
++    if (NIL_P(exc) || exc == Qfalse) {
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++    }
++    *mesg = rb_attr_get(exc, rb_intern("mesg"));
++    // Check if mesg is nil or frozen (default "compile error" may be frozen)
++    if (NIL_P(*mesg) || OBJ_FROZEN(*mesg)) {
++        *mesg = rb_enc_str_new(0, 0, enc);
++        rb_ivar_set(exc, rb_intern("mesg"), *mesg);
++    }
++    return exc;
++}
++
++RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
++VALUE
++rb_syntax_error_append(VALUE exc, VALUE file, int line, int column,
++                       rb_encoding *enc, const char *fmt, va_list args)
++{
++    const char *fn = NIL_P(file) ? NULL : RSTRING_PTR(file);
++    if (!exc) {
++        // For error_tolerant mode, create SyntaxError even when writing to stderr
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++        VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
++        // Check if mesg is nil or frozen (default "compile error" may be frozen)
++        if (NIL_P(mesg) || OBJ_FROZEN(mesg)) {
++            mesg = rb_enc_str_new(0, 0, enc);
++            rb_ivar_set(exc, rb_intern("mesg"), mesg);
++        }
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++        // Still write to stderr for compatibility
++        VALUE err_mesg = rb_str_dup(mesg);
++        rb_str_cat_cstr(err_mesg, "\n");
++        rb_write_error_str(err_mesg);
++    }
++    else {
++        VALUE mesg;
++        exc = syntax_error_with_path(exc, file, &mesg, enc);
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++    }
++
++    return exc;
++}
++
+ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
+ static VALUE
+ syntax_error_append(VALUE exc, VALUE file, int line, int column,
+@@ -314,6 +408,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
+
  extern VALUE rb_eArgError;
- 
+
 +//　Add for Kanayago
 +static void *
 +xmalloc_mul_add(size_t x, size_t y, size_t z)
@@ -81,51 +182,51 @@ index 267f619..841db65 100644
  static const rb_parser_config_t rb_global_parser_config = {
      .malloc = ruby_xmalloc,
      .calloc = ruby_xcalloc,
-@@ -325,9 +363,9 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -325,9 +457,9 @@ static const rb_parser_config_t rb_global_parser_config = {
      .zalloc = zalloc,
      .rb_memmove = memmove2,
      .nonempty_memcpy = nonempty_memcpy,
 -    .xmalloc_mul_add = rb_xmalloc_mul_add,
 +    .xmalloc_mul_add = xmalloc_mul_add, // use xmalloc_mul_add for Kanayago
- 
+
 -    .compile_callback = rb_suppress_tracing,
 +    .compile_callback = suppress_tracing, // use suppress_tracing for Kanayago
      .reg_named_capture_assign = reg_named_capture_assign,
- 
+
      .attr_get = rb_attr_get,
-@@ -335,7 +373,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -335,7 +467,7 @@ static const rb_parser_config_t rb_global_parser_config = {
      .ary_new_from_args = rb_ary_new_from_args,
      .ary_unshift = rb_ary_unshift,
- 
+
 -    .make_temporary_id = rb_make_temporary_id,
 +    .make_temporary_id = make_temporary_id, // use make_temporary_id for Kanayago
      .is_local_id = is_local_id2,
      .is_attrset_id = is_attrset_id2,
      .is_global_name_punct = is_global_name_punct,
-@@ -365,7 +403,7 @@ static const rb_parser_config_t rb_global_parser_config = {
- 
+@@ -365,7 +497,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+
      .int2num = rb_int2num_inline,
- 
+
 -    .stderr_tty_p = rb_stderr_tty_p,
 +    .stderr_tty_p = stderr_tty_p, //use stderr_tty_p for Kanayago
      .write_error_str = rb_write_error_str,
      .io_write = rb_io_write,
      .io_flush = rb_io_flush,
-@@ -412,8 +450,8 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -412,8 +544,8 @@ static const rb_parser_config_t rb_global_parser_config = {
      .gc_guard = gc_guard,
      .gc_mark = rb_gc_mark,
- 
+
 -    .reg_compile = rb_reg_compile,
 -    .reg_check_preprocess = rb_reg_check_preprocess,
 +    .reg_compile = reg_compile, // use reg_compile for Kanayago
 +    .reg_check_preprocess = reg_check_preprocess, // use reg_check_preprocess for Kanayago
      .memcicmp = rb_memcicmp,
- 
+
      .compile_warn = rb_compile_warn,
-@@ -443,27 +481,6 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -443,27 +575,6 @@ static const rb_parser_config_t rb_global_parser_config = {
  };
  #endif
- 
+
 -enum lex_type {
 -    lex_type_str,
 -    lex_type_io,
@@ -150,13 +251,32 @@ index 267f619..841db65 100644
  static void
  parser_mark(void *ptr)
  {
-@@ -501,7 +518,8 @@ parser_memsize(const void *ptr)
+@@ -501,7 +612,8 @@ parser_memsize(const void *ptr)
      return rb_ruby_parser_memsize(parser->parser_params);
  }
- 
+
 -static const rb_data_type_t ruby_parser_data_type = {
 +// Not static const for Kanayago
 +const rb_data_type_t ruby_parser_data_type = {
      "parser",
      {
          parser_mark,
+diff --git a/ext/kanayago/parse.c b/ext/kanayago/parse.c
+--- a/ext/kanayago/parse.c
++++ b/ext/kanayago/parse.c
+@@ -26941,6 +26941,15 @@ ripper_value(struct parser_params *p)
+     return p->value;
+ }
+
++#else /* !RIPPER */
++
++// Accessor function for error_buffer (for Kanayago)
++VALUE
++rb_ruby_parser_error_buffer_get(rb_parser_t *p)
++{
++    return p->error_buffer;
++}
++
+ #endif /* RIPPER */
+ /*
+  * Local variables:

data/patch/head/copy_target.rb

@@ -13,6 +13,7 @@ RUBY_PARSER_COPY_TARGETS = %w[
   internal/basic_operators.h
   internal/bignum.h
   internal/bits.h
+  internal/box.h
   internal/compile.h
   internal/compilers.h
   internal/complex.h

data/patch/head/kanayago.patch

@@ -5,7 +5,7 @@ index 8e306d1..d420a02 100644
 @@ -15,6 +15,29 @@ struct lex_pointer_string {
      long ptr;
  };
- 
+
 +// Add Ruby's Parser struct and enum for Kanayago
 +enum lex_type {
 +    lex_type_str,
@@ -36,10 +36,111 @@ diff --git a/ext/kanayago/ruby_parser.c b/ext/kanayago/ruby_parser.c
 index 267f619..841db65 100644
 --- a/ext/kanayago/ruby_parser.c
 +++ b/ext/kanayago/ruby_parser.c
-@@ -314,6 +314,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
- 
+@@ -34,6 +34,100 @@
+
+ #define parser_encoding const void
+
++/*
++ * The following functions are ported from Ruby's error.c for Kanayago:
++ *   - err_vcatf
++ *   - syntax_error_with_path
++ *   - rb_syntax_error_append
++ *
++ * Copyright (C) 1993-2007 Yukihiro Matsumoto
++ *
++ * Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
++ * You can redistribute it and/or modify it under either the terms of the
++ * 2-clause BSDL (see the file BSDL), or the conditions below:
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++static VALUE
++err_vcatf(VALUE str, const char *pre, const char *file, int line,
++          const char *fmt, va_list args)
++{
++    if (file) {
++        rb_str_cat_cstr(str, file);
++        if (line) rb_str_catf(str, ":%d", line);
++        rb_str_cat_cstr(str, ": ");
++    }
++    if (pre) rb_str_cat_cstr(str, pre);
++    rb_str_vcatf(str, fmt, args);
++    return str;
++}
++
++static VALUE
++syntax_error_with_path(VALUE exc, VALUE file, VALUE *mesg, rb_encoding *enc)
++{
++    // Create new SyntaxError if exc is nil or Qfalse (for error_tolerant mode)
++    if (NIL_P(exc) || exc == Qfalse) {
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++    }
++    *mesg = rb_attr_get(exc, rb_intern("mesg"));
++    // Check if mesg is nil or frozen (default "compile error" may be frozen)
++    if (NIL_P(*mesg) || OBJ_FROZEN(*mesg)) {
++        *mesg = rb_enc_str_new(0, 0, enc);
++        rb_ivar_set(exc, rb_intern("mesg"), *mesg);
++    }
++    return exc;
++}
++
++RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
++VALUE
++rb_syntax_error_append(VALUE exc, VALUE file, int line, int column,
++                       rb_encoding *enc, const char *fmt, va_list args)
++{
++    const char *fn = NIL_P(file) ? NULL : RSTRING_PTR(file);
++    if (!exc) {
++        // For error_tolerant mode, create SyntaxError even when writing to stderr
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++        VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
++        // Check if mesg is nil or frozen (default "compile error" may be frozen)
++        if (NIL_P(mesg) || OBJ_FROZEN(mesg)) {
++            mesg = rb_enc_str_new(0, 0, enc);
++            rb_ivar_set(exc, rb_intern("mesg"), mesg);
++        }
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++        // Still write to stderr for compatibility
++        VALUE err_mesg = rb_str_dup(mesg);
++        rb_str_cat_cstr(err_mesg, "\n");
++        rb_write_error_str(err_mesg);
++    }
++    else {
++        VALUE mesg;
++        exc = syntax_error_with_path(exc, file, &mesg, enc);
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++    }
++
++    return exc;
++}
++
+ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
+ static VALUE
+ syntax_error_append(VALUE exc, VALUE file, int line, int column,
+@@ -314,6 +408,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
+
  extern VALUE rb_eArgError;
- 
+
 +//　Add for Kanayago
 +static void *
 +xmalloc_mul_add(size_t x, size_t y, size_t z)
@@ -81,51 +182,51 @@ index 267f619..841db65 100644
  static const rb_parser_config_t rb_global_parser_config = {
      .malloc = ruby_xmalloc,
      .calloc = ruby_xcalloc,
-@@ -325,9 +363,9 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -325,9 +457,9 @@ static const rb_parser_config_t rb_global_parser_config = {
      .zalloc = zalloc,
      .rb_memmove = memmove2,
      .nonempty_memcpy = nonempty_memcpy,
 -    .xmalloc_mul_add = rb_xmalloc_mul_add,
 +    .xmalloc_mul_add = xmalloc_mul_add, // use xmalloc_mul_add for Kanayago
- 
+
 -    .compile_callback = rb_suppress_tracing,
 +    .compile_callback = suppress_tracing, // use suppress_tracing for Kanayago
      .reg_named_capture_assign = reg_named_capture_assign,
- 
+
      .attr_get = rb_attr_get,
-@@ -335,7 +373,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -335,7 +467,7 @@ static const rb_parser_config_t rb_global_parser_config = {
      .ary_new_from_args = rb_ary_new_from_args,
      .ary_unshift = rb_ary_unshift,
- 
+
 -    .make_temporary_id = rb_make_temporary_id,
 +    .make_temporary_id = make_temporary_id, // use make_temporary_id for Kanayago
      .is_local_id = is_local_id2,
      .is_attrset_id = is_attrset_id2,
      .is_global_name_punct = is_global_name_punct,
-@@ -365,7 +403,7 @@ static const rb_parser_config_t rb_global_parser_config = {
- 
+@@ -365,7 +497,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+
      .int2num = rb_int2num_inline,
- 
+
 -    .stderr_tty_p = rb_stderr_tty_p,
 +    .stderr_tty_p = stderr_tty_p, //use stderr_tty_p for Kanayago
      .write_error_str = rb_write_error_str,
      .io_write = rb_io_write,
      .io_flush = rb_io_flush,
-@@ -412,8 +450,8 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -412,8 +544,8 @@ static const rb_parser_config_t rb_global_parser_config = {
      .gc_guard = gc_guard,
      .gc_mark = rb_gc_mark,
- 
+
 -    .reg_compile = rb_reg_compile,
 -    .reg_check_preprocess = rb_reg_check_preprocess,
 +    .reg_compile = reg_compile, // use reg_compile for Kanayago
 +    .reg_check_preprocess = reg_check_preprocess, // use reg_check_preprocess for Kanayago
      .memcicmp = rb_memcicmp,
- 
+
      .compile_warn = rb_compile_warn,
-@@ -443,27 +481,6 @@ static const rb_parser_config_t rb_global_parser_config = {
+@@ -443,27 +575,6 @@ static const rb_parser_config_t rb_global_parser_config = {
  };
  #endif
- 
+
 -enum lex_type {
 -    lex_type_str,
 -    lex_type_io,
@@ -150,13 +251,32 @@ index 267f619..841db65 100644
  static void
  parser_mark(void *ptr)
  {
-@@ -501,7 +518,8 @@ parser_memsize(const void *ptr)
+@@ -501,7 +612,8 @@ parser_memsize(const void *ptr)
      return rb_ruby_parser_memsize(parser->parser_params);
  }
- 
+
 -static const rb_data_type_t ruby_parser_data_type = {
 +// Not static const for Kanayago
 +const rb_data_type_t ruby_parser_data_type = {
      "parser",
      {
          parser_mark,
+diff --git a/ext/kanayago/parse.c b/ext/kanayago/parse.c
+--- a/ext/kanayago/parse.c
++++ b/ext/kanayago/parse.c
+@@ -27391,6 +27391,15 @@ ripper_value(struct parser_params *p)
+     return p->value;
+ }
+
++#else /* !RIPPER */
++
++// Accessor function for error_buffer (for Kanayago)
++VALUE
++rb_ruby_parser_error_buffer_get(rb_parser_t *p)
++{
++    return p->error_buffer;
++}
++
+ #endif /* RIPPER */
+ /*
+  * Local variables:

metadata

@@ -1,18 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: kanayago
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: language_server-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
 description: Trying to Make Ruby's Parser Available as a Gem
 email:
 - gamelinks007@gmail.com
-executables: []
+executables:
+- kanayago
 extensions:
 - ext/kanayago/extconf.rb
 extra_rdoc_files: []
@@ -24,6 +39,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- exe/kanayago
 - ext/kanayago/extconf.rb
 - ext/kanayago/kanayago.c
 - ext/kanayago/kanayago.h
@@ -41,8 +57,12 @@ files:
 - ext/kanayago/variable_node.h
 - lib/kanayago.rb
 - lib/kanayago/call_node.rb
+- lib/kanayago/cli.rb
 - lib/kanayago/constant_node.rb
 - lib/kanayago/literal_node.rb
+- lib/kanayago/lsp.rb
+- lib/kanayago/lsp/diagnostics.rb
+- lib/kanayago/lsp/server.rb
 - lib/kanayago/pattern_node.rb
 - lib/kanayago/scope_node.rb
 - lib/kanayago/statement_node.rb
@@ -80,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.8.0.dev
+rubygems_version: 4.0.0.dev
 specification_version: 4
 summary: Trying to Make Ruby's Parser Available as a Gem
 test_files: []