mt-lang 0.3.12 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc80c3a3240cbcf4770dd067aa33559e74e3f139322b8fdb757316f3c7faf8af
-  data.tar.gz: a623e5ecaa9617aa161a83e96c4cb0e7a75b08855edae27fb56c8ddc47c7cd75
+  metadata.gz: ccbf498d3496c9dac904d8f2b43442e971507874b856149171b78f7eed90e949
+  data.tar.gz: '090885ac2d6181ba4cabb1ef6ed5c5a6e79cb3e60fe4fa61315c6f2404d5e00f'
 SHA512:
-  metadata.gz: c90aa51a21411fdcfe612f2ded69afdde6e055a012a4e886f5aa9ac69110d39a8bf93a36dde0543d1375a8bfa75ffd2f287eb082833a28b42efe19ab45c62ae6
-  data.tar.gz: a87ac20f1228f059e3508818be58e11e5491a90299e56d5ab569ab3ebf1ae3dc1f7ddff8761321754bd2bfc8c520dc9ac3876360714ced2baf6e06a82bbf635d
+  metadata.gz: '08b68224eb3b428b8fab0845a98f79605c06f95ffc66a6a653586da99f230720f177781ac481debee8aede3cda843f34f12fb953f62846fc8d7048d3b97726c1'
+  data.tar.gz: cd69cddcf5b0cf2bb86fe4443c502c214fc73dda6318532f14e9548b8bbc7b84186956b9bf4a975148ad0f45d8bb9b86f1093956c089af293f1755ca2c8b6589

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.12"
+  VERSION = "0.3.13"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/bindings/bindgen.rb

@@ -5,7 +5,7 @@ require "open3"
 require "tempfile"
 require_relative "../tooling/formatter"
 require_relative "../core/token"
-require_relative "../core/types/types"
+require_relative "../core/types"
 require_relative "bindgen/ast_parser"
 require_relative "bindgen/declaration"
 require_relative "bindgen/type_mapper"

data/lib/milk_tea/bindings/imported_bindings.rb

@@ -3,7 +3,7 @@
 require "json"
 require_relative "../tooling/formatter"
 require_relative "../core/token"
-require_relative "../core/types/types"
+require_relative "../core/types"
 
 require_relative "imported_bindings/generator"
 require_relative "imported_bindings/method_source"

data/lib/milk_tea/core/types/layout.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "fiddle"
-require_relative "types"
+require_relative "../types"
 
 module MilkTea
   module Layout

data/lib/milk_tea/core/{types/types.rb → types.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "fiddle"
-require_relative "registry"
-require_relative "visitor"
+require_relative "types/registry"
+require_relative "types/visitor"
 
 module MilkTea
   module Types

data/lib/milk_tea/core.rb

@@ -9,7 +9,7 @@ require_relative "core/lexer"
 require_relative "core/cst"
 require_relative "core/cst_builder"
 require_relative "core/ast"
-require_relative "core/types/types"
+require_relative "core/types"
 require_relative "core/binding_types"
 require_relative "core/compile_time"
 require_relative "core/compatibility_helpers"

data/lib/milk_tea/tooling/cli.rb

@@ -229,6 +229,7 @@ module MilkTea
 
     def lex_command
       path = nil
+      sexpr = false
 
       args = @argv.dup
       @argv = []
@@ -236,6 +237,11 @@ module MilkTea
         arg = args.shift
         next if arg == "--"
 
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
+
         if path.nil?
           path = arg
         else
@@ -252,15 +258,24 @@ module MilkTea
       end
 
       tokens = Lexer.lex(read_source_file(path), path: path)
-      @out.write(PP.pp(tokens, +""))
+      if sexpr
+        @out.puts(SexprDumper.dump_tokens(tokens))
+      else
+        @out.write(PP.pp(tokens, +""))
+      end
       0
     end
 
     def parse_command
+      sexpr = false
       args = @argv.dup
       @argv = []
       until args.empty?
         arg = args.shift
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
         @argv << arg
       end
 
@@ -283,9 +298,13 @@ module MilkTea
       paths.each_with_index do |path, index|
         ast = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).load_file(path)
         if multiple
