mt-lang 0.3.34 → 0.3.38

data/lib/milk_tea/core/semantic_analyzer/name_resolution.rb

@@ -101,11 +101,21 @@ module MilkTea
 
       def find_method_by_receiver_name(module_binding, receiver_type, name)
         module_binding.methods.each do |key, methods|
-          return methods[name] if key.is_a?(receiver_type.class) && key.name == receiver_type.name && methods.key?(name)
+          next unless key.is_a?(receiver_type.class)
+          next unless key.name == receiver_type.name
+          next unless same_type_module?(key, receiver_type)
+          return methods[name] if methods.key?(name)
         end
         nil
       end
 
+      def same_type_module?(type_a, type_b)
+        module_a = receiver_type_module_name(type_a)
+        module_b = receiver_type_module_name(type_b)
+        return true if module_a.nil? || module_b.nil?
+        module_a == module_b
+      end
+
     def reachable_module_binding_for_type(receiver_type)
       module_name = receiver_type_module_name(receiver_type)
       return nil unless module_name
@@ -709,7 +719,7 @@ module MilkTea
 
       def sized_layout_type?(type)
         case type
-        when Types::Primitive, Types::Struct, Types::StructInstance, Types::Union, Types::Enum, Types::Flags, Types::Variant, Types::Span, Types::StringView, Types::Task, Types::Event, Types::Subscription
+        when Types::Primitive, Types::Struct, Types::StructInstance, Types::Union, Types::Enum, Types::Flags, Types::Variant, Types::Tuple, Types::Span, Types::StringView, Types::Task, Types::Event, Types::Subscription
           true
         when Types::Nullable
           true

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

@@ -34,17 +34,17 @@ module MilkTea
                   end
                   record_local_completion_snapshot(end_line, 1_000_000, nested_scopes)
                 rescue SemanticError => e
-                  if @collecting_errors
-                    @structural_errors << e
-                    next
+                  if e.line.nil? && statement.line
+                    e = SemanticError.new(
+                      e.message,
+                      line: statement.line,
+                      column: source_column(statement),
+                      length: source_length(statement),
+                      path: @path,
+                    )
                   end
-
-                  raise e unless e.line.nil?
-
-                  stmt_line = statement.line
-                  raise e if stmt_line.nil?
-
-                  raise_sema_error(e.message, statement)
+                  @structural_errors << e
+                  next
                 end
               end
             end

data/lib/milk_tea/core/semantic_analyzer/top_level.rb

@@ -18,7 +18,8 @@ module MilkTea
                 collect_structural_error(e)
               end
             when AST::VarDecl
-              binding = @ctx.top_level_values.fetch(decl.name)
+              binding = @ctx.top_level_values[decl.name]
+              next unless binding
               if decl.value
                 validate_consuming_foreign_expression!(decl.value, scopes: [], root_allowed: false)
                 validate_hoistable_foreign_expression!(decl.value, scopes: [], root_hoistable: false)
@@ -39,7 +40,8 @@ module MilkTea
       end
 
       def check_expr_const(decl)
-        binding = @ctx.top_level_values.fetch(decl.name)
+        binding = @ctx.top_level_values[decl.name]
+        return unless binding
         validate_consuming_foreign_expression!(decl.value, scopes: [], root_allowed: false)
         validate_hoistable_foreign_expression!(decl.value, scopes: [], root_hoistable: false)
 
@@ -173,7 +175,7 @@ module MilkTea
 
           if (type_ref = type_ref_from_specialization(callee))
             specialized_type = resolve_type_ref(type_ref)
-            return if specialized_type.is_a?(Types::Struct) || result_type?(specialized_type)
+            return if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
           end
         end
 
@@ -270,9 +272,7 @@ module MilkTea
       def evaluate_compile_time_block(statements, scopes: nil)
         ctx = CompileTime::BlockContext.new(self)
         result = ctx.evaluate_block(statements, scopes:)
-        result
-      rescue CompileTime::ReturnValue => e
-        e.value
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end
@@ -558,9 +558,8 @@ module MilkTea
         end
 
         ctx = CompileTime::BlockContext.new(self, initial_variables: initial_vars)
