From e627e553ae900294c0540774befce2ce70762327 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Thu, 19 Mar 2026 11:01:44 -0500 Subject: [PATCH 01/11] Add WASM backend for Ruby API --- lib/prism.rb | 7 +- lib/prism/wasm.rb | 377 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 383 insertions(+), 1 deletion(-) create mode 100644 lib/prism/wasm.rb diff --git a/lib/prism.rb b/lib/prism.rb index 8f0342724a..14c79c4501 100644 --- a/lib/prism.rb +++ b/lib/prism.rb @@ -141,5 +141,10 @@ def self.find(callable, rubyvm: !!defined?(RubyVM)) # The FFI backend is used on other Ruby implementations. Prism::BACKEND = :FFI - require_relative "prism/ffi" + begin + require_relative "prism/ffi" + rescue LoadError + raise $! unless RUBY_ENGINE == "jruby" + require_relative "prism/wasm" + end end diff --git a/lib/prism/wasm.rb b/lib/prism/wasm.rb new file mode 100644 index 0000000000..e57c6bb375 --- /dev/null +++ b/lib/prism/wasm.rb @@ -0,0 +1,377 @@ +# frozen_string_literal: true +# :markup: markdown +# typed: ignore + +# This file is responsible for mirroring the API provided by the C extension by +# using FFI to call into the shared library. + +require "rbconfig" +require "ffi" + +# We want to eagerly load this file if there are Ractors so that it does not get +# autoloaded from within a non-main Ractor. +require "prism/serialize" if defined?(Ractor) + +# Load the prism-parser-wasm jar +require 'jar-dependencies' +require_jar('org.ruby-lang', 'prism-parser-wasm', '0.0.1-SNAPSHOT') +require_jar('com.dylibso.chicory', 'runtime', '1.6.1') +require_jar('com.dylibso.chicory', 'wasi', '1.6.1') +require_jar('com.dylibso.chicory', 'wasm', '1.6.1') +require_jar('com.dylibso.chicory', 'log', '1.6.1') + +module Prism # :nodoc: + module WASM + java_import org.ruby_lang.prism.wasm.Prism + + # TODO: concurrency + PRISM = org.ruby_lang.prism.wasm.Prism.new + end + private_constant :WASM + + # The version constant is set by reading the result of calling pm_version. + VERSION = WASM::PRISM.version + + class << self + # Mirror the Prism.dump API by using the serialization API. + def dump(source, **options) + parsed = WASM::PRISM.parse(source.to_java_bytes, dump_options(options).to_java_bytes) + String.from_java_bytes(parsed) + end + + # Mirror the Prism.dump_file API by using the serialization API. + def dump_file(filepath, **options) + dump_file(File.read(filepath), filepath: filepath, **options) + end + + # Mirror the Prism.lex API by using the serialization API. + def lex(source, **options) + lexed = WASM::PRISM.lex(source.to_java_bytes, dump_options(options).to_java_bytes) + Serialize.load_lex(source, lexed, options.fetch(:freeze, false)) + end + + # Mirror the Prism.lex_file API by using the serialization API. + def lex_file(filepath, **options) + lex_file(File.read(filepath), filepath: filepath, **options) + end + + # Mirror the Prism.parse API by using the serialization API. + def parse(source, **options) + serialized = dump(source, **options) + Serialize.load_parse(source, serialized, options.fetch(:freeze, false)) + end + + # Mirror the Prism.parse_file API by using the serialization API. This uses + # native strings instead of Ruby strings because it allows us to use mmap + # when it is available. + def parse_file(filepath, **options) + parse(File.read(filepath), filepath: filepath, **options) + end + + # Mirror the Prism.parse_stream API by using the serialization API. + def parse_stream(stream, **options) + LibRubyParser::PrismBuffer.with do |buffer| + source = +"" + callback = -> (string, size, _) { + raise "Expected size to be >= 0, got: #{size}" if size <= 0 + + if !(line = stream.gets(size - 1)).nil? + source << line + string.write_string("#{line}\x00", line.bytesize + 1) + end + } + + eof_callback = -> (_) { stream.eof? } + + # In the pm_serialize_parse_stream function it accepts a pointer to the + # IO object as a void* and then passes it through to the callback as the + # third argument, but it never touches it itself. As such, since we have + # access to the IO object already through the closure of the lambda, we + # can pass a null pointer here and not worry. + LibRubyParser.pm_serialize_parse_stream(buffer.pointer, nil, callback, eof_callback, dump_options(options)) + Prism.load(source, buffer.read, options.fetch(:freeze, false)) + end + end + + # Mirror the Prism.parse_comments API by using the serialization API. + def parse_comments(code, **options) + LibRubyParser::PrismString.with_string(code) { |string| parse_comments_common(string, code, options) } + end + + # Mirror the Prism.parse_file_comments API by using the serialization + # API. This uses native strings instead of Ruby strings because it allows us + # to use mmap when it is available. + def parse_file_comments(filepath, **options) + options[:filepath] = filepath + LibRubyParser::PrismString.with_file(filepath) { |string| parse_comments_common(string, string.read, options) } + end + + # Mirror the Prism.parse_lex API by using the serialization API. + def parse_lex(code, **options) + LibRubyParser::PrismString.with_string(code) { |string| parse_lex_common(string, code, options) } + end + + # Mirror the Prism.parse_lex_file API by using the serialization API. + def parse_lex_file(filepath, **options) + options[:filepath] = filepath + LibRubyParser::PrismString.with_file(filepath) { |string| parse_lex_common(string, string.read, options) } + end + + # Mirror the Prism.parse_success? API by using the serialization API. + def parse_success?(code, **options) + LibRubyParser::PrismString.with_string(code) { |string| parse_file_success_common(string, options) } + end + + # Mirror the Prism.parse_failure? API by using the serialization API. + def parse_failure?(code, **options) + !parse_success?(code, **options) + end + + # Mirror the Prism.parse_file_success? API by using the serialization API. + def parse_file_success?(filepath, **options) + options[:filepath] = filepath + LibRubyParser::PrismString.with_file(filepath) { |string| parse_file_success_common(string, options) } + end + + # Mirror the Prism.parse_file_failure? API by using the serialization API. + def parse_file_failure?(filepath, **options) + !parse_file_success?(filepath, **options) + end + + # Mirror the Prism.profile API by using the serialization API. + def profile(source, **options) + LibRubyParser::PrismString.with_string(source) do |string| + LibRubyParser::PrismBuffer.with do |buffer| + LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) + nil + end + end + end + + # Mirror the Prism.profile_file API by using the serialization API. + def profile_file(filepath, **options) + LibRubyParser::PrismString.with_file(filepath) do |string| + LibRubyParser::PrismBuffer.with do |buffer| + options[:filepath] = filepath + LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) + nil + end + end + end + + private + + def lex_common(string, code, options) # :nodoc: + LibRubyParser::PrismBuffer.with do |buffer| + LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) + Serialize.load_lex(code, buffer.read, options.fetch(:freeze, false)) + end + end + + def parse_common(string, code, options) # :nodoc: + serialized = dump_common(string, options) + Serialize.load_parse(code, serialized, options.fetch(:freeze, false)) + end + + def parse_comments_common(string, code, options) # :nodoc: + LibRubyParser::PrismBuffer.with do |buffer| + LibRubyParser.pm_serialize_parse_comments(buffer.pointer, string.pointer, string.length, dump_options(options)) + Serialize.load_parse_comments(code, buffer.read, options.fetch(:freeze, false)) + end + end + + def parse_lex_common(string, code, options) # :nodoc: + LibRubyParser::PrismBuffer.with do |buffer| + LibRubyParser.pm_serialize_parse_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) + Serialize.load_parse_lex(code, buffer.read, options.fetch(:freeze, false)) + end + end + + def parse_file_success_common(string, options) # :nodoc: + LibRubyParser.pm_parse_success_p(string.pointer, string.length, dump_options(options)) + end + + # Return the value that should be dumped for the command_line option. + def dump_options_command_line(options) + command_line = options.fetch(:command_line, "") + raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String) + + command_line.each_char.inject(0) do |value, char| + case char + when "a" then value | 0b000001 + when "e" then value | 0b000010 + when "l" then value | 0b000100 + when "n" then value | 0b001000 + when "p" then value | 0b010000 + when "x" then value | 0b100000 + else raise ArgumentError, "invalid command_line option: #{char}" + end + end + end + + # Return the value that should be dumped for the version option. + def dump_options_version(version) + case version + when "current" + version_string_to_number(RUBY_VERSION) || raise(CurrentVersionError, RUBY_VERSION) + when "latest", nil + 0 # Handled in pm_parser_init + when "nearest" + dump = version_string_to_number(RUBY_VERSION) + return dump if dump + if RUBY_VERSION < "3.3" + version_string_to_number("3.3") + else + 0 # Handled in pm_parser_init + end + else + version_string_to_number(version) || raise(ArgumentError, "invalid version: #{version}") + end + end + + # Converts a version string like "4.0.0" or "4.0" into a number. + # Returns nil if the version is unknown. + def version_string_to_number(version) + case version + when /\A3\.3(\.\d+)?\z/ + 1 + when /\A3\.4(\.\d+)?\z/ + 2 + when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/ + 3 + when /\A4\.1(\.\d+)?\z/ + 4 + end + end + + # Convert the given options into a serialized options string. + def dump_options(options) + template = +"" + values = [] + + template << "L" + if (filepath = options[:filepath]) + values.push(filepath.bytesize, filepath.b) + template << "A*" + else + values << 0 + end + + template << "l" + values << options.fetch(:line, 1) + + template << "L" + if (encoding = options[:encoding]) + name = encoding.is_a?(Encoding) ? encoding.name : encoding + values.push(name.bytesize, name.b) + template << "A*" + else + values << 0 + end + + template << "C" + values << (options.fetch(:frozen_string_literal, false) ? 1 : 0) + + template << "C" + values << dump_options_command_line(options) + + template << "C" + values << dump_options_version(options[:version]) + + template << "C" + values << (options[:encoding] == false ? 1 : 0) + + template << "C" + values << (options.fetch(:main_script, false) ? 1 : 0) + + template << "C" + values << (options.fetch(:partial_script, false) ? 1 : 0) + + template << "C" + values << (options.fetch(:freeze, false) ? 1 : 0) + + template << "L" + if (scopes = options[:scopes]) + values << scopes.length + + scopes.each do |scope| + locals = nil + forwarding = 0 + + case scope + when Array + locals = scope + when Scope + locals = scope.locals + + scope.forwarding.each do |forward| + case forward + when :* then forwarding |= 0x1 + when :** then forwarding |= 0x2 + when :& then forwarding |= 0x4 + when :"..." then forwarding |= 0x8 + else raise ArgumentError, "invalid forwarding value: #{forward}" + end + end + else + raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)" + end + + template << "L" + values << locals.length + + template << "C" + values << forwarding + + locals.each do |local| + name = local.name + template << "L" + values << name.bytesize + + template << "A*" + values << name.b + end + end + else + values << 0 + end + + values.pack(template) + end + end + + # Here we are going to patch StringQuery to put in the class-level methods so + # that it can maintain a consistent interface + class StringQuery # :nodoc: + class << self + # Mirrors the C extension's StringQuery::local? method. + def local?(string) + query(LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name)) + end + + # Mirrors the C extension's StringQuery::constant? method. + def constant?(string) + query(LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name)) + end + + # Mirrors the C extension's StringQuery::method_name? method. + def method_name?(string) + query(LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name)) + end + + private + + # Parse the enum result and return an appropriate boolean. + def query(result) + case result + when :PM_STRING_QUERY_ERROR + raise ArgumentError, "Invalid or non ascii-compatible encoding" + when :PM_STRING_QUERY_FALSE + false + when :PM_STRING_QUERY_TRUE + true + end + end + end + end +end From b81eba8d3deeee8b50592e21b61b07ec6a13b983 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Fri, 20 Mar 2026 13:00:12 -0500 Subject: [PATCH 02/11] Separate common parts of FFI for WASM use --- lib/prism.rb | 7 +- lib/prism/ffi.rb | 502 +++--------------------------------- lib/prism/ffi/common.rb | 229 ++++++++++++++++ lib/prism/ffi/native_ffi.rb | 325 +++++++++++++++++++++++ lib/prism/ffi/wasm_ffi.rb | 104 ++++++++ lib/prism/wasm.rb | 377 --------------------------- 6 files changed, 694 insertions(+), 850 deletions(-) create mode 100644 lib/prism/ffi/common.rb create mode 100644 lib/prism/ffi/native_ffi.rb create mode 100644 lib/prism/ffi/wasm_ffi.rb delete mode 100644 lib/prism/wasm.rb diff --git a/lib/prism.rb b/lib/prism.rb index 14c79c4501..8f0342724a 100644 --- a/lib/prism.rb +++ b/lib/prism.rb @@ -141,10 +141,5 @@ def self.find(callable, rubyvm: !!defined?(RubyVM)) # The FFI backend is used on other Ruby implementations. Prism::BACKEND = :FFI - begin - require_relative "prism/ffi" - rescue LoadError - raise $! unless RUBY_ENGINE == "jruby" - require_relative "prism/wasm" - end + require_relative "prism/ffi" end diff --git a/lib/prism/ffi.rb b/lib/prism/ffi.rb index 6b9bde51ea..fb5ca055b7 100644 --- a/lib/prism/ffi.rb +++ b/lib/prism/ffi.rb @@ -2,285 +2,49 @@ # :markup: markdown # typed: ignore -# This file is responsible for mirroring the API provided by the C extension by -# using FFI to call into the shared library. - -require "rbconfig" -require "ffi" - -# We want to eagerly load this file if there are Ractors so that it does not get -# autoloaded from within a non-main Ractor. -require "prism/serialize" if defined?(Ractor) - -module Prism # :nodoc: - module LibRubyParser # :nodoc: - extend FFI::Library - - # Define the library that we will be pulling functions from. Note that this - # must align with the build shared library from make/rake. - libprism_in_build = File.expand_path("../../build/libprism.#{RbConfig::CONFIG["SOEXT"]}", __dir__) - libprism_in_libdir = "#{RbConfig::CONFIG["libdir"]}/prism/libprism.#{RbConfig::CONFIG["SOEXT"]}" - - if File.exist?(libprism_in_build) - INCLUDE_DIR = File.expand_path("../../include", __dir__) - ffi_lib libprism_in_build - else - INCLUDE_DIR = "#{RbConfig::CONFIG["libdir"]}/prism/include" - ffi_lib libprism_in_libdir - end - - # Convert a native C type declaration into a symbol that FFI understands. - # For example: - # - # const char * -> :pointer - # bool -> :bool - # size_t -> :size_t - # void -> :void - # - def self.resolve_type(type, callbacks) - type = type.strip - - if !type.end_with?("*") - type.delete_prefix("const ").to_sym - else - type = type.delete_suffix("*").rstrip - callbacks.include?(type.to_sym) ? type.to_sym : :pointer - end - end - - # Read through the given header file and find the declaration of each of the - # given functions. For each one, define a function with the same name and - # signature as the C function. - def self.load_exported_functions_from(header, *functions, callbacks) - File.foreach("#{INCLUDE_DIR}/#{header}") do |line| - # We only want to attempt to load exported functions. - next unless line.start_with?("PRISM_EXPORTED_FUNCTION ") - - # We only want to load the functions that we are interested in. - next unless functions.any? { |function| line.include?(function) } - - # Strip trailing attributes (PRISM_NODISCARD, PRISM_NONNULL(...), etc.) - line = line.sub(/\)(\s+PRISM_\w+(?:\([^)]*\))?)+\s*;/, ");") - - # Parse the function declaration. - unless /^PRISM_EXPORTED_FUNCTION (?.+) (?\w+)\((?.+)\);$/ =~ line - raise "Could not parse #{line}" - end - - # Delete the function from the list of functions we are looking for to - # mark it as having been found. - functions.delete(name) - - # Split up the argument types into an array, ensure we handle the case - # where there are no arguments (by explicit void). - arg_types = arg_types.split(",").map(&:strip) - arg_types = [] if arg_types == %w[void] - - # Resolve the type of the argument by dropping the name of the argument - # first if it is present. - arg_types.map! { |type| resolve_type(type.sub(/\w+$/, ""), callbacks) } - - # Attach the function using the FFI library. - attach_function name, arg_types, resolve_type(return_type, []) - end - - # If we didn't find all of the functions, raise an error. - raise "Could not find functions #{functions.inspect}" unless functions.empty? - end - - callback :pm_source_stream_fgets_t, [:pointer, :int, :pointer], :pointer - callback :pm_source_stream_feof_t, [:pointer], :int - pm_source_init_result_values = %i[PM_SOURCE_INIT_SUCCESS PM_SOURCE_INIT_ERROR_GENERIC PM_SOURCE_INIT_ERROR_DIRECTORY PM_SOURCE_INIT_ERROR_NON_REGULAR] - enum :pm_source_init_result_t, pm_source_init_result_values - enum :pm_string_query_t, [:PM_STRING_QUERY_ERROR, -1, :PM_STRING_QUERY_FALSE, :PM_STRING_QUERY_TRUE] - - # Ractor-safe lookup table for pm_source_init_result_t, since FFI's - # enum_type accesses module instance variables that are not shareable. - SOURCE_INIT_RESULT = pm_source_init_result_values.freeze - - load_exported_functions_from( - "prism/version.h", - "pm_version", - [] - ) - - load_exported_functions_from( - "prism/serialize.h", - "pm_serialize_parse", - "pm_serialize_parse_stream", - "pm_serialize_parse_comments", - "pm_serialize_lex", - "pm_serialize_parse_lex", - "pm_serialize_parse_success_p", - [] - ) - - load_exported_functions_from( - "prism/string_query.h", - "pm_string_query_local", - "pm_string_query_constant", - "pm_string_query_method_name", - [] - ) - - load_exported_functions_from( - "prism/buffer.h", - "pm_buffer_new", - "pm_buffer_value", - "pm_buffer_length", - "pm_buffer_free", - [] - ) - - load_exported_functions_from( - "prism/source.h", - "pm_source_file_new", - "pm_source_mapped_new", - "pm_source_stream_new", - "pm_source_free", - "pm_source_source", - "pm_source_length", - [:pm_source_stream_fgets_t, :pm_source_stream_feof_t] - ) - - # This object represents a pm_buffer_t. We only use it as an opaque pointer, - # so it doesn't need to know the fields of pm_buffer_t. - class PrismBuffer # :nodoc: - attr_reader :pointer - - def initialize(pointer) - @pointer = pointer - end - - def value - LibRubyParser.pm_buffer_value(pointer) - end - - def length - LibRubyParser.pm_buffer_length(pointer) - end - - def read - value.read_string(length) - end - - # Initialize a new buffer and yield it to the block. The buffer will be - # automatically freed when the block returns. - def self.with - buffer = LibRubyParser.pm_buffer_new - raise unless buffer - - begin - yield new(buffer) - ensure - LibRubyParser.pm_buffer_free(buffer) - end - end - end - - # This object represents source code to be parsed. For strings it wraps a - # pointer directly; for files it uses a pm_source_t under the hood. - class PrismSource # :nodoc: - PLATFORM_EXPECTS_UTF8 = - RbConfig::CONFIG["host_os"].match?(/bccwin|cygwin|djgpp|mingw|mswin|wince|darwin/i) - - attr_reader :pointer, :length - - def initialize(pointer, length, from_string) - @pointer = pointer - @length = length - @from_string = from_string - end - - def read - raise "should use the original String instead" if @from_string - @pointer.read_string(@length) - end - - # Yields a PrismSource backed by the given string to the block. - def self.with_string(string) - raise TypeError unless string.is_a?(String) - - length = string.bytesize - # + 1 to never get an address of 0, which pm_parser_init() asserts - FFI::MemoryPointer.new(:char, length + 1, false) do |pointer| - pointer.write_string(string) - # since we have the extra byte we might as well \0-terminate - pointer.put_char(length, 0) - return yield new(pointer, length, true) - end - end - - # Yields a PrismSource to the given block, backed by a pm_source_t. - def self.with_file(filepath) - raise TypeError unless filepath.is_a?(String) - - # On Windows and Mac, it's expected that filepaths will be encoded in - # UTF-8. If they are not, we need to convert them to UTF-8 before - # passing them into pm_source_mapped_new. - if PLATFORM_EXPECTS_UTF8 && (encoding = filepath.encoding) != Encoding::ASCII_8BIT && encoding != Encoding::UTF_8 - filepath = filepath.encode(Encoding::UTF_8) - end - - FFI::MemoryPointer.new(:int) do |result_ptr| - pm_source = LibRubyParser.pm_source_mapped_new(filepath, 0, result_ptr) - - case SOURCE_INIT_RESULT[result_ptr.read_int] - when :PM_SOURCE_INIT_SUCCESS - pointer = LibRubyParser.pm_source_source(pm_source) - length = LibRubyParser.pm_source_length(pm_source) - return yield new(pointer, length, false) - when :PM_SOURCE_INIT_ERROR_GENERIC - raise SystemCallError.new(filepath, FFI.errno) - when :PM_SOURCE_INIT_ERROR_DIRECTORY - raise Errno::EISDIR.new(filepath) - when :PM_SOURCE_INIT_ERROR_NON_REGULAR - # Fall back to reading the file through Ruby IO for non-regular - # files (pipes, character devices, etc.) - return with_string(File.read(filepath)) { |string| yield string } - else - raise "Unknown error initializing pm_source_t: #{result_ptr.read_int}" - end - ensure - LibRubyParser.pm_source_free(pm_source) if pm_source && !pm_source.null? - end - end - end +require_relative "ffi/common" + +begin + require_relative "ffi/native_ffi.rb" +rescue LoadError + if RUBY_ENGINE == "jruby" + require_relative "ffi/wasm_ffi.rb" + else + raise end +end - # Mark the LibRubyParser module as private as it should only be called through - # the prism module. - private_constant :LibRubyParser +module Prism # :nodoc: # The version constant is set by reading the result of calling pm_version. - VERSION = LibRubyParser.pm_version.read_string.freeze + VERSION = FFICommon.version class << self # Mirror the Prism.dump API by using the serialization API. def dump(source, **options) - LibRubyParser::PrismSource.with_string(source) { |string| dump_common(string, options) } + FFICommon.with_string(source) { |string| FFICommon.dump(string, options) } end # Mirror the Prism.dump_file API by using the serialization API. def dump_file(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| dump_common(string, options) } + FFICommon.with_file(filepath) { |string| FFICommon.dump(string, options) } end # Mirror the Prism.lex API by using the serialization API. def lex(code, **options) - LibRubyParser::PrismSource.with_string(code) { |string| lex_common(string, code, options) } + FFICommon.with_string(code) { |string| FFICommon.lex(string, code, options) } end # Mirror the Prism.lex_file API by using the serialization API. def lex_file(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| lex_common(string, string.read, options) } + FFICommon.with_file(filepath) { |string| FFICommon.lex(string, string.read, options) } end # Mirror the Prism.parse API by using the serialization API. def parse(code, **options) - LibRubyParser::PrismSource.with_string(code) { |string| parse_common(string, code, options) } + FFICommon.with_string(code) { |string| FFICommon.parse(string, code, options) } end # Mirror the Prism.parse_file API by using the serialization API. This uses @@ -288,12 +52,12 @@ def parse(code, **options) # when it is available. def parse_file(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| parse_common(string, string.read, options) } + FFICommon.with_file(filepath) { |string| FFICommon.parse(string, string.read, options) } end # Mirror the Prism.parse_stream API by using the serialization API. def parse_stream(stream, **options) - LibRubyParser::PrismBuffer.with do |buffer| + FFICommon.with_buffer do |buffer| source = +"" callback = -> (string, size, _) { raise "Expected size to be >= 0, got: #{size}" if size <= 0 @@ -306,19 +70,13 @@ def parse_stream(stream, **options) eof_callback = -> (_) { stream.eof? } - pm_source = LibRubyParser.pm_source_stream_new(nil, callback, eof_callback) - begin - LibRubyParser.pm_serialize_parse_stream(buffer.pointer, pm_source, dump_options(options)) - Prism.load(source, buffer.read, options.fetch(:freeze, false)) - ensure - LibRubyParser.pm_source_free(pm_source) if pm_source && !pm_source.null? - end + FFICommon.parse_stream(buffer, callback, eof_callback, options, source) end end # Mirror the Prism.parse_comments API by using the serialization API. def parse_comments(code, **options) - LibRubyParser::PrismSource.with_string(code) { |string| parse_comments_common(string, code, options) } + FFICommon.with_string(code) { |string| FFICommon.parse_comments(string, code, options) } end # Mirror the Prism.parse_file_comments API by using the serialization @@ -326,23 +84,23 @@ def parse_comments(code, **options) # to use mmap when it is available. def parse_file_comments(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| parse_comments_common(string, string.read, options) } + FFICommon.with_file(filepath) { |string| FFICommon.parse_comments(string, string.read, options) } end # Mirror the Prism.parse_lex API by using the serialization API. def parse_lex(code, **options) - LibRubyParser::PrismSource.with_string(code) { |string| parse_lex_common(string, code, options) } + FFICommon.with_string(code) { |string| FFICommon.parse_lex(string, code, options) } end # Mirror the Prism.parse_lex_file API by using the serialization API. def parse_lex_file(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| parse_lex_common(string, string.read, options) } + FFICommon.with_file(filepath) { |string| FFICommon.parse_lex(string, string.read, options) } end # Mirror the Prism.parse_success? API by using the serialization API. def parse_success?(code, **options) - LibRubyParser::PrismSource.with_string(code) { |string| parse_file_success_common(string, options) } + FFICommon.with_string(code) { |string| FFICommon.parse_file_success(string, options) } end # Mirror the Prism.parse_failure? API by using the serialization API. @@ -353,7 +111,7 @@ def parse_failure?(code, **options) # Mirror the Prism.parse_file_success? API by using the serialization API. def parse_file_success?(filepath, **options) options[:filepath] = filepath - LibRubyParser::PrismSource.with_file(filepath) { |string| parse_file_success_common(string, options) } + FFICommon.with_file(filepath) { |string| FFICommon.parse_file_success(string, options) } end # Mirror the Prism.parse_file_failure? API by using the serialization API. @@ -363,9 +121,9 @@ def parse_file_failure?(filepath, **options) # Mirror the Prism.profile API by using the serialization API. def profile(source, **options) - LibRubyParser::PrismSource.with_string(source) do |string| - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) + FFICommon.with_string(source) do |string| + FFICommon.with_buffer do |buffer| + FFICommon.parse_only(buffer, string, options) nil end end @@ -373,205 +131,15 @@ def profile(source, **options) # Mirror the Prism.profile_file API by using the serialization API. def profile_file(filepath, **options) - LibRubyParser::PrismSource.with_file(filepath) do |string| - LibRubyParser::PrismBuffer.with do |buffer| + FFICommon.with_file(filepath) do |string| + FFICommon.with_buffer do |buffer| options[:filepath] = filepath - LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) + FFICommon.parse_only(buffer, string, options) nil end end end - private - - def dump_common(string, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) - - dumped = buffer.read - dumped.freeze if options.fetch(:freeze, false) - - dumped - end - end - - def lex_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_lex(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_common(string, code, options) # :nodoc: - serialized = dump_common(string, options) - Serialize.load_parse(code, serialized, options.fetch(:freeze, false)) - end - - def parse_comments_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse_comments(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_parse_comments(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_lex_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_parse_lex(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_file_success_common(string, options) # :nodoc: - LibRubyParser.pm_serialize_parse_success_p(string.pointer, string.length, dump_options(options)) - end - - # Return the value that should be dumped for the command_line option. - def dump_options_command_line(options) - command_line = options.fetch(:command_line, "") - raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String) - - command_line.each_char.inject(0) do |value, char| - case char - when "a" then value | 0b000001 - when "e" then value | 0b000010 - when "l" then value | 0b000100 - when "n" then value | 0b001000 - when "p" then value | 0b010000 - when "x" then value | 0b100000 - else raise ArgumentError, "invalid command_line option: #{char}" - end - end - end - - # Return the value that should be dumped for the version option. - def dump_options_version(version) - case version - when "current" - version_string_to_number(RUBY_VERSION) || raise(CurrentVersionError, RUBY_VERSION) - when "latest", nil - 0 # Handled in pm_parser_init - when "nearest" - dump = version_string_to_number(RUBY_VERSION) - return dump if dump - if RUBY_VERSION < "3.3" - version_string_to_number("3.3") - else - 0 # Handled in pm_parser_init - end - else - version_string_to_number(version) || raise(ArgumentError, "invalid version: #{version}") - end - end - - # Converts a version string like "4.0.0" or "4.0" into a number. - # Returns nil if the version is unknown. - def version_string_to_number(version) - case version - when /\A3\.3(\.\d+)?\z/ - 1 - when /\A3\.4(\.\d+)?\z/ - 2 - when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/ - 3 - when /\A4\.1(\.\d+)?\z/ - 4 - end - end - - # Convert the given options into a serialized options string. - def dump_options(options) - template = +"" - values = [] - - template << "L" - if (filepath = options[:filepath]) - values.push(filepath.bytesize, filepath.b) - template << "A*" - else - values << 0 - end - - template << "l" - values << options.fetch(:line, 1) - - template << "L" - if (encoding = options[:encoding]) - name = encoding.is_a?(Encoding) ? encoding.name : encoding - values.push(name.bytesize, name.b) - template << "A*" - else - values << 0 - end - - template << "C" - values << (options.fetch(:frozen_string_literal, false) ? 1 : 0) - - template << "C" - values << dump_options_command_line(options) - - template << "C" - values << dump_options_version(options[:version]) - - template << "C" - values << (options[:encoding] == false ? 1 : 0) - - template << "C" - values << (options.fetch(:main_script, false) ? 1 : 0) - - template << "C" - values << (options.fetch(:partial_script, false) ? 1 : 0) - - template << "C" - values << (options.fetch(:freeze, false) ? 1 : 0) - - template << "L" - if (scopes = options[:scopes]) - values << scopes.length - - scopes.each do |scope| - locals = nil - forwarding = 0 - - case scope - when Array - locals = scope - when Scope - locals = scope.locals - - scope.forwarding.each do |forward| - case forward - when :* then forwarding |= 0x1 - when :** then forwarding |= 0x2 - when :& then forwarding |= 0x4 - when :"..." then forwarding |= 0x8 - else raise ArgumentError, "invalid forwarding value: #{forward}" - end - end - else - raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)" - end - - template << "L" - values << locals.length - - template << "C" - values << forwarding - - locals.each do |local| - name = local.name - template << "L" - values << name.bytesize - - template << "A*" - values << name.b - end - end - else - values << 0 - end - - values.pack(template) - end end # Here we are going to patch StringQuery to put in the class-level methods so @@ -580,17 +148,17 @@ class StringQuery # :nodoc: class << self # Mirrors the C extension's StringQuery::local? method. def local?(string) - query(LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name)) + query(FFICommon.string_query_local(string)) end # Mirrors the C extension's StringQuery::constant? method. def constant?(string) - query(LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name)) + query(FFICommon.string_query_constant(string)) end # Mirrors the C extension's StringQuery::method_name? method. def method_name?(string) - query(LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name)) + query(FFICommon.string_query_method_name(string)) end private diff --git a/lib/prism/ffi/common.rb b/lib/prism/ffi/common.rb new file mode 100644 index 0000000000..2600273318 --- /dev/null +++ b/lib/prism/ffi/common.rb @@ -0,0 +1,229 @@ +# frozen_string_literal: true +# :markup: markdown +# typed: ignore + +module Prism + + class Common + def dump(string, options) # :nodoc: + with_buffer do |buffer| + parse_only(buffer, string, options) + + dumped = buffer.read + dumped.freeze if options.fetch(:freeze, false) + + dumped + end + end + + def parse(string, code, options) # :nodoc: + serialized = dump(string, options) + Serialize.load_parse(code, serialized, options.fetch(:freeze, false)) + end + + def lex(string, code, options) # :nodoc: + with_buffer do |buffer| + lex_only(buffer, string, options) + Serialize.load_lex(code, buffer.read, options.fetch(:freeze, false)) + end + end + + # Return the value that should be dumped for the command_line option. + def dump_options_command_line(options) + command_line = options.fetch(:command_line, "") + raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String) + + command_line.each_char.inject(0) do |value, char| + case char + when "a" then value | 0b000001 + when "e" then value | 0b000010 + when "l" then value | 0b000100 + when "n" then value | 0b001000 + when "p" then value | 0b010000 + when "x" then value | 0b100000 + else raise ArgumentError, "invalid command_line option: #{char}" + end + end + end + + # Return the value that should be dumped for the version option. + def dump_options_version(version) + case version + when "current" + version_string_to_number(RUBY_VERSION) || raise(CurrentVersionError, RUBY_VERSION) + when "latest", nil + 0 # Handled in pm_parser_init + when "nearest" + dump = version_string_to_number(RUBY_VERSION) + return dump if dump + if RUBY_VERSION < "3.3" + version_string_to_number("3.3") + else + 0 # Handled in pm_parser_init + end + else + version_string_to_number(version) || raise(ArgumentError, "invalid version: #{version}") + end + end + + # Converts a version string like "4.0.0" or "4.0" into a number. + # Returns nil if the version is unknown. + def version_string_to_number(version) + case version + when /\A3\.3(\.\d+)?\z/ + 1 + when /\A3\.4(\.\d+)?\z/ + 2 + when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/ + 3 + when /\A4\.1(\.\d+)?\z/ + 4 + end + end + + # Convert the given options into a serialized options string. + def dump_options(options) + template = +"" + values = [] + + template << "L" + if (filepath = options[:filepath]) + values.push(filepath.bytesize, filepath.b) + template << "A*" + else + values << 0 + end + + template << "l" + values << options.fetch(:line, 1) + + template << "L" + if (encoding = options[:encoding]) + name = encoding.is_a?(Encoding) ? encoding.name : encoding + values.push(name.bytesize, name.b) + template << "A*" + else + values << 0 + end + + template << "C" + values << (options.fetch(:frozen_string_literal, false) ? 1 : 0) + + template << "C" + values << dump_options_command_line(options) + + template << "C" + values << dump_options_version(options[:version]) + + template << "C" + values << (options[:encoding] == false ? 1 : 0) + + template << "C" + values << (options.fetch(:main_script, false) ? 1 : 0) + + template << "C" + values << (options.fetch(:partial_script, false) ? 1 : 0) + + template << "C" + values << (options.fetch(:freeze, false) ? 1 : 0) + + template << "L" + if (scopes = options[:scopes]) + values << scopes.length + + scopes.each do |scope| + locals = nil + forwarding = 0 + + case scope + when Array + locals = scope + when Scope + locals = scope.locals + + scope.forwarding.each do |forward| + case forward + when :* then forwarding |= 0x1 + when :** then forwarding |= 0x2 + when :& then forwarding |= 0x4 + when :"..." then forwarding |= 0x8 + else raise ArgumentError, "invalid forwarding value: #{forward}" + end + end + else + raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)" + end + + template << "L" + values << locals.length + + template << "C" + values << forwarding + + locals.each do |local| + name = local.name + template << "L" + values << name.bytesize + + template << "A*" + values << name.b + end + end + else + values << 0 + end + + values.pack(template) + end + + # Required APIs below + + def with_buffer(&b) + raise NotImplementedError + end + + def with_string(string, &b) + raise NotImplementedError + end + + def with_file(string, &b) + raise NotImplementedError + end + + def lex_only(buffer, string, options) + raise NotImplementedError + end + + def parse_only(buffer, string, options) + raise NotImplementedError + end + + def parse_stream(buffer, callback, eof_callback, options, source) + raise NotImplementedError + end + + def parse_comments(string, code, options) # :nodoc: + raise NotImplementedError + end + + def parse_lex(string, code, options) # :nodoc: + raise NotImplementedError + end + + def parse_file_success(string, options) # :nodoc: + raise NotImplementedError + end + + def string_query_method_name(string) + raise NotImplementedError + end + + def string_query_constant(string) + raise NotImplementedError + end + + def string_query_local(string) + raise NotImplementedError + end + end +end diff --git a/lib/prism/ffi/native_ffi.rb b/lib/prism/ffi/native_ffi.rb new file mode 100644 index 0000000000..600e4236ec --- /dev/null +++ b/lib/prism/ffi/native_ffi.rb @@ -0,0 +1,325 @@ +# frozen_string_literal: true +# :markup: markdown +# typed: ignore + +# This file is responsible for mirroring the API provided by the C extension by +# using FFI to call into the shared library. + +require "rbconfig" +require "ffi" + +# We want to eagerly load this file if there are Ractors so that it does not get +# autoloaded from within a non-main Ractor. +require "prism/serialize" if defined?(Ractor) + +module Prism # :nodoc: + module LibRubyParser # :nodoc: + extend FFI::Library + + # Define the library that we will be pulling functions from. Note that this + # must align with the build shared library from make/rake. + libprism_in_build = File.expand_path("../../../build/libprism.#{RbConfig::CONFIG["SOEXT"]}", __dir__) + libprism_in_libdir = "#{RbConfig::CONFIG["libdir"]}/prism/libprism.#{RbConfig::CONFIG["SOEXT"]}" + + if File.exist?(libprism_in_build) + INCLUDE_DIR = File.expand_path("../../../include", __dir__) + ffi_lib libprism_in_build + else + INCLUDE_DIR = "#{RbConfig::CONFIG["libdir"]}/prism/include" + ffi_lib libprism_in_libdir + end + + # Convert a native C type declaration into a symbol that FFI understands. + # For example: + # + # const char * -> :pointer + # bool -> :bool + # size_t -> :size_t + # void -> :void + # + def self.resolve_type(type, callbacks) + type = type.strip + + if !type.end_with?("*") + type.delete_prefix("const ").to_sym + else + type = type.delete_suffix("*").rstrip + callbacks.include?(type.to_sym) ? type.to_sym : :pointer + end + end + + # Read through the given header file and find the declaration of each of the + # given functions. For each one, define a function with the same name and + # signature as the C function. + def self.load_exported_functions_from(header, *functions, callbacks) + File.foreach("#{INCLUDE_DIR}/#{header}") do |line| + # We only want to attempt to load exported functions. + next unless line.start_with?("PRISM_EXPORTED_FUNCTION ") + + # We only want to load the functions that we are interested in. + next unless functions.any? { |function| line.include?(function) } + + # Strip trailing attributes (PRISM_NODISCARD, PRISM_NONNULL(...), etc.) + line = line.sub(/\)(\s+PRISM_\w+(?:\([^)]*\))?)+\s*;/, ");") + + # Parse the function declaration. + unless /^PRISM_EXPORTED_FUNCTION (?.+) (?\w+)\((?.+)\);$/ =~ line + raise "Could not parse #{line}" + end + + # Delete the function from the list of functions we are looking for to + # mark it as having been found. + functions.delete(name) + + # Split up the argument types into an array, ensure we handle the case + # where there are no arguments (by explicit void). + arg_types = arg_types.split(",").map(&:strip) + arg_types = [] if arg_types == %w[void] + + # Resolve the type of the argument by dropping the name of the argument + # first if it is present. + arg_types.map! { |type| resolve_type(type.sub(/\w+$/, ""), callbacks) } + + # Attach the function using the FFI library. + attach_function name, arg_types, resolve_type(return_type, []) + end + + # If we didn't find all of the functions, raise an error. + raise "Could not find functions #{functions.inspect}" unless functions.empty? + end + + callback :pm_source_stream_fgets_t, [:pointer, :int, :pointer], :pointer + callback :pm_source_stream_feof_t, [:pointer], :int + pm_source_init_result_values = %i[PM_SOURCE_INIT_SUCCESS PM_SOURCE_INIT_ERROR_GENERIC PM_SOURCE_INIT_ERROR_DIRECTORY PM_SOURCE_INIT_ERROR_NON_REGULAR] + enum :pm_source_init_result_t, pm_source_init_result_values + enum :pm_string_query_t, [:PM_STRING_QUERY_ERROR, -1, :PM_STRING_QUERY_FALSE, :PM_STRING_QUERY_TRUE] + + # Ractor-safe lookup table for pm_source_init_result_t, since FFI's + # enum_type accesses module instance variables that are not shareable. + SOURCE_INIT_RESULT = pm_source_init_result_values.freeze + + load_exported_functions_from( + "prism/version.h", + "pm_version", + [] + ) + + load_exported_functions_from( + "prism/serialize.h", + "pm_serialize_parse", + "pm_serialize_parse_stream", + "pm_serialize_parse_comments", + "pm_serialize_lex", + "pm_serialize_parse_lex", + "pm_serialize_parse_success_p", + [] + ) + + load_exported_functions_from( + "prism/string_query.h", + "pm_string_query_local", + "pm_string_query_constant", + "pm_string_query_method_name", + [] + ) + + load_exported_functions_from( + "prism/buffer.h", + "pm_buffer_new", + "pm_buffer_value", + "pm_buffer_length", + "pm_buffer_free", + [] + ) + + load_exported_functions_from( + "prism/source.h", + "pm_source_file_new", + "pm_source_mapped_new", + "pm_source_stream_new", + "pm_source_free", + "pm_source_source", + "pm_source_length", + [:pm_source_stream_fgets_t, :pm_source_stream_feof_t] + ) + + # This object represents a pm_buffer_t. We only use it as an opaque pointer, + # so it doesn't need to know the fields of pm_buffer_t. + class NativeBuffer # :nodoc: + attr_reader :pointer + + def initialize(pointer) + @pointer = pointer + end + + def value + LibRubyParser.pm_buffer_value(pointer) + end + + def length + LibRubyParser.pm_buffer_length(pointer) + end + + def read + value.read_string(length) + end + + # Initialize a new buffer and yield it to the block. The buffer will be + # automatically freed when the block returns. + def self.with + buffer = LibRubyParser.pm_buffer_new + raise unless buffer + + begin + yield new(buffer) + ensure + LibRubyParser.pm_buffer_free(buffer) + end + end + end + + # This object represents source code to be parsed. For strings it wraps a + # pointer directly; for files it uses a pm_source_t under the hood. + class NativeSource # :nodoc: + PLATFORM_EXPECTS_UTF8 = + RbConfig::CONFIG["host_os"].match?(/bccwin|cygwin|djgpp|mingw|mswin|wince|darwin/i) + + attr_reader :pointer, :length + + def initialize(pointer, length, from_string) + @pointer = pointer + @length = length + @from_string = from_string + end + + def read + raise "should use the original String instead" if @from_string + @pointer.read_string(@length) + end + + # Yields a PrismSource backed by the given string to the block. + def self.with_string(string) + raise TypeError unless string.is_a?(String) + + length = string.bytesize + # + 1 to never get an address of 0, which pm_parser_init() asserts + FFI::MemoryPointer.new(:char, length + 1, false) do |pointer| + pointer.write_string(string) + # since we have the extra byte we might as well \0-terminate + pointer.put_char(length, 0) + return yield new(pointer, length, true) + end + end + + # Yields a PrismSource to the given block, backed by a pm_source_t. + def self.with_file(filepath) + raise TypeError unless filepath.is_a?(String) + + # On Windows and Mac, it's expected that filepaths will be encoded in + # UTF-8. If they are not, we need to convert them to UTF-8 before + # passing them into pm_source_mapped_new. + if PLATFORM_EXPECTS_UTF8 && (encoding = filepath.encoding) != Encoding::ASCII_8BIT && encoding != Encoding::UTF_8 + filepath = filepath.encode(Encoding::UTF_8) + end + + FFI::MemoryPointer.new(:int) do |result_ptr| + pm_source = LibRubyParser.pm_source_mapped_new(filepath, 0, result_ptr) + + case SOURCE_INIT_RESULT[result_ptr.read_int] + when :PM_SOURCE_INIT_SUCCESS + pointer = LibRubyParser.pm_source_source(pm_source) + length = LibRubyParser.pm_source_length(pm_source) + return yield new(pointer, length, false) + when :PM_SOURCE_INIT_ERROR_GENERIC + raise SystemCallError.new(filepath, FFI.errno) + when :PM_SOURCE_INIT_ERROR_DIRECTORY + raise Errno::EISDIR.new(filepath) + when :PM_SOURCE_INIT_ERROR_NON_REGULAR + # Fall back to reading the file through Ruby IO for non-regular + # files (pipes, character devices, etc.) + return with_string(File.read(filepath)) { |string| yield string } + else + raise "Unknown error initializing pm_source_t: #{result_ptr.read_int}" + end + ensure + LibRubyParser.pm_source_free(pm_source) if pm_source && !pm_source.null? + end + end + end + end + + # Mark the LibRubyParser module as private as it should only be called through + # the prism module. + private_constant :LibRubyParser + + class NativeCommon < Common + + # The version constant is set by reading the result of calling pm_version. + def version + LibRubyParser.pm_version.read_string.freeze + end + + def with_buffer(&b) + LibRubyParser::NativeBuffer.with(&b) + end + + def with_string(string, &b) + LibRubyParser::NativeSource.with_string(string, &b) + end + + def with_file(string, &b) + LibRubyParser::NativeSource.with_file(string, &b) + end + + def lex_only(buffer, string, options) + LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) + end + + def parse_only(buffer, string, options) + LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) + end + + def parse_stream(buffer, callback, eof_callback, options, source) + pm_source = LibRubyParser.pm_source_stream_new(nil, callback, eof_callback) + begin + LibRubyParser.pm_serialize_parse_stream(buffer.pointer, pm_source, dump_options(options)) + Prism.load(source, buffer.read, options.fetch(:freeze, false)) + ensure + LibRubyParser.pm_source_free(pm_source) if pm_source && !pm_source.null? + end + end + + def parse_comments(string, code, options) # :nodoc: + with_buffer do |buffer| + LibRubyParser.pm_serialize_parse_comments(buffer.pointer, string.pointer, string.length, dump_options(options)) + Serialize.load_parse_comments(code, buffer.read, options.fetch(:freeze, false)) + end + end + + def parse_lex(string, code, options) # :nodoc: + with_buffer do |buffer| + LibRubyParser.pm_serialize_parse_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) + Serialize.load_parse_lex(code, buffer.read, options.fetch(:freeze, false)) + end + end + + def parse_file_success(string, options) # :nodoc: + LibRubyParser.pm_serialize_parse_success_p(string.pointer, string.length, dump_options(options)) + end + + def string_query_method_name(string) + LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name) + end + + def string_query_constant(string) + LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name) + end + + def string_query_local(string) + LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name) + end + end + + FFICommon = NativeCommon.new + private_constant(:FFICommon) +end diff --git a/lib/prism/ffi/wasm_ffi.rb b/lib/prism/ffi/wasm_ffi.rb new file mode 100644 index 0000000000..37ad421474 --- /dev/null +++ b/lib/prism/ffi/wasm_ffi.rb @@ -0,0 +1,104 @@ +# frozen_string_literal: true +# :markup: markdown +# typed: ignore + +# This file is responsible for mirroring the API provided by the C extension by +# using FFI to call into the shared library. + +require "rbconfig" +require "ffi" + +# We want to eagerly load this file if there are Ractors so that it does not get +# autoloaded from within a non-main Ractor. +require "prism/serialize" if defined?(Ractor) + +# Load the prism-parser-wasm jar +require 'jar-dependencies' +require_jar('org.ruby-lang', 'prism-parser-wasm', '0.0.1-SNAPSHOT') +require_jar('com.dylibso.chicory', 'runtime', '1.6.1') +require_jar('com.dylibso.chicory', 'wasi', '1.6.1') +require_jar('com.dylibso.chicory', 'wasm', '1.6.1') +require_jar('com.dylibso.chicory', 'log', '1.6.1') + +module Prism # :nodoc: + class WASMCommon < Common + java_import org.ruby_lang.prism.wasm.Prism + + # TODO: concurrency + PRISM = org.ruby_lang.prism.wasm.Prism.new + + def version + # The version constant is set by reading the result of calling pm_version. + WASM::PRISM.version + end + + # Prototype WASM code + # def dump(source, **options) + # parsed = WASM::PRISM.parse(source.to_java_bytes, dump_options(options).to_java_bytes) + # end + # + # # Mirror the Prism.dump_file API by using the serialization API. + # def dump_file(filepath, **options) + # dump_file(File.read(filepath), filepath: filepath, **options) + # end + # + # # Mirror the Prism.lex API by using the serialization API. + # def lex(source, **options) + # lexed = WASM::PRISM.lex(source.to_java_bytes, dump_options(options).to_java_bytes) + # Serialize.load_lex(source, lexed, options.fetch(:freeze, false)) + # end + # + # # Mirror the Prism.lex_file API by using the serialization API. + # def lex_file(filepath, **options) + # lex_file(File.read(filepath), filepath: filepath, **options) + # end + + def with_buffer(&b) + raise NotImplementedError + end + + def with_string(string, &b) + raise NotImplementedError + end + + def with_file(string, &b) + raise NotImplementedError + end + + def lex_only(buffer, string, options) + raise NotImplementedError + end + + def parse_only(buffer, string, options) + raise NotImplementedError + end + + def parse_stream(buffer, callback, eof_callback, options, source) + raise NotImplementedError + end + + def parse_comments(string, code, options) # :nodoc: + raise NotImplementedError + end + + def parse_lex(string, code, options) # :nodoc: + raise NotImplementedError + end + + def parse_file_success(string, options) # :nodoc: + raise NotImplementedError + end + + def string_query_method_name(string) + raise NotImplementedError + end + + def string_query_constant(string) + raise NotImplementedError + end + + def string_query_local(string) + raise NotImplementedError + end + end +end diff --git a/lib/prism/wasm.rb b/lib/prism/wasm.rb deleted file mode 100644 index e57c6bb375..0000000000 --- a/lib/prism/wasm.rb +++ /dev/null @@ -1,377 +0,0 @@ -# frozen_string_literal: true -# :markup: markdown -# typed: ignore - -# This file is responsible for mirroring the API provided by the C extension by -# using FFI to call into the shared library. - -require "rbconfig" -require "ffi" - -# We want to eagerly load this file if there are Ractors so that it does not get -# autoloaded from within a non-main Ractor. -require "prism/serialize" if defined?(Ractor) - -# Load the prism-parser-wasm jar -require 'jar-dependencies' -require_jar('org.ruby-lang', 'prism-parser-wasm', '0.0.1-SNAPSHOT') -require_jar('com.dylibso.chicory', 'runtime', '1.6.1') -require_jar('com.dylibso.chicory', 'wasi', '1.6.1') -require_jar('com.dylibso.chicory', 'wasm', '1.6.1') -require_jar('com.dylibso.chicory', 'log', '1.6.1') - -module Prism # :nodoc: - module WASM - java_import org.ruby_lang.prism.wasm.Prism - - # TODO: concurrency - PRISM = org.ruby_lang.prism.wasm.Prism.new - end - private_constant :WASM - - # The version constant is set by reading the result of calling pm_version. - VERSION = WASM::PRISM.version - - class << self - # Mirror the Prism.dump API by using the serialization API. - def dump(source, **options) - parsed = WASM::PRISM.parse(source.to_java_bytes, dump_options(options).to_java_bytes) - String.from_java_bytes(parsed) - end - - # Mirror the Prism.dump_file API by using the serialization API. - def dump_file(filepath, **options) - dump_file(File.read(filepath), filepath: filepath, **options) - end - - # Mirror the Prism.lex API by using the serialization API. - def lex(source, **options) - lexed = WASM::PRISM.lex(source.to_java_bytes, dump_options(options).to_java_bytes) - Serialize.load_lex(source, lexed, options.fetch(:freeze, false)) - end - - # Mirror the Prism.lex_file API by using the serialization API. - def lex_file(filepath, **options) - lex_file(File.read(filepath), filepath: filepath, **options) - end - - # Mirror the Prism.parse API by using the serialization API. - def parse(source, **options) - serialized = dump(source, **options) - Serialize.load_parse(source, serialized, options.fetch(:freeze, false)) - end - - # Mirror the Prism.parse_file API by using the serialization API. This uses - # native strings instead of Ruby strings because it allows us to use mmap - # when it is available. - def parse_file(filepath, **options) - parse(File.read(filepath), filepath: filepath, **options) - end - - # Mirror the Prism.parse_stream API by using the serialization API. - def parse_stream(stream, **options) - LibRubyParser::PrismBuffer.with do |buffer| - source = +"" - callback = -> (string, size, _) { - raise "Expected size to be >= 0, got: #{size}" if size <= 0 - - if !(line = stream.gets(size - 1)).nil? - source << line - string.write_string("#{line}\x00", line.bytesize + 1) - end - } - - eof_callback = -> (_) { stream.eof? } - - # In the pm_serialize_parse_stream function it accepts a pointer to the - # IO object as a void* and then passes it through to the callback as the - # third argument, but it never touches it itself. As such, since we have - # access to the IO object already through the closure of the lambda, we - # can pass a null pointer here and not worry. - LibRubyParser.pm_serialize_parse_stream(buffer.pointer, nil, callback, eof_callback, dump_options(options)) - Prism.load(source, buffer.read, options.fetch(:freeze, false)) - end - end - - # Mirror the Prism.parse_comments API by using the serialization API. - def parse_comments(code, **options) - LibRubyParser::PrismString.with_string(code) { |string| parse_comments_common(string, code, options) } - end - - # Mirror the Prism.parse_file_comments API by using the serialization - # API. This uses native strings instead of Ruby strings because it allows us - # to use mmap when it is available. - def parse_file_comments(filepath, **options) - options[:filepath] = filepath - LibRubyParser::PrismString.with_file(filepath) { |string| parse_comments_common(string, string.read, options) } - end - - # Mirror the Prism.parse_lex API by using the serialization API. - def parse_lex(code, **options) - LibRubyParser::PrismString.with_string(code) { |string| parse_lex_common(string, code, options) } - end - - # Mirror the Prism.parse_lex_file API by using the serialization API. - def parse_lex_file(filepath, **options) - options[:filepath] = filepath - LibRubyParser::PrismString.with_file(filepath) { |string| parse_lex_common(string, string.read, options) } - end - - # Mirror the Prism.parse_success? API by using the serialization API. - def parse_success?(code, **options) - LibRubyParser::PrismString.with_string(code) { |string| parse_file_success_common(string, options) } - end - - # Mirror the Prism.parse_failure? API by using the serialization API. - def parse_failure?(code, **options) - !parse_success?(code, **options) - end - - # Mirror the Prism.parse_file_success? API by using the serialization API. - def parse_file_success?(filepath, **options) - options[:filepath] = filepath - LibRubyParser::PrismString.with_file(filepath) { |string| parse_file_success_common(string, options) } - end - - # Mirror the Prism.parse_file_failure? API by using the serialization API. - def parse_file_failure?(filepath, **options) - !parse_file_success?(filepath, **options) - end - - # Mirror the Prism.profile API by using the serialization API. - def profile(source, **options) - LibRubyParser::PrismString.with_string(source) do |string| - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) - nil - end - end - end - - # Mirror the Prism.profile_file API by using the serialization API. - def profile_file(filepath, **options) - LibRubyParser::PrismString.with_file(filepath) do |string| - LibRubyParser::PrismBuffer.with do |buffer| - options[:filepath] = filepath - LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) - nil - end - end - end - - private - - def lex_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_lex(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_common(string, code, options) # :nodoc: - serialized = dump_common(string, options) - Serialize.load_parse(code, serialized, options.fetch(:freeze, false)) - end - - def parse_comments_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse_comments(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_parse_comments(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_lex_common(string, code, options) # :nodoc: - LibRubyParser::PrismBuffer.with do |buffer| - LibRubyParser.pm_serialize_parse_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) - Serialize.load_parse_lex(code, buffer.read, options.fetch(:freeze, false)) - end - end - - def parse_file_success_common(string, options) # :nodoc: - LibRubyParser.pm_parse_success_p(string.pointer, string.length, dump_options(options)) - end - - # Return the value that should be dumped for the command_line option. - def dump_options_command_line(options) - command_line = options.fetch(:command_line, "") - raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String) - - command_line.each_char.inject(0) do |value, char| - case char - when "a" then value | 0b000001 - when "e" then value | 0b000010 - when "l" then value | 0b000100 - when "n" then value | 0b001000 - when "p" then value | 0b010000 - when "x" then value | 0b100000 - else raise ArgumentError, "invalid command_line option: #{char}" - end - end - end - - # Return the value that should be dumped for the version option. - def dump_options_version(version) - case version - when "current" - version_string_to_number(RUBY_VERSION) || raise(CurrentVersionError, RUBY_VERSION) - when "latest", nil - 0 # Handled in pm_parser_init - when "nearest" - dump = version_string_to_number(RUBY_VERSION) - return dump if dump - if RUBY_VERSION < "3.3" - version_string_to_number("3.3") - else - 0 # Handled in pm_parser_init - end - else - version_string_to_number(version) || raise(ArgumentError, "invalid version: #{version}") - end - end - - # Converts a version string like "4.0.0" or "4.0" into a number. - # Returns nil if the version is unknown. - def version_string_to_number(version) - case version - when /\A3\.3(\.\d+)?\z/ - 1 - when /\A3\.4(\.\d+)?\z/ - 2 - when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/ - 3 - when /\A4\.1(\.\d+)?\z/ - 4 - end - end - - # Convert the given options into a serialized options string. - def dump_options(options) - template = +"" - values = [] - - template << "L" - if (filepath = options[:filepath]) - values.push(filepath.bytesize, filepath.b) - template << "A*" - else - values << 0 - end - - template << "l" - values << options.fetch(:line, 1) - - template << "L" - if (encoding = options[:encoding]) - name = encoding.is_a?(Encoding) ? encoding.name : encoding - values.push(name.bytesize, name.b) - template << "A*" - else - values << 0 - end - - template << "C" - values << (options.fetch(:frozen_string_literal, false) ? 1 : 0) - - template << "C" - values << dump_options_command_line(options) - - template << "C" - values << dump_options_version(options[:version]) - - template << "C" - values << (options[:encoding] == false ? 1 : 0) - - template << "C" - values << (options.fetch(:main_script, false) ? 1 : 0) - - template << "C" - values << (options.fetch(:partial_script, false) ? 1 : 0) - - template << "C" - values << (options.fetch(:freeze, false) ? 1 : 0) - - template << "L" - if (scopes = options[:scopes]) - values << scopes.length - - scopes.each do |scope| - locals = nil - forwarding = 0 - - case scope - when Array - locals = scope - when Scope - locals = scope.locals - - scope.forwarding.each do |forward| - case forward - when :* then forwarding |= 0x1 - when :** then forwarding |= 0x2 - when :& then forwarding |= 0x4 - when :"..." then forwarding |= 0x8 - else raise ArgumentError, "invalid forwarding value: #{forward}" - end - end - else - raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)" - end - - template << "L" - values << locals.length - - template << "C" - values << forwarding - - locals.each do |local| - name = local.name - template << "L" - values << name.bytesize - - template << "A*" - values << name.b - end - end - else - values << 0 - end - - values.pack(template) - end - end - - # Here we are going to patch StringQuery to put in the class-level methods so - # that it can maintain a consistent interface - class StringQuery # :nodoc: - class << self - # Mirrors the C extension's StringQuery::local? method. - def local?(string) - query(LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name)) - end - - # Mirrors the C extension's StringQuery::constant? method. - def constant?(string) - query(LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name)) - end - - # Mirrors the C extension's StringQuery::method_name? method. - def method_name?(string) - query(LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name)) - end - - private - - # Parse the enum result and return an appropriate boolean. - def query(result) - case result - when :PM_STRING_QUERY_ERROR - raise ArgumentError, "Invalid or non ascii-compatible encoding" - when :PM_STRING_QUERY_FALSE - false - when :PM_STRING_QUERY_TRUE - true - end - end - end - end -end From dfbd3c5499dab0c5caef7c99190cd29bf38099a3 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 1 Apr 2026 19:09:05 -0500 Subject: [PATCH 03/11] Move semantic field flag into C sources Rather than templating two versions of sources with and without non-semantic fields, we can make that determination at build time. Passing -DPRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 to `make` will force that variable to be literally true, and the compiler will eliminate `if` blocks that use it to conditionally serialize non- semantic data. This simplifies the templates by removing that variation and allows building both forms of the library from a single generated set of sources. --- .github/workflows/java-wasm-bindings.yml | 2 +- Makefile | 2 +- java/README.md | 2 +- rakelib/serialization.rake | 7 ++--- src/prism.c | 2 +- templates/include/prism/ast.h.erb | 14 +++++----- .../org/ruby_lang/prism/Loader.java.erb | 6 ++--- .../org/ruby_lang/prism/Nodes.java.erb | 10 +++---- templates/src/serialize.c.erb | 26 ++++++++++++++----- templates/template.rb | 7 +---- 10 files changed, 42 insertions(+), 36 deletions(-) diff --git a/.github/workflows/java-wasm-bindings.yml b/.github/workflows/java-wasm-bindings.yml index 7fe24455a7..de90a4173c 100644 --- a/.github/workflows/java-wasm-bindings.yml +++ b/.github/workflows/java-wasm-bindings.yml @@ -27,7 +27,7 @@ jobs: bundler-cache: true - name: rake templates - run: PRISM_EXCLUDE_PRETTYPRINT=1 PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 bundle exec rake templates + run: PRISM_EXCLUDE_PRETTYPRINT=1 PRISM_OMIT_NODE_ID=1 bundle exec rake templates - name: Set up WASI-SDK run: | diff --git a/Makefile b/Makefile index 0f6f5264d1..2aaec05478 100644 --- a/Makefile +++ b/Makefile @@ -56,7 +56,7 @@ java/wasm/src/main/wasm/prism.wasm: Makefile $(SOURCES) $(HEADERS) $(Q) $(MAKEDIRS) $(@D) $(Q) $(WASI_SDK_PATH)/bin/clang \ $(DEBUG_FLAGS) \ - -DPRISM_EXCLUDE_PRETTYPRINT -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN \ + -DPRISM_EXCLUDE_PRETTYPRINT -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN -DPRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 \ -lwasi-emulated-mman $(CPPFLAGS) $(JAVA_WASM_CFLAGS) \ -Wl,--export-all -Wl,--no-entry -mexec-model=reactor -lc++ -lc++abi \ -o $@ $(SOURCES) diff --git a/java/README.md b/java/README.md index 0dd4215777..bd06639f67 100644 --- a/java/README.md +++ b/java/README.md @@ -15,7 +15,7 @@ Some files need to be generated before the Maven artifacts can build: Sources under `api` are generated from templates in `../templates`. Those sources are generated using the follow command line: ``` -$ PRISM_EXCLUDE_PRETTYPRINT=1 PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 bundle exec rake templates +$ PRISM_EXCLUDE_PRETTYPRINT=1 bundle exec rake templates ``` The files are generated under `api/src/main/java-templates` and will not be removed with `mvn clean`. diff --git a/rakelib/serialization.rake b/rakelib/serialization.rake index 516e8fe5ba..65c382fcc3 100644 --- a/rakelib/serialization.rake +++ b/rakelib/serialization.rake @@ -1,12 +1,9 @@ # frozen_string_literal: true task "test:java_loader" do - # Recompile with PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 - # Due to some JRuby bug this does not get propagated to the compile task, so require the caller to set the env var - # ENV["PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS"] = "1" - raise "this task requires $SERIALIZE_ONLY_SEMANTICS_FIELDS to be set" unless ENV["PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS"] - Rake::Task["clobber"].invoke + # All Java API consumers want semantic-only build + ENV["CFLAGS"] = "-DPRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1" Rake::Task["test:java_loader:internal"].invoke end diff --git a/src/prism.c b/src/prism.c index 72c49da6f2..7d4a11b7bf 100644 --- a/src/prism.c +++ b/src/prism.c @@ -22843,7 +22843,7 @@ pm_serialize_header(pm_buffer_t *buffer) { pm_buffer_append_byte(buffer, PRISM_VERSION_MAJOR); pm_buffer_append_byte(buffer, PRISM_VERSION_MINOR); pm_buffer_append_byte(buffer, PRISM_VERSION_PATCH); - pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0); + pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS); } /** diff --git a/templates/include/prism/ast.h.erb b/templates/include/prism/ast.h.erb index 3b3be25e76..44e2385d7c 100644 --- a/templates/include/prism/ast.h.erb +++ b/templates/include/prism/ast.h.erb @@ -268,11 +268,13 @@ PRISM_EXPORTED_FUNCTION pm_<%= node.human %>_t * pm_<%= node.human %>_new(pm_are <%- end -%> /** - * When we're serializing to Java, we want to skip serializing the location - * fields as they won't be used by JRuby or TruffleRuby. This boolean allows us - * to specify that through the environment. It will never be true except for in - * those build systems. - */ -#define PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS <%= Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0 %> +* When we're serializing to Java, we want to skip serializing the location +* fields as they won't be used by JRuby or TruffleRuby. This boolean allows us +* to specify that through the environment. It will never be true except for in +* those build systems. +*/ +#ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS +#define PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS 0 +#endif #endif diff --git a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb index 2d2440b8e6..b8fa7c5913 100644 --- a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb +++ b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb @@ -326,12 +326,12 @@ public class Loader { } <%- - base_params = [*("nodeId" if Prism::Template::INCLUDE_NODE_ID), "startOffset", "length"] + base_params = [*("nodeId" unless Prism::Template::OMIT_NODE_ID), "startOffset", "length"] base_params_sig = base_params.map { "int #{_1}" }.join(", ") -%> private Nodes.Node loadNode() { int type = buffer.get() & 0xFF; - <%- if Prism::Template::INCLUDE_NODE_ID -%> + <%- unless Prism::Template::OMIT_NODE_ID -%> int nodeId = loadVarUInt(); <%- end -%> int startOffset = loadVarUInt(); @@ -343,7 +343,7 @@ public class Loader { case <%= index + 1 %>: <%- params = [] - params << "nodeId" if Prism::Template::INCLUDE_NODE_ID + params << "nodeId" unless Prism::Template::OMIT_NODE_ID params << "startOffset" << "length" params << "buffer.getInt()" << "null" if node.needs_serialized_length? params << "loadFlags()" if node.flags diff --git a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb index 9ef03e99cd..e4c0eb2f6b 100644 --- a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb +++ b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb @@ -89,14 +89,14 @@ public abstract class Nodes { public static final Node[] EMPTY_ARRAY = {}; - <%- if Prism::Template::INCLUDE_NODE_ID -%> + <%- unless Prism::Template::OMIT_NODE_ID -%> public final int nodeId; <%- end -%> public final int startOffset; public final int length; private boolean newLineFlag = false; - <%- if Prism::Template::INCLUDE_NODE_ID -%> + <%- unless Prism::Template::OMIT_NODE_ID -%> public Node(int nodeId, int startOffset, int length) { this.nodeId = nodeId; <%- else -%> @@ -246,7 +246,7 @@ public abstract class Nodes { <%- params = [] - params << "int nodeId" if Prism::Template::INCLUDE_NODE_ID + params << "int nodeId" unless Prism::Template::OMIT_NODE_ID params << "int startOffset" << "int length" if node.needs_serialized_length? params << "int serializedLength" @@ -256,7 +256,7 @@ public abstract class Nodes { params.concat(node.semantic_fields.map { |field| "#{field.java_type} #{field.name}" }) -%> public <%= node.name -%>(<%= params.join(", ") %>) { - <%- if Prism::Template::INCLUDE_NODE_ID -%> + <%- unless Prism::Template::OMIT_NODE_ID -%> super(nodeId, startOffset, length); <%- else -%> super(startOffset, length); @@ -281,7 +281,7 @@ public abstract class Nodes { public <%= node.name -%> getNonLazy() { if (isLazy()) { - return loader.createDefNodeFromSavedPosition(<%= "nodeId, " if Prism::Template::INCLUDE_NODE_ID %>startOffset, length, -serializedLength); + return loader.createDefNodeFromSavedPosition(<%= "nodeId, " unless Prism::Template::OMIT_NODE_ID %>startOffset, length, -serializedLength); } else { return this; } diff --git a/templates/src/serialize.c.erb b/templates/src/serialize.c.erb index 3d9811e5db..a98692054f 100644 --- a/templates/src/serialize.c.erb +++ b/templates/src/serialize.c.erb @@ -73,7 +73,7 @@ static void pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node)); - <%- if Prism::Template::INCLUDE_NODE_ID -%> + <%- unless Prism::Template::OMIT_NODE_ID -%> pm_buffer_append_varuint(buffer, node->node_id); <%- end -%> pm_serialize_location(&node->location, buffer); @@ -91,8 +91,12 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { size_t length_offset = buffer->length; pm_buffer_append_string(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */ <%- end -%> - <%- unless Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS && !node.flags -%> + <%- if node.flags -%> pm_buffer_append_varuint(buffer, (uint32_t) node->flags); + <%- else -%> + if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + pm_buffer_append_varuint(buffer, (uint32_t) node->flags); + } <%- end -%> <%- node.fields.each do |field| -%> <%- case field -%> @@ -121,17 +125,25 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index])); } <%- when Prism::Template::LocationField -%> - <%- if field.should_be_serialized? -%> + <%- unless field.semantic_field? -%> + if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + <%- end -%> pm_serialize_location(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); + <%- unless field.semantic_field? -%> + } <%- end -%> <%- when Prism::Template::OptionalLocationField -%> - <%- if field.should_be_serialized? -%> + <%- unless field.semantic_field? -%> + if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + <%- end -%> if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.length == 0) { pm_buffer_append_byte(buffer, 0); } else { pm_buffer_append_byte(buffer, 1); pm_serialize_location(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); } + <%- unless field.semantic_field? -%> + } <%- end -%> <%- when Prism::Template::UInt8Field -%> pm_buffer_append_byte(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>); @@ -261,9 +273,9 @@ pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) { pm_serialize_encoding(parser->encoding, buffer); pm_buffer_append_varsint(buffer, parser->start_line); pm_serialize_line_offset_list(&parser->line_offsets, buffer); -<%- unless Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS -%> - pm_serialize_comment_list(&parser->comment_list, buffer); -<%- end -%> + if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + pm_serialize_comment_list(&parser->comment_list, buffer); + } pm_serialize_magic_comment_list(&parser->magic_comment_list, buffer); pm_serialize_data_loc(parser, buffer); pm_serialize_diagnostic_list(&parser->error_list, buffer); diff --git a/templates/template.rb b/templates/template.rb index 7638c9c058..047b8d0e3e 100755 --- a/templates/template.rb +++ b/templates/template.rb @@ -7,12 +7,11 @@ module Prism module Template # :nodoc: all - SERIALIZE_ONLY_SEMANTICS_FIELDS = ENV.fetch("PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS", false) CHECK_FIELD_KIND = ENV.fetch("CHECK_FIELD_KIND", false) JAVA_BACKEND = ENV["PRISM_JAVA_BACKEND"] || "default" JAVA_IDENTIFIER_TYPE = JAVA_BACKEND == "truffleruby" ? "String" : "byte[]" - INCLUDE_NODE_ID = !SERIALIZE_ONLY_SEMANTICS_FIELDS || JAVA_BACKEND == "jruby" + OMIT_NODE_ID = ENV.fetch("PRISM_OMIT_NODE_ID", false) COMMON_FLAGS_COUNT = 2 @@ -95,10 +94,6 @@ def each_comment_java_line(&block) def semantic_field? true end - - def should_be_serialized? - SERIALIZE_ONLY_SEMANTICS_FIELDS ? semantic_field? : true - end end # Some node fields can be specialized if they point to a specific kind of From 5dc96581ce212a3a997d24a1eae3703e5b3c70e3 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 22:34:40 -0500 Subject: [PATCH 04/11] Switch node ID flag to a positive condition --- .../java-templates/org/ruby_lang/prism/Loader.java.erb | 6 +++--- .../java-templates/org/ruby_lang/prism/Nodes.java.erb | 10 +++++----- templates/src/serialize.c.erb | 2 +- templates/template.rb | 2 +- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb index b8fa7c5913..2d2440b8e6 100644 --- a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb +++ b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Loader.java.erb @@ -326,12 +326,12 @@ public class Loader { } <%- - base_params = [*("nodeId" unless Prism::Template::OMIT_NODE_ID), "startOffset", "length"] + base_params = [*("nodeId" if Prism::Template::INCLUDE_NODE_ID), "startOffset", "length"] base_params_sig = base_params.map { "int #{_1}" }.join(", ") -%> private Nodes.Node loadNode() { int type = buffer.get() & 0xFF; - <%- unless Prism::Template::OMIT_NODE_ID -%> + <%- if Prism::Template::INCLUDE_NODE_ID -%> int nodeId = loadVarUInt(); <%- end -%> int startOffset = loadVarUInt(); @@ -343,7 +343,7 @@ public class Loader { case <%= index + 1 %>: <%- params = [] - params << "nodeId" unless Prism::Template::OMIT_NODE_ID + params << "nodeId" if Prism::Template::INCLUDE_NODE_ID params << "startOffset" << "length" params << "buffer.getInt()" << "null" if node.needs_serialized_length? params << "loadFlags()" if node.flags diff --git a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb index e4c0eb2f6b..9ef03e99cd 100644 --- a/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb +++ b/templates/java/api/src/main/java-templates/org/ruby_lang/prism/Nodes.java.erb @@ -89,14 +89,14 @@ public abstract class Nodes { public static final Node[] EMPTY_ARRAY = {}; - <%- unless Prism::Template::OMIT_NODE_ID -%> + <%- if Prism::Template::INCLUDE_NODE_ID -%> public final int nodeId; <%- end -%> public final int startOffset; public final int length; private boolean newLineFlag = false; - <%- unless Prism::Template::OMIT_NODE_ID -%> + <%- if Prism::Template::INCLUDE_NODE_ID -%> public Node(int nodeId, int startOffset, int length) { this.nodeId = nodeId; <%- else -%> @@ -246,7 +246,7 @@ public abstract class Nodes { <%- params = [] - params << "int nodeId" unless Prism::Template::OMIT_NODE_ID + params << "int nodeId" if Prism::Template::INCLUDE_NODE_ID params << "int startOffset" << "int length" if node.needs_serialized_length? params << "int serializedLength" @@ -256,7 +256,7 @@ public abstract class Nodes { params.concat(node.semantic_fields.map { |field| "#{field.java_type} #{field.name}" }) -%> public <%= node.name -%>(<%= params.join(", ") %>) { - <%- unless Prism::Template::OMIT_NODE_ID -%> + <%- if Prism::Template::INCLUDE_NODE_ID -%> super(nodeId, startOffset, length); <%- else -%> super(startOffset, length); @@ -281,7 +281,7 @@ public abstract class Nodes { public <%= node.name -%> getNonLazy() { if (isLazy()) { - return loader.createDefNodeFromSavedPosition(<%= "nodeId, " unless Prism::Template::OMIT_NODE_ID %>startOffset, length, -serializedLength); + return loader.createDefNodeFromSavedPosition(<%= "nodeId, " if Prism::Template::INCLUDE_NODE_ID %>startOffset, length, -serializedLength); } else { return this; } diff --git a/templates/src/serialize.c.erb b/templates/src/serialize.c.erb index a98692054f..a6a7bd91aa 100644 --- a/templates/src/serialize.c.erb +++ b/templates/src/serialize.c.erb @@ -73,7 +73,7 @@ static void pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node)); - <%- unless Prism::Template::OMIT_NODE_ID -%> + <%- if Prism::Template::INCLUDE_NODE_ID -%> pm_buffer_append_varuint(buffer, node->node_id); <%- end -%> pm_serialize_location(&node->location, buffer); diff --git a/templates/template.rb b/templates/template.rb index 047b8d0e3e..92140851a3 100755 --- a/templates/template.rb +++ b/templates/template.rb @@ -11,7 +11,7 @@ module Template # :nodoc: all JAVA_BACKEND = ENV["PRISM_JAVA_BACKEND"] || "default" JAVA_IDENTIFIER_TYPE = JAVA_BACKEND == "truffleruby" ? "String" : "byte[]" - OMIT_NODE_ID = ENV.fetch("PRISM_OMIT_NODE_ID", false) + INCLUDE_NODE_ID = ENV.fetch("PRISM_INCLUDE_NODE_ID", "true") != "false" COMMON_FLAGS_COUNT = 2 From cec815b6f32f88a5b30ab60eda5826a93e6d167a Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 22:53:01 -0500 Subject: [PATCH 05/11] Use #ifndef for semantic fields only check --- src/prism.c | 6 +++++- templates/include/prism/ast.h.erb | 10 ---------- templates/src/serialize.c.erb | 16 ++++++++-------- 3 files changed, 13 insertions(+), 19 deletions(-) diff --git a/src/prism.c b/src/prism.c index 7d4a11b7bf..61233b5d43 100644 --- a/src/prism.c +++ b/src/prism.c @@ -22843,7 +22843,11 @@ pm_serialize_header(pm_buffer_t *buffer) { pm_buffer_append_byte(buffer, PRISM_VERSION_MAJOR); pm_buffer_append_byte(buffer, PRISM_VERSION_MINOR); pm_buffer_append_byte(buffer, PRISM_VERSION_PATCH); - pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS); + #ifdef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS + pm_buffer_append_byte(buffer, 1); + #else + pm_buffer_append_byte(buffer, 0); + #endif } /** diff --git a/templates/include/prism/ast.h.erb b/templates/include/prism/ast.h.erb index 44e2385d7c..5306c0abe4 100644 --- a/templates/include/prism/ast.h.erb +++ b/templates/include/prism/ast.h.erb @@ -267,14 +267,4 @@ typedef enum pm_<%= flag.human %> { PRISM_EXPORTED_FUNCTION pm_<%= node.human %>_t * pm_<%= node.human %>_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location<%= params.empty? ? "" : ", #{params.join(", ")}" %>); <%- end -%> -/** -* When we're serializing to Java, we want to skip serializing the location -* fields as they won't be used by JRuby or TruffleRuby. This boolean allows us -* to specify that through the environment. It will never be true except for in -* those build systems. -*/ -#ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS -#define PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS 0 -#endif - #endif diff --git a/templates/src/serialize.c.erb b/templates/src/serialize.c.erb index a6a7bd91aa..2e2fa65251 100644 --- a/templates/src/serialize.c.erb +++ b/templates/src/serialize.c.erb @@ -94,9 +94,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { <%- if node.flags -%> pm_buffer_append_varuint(buffer, (uint32_t) node->flags); <%- else -%> - if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + #ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS pm_buffer_append_varuint(buffer, (uint32_t) node->flags); - } + #endif <%- end -%> <%- node.fields.each do |field| -%> <%- case field -%> @@ -126,15 +126,15 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { } <%- when Prism::Template::LocationField -%> <%- unless field.semantic_field? -%> - if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + #ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS <%- end -%> pm_serialize_location(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); <%- unless field.semantic_field? -%> - } + #endif <%- end -%> <%- when Prism::Template::OptionalLocationField -%> <%- unless field.semantic_field? -%> - if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + #ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS <%- end -%> if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.length == 0) { pm_buffer_append_byte(buffer, 0); @@ -143,7 +143,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_serialize_location(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); } <%- unless field.semantic_field? -%> - } + #endif <%- end -%> <%- when Prism::Template::UInt8Field -%> pm_buffer_append_byte(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>); @@ -273,9 +273,9 @@ pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) { pm_serialize_encoding(parser->encoding, buffer); pm_buffer_append_varsint(buffer, parser->start_line); pm_serialize_line_offset_list(&parser->line_offsets, buffer); - if (!PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS) { + #ifndef PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS pm_serialize_comment_list(&parser->comment_list, buffer); - } + #endif pm_serialize_magic_comment_list(&parser->magic_comment_list, buffer); pm_serialize_data_loc(parser, buffer); pm_serialize_diagnostic_list(&parser->error_list, buffer); From cdbe615c2cbc1d645166daadb054cc3f83b2c79a Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 23:06:43 -0500 Subject: [PATCH 06/11] Freeze NativeCommon for Ractor Only used while testing the FFI backend on CRuby. --- lib/prism/ffi/native_ffi.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/prism/ffi/native_ffi.rb b/lib/prism/ffi/native_ffi.rb index 600e4236ec..b0ab9cb0e1 100644 --- a/lib/prism/ffi/native_ffi.rb +++ b/lib/prism/ffi/native_ffi.rb @@ -320,6 +320,6 @@ def string_query_local(string) end end - FFICommon = NativeCommon.new + FFICommon = NativeCommon.new.freeze private_constant(:FFICommon) end From a9f794a6f1ddd9802be67079b2f14f0675d8bbe1 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 23:26:25 -0500 Subject: [PATCH 07/11] Some cleanup of FFI files --- lib/prism/ffi.rb | 7 +++++++ lib/prism/ffi/native_ffi.rb | 4 +--- lib/prism/ffi/wasm_ffi.rb | 4 +--- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/lib/prism/ffi.rb b/lib/prism/ffi.rb index fb5ca055b7..93efcd0836 100644 --- a/lib/prism/ffi.rb +++ b/lib/prism/ffi.rb @@ -1,7 +1,14 @@ # frozen_string_literal: true # :markup: markdown +# -- # typed: ignore +# This file is responsible for mirroring the API provided by the C extension. There +# are two backends: +# +# * Native FFI based on the 'ffi' gem +# * WASM compiled to JVM bytecode (JRuby only) + require_relative "ffi/common" begin diff --git a/lib/prism/ffi/native_ffi.rb b/lib/prism/ffi/native_ffi.rb index b0ab9cb0e1..3651182797 100644 --- a/lib/prism/ffi/native_ffi.rb +++ b/lib/prism/ffi/native_ffi.rb @@ -1,10 +1,8 @@ # frozen_string_literal: true # :markup: markdown +# -- # typed: ignore -# This file is responsible for mirroring the API provided by the C extension by -# using FFI to call into the shared library. - require "rbconfig" require "ffi" diff --git a/lib/prism/ffi/wasm_ffi.rb b/lib/prism/ffi/wasm_ffi.rb index 37ad421474..0b9dedd58c 100644 --- a/lib/prism/ffi/wasm_ffi.rb +++ b/lib/prism/ffi/wasm_ffi.rb @@ -1,10 +1,8 @@ # frozen_string_literal: true # :markup: markdown +# -- # typed: ignore -# This file is responsible for mirroring the API provided by the C extension by -# using FFI to call into the shared library. - require "rbconfig" require "ffi" From 55278f2885f0d1e61dc6ce579ae1f493e47e3a02 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 23:31:27 -0500 Subject: [PATCH 08/11] Add new files to gemspec --- prism.gemspec | 3 +++ 1 file changed, 3 insertions(+) diff --git a/prism.gemspec b/prism.gemspec index aac056b3f8..449b9c052c 100644 --- a/prism.gemspec +++ b/prism.gemspec @@ -113,6 +113,9 @@ Gem::Specification.new do |spec| "lib/prism/dot_visitor.rb", "lib/prism/dsl.rb", "lib/prism/ffi.rb", + "lib/prism/ffi/common.rb", + "lib/prism/ffi/native_ffi.rb", + "lib/prism/ffi/wasm_ffi.rb", "lib/prism/inspect_visitor.rb", "lib/prism/lex_compat.rb", "lib/prism/mutation_compiler.rb", From c890df6538003c9936a8f90797474162b129521e Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 23:46:41 -0500 Subject: [PATCH 09/11] Add nodoc for FFI backend internals --- lib/prism/ffi/common.rb | 20 +++++++++--------- lib/prism/ffi/native_ffi.rb | 20 +++++++++--------- lib/prism/ffi/wasm_ffi.rb | 41 +++++++++---------------------------- 3 files changed, 30 insertions(+), 51 deletions(-) diff --git a/lib/prism/ffi/common.rb b/lib/prism/ffi/common.rb index 2600273318..440b1826da 100644 --- a/lib/prism/ffi/common.rb +++ b/lib/prism/ffi/common.rb @@ -4,7 +4,7 @@ module Prism - class Common + class Common # :nodoc: def dump(string, options) # :nodoc: with_buffer do |buffer| parse_only(buffer, string, options) @@ -178,27 +178,27 @@ def dump_options(options) # Required APIs below - def with_buffer(&b) + def with_buffer(&b) # :nodoc: raise NotImplementedError end - def with_string(string, &b) + def with_string(string, &b) # :nodoc: raise NotImplementedError end - def with_file(string, &b) + def with_file(string, &b) # :nodoc: raise NotImplementedError end - def lex_only(buffer, string, options) + def lex_only(buffer, string, options) # :nodoc: raise NotImplementedError end - def parse_only(buffer, string, options) + def parse_only(buffer, string, options) # :nodoc: raise NotImplementedError end - def parse_stream(buffer, callback, eof_callback, options, source) + def parse_stream(buffer, callback, eof_callback, options, source) # :nodoc: raise NotImplementedError end @@ -214,15 +214,15 @@ def parse_file_success(string, options) # :nodoc: raise NotImplementedError end - def string_query_method_name(string) + def string_query_method_name(string) # :nodoc: raise NotImplementedError end - def string_query_constant(string) + def string_query_constant(string) # :nodoc: raise NotImplementedError end - def string_query_local(string) + def string_query_local(string) # :nodoc: raise NotImplementedError end end diff --git a/lib/prism/ffi/native_ffi.rb b/lib/prism/ffi/native_ffi.rb index 3651182797..c4fbbcb660 100644 --- a/lib/prism/ffi/native_ffi.rb +++ b/lib/prism/ffi/native_ffi.rb @@ -250,34 +250,34 @@ def self.with_file(filepath) # the prism module. private_constant :LibRubyParser - class NativeCommon < Common + class NativeCommon < Common # :nodoc: # The version constant is set by reading the result of calling pm_version. def version LibRubyParser.pm_version.read_string.freeze end - def with_buffer(&b) + def with_buffer(&b) # :nodoc: LibRubyParser::NativeBuffer.with(&b) end - def with_string(string, &b) + def with_string(string, &b) # :nodoc: LibRubyParser::NativeSource.with_string(string, &b) end - def with_file(string, &b) + def with_file(string, &b) # :nodoc: LibRubyParser::NativeSource.with_file(string, &b) end - def lex_only(buffer, string, options) + def lex_only(buffer, string, options) # :nodoc: LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options)) end - def parse_only(buffer, string, options) + def parse_only(buffer, string, options) # :nodoc: LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options)) end - def parse_stream(buffer, callback, eof_callback, options, source) + def parse_stream(buffer, callback, eof_callback, options, source) # :nodoc: pm_source = LibRubyParser.pm_source_stream_new(nil, callback, eof_callback) begin LibRubyParser.pm_serialize_parse_stream(buffer.pointer, pm_source, dump_options(options)) @@ -305,15 +305,15 @@ def parse_file_success(string, options) # :nodoc: LibRubyParser.pm_serialize_parse_success_p(string.pointer, string.length, dump_options(options)) end - def string_query_method_name(string) + def string_query_method_name(string) # :nodoc: LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name) end - def string_query_constant(string) + def string_query_constant(string) # :nodoc: LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name) end - def string_query_local(string) + def string_query_local(string) # :nodoc: LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name) end end diff --git a/lib/prism/ffi/wasm_ffi.rb b/lib/prism/ffi/wasm_ffi.rb index 0b9dedd58c..c6e4e07293 100644 --- a/lib/prism/ffi/wasm_ffi.rb +++ b/lib/prism/ffi/wasm_ffi.rb @@ -19,7 +19,7 @@ require_jar('com.dylibso.chicory', 'log', '1.6.1') module Prism # :nodoc: - class WASMCommon < Common + class WASMCommon < Common # :nodoc: java_import org.ruby_lang.prism.wasm.Prism # TODO: concurrency @@ -30,48 +30,27 @@ def version WASM::PRISM.version end - # Prototype WASM code - # def dump(source, **options) - # parsed = WASM::PRISM.parse(source.to_java_bytes, dump_options(options).to_java_bytes) - # end - # - # # Mirror the Prism.dump_file API by using the serialization API. - # def dump_file(filepath, **options) - # dump_file(File.read(filepath), filepath: filepath, **options) - # end - # - # # Mirror the Prism.lex API by using the serialization API. - # def lex(source, **options) - # lexed = WASM::PRISM.lex(source.to_java_bytes, dump_options(options).to_java_bytes) - # Serialize.load_lex(source, lexed, options.fetch(:freeze, false)) - # end - # - # # Mirror the Prism.lex_file API by using the serialization API. - # def lex_file(filepath, **options) - # lex_file(File.read(filepath), filepath: filepath, **options) - # end - - def with_buffer(&b) + def with_buffer(&b) # :nodoc: raise NotImplementedError end - def with_string(string, &b) + def with_string(string, &b) # :nodoc: raise NotImplementedError end - def with_file(string, &b) + def with_file(string, &b) # :nodoc: raise NotImplementedError end - def lex_only(buffer, string, options) + def lex_only(buffer, string, options) # :nodoc: raise NotImplementedError end - def parse_only(buffer, string, options) + def parse_only(buffer, string, options) # :nodoc: raise NotImplementedError end - def parse_stream(buffer, callback, eof_callback, options, source) + def parse_stream(buffer, callback, eof_callback, options, source) # :nodoc: raise NotImplementedError end @@ -87,15 +66,15 @@ def parse_file_success(string, options) # :nodoc: raise NotImplementedError end - def string_query_method_name(string) + def string_query_method_name(string) # :nodoc: raise NotImplementedError end - def string_query_constant(string) + def string_query_constant(string) # :nodoc: raise NotImplementedError end - def string_query_local(string) + def string_query_local(string) # :nodoc: raise NotImplementedError end end From 9451d4a4cee0feef47ebcba0e5a1123f1dd41e7a Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 6 Apr 2026 23:54:15 -0500 Subject: [PATCH 10/11] Ignore restructured FFI sources --- Steepfile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Steepfile b/Steepfile index e6e1a8efb5..9db20dfa1e 100644 --- a/Steepfile +++ b/Steepfile @@ -15,4 +15,7 @@ target :lib do # Ignored because we do not want to overlap with the C extension. ignore "lib/prism/ffi.rb" + ignore "lib/prism/ffi/common.rb" + ignore "lib/prism/ffi/native_ffi.rb" + ignore "lib/prism/ffi/wasm_ffi.rb" end From a674327deabc3e152b9c5d72aa1df271f88ffd72 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 7 Apr 2026 00:36:20 -0500 Subject: [PATCH 11/11] Duplicate WASM artifact for full and start hooking up --- Makefile | 13 +- Rakefile | 1 + java/api/pom.xml | 2 +- java/pom.xml | 3 +- java/wasm-full/pom.xml | 80 +++++++++ .../org/ruby_lang/prism/wasm/full/Prism.java | 153 ++++++++++++++++++ java/wasm-full/src/main/wasm/prism-full.wasm | Bin 0 -> 729988 bytes java/wasm/pom.xml | 2 +- lib/prism/ffi/common.rb | 4 + lib/prism/ffi/wasm_ffi.rb | 29 +++- 10 files changed, 275 insertions(+), 12 deletions(-) create mode 100644 java/wasm-full/pom.xml create mode 100644 java/wasm-full/src/main/java/org/ruby_lang/prism/wasm/full/Prism.java create mode 100755 java/wasm-full/src/main/wasm/prism-full.wasm diff --git a/Makefile b/Makefile index 2aaec05478..5e83dfa146 100644 --- a/Makefile +++ b/Makefile @@ -31,7 +31,7 @@ all: shared static shared: build/libprism.$(SOEXT) static: build/libprism.a wasm: javascript/src/prism.wasm -java-wasm: java/wasm/src/main/wasm/prism.wasm +java-wasm: java/wasm/src/main/wasm/prism.wasm java/wasm-full/src/main/wasm/prism-full.wasm build/libprism.$(SOEXT): $(SHARED_OBJECTS) $(ECHO) "linking $@ with $(CC)" @@ -57,6 +57,17 @@ java/wasm/src/main/wasm/prism.wasm: Makefile $(SOURCES) $(HEADERS) $(Q) $(WASI_SDK_PATH)/bin/clang \ $(DEBUG_FLAGS) \ -DPRISM_EXCLUDE_PRETTYPRINT -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN -DPRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 \ + -DPRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS \ + -lwasi-emulated-mman $(CPPFLAGS) $(JAVA_WASM_CFLAGS) \ + -Wl,--export-all -Wl,--no-entry -mexec-model=reactor -lc++ -lc++abi \ + -o $@ $(SOURCES) + +java/wasm-full/src/main/wasm/prism-full.wasm: Makefile $(SOURCES) $(HEADERS) + $(ECHO) "building $@" + $(Q) $(MAKEDIRS) $(@D) + $(Q) $(WASI_SDK_PATH)/bin/clang \ + $(DEBUG_FLAGS) \ + -DPRISM_EXCLUDE_PRETTYPRINT -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN \ -lwasi-emulated-mman $(CPPFLAGS) $(JAVA_WASM_CFLAGS) \ -Wl,--export-all -Wl,--no-entry -mexec-model=reactor -lc++ -lc++abi \ -o $@ $(SOURCES) diff --git a/Rakefile b/Rakefile index eb96249985..998640eede 100644 --- a/Rakefile +++ b/Rakefile @@ -55,6 +55,7 @@ CLOBBER.concat(Prism::Template::TEMPLATES) CLOBBER.concat(["build"]) CLOBBER << "lib/prism/prism.#{RbConfig::CONFIG["DLEXT"]}" CLOBBER << "java/wasm/src/main/resources/prism.wasm" +CLOBBER << "java/wasm-full/src/main/resources/prism-full.wasm" Prism::Template::TEMPLATES.each do |filepath| desc "Generate #{filepath}" diff --git a/java/api/pom.xml b/java/api/pom.xml index 396fa33161..4fe0252d08 100644 --- a/java/api/pom.xml +++ b/java/api/pom.xml @@ -9,7 +9,7 @@ prism-parser-api - Java Prism + Java Prism API Java API for the Prism Ruby language parser https://github.com/ruby/prism diff --git a/java/pom.xml b/java/pom.xml index f405af5304..8b71d4efee 100644 --- a/java/pom.xml +++ b/java/pom.xml @@ -6,7 +6,7 @@ prism-parser 0.0.2-SNAPSHOT pom - Java Prism + Java Prism parent Java API for the Prism Ruby language parser https://github.com/ruby/prism @@ -51,6 +51,7 @@ api wasm + wasm-full diff --git a/java/wasm-full/pom.xml b/java/wasm-full/pom.xml new file mode 100644 index 0000000000..e70172d838 --- /dev/null +++ b/java/wasm-full/pom.xml @@ -0,0 +1,80 @@ + + + 4.0.0 + + + org.ruby-lang + prism-parser + 0.0.2-SNAPSHOT + + + prism-parser-wasm-full + Java Prism WASM with full parsed content + Java WASM bindings for the Prism parser shared library + https://github.com/ruby/prism + + + 1.7.5 + + + + + + com.dylibso.chicory + bom + ${chicory.version} + pom + import + + + + + + + com.dylibso.chicory + runtime + + + com.dylibso.chicory + log + + + com.dylibso.chicory + wasi + + + com.dylibso.chicory + wasm + + + org.junit.jupiter + junit-jupiter-engine + ${junit.version} + test + + + + + + + com.dylibso.chicory + chicory-compiler-maven-plugin + ${chicory.version} + + + prism + + compile + + + org.ruby_lang.prism.wasm.full.PrismParser + org.ruby_lang.prism.wasm.full.Prism + src/main/wasm/prism-full.wasm + + + + + + + + diff --git a/java/wasm-full/src/main/java/org/ruby_lang/prism/wasm/full/Prism.java b/java/wasm-full/src/main/java/org/ruby_lang/prism/wasm/full/Prism.java new file mode 100644 index 0000000000..68c9707f7a --- /dev/null +++ b/java/wasm-full/src/main/java/org/ruby_lang/prism/wasm/full/Prism.java @@ -0,0 +1,153 @@ +package org.ruby_lang.prism.wasm.full; + +import com.dylibso.chicory.runtime.ByteArrayMemory; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.wasi.WasiOptions; +import com.dylibso.chicory.wasi.WasiPreview1; + +import java.nio.charset.StandardCharsets; + +public class Prism implements AutoCloseable { + private final WasiPreview1 wasi; + protected final Prism_ModuleExports exports; + private final Instance instance; + + public Prism() { + this(WasiOptions.builder().build()); + } + + public Prism(WasiOptions wasiOpts) { + wasi = WasiPreview1.builder().withOptions(wasiOpts).build(); + instance = Instance.builder(PrismParser.load()) + .withMemoryFactory(ByteArrayMemory::new) + .withMachineFactory(PrismParser::create) + .withImportValues(ImportValues.builder().addFunction(wasi.toHostFunctions()).build()) + .build(); + exports = new Prism_ModuleExports(instance); + } + + public String version() { + int versionPointer = exports.pmVersion(); + int length = exports.strchr(versionPointer, 0); + + return new String(instance.memory().readBytes(versionPointer, length - versionPointer)); + } + + public byte[] parse(byte[] sourceBytes, byte[] packedOptions) { + try ( + Buffer buffer = new Buffer(); + Source source = new Source(sourceBytes, 0, sourceBytes.length); + Options options = new Options(packedOptions)) { + + return parse(buffer, source, options); + } + } + + public byte[] lex(byte[] sourceBytes, byte[] packedOptions) { + try ( + Buffer buffer = new Buffer(); + Source source = new Source(sourceBytes, 0, sourceBytes.length); + Options options = new Options(packedOptions)) { + + return lex(buffer, source, options); + } + } + + public byte[] parse(byte[] sourceBytes, int sourceOffset, int sourceLength, byte[] packedOptions) { + try ( + Buffer buffer = new Buffer(); + Source source = new Source(sourceBytes, sourceOffset, sourceLength); + Options options = new Options(packedOptions)) { + + return parse(buffer, source, options); + } + } + + public byte[] parse(Buffer buffer, Source source, Options options) { + exports.pmSerializeParse( + buffer.pointer, source.pointer, source.length, options.pointer); + + return buffer.read(); + } + + public byte[] lex(Buffer buffer, Source source, Options options) { + exports.pmSerializeLex( + buffer.pointer, source.pointer, source.length, options.pointer); + + return buffer.read(); + } + + public class Buffer implements AutoCloseable { + final int pointer; + + Buffer() { + pointer = exports.pmBufferNew(); + clear(); + } + + public void clear() { + exports.pmBufferClear(pointer); + } + + public void close() { + exports.pmBufferFree(pointer); + } + + public byte[] read() { + return instance.memory().readBytes( + exports.pmBufferValue(pointer), + exports.pmBufferLength(pointer)); + } + } + + public class Source implements AutoCloseable{ + final int pointer; + final int length; + + public Source(int length) { + pointer = exports.calloc(1, length); + this.length = length; + } + + public Source(byte[] bytes, int offset, int length) { + this(length + 1); + write(bytes, offset, length); + } + + public Source(byte[] bytes) { + this(bytes, 0, bytes.length); + } + + public void write(byte[] bytes, int offset, int length) { + assert length + 1 <= this.length; + instance.memory().write(pointer, bytes, offset, length); + instance.memory().writeByte(pointer + length, (byte) 0); + } + + public void close() { + exports.free(pointer); + } + } + + class Options implements AutoCloseable { + final int pointer; + + Options(byte[] packedOptions) { + int pointer = exports.calloc(1, packedOptions.length); + instance.memory().write(pointer, packedOptions); + this.pointer = pointer; + } + + public void close() { + exports.free(pointer); + } + } + + @Override + public void close() { + if (wasi != null) { + wasi.close(); + } + } +} diff --git a/java/wasm-full/src/main/wasm/prism-full.wasm b/java/wasm-full/src/main/wasm/prism-full.wasm new file mode 100755 index 0000000000000000000000000000000000000000..5af8299c37e803414ee3c6ede091335b72bb39ce GIT binary patch literal 729988 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