-          @out.puts("# --- #{path} ---")
+          @out.puts("# --- #{path} ---") unless sexpr
+        end
+        if sexpr
+          @out.puts(SexprDumper.dump_ast(ast))
+        else
+          @out.write(PrettyPrinter.format_ast(ast))
         end
-        @out.write(PrettyPrinter.format_ast(ast))
         @out.puts if multiple && index < paths.length - 1
       end
       0
@@ -764,10 +783,15 @@ module MilkTea
     end
 
     def lower_command
+      sexpr = false
       args = @argv.dup
       @argv = []
       until args.empty?
         arg = args.shift
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
         @argv << arg
       end
 
@@ -790,10 +814,13 @@ module MilkTea
       paths.each_with_index do |path, index|
         program = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).check_program(path)
         if multiple
-          @out.puts("# --- #{path} ---")
+          @out.puts("# --- #{path} ---") unless sexpr
+        end
+        if sexpr
+          @out.puts(SexprDumper.dump_ir(Lowering.lower(program)))
+        else
+          @out.write(PrettyPrinter.format_ir(Lowering.lower(program)))
         end
-        @out.write(PrettyPrinter.format_ir(Lowering.lower(program)))
-        @out.puts if multiple && index < paths.length - 1
       end
       0
     end

data/lib/milk_tea/tooling/sexpr_dumper.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module SexprDumper
+    module_function
+
+    def dump_ir(program)
+      buf = +""
+      emit_value(program, buf)
+      buf
+    end
+
+    def dump_ast(ast)
+      buf = +""
+      emit_value(ast, buf)
+      buf
+    end
+
+    def dump_tokens(tokens)
+      buf = +""
+      buf << "("
+      tokens.each_with_index { |t, i| buf << " " if i > 0; emit_token(t, buf) }
+      buf << ")"
+      buf
+    end
+
+    # ── value dispatcher ──────────────────────────────────────────────
+
+    def emit_value(value, buf)
+      case value
+      when ::Data then emit_data(value, buf)
+      when Array  then emit_array(value, buf)
+      when *TYPES_CLASSES then emit_types_object(value, buf)
+      when nil    then buf << "nil"
+      when true   then buf << "true"
+      when false  then buf << "false"
+      when Integer then buf << value.to_s
+      when Float   then buf << format_float(value)
+      when String  then emit_string(value, buf)
+      when Symbol  then buf << ":" << value.to_s.tr("_", "-")
+      else buf << escape_string(value.to_s)
+      end
+    end
+
+    # ── Data serialisation ────────────────────────────────────────────
+
+    def emit_data(node, buf)
+      type_name = node.class.name.split("::").last(2).join("::")
+      members = node.class.members
+      buf << "(" << type_name
+      members.each do |field|
+        val = node.public_send(field)
+        buf << " :" << field.to_s << " "
+        emit_value(val, buf)
+      end
+      buf << ")"
+    end
+
+    # ── Array serialisation ───────────────────────────────────────────
+
+    def emit_array(values, buf)
+      buf << "("
+      values.each_with_index do |v, i|
+        buf << " " if i > 0
+        emit_value(v, buf)
+      end
+      buf << ")"
+    end
+
+    # ── Token serialisation ───────────────────────────────────────────
+
+    def emit_token(token, buf)
+      buf << "(token :type " << emit_token_type(token.type)
+      buf << " :lexeme "
+      emit_string(token.lexeme, buf)
+      buf << " :literal "
+      emit_value(token.literal, buf)
+      buf << " :line " << token.line.to_s
+      buf << " :column " << token.column.to_s
+      buf << " :start_offset " << token.start_offset.to_s
+      buf << " :end_offset " << token.end_offset.to_s
+      buf << ")"
+    end
+
+    def emit_token_type(sym)
+      ":" + sym.to_s.tr("_", "-")
+    end
+
+    # ── Types serialisation ───────────────────────────────────────────
+
+    TYPES_SHORT_NAMES = {
+      "MilkTea::Types::Primitive"              => "Primitive",
+      "MilkTea::Types::Null"                   => "Null",
+      "MilkTea::Types::Nullable"               => "Nullable",
+      "MilkTea::Types::GenericInstance"        => "Generic",
+      "MilkTea::Types::Span"                   => "Span",
+      "MilkTea::Types::Task"                   => "Task",
+      "MilkTea::Types::Function"               => "Function",
+      "MilkTea::Types::Proc"                   => "Proc",
+      "MilkTea::Types::Tuple"                  => "Tuple",
+      "MilkTea::Types::Vector"                 => "Vector",
+      "MilkTea::Types::Matrix"                 => "Matrix",
+      "MilkTea::Types::Quaternion"             => "Quaternion",
+      "MilkTea::Types::SoA"                    => "SoA",
+      "MilkTea::Types::Simd"                   => "Simd",
+      "MilkTea::Types::Struct"                 => "Struct",
+      "MilkTea::Types::StructInstance"         => "StructInstance",
+      "MilkTea::Types::Union"                  => "Union",
+      "MilkTea::Types::Variant"                => "Variant",
+      "MilkTea::Types::VariantInstance"        => "VariantInstance",
+      "MilkTea::Types::VariantArmPayload"      => "VariantArmPayload",
+      "MilkTea::Types::Enum"                   => "Enum",
+      "MilkTea::Types::Flags"                  => "Flags",
+      "MilkTea::Types::Opaque"                 => "Opaque",
+      "MilkTea::Types::StringView"             => "StringView",
+      "MilkTea::Types::Dyn"                    => "Dyn",
+      "MilkTea::Types::Parameter"              => "Parameter",
+      "MilkTea::Types::LiteralTypeArg"         => "LiteralTypeArg",
+      "MilkTea::Types::TypeVar"                => "TypeVar",
+      "MilkTea::Types::LifetimeRef"            => "LifetimeRef",
+      "MilkTea::Types::Event"                  => "Event",
+      "MilkTea::Types::Subscription"           => "Subscription",
+      "MilkTea::Types::Handle"                 => "Handle",
+      "MilkTea::Types::TypeType"               => "TypeType",
+      "MilkTea::Types::Error"                  => "Error",
+      "MilkTea::Types::DynVtable"              => "DynVtable",
+    }.freeze
+
+    TYPES_CLASSES = TYPES_SHORT_NAMES.keys.map do |name|
+      name.split("::").reduce(Object) { |mod, part| mod.const_get(part) }
+    end.freeze
+
+    def emit_types_object(type, buf)
+      short = TYPES_SHORT_NAMES[type.class.name] || type.class.name.split("::").last
+      buf << "(Types::" << short
+      emit_types_fields(type, buf)
+      buf << ")"
+    end
+
+    def emit_types_fields(type, buf)
+      case type
+      when Types::Primitive
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::Null
+        buf << " :target_type "
+        emit_value(type.target_type, buf)
+      when Types::Nullable
+        buf << " :base "
+        emit_value(type.base, buf)
+      when Types::GenericInstance
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :arguments "
+        emit_array(type.arguments, buf)
+      when Types::Span
+        buf << " :element_type "
+        emit_value(type.element_type, buf)
+      when Types::Task
+        buf << " :result_type "
+        emit_value(type.result_type, buf)
+      when Types::Function
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :params "
+        emit_array(type.params, buf)
+        buf << " :return_type "
+        emit_value(type.return_type, buf)
+        buf << " :receiver_type "
+        emit_value(type.receiver_type, buf)
+        buf << " :receiver_editable "
+        emit_value(type.receiver_editable, buf)
+        buf << " :variadic "
+        emit_value(type.variadic, buf)
+        buf << " :external "
+        emit_value(type.external, buf)
+      when Types::Proc
+        buf << " :params "
+        emit_array(type.params, buf)
+        buf << " :return_type "
+        emit_value(type.return_type, buf)
+      when Types::Tuple
+        buf << " :element_types "
+        emit_array(type.element_types, buf)
+        buf << " :field_names "
+        emit_value(type.field_names, buf)
+      when Types::Vector
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::Matrix
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::Quaternion
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::SoA
+        buf << " :element_type "
+        emit_value(type.element_type, buf)
+        buf << " :count "
+        emit_value(type.count, buf)
+      when Types::Simd
+        buf << " :element_type "
+        emit_value(type.element_type, buf)
+        buf << " :lane_count "
+        emit_value(type.lane_count, buf)
+      when Types::Struct
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::StructInstance
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+        buf << " :arguments "
+        emit_array(type.arguments, buf)
+      when Types::Union
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::Variant
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::VariantInstance
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+        buf << " :arguments "
+        emit_array(type.arguments, buf)
+      when Types::VariantArmPayload
+        buf << " :variant_name "
+        emit_string(type.variant_type.name, buf)
+        buf << " :arm_name "
+        emit_string(type.arm_name, buf)
+      when Types::Enum
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::Flags
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::Opaque
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :module_name "
+        emit_value(type.module_name, buf)
+      when Types::StringView
+        # no fields
+      when Types::Dyn
+        buf << " :interface_name "
+        emit_string(type.interface_binding.name, buf)
+        buf << " :type_arguments "
+        emit_array(type.type_arguments, buf)
+      when Types::Parameter
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :type "
+        emit_value(type.type, buf)
+        buf << " :mutable "
+        emit_value(type.mutable, buf)
+        buf << " :passing_mode "
+        emit_value(type.passing_mode, buf)
+        buf << " :boundary_type "
+        emit_value(type.boundary_type, buf)
+      when Types::LiteralTypeArg
+        buf << " :value "
+        emit_value(type.value, buf)
+      when Types::TypeVar
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::LifetimeRef
+        buf << " :name "
+        emit_string(type.name, buf)
+      when Types::Event
+        buf << " :name "
+        emit_string(type.name, buf)
+        buf << " :capacity "
+        emit_value(type.capacity, buf)
+        buf << " :payload_type "
+        emit_value(type.payload_type, buf)
+      when Types::Subscription
+        # no fields (singleton)
+      when Types::Handle
+        # no fields (singleton)
+      else
+        _emit_generic_type(type, buf)
+      end
+    end
+
+    def _emit_generic_type(type, buf)
+      type.instance_variables.sort.each do |ivar|
+        next if skip_types_ivar?(ivar)
+        name = ivar.to_s.sub(/\A@/, "")
+        val = type.instance_variable_get(ivar)
+        next if val.is_a?(Hash) || val.is_a?(Set) || val.is_a?(Proc)
+        buf << " :" << name << " "
+        emit_value(val, buf)
+      end
+    end
+
+    def skip_types_ivar?(ivar)
+      %i[@hash @integer @float @numeric @pointer_sized_integer
+         @signed_integer @unsigned_integer @fixed_width_integer
+         @boolean @void @integer_width @float_width @backing_type
+         @arms @arm_names @arm_field_hashes @instances].include?(ivar)
+    end
+
+    # ── atom helpers ──────────────────────────────────────────────────
+
+    def emit_string(value, buf)
+      escaped = value.to_s
+        .gsub("\\", "\\\\")
+        .gsub('"', '\"')
+        .gsub("\n", '\\n')
+        .gsub("\t", '\\t')
+        .gsub("\r", '\\r')
+      buf << '"' << escaped << '"'
+    end
+
+    def escape_string(value)
+      value.to_s
+        .gsub("\\", "\\\\")
+        .gsub('"', '\"')
+        .gsub("\n", '\\n')
+        .gsub("\t", '\\t')
+        .gsub("\r", '\\r')
+    end
+
+    def format_float(value)
+      s = sprintf("%.17g", value)
+      s.include?(".") || s.include?("e") ? s : s + ".0"
+    end
+  end
+end