-        ctx.evaluate_block(func.ast.body, scopes: nil)
-      rescue CompileTime::ReturnValue => e
-        e.value
+        result = ctx.evaluate_block(func.ast.body, scopes: nil)
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end
@@ -589,9 +588,8 @@ module MilkTea
         end
 
         ctx = CompileTime::BlockContext.new(self, initial_variables: initial_vars)
-        ctx.evaluate_block(func.ast.body, scopes: nil)
-      rescue CompileTime::ReturnValue => e
-        e.value
+        result = ctx.evaluate_block(func.ast.body, scopes: nil)
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end

data/lib/milk_tea/core/semantic_analyzer/type_declaration.rb

@@ -293,9 +293,15 @@ module MilkTea
 
             constraints = resolve_type_param_constraints(decl.type_params)
             if decl.is_a?(AST::InterfaceDecl)
-              @ctx.interfaces[decl.name] = @ctx.interfaces.fetch(decl.name).with(type_param_constraints: constraints)
+              interface_binding = @ctx.interfaces[decl.name]
+              next unless interface_binding
+
+              @ctx.interfaces[decl.name] = interface_binding.with(type_param_constraints: constraints)
             else
-              @ctx.types.fetch(decl.name).define_type_param_constraints(constraints)
+              type_binding = @ctx.types[decl.name]
+              next unless type_binding
+
+              type_binding.define_type_param_constraints(constraints)
             end
           end
         end
@@ -455,7 +461,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::StructDecl) || decl.is_a?(AST::UnionDecl)
 
-            struct_type = @ctx.types.fetch(decl.name)
+            struct_type = @ctx.types[decl.name]
+            next unless struct_type
             struct_type.ast_declaration = decl if struct_type.respond_to?(:ast_declaration=)
             type_params = if struct_type.is_a?(Types::GenericStructDefinition)
               seen = {}
@@ -581,7 +588,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::EnumDecl) || decl.is_a?(AST::FlagsDecl)
 
-            enum_type = @ctx.types.fetch(decl.name)
+            enum_type = @ctx.types[decl.name]
+            next unless enum_type
             backing_type = resolve_type_ref(decl.backing_type)
             unless backing_type.is_a?(Types::Primitive) && backing_type.integer?
               raise_sema_error("#{decl.name} backing type must be an integer primitive, got #{backing_type}")
@@ -641,7 +649,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::VariantDecl)
 
-            variant_type = @ctx.types.fetch(decl.name)
+            variant_type = @ctx.types[decl.name]
+            next unless variant_type
             type_params = if variant_type.is_a?(Types::GenericVariantDefinition)
               seen = {}
               variant_type.type_params.each_with_object({}) do |name, params|

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -187,31 +187,9 @@ module MilkTea
       end
 
       def check
-        @completed_phases = Set.new
-
-        run_phase(:install_builtin_types)
-        run_phase(:install_builtin_attributes)
-        run_phase(:install_imports)
-        run_phase(:install_prelude_types, requires: [:install_imports])
-        run_phase(:declare_named_types, requires: [:install_builtin_types, :install_imports, :install_prelude_types])
-        run_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
-        run_phase(:resolve_type_aliases, requires: [:declare_named_types])
-        run_phase(:declare_attributes)
-        run_phase(:predeclare_top_level_consts)
-        run_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
-        run_phase(:resolve_enum_members, requires: [:declare_named_types])
-        run_phase(:resolve_variant_arms, requires: [:declare_named_types])
-        run_phase(:collect_emit_declarations)
-        run_phase(:declare_top_level_values, requires: [:resolve_aggregate_fields, :resolve_type_aliases])
-        run_phase(:check_attribute_applications, requires: [:declare_attributes])
-        run_phase(:declare_functions, requires: [:resolve_aggregate_fields, :resolve_enum_members, :resolve_variant_arms])
-        run_phase(:check_interface_conformances, requires: [:declare_functions, :resolve_aggregate_fields])
-        run_phase(:check_top_level_values, requires: [:declare_top_level_values])
-        run_phase(:finalize_top_level_const_values, requires: [:check_top_level_values])
-        run_phase(:check_top_level_static_asserts, requires: [:finalize_top_level_const_values])
-        run_phase(:check_functions, requires: [:declare_functions, :resolve_aggregate_fields, :check_interface_conformances])
-
-        build_analysis
+        result = check_collecting_errors
+        raise result[:errors].first unless result[:errors].empty?
+        result[:analysis]
       end
 
       def run_phase(name, requires: [])
