mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/core/lowering.rb

@@ -139,7 +139,7 @@ module MilkTea
         next if analysis.module_kind == :raw_module
         next if modules.key?(analysis.module_name)
 
-        prepare_analysis(analysis, source_path: path)
+        prepare_analysis(analysis, path: path)
         collect_structs
 
         synth_before_s = @artifacts.synthetic_structs.length
@@ -159,7 +159,7 @@ module MilkTea
           variants: lower_variants.dup,
           static_asserts: lower_static_asserts.dup,
           functions: [],
-          source_path: path,
+          path: path,
         )
         per_module_funcs[analysis.module_name].concat(lower_functions)
 
@@ -178,7 +178,7 @@ module MilkTea
         ordered_analysis_pairs.each do |path, analysis|
           next if analysis.module_kind == :raw_module
 
-          prepare_analysis(analysis, source_path: path)
+          prepare_analysis(analysis, path: path)
           ensure_events_for_analysis(analysis)
 
           synth_before_s = @artifacts.synthetic_structs.length
@@ -279,7 +279,7 @@ module MilkTea
         variants: all_variants,
         static_asserts: all_static_asserts,
         functions: all_functions,
-        source_path: @program.root_path,
+        path: @program.root_path,
       )
     end
 
@@ -287,7 +287,7 @@ module MilkTea
       ordered_analysis_pairs.each do |path, analysis|
         next if analysis.module_kind == :raw_module
 
-        prepare_analysis(analysis, source_path: path)
+        prepare_analysis(analysis, path: path)
         analysis.ast.declarations.grep(AST::EventDecl).each do |decl|
           event_type = analysis.values.fetch(decl.name).type
           ensure_event_runtime(event_type) if event_type.is_a?(Types::Event)
@@ -359,8 +359,6 @@ module MilkTea
       ordered
     end
 
-    private
-
     include LowererScans
     include LowererDeclarations
     include LowererEvents

data/lib/milk_tea/core/module_binder.rb

@@ -61,8 +61,6 @@ module MilkTea
       )
     end
 
-    private
-
     def exported_declaration?(analysis, declaration)
       return true if analysis.module_kind == :raw_module
       return false unless declaration.respond_to?(:visibility)

data/lib/milk_tea/core/module_loader/errors.rb

@@ -2,10 +2,12 @@
 
 module MilkTea
   class ModuleLoadError < StandardError
-    attr_reader :path
+    attr_reader :path, :line, :column
 
-    def initialize(message, path:)
+    def initialize(message, path:, line: nil, column: nil)
       @path = path
+      @line = line
+      @column = column
       super("#{message}: #{path}")
     end
 

data/lib/milk_tea/core/module_loader.rb

@@ -98,6 +98,7 @@ module MilkTea
       @collecting_analysis_cache = {}
       @collecting_path_errors = {}
       @checking_paths = []
+      @forward_bindings = {}
       @platform = self.class.normalize_platform_name(platform)
       @package_graph = package_graph
       @package_manifest_cache = {}
@@ -176,7 +177,59 @@ module MilkTea
       # Phase 3: Topological sort into independent levels
       levels = topo_sort_levels(graph)
 
