mt-lang 0.3.9 → 0.3.11

data/lib/milk_tea/bindings/vendored_flecs.rb

@@ -19,14 +19,12 @@ module MilkTea
       -std=gnu99
     ].freeze
 
-    module_function
-
-    def source(root: MilkTea.root)
+    def self.source(root: MilkTea.root)
       UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
         raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
     end
 
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= VendoredCLibrary::Archive.new(
@@ -42,35 +40,35 @@ module MilkTea
       )
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       source(root:).checkout_root
     end
 
-    def include_root(root: MilkTea.root)
+    def self.include_root(root: MilkTea.root)
       source_root(root:).join("distr")
     end
 
-    def header_path(root: MilkTea.root)
+    def self.header_path(root: MilkTea.root)
       include_root(root:).join("flecs.h")
     end
 
-    def build_root(root: MilkTea.root)
+    def self.build_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-flecs")
     end
 
-    def archive_path(root: MilkTea.root)
+    def self.archive_path(root: MilkTea.root)
       build_root(root:).join("libflecs.a")
     end
 
-    def include_flags(root: MilkTea.root)
+    def self.include_flags(root: MilkTea.root)
       library(root:).include_flags
     end
 
-    def link_flags(root: MilkTea.root)
+    def self.link_flags(root: MilkTea.root)
       library(root:).link_flags
     end
 
-    def prepare!(root: MilkTea.root, **kwargs)
+    def self.prepare!(root: MilkTea.root, **kwargs)
       source(root:).bootstrap!
       library(root:).prepare!(**kwargs)
     end

data/lib/milk_tea/bindings/vendored_glfw.rb

@@ -14,14 +14,12 @@ module MilkTea
       -DGLFW_BUILD_DOCS=OFF
     ].freeze
 
-    module_function
-
-    def source(root: MilkTea.root)
+    def self.source(root: MilkTea.root)
       UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
         raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
     end
 
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
@@ -37,39 +35,39 @@ module MilkTea
       )
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       source(root:).checkout_root
     end
 
-    def include_root(root: MilkTea.root)
+    def self.include_root(root: MilkTea.root)
       source_root(root:).join("include")
     end
 
-    def header_root(root: MilkTea.root)
+    def self.header_root(root: MilkTea.root)
       include_root(root:).join("GLFW")
     end
 
-    def build_root(root: MilkTea.root)
+    def self.build_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-glfw")
     end
 
-    def install_root(root: MilkTea.root)
+    def self.install_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-glfw-prefix")
     end
 
-    def archive_path(root: MilkTea.root)
+    def self.archive_path(root: MilkTea.root)
       install_root(root:).join("lib/libglfw3.a")
     end
 
-    def include_flags(root: MilkTea.root)
+    def self.include_flags(root: MilkTea.root)
       library(root:).include_flags
     end
 
-    def link_flags(root: MilkTea.root)
+    def self.link_flags(root: MilkTea.root)
       library(root:).link_flags
     end
 
-    def prepare!(root: MilkTea.root, **kwargs)
+    def self.prepare!(root: MilkTea.root, **kwargs)
       source(root:).bootstrap!
       library(root:).prepare!(**kwargs)
     end

data/lib/milk_tea/bindings/vendored_libuv.rb

@@ -12,14 +12,12 @@ module MilkTea
       -DBUILD_TESTING=OFF
     ].freeze
 
-    module_function
-
-    def source(root: MilkTea.root)
+    def self.source(root: MilkTea.root)
       UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
         raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
     end
 
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
@@ -35,39 +33,39 @@ module MilkTea
       )
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       source(root:).checkout_root
     end
 
-    def include_root(root: MilkTea.root)
+    def self.include_root(root: MilkTea.root)
       source_root(root:).join("include")
     end
 
-    def header_path(root: MilkTea.root)
+    def self.header_path(root: MilkTea.root)
       include_root(root:).join("uv.h")
     end
 
-    def build_root(root: MilkTea.root)
+    def self.build_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-libuv")
     end
 
-    def install_root(root: MilkTea.root)
+    def self.install_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-libuv-prefix")
     end
 
-    def archive_path(root: MilkTea.root)
+    def self.archive_path(root: MilkTea.root)
       install_root(root:).join("lib/libuv.a")
     end
 
-    def include_flags(root: MilkTea.root)
+    def self.include_flags(root: MilkTea.root)
       library(root:).include_flags
     end
 
-    def link_flags(root: MilkTea.root)
+    def self.link_flags(root: MilkTea.root)
       library(root:).link_flags
     end
 
-    def prepare!(root: MilkTea.root, **kwargs)
+    def self.prepare!(root: MilkTea.root, **kwargs)
       source(root:).bootstrap!
       library(root:).prepare!(**kwargs)
     end

data/lib/milk_tea/bindings/vendored_pcre2.rb

@@ -21,14 +21,12 @@ module MilkTea
       -lm
     ].freeze
 
-    module_function
-
-    def source(root: MilkTea.root)
+    def self.source(root: MilkTea.root)
       UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
         raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
     end
 
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
@@ -44,39 +42,39 @@ module MilkTea
       )
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       source(root:).checkout_root
     end
 
-    def include_root(root: MilkTea.root)
+    def self.include_root(root: MilkTea.root)
       install_root(root:).join("include")
     end
 
-    def header_path(root: MilkTea.root)
+    def self.header_path(root: MilkTea.root)
       include_root(root:).join("pcre2.h")
     end
 
-    def build_root(root: MilkTea.root)
+    def self.build_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-pcre2")
     end
 
-    def install_root(root: MilkTea.root)
+    def self.install_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-pcre2-prefix")
     end
 
-    def archive_path(root: MilkTea.root)
+    def self.archive_path(root: MilkTea.root)
       install_root(root:).join("lib/libpcre2-8.a")
     end
 
-    def include_flags(root: MilkTea.root)
+    def self.include_flags(root: MilkTea.root)
       library(root:).include_flags
     end
 
-    def link_flags(root: MilkTea.root)
+    def self.link_flags(root: MilkTea.root)
       library(root:).link_flags
     end
 
-    def prepare!(root: MilkTea.root, **kwargs)
+    def self.prepare!(root: MilkTea.root, **kwargs)
       source(root:).bootstrap!
       library(root:).prepare!(**kwargs)
     end

data/lib/milk_tea/bindings/vendored_raylib.rb

@@ -92,39 +92,35 @@ module MilkTea
         archive_for(platform).prepare!(env:, cc:, platform:)
       end
 
-      private
-
       def archive_for(platform)
         platform == :wasm ? @wasm_archive : @desktop_archive
       end
     end
 
-    module_function
-
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= AdaptiveArchive.new(root: resolved_root)
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("third_party/raylib-upstream/src")
     end
 
-    def build_root(root: MilkTea.root, platform: nil)
+    def self.build_root(root: MilkTea.root, platform: nil)
       suffix = platform == :wasm ? "tmp/vendored-raylib-web" : "tmp/vendored-raylib-opengl43"
       MilkTea.writable_root_for(root).join(suffix)
     end
 
-    def archive_path(root: MilkTea.root, platform: nil)
+    def self.archive_path(root: MilkTea.root, platform: nil)
       build_root(root:, platform:).join("libraylib.a")
     end
 
-    def link_flags(root: MilkTea.root, platform: nil)
+    def self.link_flags(root: MilkTea.root, platform: nil)
       library(root:).link_flags(platform:)
     end
 
-    def prepare!(root: MilkTea.root, platform: nil, **kwargs)
+    def self.prepare!(root: MilkTea.root, platform: nil, **kwargs)
       library(root:).prepare!(platform:, **kwargs)
     end
   end

data/lib/milk_tea/bindings/vendored_sdl3.rb

@@ -15,14 +15,12 @@ module MilkTea
       -DSDL_EXAMPLES=OFF
     ].freeze
 