@@ -291,12 +269,11 @@ module MilkTea
         end
       end
 
-      # Like check, but collects per-function errors instead of raising at first.
-      # Structural phases (imports, type resolution, declaration) collect errors per
-      # declaration so that the maximum number of diagnostics are surfaced.
+      # Runs all sema phases and collects every error instead of stopping at
+      # the first one.  Structural phases collect per-declaration, and
+      # function-body phases collect per function/method.
       # Returns { analysis: Analysis, errors: [SemanticError] }.
       def check_collecting_errors
-        @collecting_errors = true
         @structural_errors = []
         @completed_phases = Set.new
 
@@ -353,8 +330,6 @@ module MilkTea
       end
 
       def collect_structural_error(error)
-        raise error unless @collecting_errors
-
         @structural_errors << error
       end
     end

data/lib/milk_tea/lsp/server/code_actions.rb

@@ -404,6 +404,12 @@ module MilkTea
         end
 
         def handle_workspace_diagnostic(params)
+          progress = nil
+          if (work_done_token = params['workDoneToken'])
+            progress = create_progress_handle(@protocol, work_done_token)
+            progress.report(percentage: 0, message: 'Collecting workspace diagnostics...')
+          end
+
           previous_ids = params['previousResultIds'] || []
           prev_map = previous_ids.each_with_object({}) do |entry, h|
             h[entry['uri']] = entry['value'] if entry.is_a?(Hash) && entry['uri']
@@ -420,15 +426,19 @@ module MilkTea
 
             cached = @workspace_diagnostic_cache[uri]
             if cached && cached[:result_id] == prev_map[uri] && cached[:fingerprint] == fingerprint
-              { uri: uri, kind: 'unchanged', resultId: result_id, items: [] }
+              { uri: uri, kind: 'unchanged', resultId: result_id, items: [], version: nil }
             else
               @workspace_diagnostic_cache[uri] = { result_id: result_id, fingerprint: fingerprint }
-              { uri: uri, kind: 'full', resultId: result_id, items: diagnostics }
+              { uri: uri, kind: 'full', resultId: result_id, items: diagnostics, version: nil }
             end
           end
 
+          progress&.report(percentage: 100, message: "#{items.length} document#{items.length == 1 ? '' : 's'} checked")
+          progress&.done(message: 'Workspace diagnostics ready')
+
           { items: items }
         rescue StandardError => e
+          progress&.done(message: 'Workspace diagnostics failed')
           warn "Error in workspace/diagnostic handler: #{e.message}"
           { items: [] }
         end

data/lib/milk_tea/lsp/server/formatting.rb

@@ -16,7 +16,8 @@ module MilkTea
           # Enrich with hierarchical children from AST
           ast = @workspace.get_ast(uri)
           if ast && result
-            enrich_with_children(result, ast)
+            facts = @workspace.get_facts(uri)
+            enrich_with_children(result, ast, facts)
           end
 
           module_name = resolve_outline_module_name(uri)
@@ -74,17 +75,42 @@ module MilkTea
           children
         end
 
-        def enrich_with_children(symbols, ast)
+        def enrich_with_children(symbols, ast, facts)
           removed_local_names = []
           removed_method_names = []
           removed_nested_type_names = []
           removed_event_names = []
           name_index = symbols.each_with_object(Hash.new { |h, k| h[k] = [] }) { |s, h| h[s[:name]] << s }
 
-          ast.declarations&.each do |decl|
+          flatten_module_declarations(ast.declarations).each do |decl|
             removed_nested_type_names.concat(collect_nested_type_names(decl)) if decl.is_a?(AST::StructDecl)
 
             case decl