-      # Phase 4: Check each level (parallel within level, sequential across levels)
+      # Pre-register forward bindings for cycle members
+      all_checked = levels.flatten.to_set
+      cycle_members = graph.keys.reject { |p| all_checked.include?(p) }
+      cycle_members.each do |resolved_path|
+        ast = @parse_cache[resolved_path]
+        @forward_bindings[resolved_path] = create_forward_binding(ast)
+      end
+
+      # Phase 4: Check cycle members with iterative refinement
+      # Pass 1: Check with forward bindings — registers type declarations.
+      # SemanticError is expected (forward types lack fields/constructors)
+      # but ModuleLoadError indicates a broken dependency graph.
+      cycle_members.each do |resolved_path|
+        check_path(resolved_path)
+      rescue SemanticError
+        # Forward types can't satisfy constructors. Pass 2 will retry.
+      end
+
+      # Update forward type objects in-place with field/arm info from the
+      # real analyses. This way, all references to forward types (function
+      # return types, struct field types, etc.) automatically see the full
+      # type information without needing to replace the objects themselves.
+      cycle_members.each do |resolved_path|
+        analysis = @analysis_cache[resolved_path]
+        next unless analysis
+
+        fw_binding = @forward_bindings[resolved_path]
+        next unless fw_binding
+
+        analysis.types.each do |name, real_type|
+          fw_type = fw_binding.types[name]
+          next unless fw_type
+
+          if real_type.respond_to?(:fields) && fw_type.respond_to?(:define_fields)
+            fw_type.define_fields(real_type.fields) unless real_type.fields.empty?
+          end
+          if real_type.respond_to?(:arms) && fw_type.respond_to?(:define_arms)
+            fw_type.define_arms(real_type.arms) unless real_type.arms.empty?
+          end
+        end
+      end
+
+      # Pass 2: Re-check with populated types — now cycle members see
+      # complete type information for each other.
+      cycle_members.each do |resolved_path|
+        previous = @analysis_cache.delete(resolved_path)
+        check_path(resolved_path)
+      rescue SemanticError
+        @analysis_cache[resolved_path] = previous if previous
+      end
+      @forward_bindings.clear
+
+      # Phase 5: Check acyclic modules (they see fully-checked analyses for all imports)
       levels.each do |level_paths|
         if level_paths.length == 1
           check_path(level_paths.first)
@@ -189,10 +242,6 @@ module MilkTea
     def parse_all(resolved_path)
       return if @parse_cache.key?(resolved_path)
 
-      if @checking_paths.include?(resolved_path)
-        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
-      end
-
       @checking_paths << resolved_path
       ast = load_file(resolved_path)
       @parse_cache[resolved_path] = ast
@@ -202,7 +251,7 @@ module MilkTea
         parse_all(import_path)
       end
     ensure
-      @checking_paths.pop if @checking_paths.last == resolved_path
+      @checking_paths.pop
     end
 
     def topo_sort_levels(graph)
@@ -252,8 +301,13 @@ module MilkTea
 
       ast.imports.each do |import|
         import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path:, importer_module_name: ast.module_name.to_s)
-        import_analysis = check_path(import_path)
-        modules[import.path.to_s] = @binder.module_binding(import_analysis)
+
+        if @forward_bindings.key?(import_path)
+          modules[import.path.to_s] = @forward_bindings[import_path]
+        else
+          import_analysis = check_path(import_path)
+          modules[import.path.to_s] = @binder.module_binding(import_analysis)
+        end
       end
 
       @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: false)
@@ -291,8 +345,13 @@ module MilkTea
       ast.imports.each do |import|
         begin
           import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path:, importer_module_name: ast.module_name.to_s)
-          import_analysis = check_path_collecting_errors(import_path)
-          modules[import.path.to_s] = @binder.module_binding(import_analysis)
+
+          if @forward_bindings.key?(import_path)
+            modules[import.path.to_s] = @forward_bindings[import_path]
+          else
+            import_analysis = check_path_collecting_errors(import_path)
+            modules[import.path.to_s] = @binder.module_binding(import_analysis)
+          end
         rescue ModuleLoadError, PackageLockError, SemanticError => e
           errors << ImportResolutionError.new(import:, error: e)
         end
@@ -321,8 +380,6 @@ module MilkTea
       @collecting_path_errors
     end
 
-    private
-
     def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
       if error_class == ModuleLoadError
         raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
@@ -331,12 +388,16 @@ module MilkTea
       message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
       raise(error_class || ArgumentError, message)
     end
-    private_class_method :raise_platform_conflict!
 
     def check_path(path)
       resolved_path, ast, cached = check_module_cache(path)
       return cached if cached
 
+      if @checking_paths.include?(resolved_path) && !@forward_bindings.key?(resolved_path)
+        raise ModuleLoadError.new("circular import not resolvable: module #{@parse_cache[resolved_path]&.module_name || File.basename(path)}", path: resolved_path)
+      end
+
+      @checking_paths << resolved_path
       imported_modules = imported_modules_for_ast(ast, importer_path: resolved_path)
       global_index = build_global_import_index(ast)
       analysis = SemanticAnalyzer.check(ast, imported_modules:, path: resolved_path, global_import_index: global_index)
@@ -344,13 +405,18 @@ module MilkTea
       update_shared_cache(resolved_path, analysis)
       analysis
     ensure
-      @checking_paths.pop if @checking_paths.last == resolved_path
+      @checking_paths.pop
     end
 
     def check_path_collecting_errors(path)
       resolved_path, ast, cached = check_module_cache(path, extra_cache: @collecting_analysis_cache)
       return cached if cached
 
+      if @checking_paths.include?(resolved_path) && !@forward_bindings.key?(resolved_path)
+        raise ModuleLoadError.new("circular import not resolvable: module #{@parse_cache[resolved_path]&.module_name || File.basename(path)}", path: resolved_path)
+      end
+
+      @checking_paths << resolved_path
       imported_modules = imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path).modules
       result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules:, path: resolved_path)
       analysis = result[:analysis]
@@ -360,7 +426,7 @@ module MilkTea
       @collecting_analysis_cache[resolved_path] = analysis
       analysis
     ensure
-      @checking_paths.pop if @checking_paths.last == resolved_path
+      @checking_paths.pop
     end
 
     def check_module_cache(path, extra_cache: nil)
@@ -380,9 +446,6 @@ module MilkTea
         end
       end
 
-      raise ModuleLoadError.new("cyclic import detected", path: resolved_path) if @checking_paths.include?(resolved_path)
-
-      @checking_paths << resolved_path
       ast = load_file(resolved_path)
       [resolved_path, ast, nil]
     end
@@ -433,8 +496,8 @@ module MilkTea
       end
 
       matching_root = @module_roots
-                      .select { |root| path_within_root?(path, root) }
-                      .max_by(&:length)
+        .select { |root| path_within_root?(path, root) }
+        .max_by(&:length)
       return module_name_for_path(path, matching_root) if matching_root
 
       File.basename(path).sub(/\.(linux|windows|wasm)\.mt\z/, ".mt").sub(/\.mt\z/, "")
@@ -453,6 +516,36 @@ module MilkTea
       normalized_path == normalized_root || normalized_path.start_with?(normalized_root + File::SEPARATOR)
     end
 
+    def create_forward_binding(ast)
+      module_name = ast.module_name.to_s
+      types = {}
+
+      ast.declarations.each do |decl|
+        case decl
+        when AST::StructDecl
+          types[decl.name] = Types::Struct.new(decl.name, module_name:)
+        when AST::VariantDecl
+          types[decl.name] = Types::Variant.new(decl.name, module_name:)
+        when AST::EnumDecl
+          types[decl.name] = Types::Enum.new(decl.name, module_name:)
+        when AST::FlagsDecl
+          types[decl.name] = Types::Flags.new(decl.name, module_name:)
+        when AST::OpaqueDecl
+          types[decl.name] = Types::Opaque.new(decl.name, module_name:, external: false)
+        end
+      end
+
+      ModuleBinding.new(
+        name: module_name, types:, type_declarations: {},
+        interfaces: {}, attributes: {}, attribute_applications: {},
+        values: {}, functions: {}, methods: {},
+        implemented_interfaces: {}, imports: {},
+        private_types: {}, private_interfaces: {}, private_attributes: {},
+        private_values: {}, private_functions: {}, private_methods: {},
+        private_implemented_interfaces: {},
+      )
+    end
+
     def use_shared_cache?
       @shared_cache && @source_overrides.empty?
     end

data/lib/milk_tea/core/module_path_resolver.rb