-    module_function
-
-    def source(root: MilkTea.root)
+    def self.source(root: MilkTea.root)
       UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
         raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
     end
 
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
@@ -38,39 +36,39 @@ module MilkTea
       )
     end
 
-    def source_root(root: MilkTea.root)
+    def self.source_root(root: MilkTea.root)
       source(root:).checkout_root
     end
 
-    def include_root(root: MilkTea.root)
+    def self.include_root(root: MilkTea.root)
       source_root(root:).join("include")
     end
 
-    def header_root(root: MilkTea.root)
+    def self.header_root(root: MilkTea.root)
       include_root(root:).join("SDL3")
     end
 
-    def build_root(root: MilkTea.root)
+    def self.build_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-sdl3")
     end
 
-    def install_root(root: MilkTea.root)
+    def self.install_root(root: MilkTea.root)
       MilkTea.writable_root_for(root).join("tmp/vendored-sdl3-prefix")
     end
 
-    def archive_path(root: MilkTea.root)
+    def self.archive_path(root: MilkTea.root)
       install_root(root:).join("lib/libSDL3.a")
     end
 
-    def include_flags(root: MilkTea.root)
+    def self.include_flags(root: MilkTea.root)
       library(root:).include_flags
     end
 
-    def link_flags(root: MilkTea.root)
+    def self.link_flags(root: MilkTea.root)
       library(root:).link_flags
     end
 
-    def prepare!(root: MilkTea.root, **kwargs)
+    def self.prepare!(root: MilkTea.root, **kwargs)
       source(root:).bootstrap!
       library(root:).prepare!(**kwargs)
     end

data/lib/milk_tea/bindings/vendored_steamworks.rb

@@ -6,9 +6,7 @@ module MilkTea
   module VendoredSteamworks
     Error = VendoredCLibrary::Error
 
-    module_function
-
-    def library(root: MilkTea.root)
+    def self.library(root: MilkTea.root)
       resolved_root = Pathname.new(File.expand_path(root.to_s))
       @libraries ||= {}
       @libraries[resolved_root.to_s] ||= Library.new(root: resolved_root)
@@ -51,8 +49,6 @@ module MilkTea
         raise tool_not_found(e)
       end
 
-      private
-
       def copy_if_present(path)
         return unless path && File.file?(path)
 

data/lib/milk_tea/core/ast.rb

@@ -9,8 +9,8 @@ module MilkTea
       end
     end
 
-    TypeParamConstraint = Data.define(:kind, :interface_ref) do
-      def initialize(kind:, interface_ref: nil) = super
+    TypeParamConstraint = Data.define(:kind, :interface_ref, :line, :column) do
+      def initialize(kind:, interface_ref: nil, line: nil, column: nil) = super
     end
 
     TypeParam = Data.define(:name, :constraints, :line, :column, :length) do
@@ -19,7 +19,9 @@ module MilkTea
     ValueTypeParam = Data.define(:name, :type, :line, :column, :length) do
       def initialize(name:, type:, line: nil, column: nil, length: nil) = super
     end
-    TypeArgument = Data.define(:value)
+    TypeArgument = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
     class TypeRef < Data.define(:name, :arguments, :nullable, :lifetime, :line, :column, :length)
       def initialize(name:, arguments:, nullable:, lifetime: nil, line: nil, column: nil, length: nil) = super
 
@@ -40,23 +42,33 @@ module MilkTea
         nullable ? "#{text}?" : text
       end
     end
-    FunctionType = Data.define(:params, :return_type)
-    ProcType = Data.define(:params, :return_type)
-    TupleType = Data.define(:element_types, :nullable) do
-      def initialize(element_types:, nullable: false) = super
+    FunctionType = Data.define(:params, :return_type, :line, :column) do
+      def initialize(params:, return_type:, line: nil, column: nil) = super
+    end
+    ProcType = Data.define(:params, :return_type, :line, :column) do
+      def initialize(params:, return_type:, line: nil, column: nil) = super
+    end
+    TupleType = Data.define(:element_types, :nullable, :line, :column) do
+      def initialize(element_types:, nullable: false, line: nil, column: nil) = super
     end
     DynType = Data.define(:interface, :nullable, :line, :column, :length) do
       def initialize(interface:, nullable: false, line: nil, column: nil, length: nil) = super
     end
-    SourceFile = Data.define(:module_name, :module_kind, :imports, :directives, :declarations, :line, :node_ids, :node_path_ids) do
-      def initialize(module_name:, module_kind:, imports:, directives:, declarations:, line: nil, node_ids: {}, node_path_ids: {}) = super
+    SourceFile = Data.define(:module_name, :module_kind, :imports, :directives, :declarations, :line, :column, :node_ids, :node_path_ids) do
+      def initialize(module_name:, module_kind:, imports:, directives:, declarations:, line: nil, column: nil, node_ids: {}, node_path_ids: {}) = super
     end
     Import = Data.define(:path, :alias_name, :line, :column, :length) do
       def initialize(path:, alias_name:, line: nil, column: nil, length: nil) = super
     end
-    LinkDirective = Data.define(:value)
-    IncludeDirective = Data.define(:value)
-    CompilerFlagDirective = Data.define(:value)
+    LinkDirective = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
+    IncludeDirective = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
+    CompilerFlagDirective = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
     ConstDecl = Data.define(:name, :type, :value, :block_body, :visibility, :attributes, :line, :column) do
       def initialize(name:, type:, value:, block_body: nil, visibility:, attributes: [], line: nil, column: nil) = super
     end
@@ -111,16 +123,18 @@ module MilkTea
     MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :attributes, :line, :column) do
       def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes: [], line: nil, column: nil) = super
     end
-    ExternFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :attributes, :line, :mapping) do
-      def initialize(name:, type_params:, params:, return_type:, variadic:, attributes: [], line: nil, mapping: nil) = super
+    ExternFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :attributes, :line, :column, :mapping) do
+      def initialize(name:, type_params:, params:, return_type:, variadic:, attributes: [], line: nil, column: nil, mapping: nil) = super
     end
-    ForeignFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :mapping, :visibility, :attributes, :line) do
-      def initialize(name:, type_params:, params:, return_type:, variadic:, mapping:, visibility:, attributes: [], line: nil) = super
+    ForeignFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :mapping, :visibility, :attributes, :line, :column) do
+      def initialize(name:, type_params:, params:, return_type:, variadic:, mapping:, visibility:, attributes: [], line: nil, column: nil) = super
     end
     Param = Data.define(:name, :type, :line, :column, :default_value) do
       def initialize(name:, type:, line: nil, column: nil, default_value: nil) = super
     end
-    ForeignParam = Data.define(:name, :type, :mode, :boundary_type)
+    ForeignParam = Data.define(:name, :type, :mode, :boundary_type, :line, :column) do
+      def initialize(name:, type:, mode:, boundary_type:, line: nil, column: nil) = super
+    end
     LocalDecl = Data.define(:kind, :name, :type, :value, :else_binding, :else_body, :line, :column, :recovered_else, :destructure_bindings, :destructure_type_name) do
       def initialize(kind:, name:, type:, value:, else_binding: nil, else_body: nil, line: nil, column: nil, recovered_else: false, destructure_bindings: nil, destructure_type_name: nil) = super
     end
@@ -130,24 +144,26 @@ module MilkTea
     IfBranch = Data.define(:condition, :body, :line, :column, :length) do
       def initialize(condition:, body:, line: nil, column: nil, length: nil) = super
     end
-    IfStmt = Data.define(:branches, :else_body, :inline, :line, :else_line, :else_column) do
-      def initialize(branches:, else_body:, inline: false, line: nil, else_line: nil, else_column: nil) = super
+    IfStmt = Data.define(:branches, :else_body, :inline, :line, :column, :else_line, :else_column) do
+      def initialize(branches:, else_body:, inline: false, line: nil, column: nil, else_line: nil, else_column: nil) = super
     end
     VariantDecl = Data.define(:name, :type_params, :arms, :visibility, :attributes, :line, :column) do
       def initialize(name:, type_params:, arms:, visibility:, attributes: [], line: nil, column: nil) = super
     end