+            when AST::VarDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              detail = decl.type ? type_detail_string(decl.type) : nil
+              detail ||= resolved_local_type_detail(decl, facts)
+              parent[:detail] = detail if detail
+
+            when AST::TypeAliasDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              if (detail = type_detail_string(decl.target))
+                parent[:detail] = "= #{detail}"
+              end
+
+            when AST::ExternFunctionDecl, AST::ForeignFunctionDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              detail_parts = []
+              detail_parts << 'async' if decl.respond_to?(:async) && decl.async
+              detail_parts << "-> #{type_detail_string(decl.return_type) || 'void'}"
+              parent[:detail] = detail_parts.join(' ')
+
             when AST::EventDecl
               parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
               next unless parent
@@ -100,26 +126,11 @@ module MilkTea
               detail_parts = []
               detail_parts << 'const' if decl.respond_to?(:const) && decl.const
               detail_parts << 'async' if decl.respond_to?(:async) && decl.async
-              if (ret = type_detail_string(decl.return_type))
-                detail_parts << "-> #{ret}"
-              end
-              parent[:detail] = detail_parts.join(' ') unless detail_parts.empty?
+              detail_parts << "-> #{type_detail_string(decl.return_type) || 'void'}"
+              parent[:detail] = detail_parts.join(' ')
 
               locals = collect_local_decls(decl.body)
-              next unless locals&.any?
-
-              parent[:children] ||= []
-              parent_children = parent[:children]
-              locals.each do |local|
-                next unless local.name
-
-                child = local_decl_symbol(local)
-                next unless child
-
-                parent_children << child unless parent_children.any? { |pc| pc[:name] == child[:name] }
-                removed_local_names << local.name
-                removed_local_names.concat(descendant_names(child))
-              end
+              append_local_children(parent, locals, facts, removed_local_names)
             when AST::ExtendingBlock
               type_name_str = decl.type_name.name.parts.join('.')
 
@@ -153,20 +164,7 @@ module MilkTea
                 removed_method_names << child[:name] if child[:kind] == 6
 
                 locals = collect_local_decls(method.respond_to?(:body) ? method.body : nil)
-                next unless locals&.any?
-
-                child[:children] ||= []
-                child_children = child[:children]
-                locals.each do |local|
-                  next unless local.name
-
-                  local_child = local_decl_symbol(local)
-                  next unless local_child
-
-                  child_children << local_child unless child_children.any? { |pc| pc[:name] == local_child[:name] }
-                  removed_local_names << local.name
-                  removed_local_names.concat(descendant_names(local_child))
-                end
+                append_local_children(child, locals, facts, removed_local_names)
               end
             when AST::ConstDecl
               parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
@@ -179,25 +177,13 @@ module MilkTea
               next unless decl.block_body
 
               locals = collect_local_decls(decl.block_body)
-              next unless locals&.any?
-
-              parent[:children] ||= []
-              parent_children = parent[:children]
-              locals.each do |local|
-                next unless local.name
-
-                child = local_decl_symbol(local)
-                next unless child
-
-                parent_children << child unless parent_children.any? { |pc| pc[:name] == child[:name] }
-                removed_local_names << local.name
-                removed_local_names.concat(descendant_names(child))
-              end
+              append_local_children(parent, locals, facts, removed_local_names)
             else
               parent_name = child_parent_name(decl)
               parent = parent_name ? name_index[parent_name]&.find { |s| symbol_line(s) == (decl.line || 0) } : nil
               next unless parent
 
+              detail_parts = []
               if decl.is_a?(AST::StructDecl) && decl.implements&.any?
                 ifaces = decl.implements.map { |i|
                   base = i.respond_to?(:parts) ? i.parts.join('.') : i.name.parts.join('.')
@@ -210,9 +196,19 @@ module MilkTea
                         end
                   "#{base}#{args}"
                 }.join(', ')
-                parent[:detail] = "(#{ifaces})"
+                detail_parts << "(#{ifaces})"
+              end
+
+              if decl.respond_to?(:backing_type) && decl.backing_type && (bt = type_detail_string(decl.backing_type))
+                detail_parts << ": #{bt}"
+              end
+
+              if (generic = generic_signature_detail(decl))
+                detail_parts << generic
               end
 
+              parent[:detail] = detail_parts.join(' ') unless detail_parts.empty?
+
               type_params = expand_generic_type_params(decl)
               if type_params&.any?
                 parent[:children] ||= []
@@ -374,14 +370,78 @@ module MilkTea
           line = (a.line) ? a.line : default_line
           return nil unless a.respond_to?(:name) && a.name && line
           col = a.column ? a.column : 1
+
+          detail = nil
+          if a.respond_to?(:fields) && a.fields&.any?
+            fields = a.fields.map { |f| "#{f.name}: #{type_detail_string(f.type)}" }.join(', ')
+            detail = "(#{fields})"
+          end
+
           {
             name: a.name, kind: 22,
+            detail: detail,
             range: { start: { line: line - 1, character: 0 }, end: { line: line, character: 0 } },
             selectionRange: {
               start: { line: line - 1, character: col - 1 },
               end: { line: line - 1, character: col - 1 + a.name.length },
             },
-          }
+          }.compact
+        end
+
+        # Renders the generic parameter clause of a type declaration, e.g.
+        # `[A, B]` for `struct Pair[A, B]` or `[@a]` for `struct Buffer[@a]`.
+        def generic_signature_detail(decl)
+          parts = []
+          if decl.respond_to?(:lifetime_params) && decl.lifetime_params&.any?
+            parts.concat(decl.lifetime_params.map(&:to_s))
+          end
+          if decl.respond_to?(:type_params) && decl.type_params&.any?
+            parts.concat(decl.type_params.map { |tp| tp.respond_to?(:name) ? tp.name : tp.to_s })
+          end
+          parts.empty? ? nil : "[#{parts.join(', ')}]"
+        end
+
+        # Module-level `when` branches are compile-time conditionals; the token
+        # symbol scan lists their declarations, so flatten the branch bodies so
+        # the enrichment below can type them like ordinary top-level decls.
+        def flatten_module_declarations(declarations)
+          (declarations || []).flat_map do |decl|
+            if decl.is_a?(AST::WhenStmt)
+              (decl.branches || []).flat_map { |b| flatten_module_declarations(b.body) } +
+                flatten_module_declarations(decl.else_body)
+            else
+              [decl]
+            end
+          end
+        end
+
+        # Adds local declaration children to an outline symbol. Destructure
+        # locals (`let Vec2(x, y) = ...`) introduce a spurious flat variable
+        # symbol named after the destructure type; that symbol is collected for
+        # removal instead of being shown as a typed child.
+        def append_local_children(container, locals, facts, removed_local_names)
+          return unless locals&.any?
+
+          container[:children] ||= []
+          children = container[:children]
+          locals.each do |local|
+            if local.respond_to?(:destructure_bindings) && local.destructure_bindings
+              type_name = local.destructure_type_name
+              if type_name
+                name = type_name.is_a?(Array) ? type_name.join('.') : type_name.to_s
+                removed_local_names << name unless removed_local_names.include?(name)
+              end
+              next
+            end
+            next unless local.name
+
+            child = local_decl_symbol(local, facts:)
+            next unless child
+
+            children << child unless children.any? { |pc| pc[:name] == child[:name] }
+            removed_local_names << local.name
+            removed_local_names.concat(descendant_names(child))
+          end
         end
 
         def collect_local_decls(body)
@@ -417,7 +477,7 @@ module MilkTea
           end
         end
 
-        def local_decl_symbol(decl)
+        def local_decl_symbol(decl, facts: nil)
           return nil unless decl.name
           return nil if decl.name == '_'
 
@@ -429,8 +489,9 @@ module MilkTea
           if decl.respond_to?(:value) && decl.value.is_a?(AST::ProcExpr)
             detail ||= proc_signature_detail(decl.value)
             proc_locals = collect_local_decls(decl.value.body)
-            children = proc_locals.filter_map { |l| local_decl_symbol(l) }
+            children = proc_locals.filter_map { |l| local_decl_symbol(l, facts:) }
           end
+          detail ||= resolved_local_type_detail(decl, facts)
 
           {
             name: decl.name, kind: 13,
@@ -441,6 +502,60 @@ module MilkTea
           }.compact
         end
 
+        # Resolves the declared type of an inferred local from semantic facts.
+        # Prefers the sema binding type (which reflects let/var ... else: and
+        # other flow refinement), falling back to the initializer expression
+        # type recorded during checking. Returns nil when facts are unavailable
+        # or the binding is missing.
+        def resolved_local_type_detail(decl, facts)
+          return nil unless facts
+          return nil unless facts.respond_to?(:binding_resolution) && facts.binding_resolution
+
+          binding_id = facts.binding_resolution.declaration_binding_ids[decl.object_id]
+          if binding_id
+            type = facts.binding_resolution.binding_types[binding_id]
+            return nil if type.is_a?(Types::Error)
+            return short_type_detail(type) if type
+          end
+
+          return nil unless decl.respond_to?(:value) && decl.value
+          return nil unless facts.respond_to?(:resolved_expr_types)
+
+          node_id = facts.respond_to?(:ast) && facts.ast ? facts.ast.node_ids[decl.value.object_id] : nil
+          return nil unless node_id
+
+          type = facts.resolved_expr_types[node_id]
+          return nil if type.is_a?(Types::Error)
+
+          short_type_detail(type)
+        end
+
+        # Renders a resolved semantic type for outline display without module
+        # qualifiers (e.g. std.deque.Deque[int] as Deque[int]). Falls back to
+        # the canonical #to_s when a type has no usable short form.
+        def short_type_detail(type)
+          return nil unless type
+
+          case type
+          when Types::Nullable
+            "#{short_type_detail(type.base)}?"
+          when Types::Span
+            "span[#{short_type_detail(type.element_type)}]"
+          when Types::SoA
+            "SoA[#{short_type_detail(type.element_type)}, #{type.count}]"
+          when Types::StructInstance, Types::VariantInstance, Types::GenericInstance
+            args = type.arguments.map { |arg| short_type_arg(arg) }.join(', ')
+            args.empty? ? type.name : "#{type.name}[#{args}]"
+          else
+            name = type.respond_to?(:name) ? type.name.to_s : ''
+            name.empty? ? type.to_s : name
+          end
+        end
+
+        def short_type_arg(arg)
+          arg.is_a?(Types::LiteralTypeArg) ? arg.value.to_s : short_type_detail(arg)
+        end
+
         def descendant_names(symbol)
           return [] unless symbol[:children]
 
@@ -487,9 +602,7 @@ module MilkTea
           detail_parts << 'mut' if m.respond_to?(:kind) && m.kind == :editable_function
           detail_parts << 'static' if m.respond_to?(:kind) && m.kind == :static_function
           detail_parts << 'async' if m.respond_to?(:async) && m.async
-          if (ret = type_detail_string(m.return_type))
-            detail_parts << "-> #{ret}"
-          end
+          detail_parts << "-> #{type_detail_string(m.return_type) || 'void'}"
           {
             name: m.name, kind: 6,
             range: { start: { line: m.line - 1, character: 0 }, end: { line: (m.respond_to?(:end_line) && m.end_line ? m.end_line : m.line), character: 0 } },
@@ -507,10 +620,11 @@ module MilkTea
           case type
           when AST::TypeRef
             type.to_s
-          when AST::ProcType
+          when AST::FunctionType, AST::ProcType
             params = (type.params || []).map { |p| type_detail_string(p.type) }.join(', ')
             ret = type_detail_string(type.return_type) || 'void'
-            "proc(#{params}) -> #{ret}"
+            keyword = type.is_a?(AST::FunctionType) ? 'fn' : 'proc'
+            "#{keyword}(#{params}) -> #{ret}"
           when AST::TupleType
             base = "(#{(type.element_types || []).map { |t| type_detail_string(t) }.join(', ')})"
             type.nullable ? "#{base}?" : base