@@ -37,8 +37,6 @@ module MilkTea
       @source_overrides.key?(resolved_path) || File.file?(resolved_path)
     end
 
-    private
-
     def resolve_package_module_path(module_name, importer_path: nil)
       return nil unless @package_graph && importer_path
 

data/lib/milk_tea/core/module_roots.rb

@@ -2,9 +2,8 @@
 
 module MilkTea
   module ModuleRoots
-    module_function
 
-    def roots_for_path(path, env: ENV, locked: false)
+    def self.roots_for_path(path, env: ENV, locked: false)
       roots = []
 
       add_env_roots!(roots, env)
@@ -24,7 +23,7 @@ module MilkTea
            .select { |root| File.directory?(root) }
     end
 
-    def package_roots_for_path(path, locked: false)
+    def self.package_roots_for_path(path, locked: false)
       PackageGraph.load(path, locked:).source_roots
     rescue PackageManifestError
       package_root = package_root_for_path(path)
@@ -33,7 +32,7 @@ module MilkTea
       [package_root]
     end
 
-    def project_root_for_path(path)
+    def self.project_root_for_path(path)
       return nil unless path
 
       current = File.expand_path(File.directory?(path) ? path : File.dirname(path))
@@ -47,7 +46,7 @@ module MilkTea
       end
     end
 
-    def package_root_for_path(path)
+    def self.package_root_for_path(path)
       return nil unless path
 
       current = File.expand_path(File.directory?(path) ? path : File.dirname(path))
@@ -61,7 +60,7 @@ module MilkTea
       end
     end
 
-    def normalize_root(root)
+    def self.normalize_root(root)
       return nil if root.nil? || root.to_s.strip.empty?
 
       expanded = File.expand_path(root.to_s)
@@ -72,7 +71,7 @@ module MilkTea
       end
     end
 
-    def add_env_roots!(roots, env)
+    def self.add_env_roots!(roots, env)
       env_keys = %w[MILK_TEA_MODULE_ROOT MILK_TEA_STD_ROOT]
       env_keys.each do |key|
         value = env[key]
@@ -83,6 +82,5 @@ module MilkTea
         end
       end
     end
-    private_class_method :add_env_roots!
   end
 end

data/lib/milk_tea/core/parser/attributes.rb

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Attributes
-      private
-
       def parse_attribute_applications
         attributes = []
 

data/lib/milk_tea/core/parser/blocks.rb

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Blocks
-      private
-
       def parse_block
         consume(:colon, "expected ':' before block")
         consume(:newline, "expected newline before block")

data/lib/milk_tea/core/parser/declarations.rb

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Declarations
-      private
-
       def parse_import
         line = previous.line
         path = parse_qualified_name

data/lib/milk_tea/core/parser/expressions.rb

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Expressions
-      private
-
       def parse_expression
         return parse_if_expression if match(:if)
         return parse_match_expression if match(:match)
@@ -18,18 +16,36 @@ module MilkTea
         return expr unless match(:dot_dot)
 
         line = previous.line
-        column = expr.respond_to?(:column) ? expr.column : 0
+        column = expr.column || 0
         end_expr = parse_or
         AST::RangeExpr.new(start_expr: expr, end_expr:, line:, column:)
       end
 
       def parse_if_expression
         condition = parse_or
-        consume(:colon, "expected ':' after condition in if expression")
-        then_expression = parse_expression
-        consume(:else, "expected 'else' in if expression")
-        consume(:colon, "expected ':' after 'else' in if expression")
-        else_expression = parse_expression
+
+        if inline_block_body?
+          consume(:colon, "expected ':' after condition in if expression")
+          then_expression = parse_expression
+          consume(:else, "expected 'else' in if expression")
+          consume(:colon, "expected ':' after 'else' in if expression")
+          else_expression = parse_expression
+        else
+          consume(:colon, "expected ':' after condition in if expression")
+          consume(:newline, "expected newline after 'if condition:' in if expression")
+          consume(:indent, "expected indented body in if expression")
+          then_expression = parse_expression
+          consume_end_of_statement unless block_expression?(then_expression)
+          consume(:dedent, "expected end of if expression body")
+          consume(:else, "expected 'else' in if expression")
+          consume(:colon, "expected ':' after 'else' in if expression")
+          consume(:newline, "expected newline after 'else:' in if expression")
+          consume(:indent, "expected indented else body in if expression")
+          else_expression = parse_expression
+          consume_end_of_statement unless block_expression?(else_expression)
+          consume(:dedent, "expected end of else expression body")
+        end
+
         AST::IfExpr.new(condition:, then_expression:, else_expression:)
       end
 
@@ -526,24 +542,25 @@ module MilkTea
           )
         end
 
-        parser = self.class.send(:new, tokens, path: @path)
+        parser = self.class.new(tokens, path: @path)
         parser.instance_variable_set(:@known_type_names, @known_type_names.dup)
         parser.instance_variable_set(:@known_import_aliases, @known_import_aliases.dup)
         parser.instance_variable_set(:@known_generic_callable_names, @known_generic_callable_names.dup)
         parser.instance_variable_set(:@current_type_param_names, @current_type_param_names.dup)
 
-        expression = parser.send(:parse_expression)
-        parser.send(:skip_newlines)
-        raise parser.send(:error, parser.send(:peek), "expected end of interpolation") unless parser.send(:eof?)
+        expression = parser.parse_expression
+        parser.skip_newlines
+        raise parser.error(parser.peek, "expected end of interpolation") unless parser.eof?
 
         expression
       end
 
       def parse_left_associative(operand_method, *operator_types)
-        expression = send(operand_method)
+        operand = method(operand_method)
+        expression = operand.call
         while match(*operator_types)
           operator = previous.lexeme
-          right = send(operand_method)
+          right = operand.call
           expression = AST::BinaryOp.new(operator:, left: expression, right:)
         end
         expression

data/lib/milk_tea/core/parser/recovery.rb

@@ -8,8 +8,6 @@ module MilkTea
         opaque extending foreign async function event external static_assert link include compiler_flag
       ].freeze
 
-      private
-
       def synchronize_to_top_level_boundary
         seen_newline = false
 

data/lib/milk_tea/core/parser/statements.rb

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Statements
-      private
-
       def check_inline_stmt_start?
         return false unless check(:inline)
 

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

@@ -3,8 +3,6 @@
 module MilkTea
   module Parse
     module Types
-      private
-
       def parse_params(allow_variadic: false)
         parse_parameter_list(allow_variadic:) { parse_param }
       end
@@ -263,14 +261,14 @@ module MilkTea
           parts << consume_path_component("expected identifier after '.'").lexeme
         end
         type_arguments = if match(:lbracket)
-                           args = parse_comma_separated_until(:rbracket) do
-                             parse_type_ref
-                           end
-                           consume(:rbracket, "expected ']' after type arguments")
-                           args
-                         else
-                           []
-                         end
+          args = parse_comma_separated_until(:rbracket) do
+            parse_type_ref
+          end
+          consume(:rbracket, "expected ']' after type arguments")
+          args
+        else
+          []
+        end
         AST::QualifiedName.new(parts:, type_arguments:, line: first_token.line, column: first_token.column)
       end
     end

data/lib/milk_tea/core/parser.rb

@@ -92,8 +92,6 @@ module MilkTea
       @recovery_errors = previous_recovery_errors
     end
 
-    private
-
     BUILTIN_ATTRIBUTE_NAME_LEXEMES = %w[packed align].freeze
 
     def parse_source_file(errors: nil)
@@ -253,7 +251,7 @@ module MilkTea
     end
 
     def block_expression?(expression)
-      expression.is_a?(AST::ProcExpr) || expression.is_a?(AST::MatchExpr)
+      expression.is_a?(AST::ProcExpr) || expression.is_a?(AST::MatchExpr) || expression.is_a?(AST::IfExpr)
     end
 
     def parse_qualified_name