-    VariantArm = Data.define(:name, :fields)
-    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    VariantArm = Data.define(:name, :fields, :line, :column) do
+      def initialize(name:, fields:, line: nil, column: nil) = super
+    end
+    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     MatchStmt = Data.define(:expression, :arms, :inline, :line, :column, :length) do
       def initialize(expression:, arms:, inline: false, line: nil, column: nil, length: nil) = super
     end
-    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value) do
-      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil) = super
+    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value, :line, :column) do
+      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
-    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     WhenStmt = Data.define(:discriminant, :branches, :else_body, :line, :column, :length) do
       def initialize(discriminant:, branches:, else_body:, line: nil, column: nil, length: nil) = super
@@ -155,8 +171,8 @@ module MilkTea
     UnsafeStmt = Data.define(:body, :line, :column, :length) do
       def initialize(body:, line: nil, column: nil, length: nil) = super
     end
-    StaticAssert = Data.define(:condition, :message, :line) do
-      def initialize(condition:, message:, line: nil) = super
+    StaticAssert = Data.define(:condition, :message, :line, :column) do
+      def initialize(condition:, message:, line: nil, column: nil) = super
     end
     EmitStmt = Data.define(:declaration, :line, :column) do
       def initialize(declaration:, line: nil, column: nil) = super
@@ -208,8 +224,8 @@ module MilkTea
     ErrorExpr = Data.define(:line, :column, :length, :message) do
       def initialize(line: nil, column: nil, length: nil, message: nil) = super
     end
-    ExpressionStmt = Data.define(:expression, :line) do
-      def initialize(expression:, line: nil) = super
+    ExpressionStmt = Data.define(:expression, :line, :column) do
+      def initialize(expression:, line: nil, column: nil) = super
     end
 
     Identifier = Data.define(:name, :line, :column) do
@@ -218,36 +234,78 @@ module MilkTea
     MemberAccess = Data.define(:receiver, :member, :line, :column) do
       def initialize(receiver:, member:, line: nil, column: nil) = super
     end
-    IndexAccess = Data.define(:receiver, :index)
-    Specialization = Data.define(:callee, :arguments)
-    Call = Data.define(:callee, :arguments)
-    Argument = Data.define(:name, :value)
-    UnaryOp = Data.define(:operator, :operand)
-    BinaryOp = Data.define(:operator, :left, :right)
-    RangeExpr = Data.define(:start_expr, :end_expr, :line, :column)
-    ExpressionList = Data.define(:elements, :line, :column)
-    IfExpr = Data.define(:condition, :then_expression, :else_expression)
+    IndexAccess = Data.define(:receiver, :index, :line, :column) do
+      def initialize(receiver:, index:, line: nil, column: nil) = super
+    end
+    Specialization = Data.define(:callee, :arguments, :line, :column) do
+      def initialize(callee:, arguments:, line: nil, column: nil) = super
+    end
+    Call = Data.define(:callee, :arguments, :line, :column) do
+      def initialize(callee:, arguments:, line: nil, column: nil) = super
+    end
+    Argument = Data.define(:name, :value, :line, :column) do
+      def initialize(name:, value:, line: nil, column: nil) = super
+    end
+    UnaryOp = Data.define(:operator, :operand, :line, :column) do
+      def initialize(operator:, operand:, line: nil, column: nil) = super
+    end
+    BinaryOp = Data.define(:operator, :left, :right, :line, :column) do
+      def initialize(operator:, left:, right:, line: nil, column: nil) = super
+    end
+    RangeExpr = Data.define(:start_expr, :end_expr, :line, :column) do
+      def initialize(start_expr:, end_expr:, line: nil, column: nil) = super
+    end
+    ExpressionList = Data.define(:elements, :line, :column) do
+      def initialize(elements:, line: nil, column: nil) = super
+    end
+    IfExpr = Data.define(:condition, :then_expression, :else_expression, :line, :column) do
+      def initialize(condition:, then_expression:, else_expression:, line: nil, column: nil) = super
+    end
     MatchExpr = Data.define(:expression, :arms, :line, :column, :length, :desugared_from_is) do
       def initialize(expression:, arms:, line: nil, column: nil, length: nil, desugared_from_is: false) = super
     end
     UnsafeExpr = Data.define(:expression, :line, :column, :length) do
       def initialize(expression:, line: nil, column: nil, length: nil) = super
     end
-    ProcExpr = Data.define(:params, :return_type, :body)
-    AwaitExpr = Data.define(:expression)
-    SizeofExpr = Data.define(:type)
-    AlignofExpr = Data.define(:type)
-    OffsetofExpr = Data.define(:type, :field)
-    IntegerLiteral = Data.define(:lexeme, :value)
-    FloatLiteral = Data.define(:lexeme, :value)
-    StringLiteral = Data.define(:lexeme, :value, :cstring)
-    FormatString = Data.define(:parts)
-    FormatTextPart = Data.define(:value)
-    FormatExprPart = Data.define(:expression, :format_spec)
+    ProcExpr = Data.define(:params, :return_type, :body, :line, :column) do
+      def initialize(params:, return_type:, body:, line: nil, column: nil) = super
+    end
+    AwaitExpr = Data.define(:expression, :line, :column) do
+      def initialize(expression:, line: nil, column: nil) = super
+    end
+    SizeofExpr = Data.define(:type, :line, :column) do
+      def initialize(type:, line: nil, column: nil) = super
+    end
+    AlignofExpr = Data.define(:type, :line, :column) do
+      def initialize(type:, line: nil, column: nil) = super
+    end
+    OffsetofExpr = Data.define(:type, :field, :line, :column) do
+      def initialize(type:, field:, line: nil, column: nil) = super
+    end
+    IntegerLiteral = Data.define(:lexeme, :value, :line, :column) do
+      def initialize(lexeme:, value:, line: nil, column: nil) = super
+    end
+    FloatLiteral = Data.define(:lexeme, :value, :line, :column) do
+      def initialize(lexeme:, value:, line: nil, column: nil) = super
+    end
+    StringLiteral = Data.define(:lexeme, :value, :cstring, :line, :column) do
+      def initialize(lexeme:, value:, cstring: false, line: nil, column: nil) = super
+    end
+    FormatString = Data.define(:parts, :line, :column) do
+      def initialize(parts:, line: nil, column: nil) = super
+    end
+    FormatTextPart = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
+    FormatExprPart = Data.define(:expression, :format_spec, :line, :column) do
+      def initialize(expression:, format_spec: nil, line: nil, column: nil) = super
+    end
     CharLiteral = Data.define(:lexeme, :value, :line, :column) do
       def initialize(lexeme:, value:, line: nil, column: nil) = super
     end
-    BooleanLiteral = Data.define(:value)
+    BooleanLiteral = Data.define(:value, :line, :column) do
+      def initialize(value:, line: nil, column: nil) = super
+    end
     NullLiteral = Data.define(:type, :line, :column) do
       def initialize(type:, line: nil, column: nil) = super
     end

data/lib/milk_tea/core/async_runtime_installer.rb

@@ -17,8 +17,6 @@ module MilkTea
       modules["std.async"] = @bind_block.call(import_analysis)
     end
 
-    private
-
     def async_main_declared?(ast)
       ast.declarations.any? do |decl|
         decl.is_a?(AST::FunctionDef) && decl.name == "main" && decl.async

data/lib/milk_tea/core/bindings/attribute_binding.rb

@@ -4,9 +4,7 @@ module MilkTea
   AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
   BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
 
-  module_function
-
-  def builtin_attribute_binding(name, types)
+  def self.builtin_attribute_binding(name, types)
     case name
     when "packed"
       AttributeBinding.new(