J@`UFDVcrm@2XjYR)BTpZo-Z`nwUL$aT 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 literal 0 HcmV?d00001 diff --git a/java/wasm/pom.xml b/java/wasm/pom.xml index b389c57ed1..c0772a7269 100644 --- a/java/wasm/pom.xml +++ b/java/wasm/pom.xml @@ -9,7 +9,7 @@ prism-parser-wasm - Java Prism WASM + Java Prism WASM with semantic-only content Java WASM bindings for the Prism parser shared library https://github.com/ruby/prism diff --git a/lib/prism/ffi/common.rb b/lib/prism/ffi/common.rb index 440b1826da..552810c059 100644 --- a/lib/prism/ffi/common.rb +++ b/lib/prism/ffi/common.rb @@ -178,6 +178,10 @@ def dump_options(options) # Required APIs below + def version # :nodoc: + raise NotImplementedError + end + def with_buffer(&b) # :nodoc: raise NotImplementedError end diff --git a/lib/prism/ffi/wasm_ffi.rb b/lib/prism/ffi/wasm_ffi.rb index c6e4e07293..560001fcb0 100644 --- a/lib/prism/ffi/wasm_ffi.rb +++ b/lib/prism/ffi/wasm_ffi.rb @@ -12,7 +12,7 @@ # Load the prism-parser-wasm jar require 'jar-dependencies' -require_jar('org.ruby-lang', 'prism-parser-wasm', '0.0.1-SNAPSHOT') +require_jar('org.ruby-lang', 'prism-parser-wasm-full', '0.0.2-SNAPSHOT') require_jar('com.dylibso.chicory', 'runtime', '1.6.1') require_jar('com.dylibso.chicory', 'wasi', '1.6.1') require_jar('com.dylibso.chicory', 'wasm', '1.6.1') @@ -20,22 +20,32 @@ module Prism # :nodoc: class WASMCommon < Common # :nodoc: - java_import org.ruby_lang.prism.wasm.Prism + java_import org.ruby_lang.prism.wasm.full.Prism # TODO: concurrency - PRISM = org.ruby_lang.prism.wasm.Prism.new + PRISM = org.ruby_lang.prism.wasm.full.Prism.new def version # The version constant is set by reading the result of calling pm_version. - WASM::PRISM.version + PRISM.version end def with_buffer(&b) # :nodoc: - raise NotImplementedError + buffer = Prism::Buffer.new + begin + b.call(buffer) + ensure + buffer.close + end end def with_string(string, &b) # :nodoc: - raise NotImplementedError + source = Prism::Source.new(string.to_java_bytes) + begin + b.call(source) + ensure + source.close + end end def with_file(string, &b) # :nodoc: @@ -43,11 +53,11 @@ def with_file(string, &b) # :nodoc: end def lex_only(buffer, string, options) # :nodoc: - raise NotImplementedError + String.from_java_bytes(Prism.lex(buffer, string, dump_options(options))) end def parse_only(buffer, string, options) # :nodoc: - raise NotImplementedError + String.from_java_bytes(Prism.lex(buffer, string, dump_options(options))) end def parse_stream(buffer, callback, eof_callback, options, source) # :nodoc: @@ -78,4 +88,7 @@ def string_query_local(string) # :nodoc: raise NotImplementedError end end + + FFICommon = WASMCommon.new.freeze + private_constant(:FFICommon) end