data/lib/milk_tea/tooling/sexpr_parser.rb

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module SexprParser
+    module_function
+
+    # ── public API ────────────────────────────────────────────────────
+
+    def parse_ir(sexpr)
+      tokens = tokenize(sexpr)
+      _parse_value(tokens)
+    end
+
+    def parse_ast(sexpr)
+      tokens = tokenize(sexpr)
+      _parse_value(tokens)
+    end
+
+    def parse_tokens(sexpr)
+      tokens = tokenize(sexpr)
+      _parse_value(tokens)
+    end
+
+    # ── tokenizer ─────────────────────────────────────────────────────
+
+    Token = Data.define(:kind, :text, :line, :column)
+
+    def tokenize(source)
+      tokens = []
+      i = 0
+      len = source.length
+      line = 1
+      col = 1
+      while i < len
+        ch = source[i]
+        case ch
+        when "(", ")"
+          tokens << Token.new(kind: ch, text: ch, line:, column: col)
+          i += 1
+          col += 1
+        when '"'
+          j = i + 1
+          chars = +""
+          while j < len
+            if source[j] == "\\" && j + 1 < len
+              case source[j + 1]
+              when "n"  then chars << "\n"
+              when "t"  then chars << "\t"
+              when "r"  then chars << "\r"
+              when '"'  then chars << '"'
+              when "\\" then chars << "\\"
+              else chars << source[j + 1]
+              end
+              j += 2
+            elsif source[j] == '"'
+              j += 1
+              break
+            else
+              chars << source[j]
+              j += 1
+            end
+          end
+          tokens << Token.new(kind: "string", text: chars, line:, column: col)
+          col += j - i
+          i = j
+        when ":", "-", "0".."9"
+          # keyword, negative number, or number
+          j = i
+          j += 1 while j < len && source[j] != " " && source[j] != "\n" && source[j] != "(" && source[j] != ")" && source[j] != '"'
+          text = source[i...j]
+          if text.start_with?(":")
+            tokens << Token.new(kind: "keyword", text: text[1..], line:, column: col)
+          elsif text.match?(/\A-?[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?\z/) || text.match?(/\A-?[0-9]+\.[0-9]*([eE][+-]?[0-9]+)?\z/)
+            tokens << Token.new(kind: "float", text:, line:, column: col)
+          elsif text.match?(/\A-?[0-9]+\z/)
+            tokens << Token.new(kind: "integer", text:, line:, column: col)
+          else
+            tokens << Token.new(kind: "atom", text:, line:, column: col)
+          end
+          col += j - i
+          i = j
+        when /\s/
+          if ch == "\n"
+            line += 1
+            col = 0
+          end
+          i += 1
+          col += 1
+        else
+          # atom (identifier, true, false, nil)
+          j = i
+          j += 1 while j < len && source[j] != " " && source[j] != "\n" && source[j] != "(" && source[j] != ")" && source[j] != '"'
+          text = source[i...j]
+          tokens << Token.new(kind: "atom", text:, line:, column: col)
+          col += j - i
+          i = j
+        end
+      end
+      tokens
+    end
+
+    # ── parser ────────────────────────────────────────────────────────
+
+    def _parse_value(tokens, index = [0])
+      token = tokens[index[0]]
+      return nil unless token
+
+      case token.kind
+      when "("
+        _parse_list(tokens, index)
+      when "string"
+        index[0] += 1
+        token.text
+      when "integer"
+        index[0] += 1
+        Integer(token.text)
+      when "float"
+        index[0] += 1
+        Float(token.text)
+      when "keyword"
+        index[0] += 1
+        token.text.gsub("-", "_").to_sym
+      when "atom"
+        index[0] += 1
+        case token.text
+        when "nil"  then nil
+        when "true" then true
+        when "false" then false
+        else token.text
+        end
+      else
+        raise "unexpected token: #{token.inspect}"
+      end
+    end
+
+    def _parse_list(tokens, index)
+      index[0] += 1 # skip "("
+      if tokens[index[0]]&.kind == ")"
+        index[0] += 1 # skip ")"
+        return []
+      end
+
+      first = _parse_value(tokens, index)
+
+      if first.is_a?(String) && first.match?(/\A[A-Z]/)
+        _parse_typed_node(tokens, index, first, first)
+      else
+        # plain array — first element was the first value
+        result = [first]
+        while tokens[index[0]]&.kind != ")"
+          result << _parse_value(tokens, index)
+        end
+        index[0] += 1 # skip ")"
+        result
+      end
+    end
+
+    def _parse_typed_node(tokens, index, first_token, first_str)
+      type_name = _resolve_type_name(first_str)
+
+      # Collect keyword-value pairs
+      fields = {}
+      while tokens[index[0]]&.kind == "keyword"
+        kw = tokens[index[0]].text.gsub("-", "_").to_sym
+        index[0] += 1 # skip keyword
+        val = _parse_value(tokens, index)
+        fields[kw] = val
+      end
+
+      index[0] += 1 # skip ")"
+
+      if type_name.start_with?("Types::")
+        _construct_types_object(type_name, fields)
+      elsif type_name.start_with?("IR::")
+        _construct_ir_object(type_name, fields)
+      elsif type_name.start_with?("AST::")
+        _construct_ast_object(type_name, fields)
+      else
+        _construct_generic(type_name, fields)
+      end
+    end
+
+    # ── type name resolution ──────────────────────────────────────────
+
+    def _resolve_type_name(str)
+      # Already fully qualified ("Types::Primitive", "IR::Program")
+      return str if str.include?("::")
+
+      # Try common prefixes
+      [
+        "MilkTea::IR::#{str}",
+        "MilkTea::AST::#{str}",
+        "MilkTea::Types::#{str}",
+      ].each do |candidate|
+        begin
+          return candidate if Object.const_get(candidate)
+        rescue NameError
+          nil
+        end
+      end
+      str
+    end
+
+    # ── object constructors ───────────────────────────────────────────
+
+    def _construct_ir_object(type_name, fields)
+      name = type_name.split("::").last
+      klass = MilkTea::IR.const_get(name)
+      sym_fields = fields.transform_keys(&:to_sym)
+      klass.new(**sym_fields)
+    rescue NameError
+      _construct_generic(type_name, fields)
+    end
+
+    def _construct_ast_object(type_name, fields)
+      name = type_name.split("::").last
+      klass = MilkTea::AST.const_get(name)
+      sym_fields = fields.transform_keys(&:to_sym)
+      klass.new(**sym_fields)
+    rescue NameError
+      _construct_generic(type_name, fields)
+    end
+
+    def _construct_types_object(type_name, fields)
+      short = type_name.sub(/\ATypes::/, "")
+      case short
+      when "Primitive"
+        Types::Registry.primitive(fields[:name])
+      when "Null"
+        Types::Null.new(fields[:target_type])
+      when "Nullable"
+        Types::Registry.nullable(fields[:base])
+      when "Generic"
+        Types::Registry.generic_instance(fields[:name], fields[:arguments])
+      when "Span"
+        Types::Registry.span(fields[:element_type])
+      when "Task"
+        rt = fields[:result_type] || Types::Registry.primitive("void")
+        Types::Registry.task(rt)
+      when "Function"
+        Types::Registry.function(
+          fields[:name],
+          params: fields[:params] || [],
+          return_type: fields[:return_type],
+          receiver_type: fields[:receiver_type],
+          receiver_editable: fields[:receiver_editable] || false,
+          variadic: fields[:variadic] || false,
+          external: fields[:external] || false,
+        )
+      when "Proc"
+        Types::Registry.proc(params: fields[:params] || [], return_type: fields[:return_type])
+      when "Tuple"
+        Types::Registry.tuple(
+          fields.fetch(:element_types, []),
+          field_names: fields[:field_names],
+        )
+      when "Vector"
+        Types::Registry.generic_instance(fields[:name], [Types::LiteralTypeArg.new(fields[:name].delete_prefix("vec").to_i)])
+      when "Matrix"
+        Types::Registry.generic_instance(fields[:name], [Types::LiteralTypeArg.new(fields[:name].delete_prefix("mat").to_i)])
+      when "Quaternion"
+        Types::Registry.generic_instance("quat", [])
+      when "SoA"
+        Types::Registry.soa(fields[:element_type], count: fields[:count])
+      when "Simd"
+        Types::Registry.simd(fields[:element_type], lane_count: fields[:lane_count])
+      when "StringView"
+        Types::Registry.string_view
+      when "Parameter"
+        Types::Registry.parameter(
+          fields[:name],
+          fields[:type],
+          mutable: fields[:mutable] || false,
+          passing_mode: fields[:passing_mode]&.to_sym || :plain,
+          boundary_type: fields[:boundary_type],
+        )
+      when "LiteralTypeArg"
+        Types::LiteralTypeArg.new(fields[:value])
+      when "TypeVar"
+        Types::TypeVar.new(fields[:name])
+      when "LifetimeRef"
+        Types::LifetimeRef.new(fields[:name])
+      when "Dyn"
+        interface_binding = MilkTea::SemanticAnalyzer::InterfaceBinding.new(
+          name: fields[:interface_name],
+          methods: [],
+          ast: nil,
+          module_name: nil,
+        )
+        Types::Registry.dyn(interface_binding, fields.fetch(:type_arguments, []))
+      when "Struct", "StructInstance", "Union", "Variant", "VariantInstance",
+           "VariantArmPayload", "Enum", "Flags", "Opaque", "Event", "Subscription", "Handle",
+           "TypeType", "Error", "DynVtable", "ReflectionHandleType", "StructHandle",
+           "FieldHandle", "CallableHandle", "AttributeHandle", "MemberHandle",
+           "GenericStructDefinition", "GenericVariantDefinition"
+        _construct_standalone_type(short, fields)
+      else
+        _construct_standalone_type(short, fields)
+      end
+    end
+
+    def _construct_standalone_type(short, fields)
+      case short
+      when "TypeType"
+        Types::TypeType.new
+      when "Error"
+        Types::Error.new
+      when "Subscription"
+        Types::Subscription.new
+      when "Handle"
+        Types::Handle.new
+      when "Struct"
+        Types::Struct.new(
+          fields[:name],
+          module_name: fields[:module_name],
+          external: false,
+          packed: false,
+          alignment: nil,
+          linkage_name: nil,
+          lifetime_params: [],
+        )
+      when "Variant"
+        Types::Variant.new(fields[:name], module_name: fields[:module_name])
+      when "Union"
+        Types::Union.new(
+          fields[:name],
+          module_name: fields[:module_name],
+          external: false,
+          packed: false,
+          alignment: nil,
+          linkage_name: nil,
+          lifetime_params: [],
+        )
+      when "Opaque"
+        Types::Opaque.new(fields[:name], module_name: fields[:module_name], external: false, linkage_name: nil)
+      when "Enum"
+        Types::Enum.new(fields[:name], module_name: fields[:module_name], external: false)
+      when "Flags"
+        Types::Flags.new(fields[:name], module_name: fields[:module_name], external: false)
+      when "Event"
+        Types::Event.new(
+          fields[:name],
+          capacity: fields[:capacity],
+          payload_type: fields[:payload_type],
+          module_name: nil,
+          visibility: :private,
+          owner_type_name: nil,
+        )
+      when "StringView"
+        Types::Registry.string_view
+      else
+        _construct_types_fallback(short, fields)
+      end
+    end
+
+    def _construct_types_fallback(short, fields)
+      klass = begin
+        Types.const_get(short)
+      rescue NameError
+        return fields
+      end
+
+      begin
+        sym_fields = fields.transform_keys(&:to_sym)
+        klass.new(**sym_fields)
+      rescue StandardError
+        begin
+          args = fields.values
+          klass.new(*args)
+        rescue StandardError
+          begin
+            obj = klass.allocate
+            fields.each do |k, v|
+              ivar = "@#{k}"
+              obj.instance_variable_set(ivar, v) if obj.instance_variable_defined?(ivar) || obj.respond_to?(:"#{k}=")
+            rescue StandardError
+              nil
+            end
+            begin
+              obj.instance_variable_set(:@hash, obj.object_id.hash)
+            rescue StandardError
+              nil
+            end
+            obj
+          rescue StandardError
+            fields
+          end
+        end
+      end
+    end
+
+    def _construct_generic(type_name, fields)
+      klass = begin
+        name_parts = type_name.split("::")
+        if name_parts.length > 1
+          top = Object.const_get(name_parts.first)
+          rest = name_parts[1..].join("::")
+          top.const_get(rest)
+        else
+          Object.const_get(type_name)
+        end
+      rescue NameError
+        nil
+      end
+
+      if klass && klass.respond_to?(:members)
+        sym_fields = fields.transform_keys(&:to_sym)
+        klass.new(**sym_fields)
+      else
+        fields
+      end
+    end
+
+    # ── helpers ───────────────────────────────────────────────────────
+
+    def _unescape(str)
+      str.gsub("\\n", "\n").gsub("\\t", "\t").gsub("\\r", "\r").gsub('\\"', '"').gsub("\\\\", "\\")
+    end
+  end
+end

data/lib/milk_tea/tooling.rb

@@ -7,6 +7,8 @@ require_relative "packages"
 require_relative "tooling/debug_map"
 require_relative "tooling/debug_info_formatter"
 require_relative "tooling/asset_pack"
+require_relative "tooling/sexpr_dumper"
+require_relative "tooling/sexpr_parser"
 require_relative "tooling/build"
 require_relative "tooling/run"
 require_relative "tooling/cst_formatter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.12
+  version: 0.3.13
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -288,10 +288,10 @@ files:
 - lib/milk_tea/core/semantic_analyzer/type_declaration.rb
 - lib/milk_tea/core/token.rb
 - lib/milk_tea/core/token_stream.rb
+- lib/milk_tea/core/types.rb
 - lib/milk_tea/core/types/layout.rb
 - lib/milk_tea/core/types/predicates.rb
 - lib/milk_tea/core/types/registry.rb
-- lib/milk_tea/core/types/types.rb
 - lib/milk_tea/core/types/visitor.rb
 - lib/milk_tea/dap.rb
 - lib/milk_tea/dap/backends/lldb_dap.rb
@@ -385,6 +385,8 @@ files:
 - lib/milk_tea/tooling/public/css/docs.css
 - lib/milk_tea/tooling/public/js/docs.js
 - lib/milk_tea/tooling/run.rb
+- lib/milk_tea/tooling/sexpr_dumper.rb
+- lib/milk_tea/tooling/sexpr_parser.rb
 - lib/milk_tea/tooling/templates/wasm_shell.html
 - lib/milk_tea/tooling/toolchain_cli.rb
 - lib/milk_tea/tooling/views/404.erb
@@ -603,7 +605,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.12 installed!
+  Milk Tea 0.3.13 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH