mt-lang 0.3.20 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83f7a9e4ec79d81bd7d2e64ebb469871fecb5e4b3f888c932061d5fa265b7544
-  data.tar.gz: c08d508785143d338a6a47adfcedcf605b30e8e9990913a44178344643944178
+  metadata.gz: 7cfa07273d22ec7c182da079791513e546752f942e99e85d4ae68c3596a1dd96
+  data.tar.gz: 8ca9fb2fa55d9f2a7e9db9dd1f6935a0a82c8ad0f87f907b865007d5a27b68db
 SHA512:
-  metadata.gz: 95818de5161127d240aacd92b2f8a727e29d1962c11bd9161faa0f0286ac701d2b328352d7ac51bdab23ed2b76a8ccaa7e698490c4bbe5b99edb9452de76cbac
-  data.tar.gz: 0d188ebbabd4f175a201ea61c7cde3393a93b9deed991fbb639935b125e565b3b679f16c0fb72c4f96939475d8b6a199362e66920d65e49dd60e6dbc248df372
+  metadata.gz: 0f8b9f5966a1bb53bfcf618293fdff445031610f97c316db745db6a06e3e32c50206fde9776b57ef205baab5c1ee240b11e0c003f9bed72d14f6f256d767b6d6
+  data.tar.gz: 50bd110c31a30966d1a25560c14e239ffee4f99e4991efd6a3029bb4dd6a05cea2d65c58e35dda94b917ec25ba1d7750e8d7e2d4578d1862b926dadfb4ab8f4b

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/control_flow/builder.rb

@@ -413,7 +413,8 @@ module MilkTea
           read_identifiers(expression.expression, names, reads_info)
           expression.arms.each do |arm|
             read_identifiers(arm.pattern, names, reads_info)
-            read_identifiers(arm.value, names, reads_info)
+            arm_value = arm.is_a?(AST::MatchExprArm) ? arm.value : arm.body
+            read_identifiers(arm_value, names, reads_info)
           end
         when AST::MatchStmt
           read_identifiers(expression.expression, names, reads_info)

data/lib/milk_tea/core/lowering/resolve.rb

@@ -1506,7 +1506,7 @@ module MilkTea
       case argument
       when AST::TypeRef
         resolve_type_argument_ref(argument, type_params:)
-      when AST::FunctionType, AST::ProcType
+      when AST::FunctionType, AST::ProcType, AST::TupleType
         resolve_type_ref(argument, type_params:)
       when AST::IntegerLiteral, AST::FloatLiteral
         Types::LiteralTypeArg.new(argument.value)

data/lib/milk_tea/core/module_binder.rb

@@ -20,19 +20,24 @@ module MilkTea
         when AST::StructDecl, AST::UnionDecl, AST::VariantDecl, AST::EnumDecl, AST::FlagsDecl, AST::OpaqueDecl, AST::TypeAliasDecl
           type_declarations[declaration.name] = declaration
           target = exported_declaration?(analysis, declaration) ? types : private_types
-          target[declaration.name] = analysis.types.fetch(declaration.name)
+          resolved_type = analysis.types[declaration.name]
+          target[declaration.name] = resolved_type if resolved_type
         when AST::InterfaceDecl
           target = exported_declaration?(analysis, declaration) ? interfaces : private_interfaces
-          target[declaration.name] = analysis.interfaces.fetch(declaration.name)
+          resolved_iface = analysis.interfaces[declaration.name]
+          target[declaration.name] = resolved_iface if resolved_iface
         when AST::AttributeDecl
           target = exported_declaration?(analysis, declaration) ? attributes : private_attributes
-          target[declaration.name] = analysis.attributes.fetch(declaration.name)
+          resolved_attr = analysis.attributes[declaration.name]
+          target[declaration.name] = resolved_attr if resolved_attr
         when AST::ConstDecl, AST::VarDecl, AST::EventDecl
           target = exported_declaration?(analysis, declaration) ? values : private_values
-          target[declaration.name] = analysis.values.fetch(declaration.name)
+          resolved_val = analysis.values[declaration.name]
+          target[declaration.name] = resolved_val if resolved_val
         when AST::FunctionDef, AST::ExternFunctionDecl, AST::ForeignFunctionDecl
           target = exported_declaration?(analysis, declaration) ? functions : private_functions
-          target[declaration.name] = analysis.functions.fetch(declaration.name)
+          resolved_func = analysis.functions[declaration.name]
+          target[declaration.name] = resolved_func if resolved_func
         end
       end
 

data/lib/milk_tea/core/module_loader.rb

@@ -154,15 +154,37 @@ module MilkTea
       check_program(path).root_analysis
     end
 
-    def check_program(path)
+    def with_check_context(path, &block)
       Types::Registry.reset!
       requested_path = File.expand_path(path)
       previous_platform = @platform
       @platform ||= self.class.platform_suffix_for_path(requested_path)
       root_path = self.class.resolve_source_path(requested_path, platform: @platform, error_class: ModuleLoadError)
+      block.call(root_path)
+    ensure
+      @platform = previous_platform
+    end
 
-      check_program_parallel(root_path)
+    def check_program(path)
+      with_check_context(path) do |root_path|
+        check_program_parallel(root_path)
+        build_program(root_path)
+      end
+    end
 
+    # Variant of #check_program that collects errors instead of raising so
+    # diagnostic paths (check, debug, LSP) can report all issues at once.
+    # Returns { root_analysis: Analysis|nil, errors: [SemanticError], module_name: String|nil }.
+    def check_program_collecting(path)
+      with_check_context(path) do |root_path|
+        errors = []
+        check_program_parallel(root_path, collecting_errors: errors)
+        root_analysis = @analysis_cache[root_path]
+        { root_analysis: root_analysis, errors: errors, module_name: root_analysis&.module_name }
+      end
+    end
+
+    def build_program(root_path)
       root_analysis = @analysis_cache.fetch(root_path)
       analyses_by_module_name = @analysis_cache.each_value.each_with_object({}) do |analysis, modules|
         next unless analysis.module_name
@@ -176,11 +198,27 @@ module MilkTea
         analyses_by_path: @analysis_cache.dup.freeze,
         analyses_by_module_name: analyses_by_module_name.freeze,
       )
-    ensure
-      @platform = previous_platform
     end
 
-    def check_program_parallel(root_path)
+    def node_in_cycle?(node, graph)
+      # Start from each immediate successor to avoid the trivial self-path
+      successors = graph[node] || []
+      successors.each do |next_node|
+        next unless graph.key?(next_node)
+        return true if dfs_reachable_from(next_node, node, graph, {})
+      end
+      false
+    end
+
+    def dfs_reachable_from(current, target, graph, visited)
+      return false if visited[current]
+      return true if current == target
+
+      visited[current] = true
+      (graph[current] || []).any? { |neighbor| dfs_reachable_from(neighbor, target, graph, visited) }
+    end
+
+    def check_program_parallel(root_path, collecting_errors: nil)
       # Phase 1: Parse all transitive modules (sequential)
       parse_all(root_path)
 
@@ -194,12 +232,24 @@ module MilkTea
         graph[resolved_path] = deps
       end
 
-      # Phase 3: Topological sort into independent levels
+      # Phase 3: Topological sort into independent levels.
+      # Nodes that cannot be sorted are candidates for cycle membership,
+      # but not all of them are actually part of a cycle — some are just
+      # dependencies downstream from the cycle. We separate true cycle
+      # members (nodes reachable from themselves) from tail nodes.
       levels = topo_sort_levels(graph)
 
-      # Pre-register forward bindings for cycle members
       all_checked = levels.flatten.to_set
-      cycle_members = graph.keys.reject { |p| all_checked.include?(p) }
+      unsorted = graph.keys.reject { |p| all_checked.include?(p) }
+
+      # Among unsorted nodes, identify true cycle members: nodes that can
+      # reach themselves through the graph (belong to a strongly connected
+      # component of size > 1). Tail nodes that only depend on cycle members
+      # but have no path back to themselves are NOT cycle members.
+      cycle_members = unsorted.select { |node| node_in_cycle?(node, graph) }
+      tail_members = unsorted - cycle_members
+
+      # Pre-register forward bindings only for true cycle members
       cycle_members.each do |resolved_path|
         ast = @parse_cache[resolved_path]
         @forward_bindings[resolved_path] = create_forward_binding(ast)
@@ -209,10 +259,14 @@ module MilkTea
       # Pass 1: Check with forward bindings — registers type declarations.
       # SemanticError is expected (forward types lack fields/constructors)
       # but ModuleLoadError indicates a broken dependency graph.
+      # Do NOT collect Pass 1 errors — they are temporary failures caused
+      # by incomplete forward bindings that Pass 2 resolves.
       cycle_members.each do |resolved_path|
         check_path(resolved_path)
       rescue SemanticError
-        # Forward types can't satisfy constructors. Pass 2 will retry.
+        # Forward types can't satisfy constructors / functions / methods.
+        # Re-check in collecting mode to capture the analysis for population.
+        capture_analysis_for_cycle_member(resolved_path)
       end
 
       # Update forward type objects in-place with field/arm info from the
@@ -236,26 +290,45 @@ module MilkTea
           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
+          if real_type.respond_to?(:members) && fw_type.respond_to?(:define_members)
+            member_names = real_type.members
+            unless member_names.empty?
+              fw_type.define_members(real_type.backing_type, member_names)
+              values = member_names.each_with_object({}) { |n, h| h[n] = real_type.member_value(n) }
+              fw_type.define_member_values(values)
+            end
+          end
         end
       end
 
-      # Pass 2: Re-check with populated types — now cycle members see
-      # complete type information for each other.
+      # Replace forward bindings with fully populated bindings so that
+      # Pass 2 import resolution sees functions, methods, values, and
+      # interfaces — not just type skeletons.
+      populate_full_forward_bindings(cycle_members)
+
+      # Pass 2: Re-check with populated bindings — now cycle members see
+      # complete module information for each other.
       cycle_members.each do |resolved_path|
         previous = @analysis_cache.delete(resolved_path)
         check_path(resolved_path)
-      rescue SemanticError
+      rescue SemanticError => e
         @analysis_cache[resolved_path] = previous if previous
+        collecting_errors << e if collecting_errors
       end
       @forward_bindings.clear
 
-      # Phase 5: Check acyclic modules (they see fully-checked analyses for all imports)
-      levels.each do |level_paths|
+      # Phase 5: Check acyclic modules (they see fully-checked analyses for all imports).
+      # Also check tail members — nodes that were in the unsorted set but
+      # are not themselves part of a cycle; they just depended on cycle members.
+      (levels + [tail_members]).each do |level_paths|
         if level_paths.length == 1
           check_path(level_paths.first)
-        else
+        elsif level_paths.any?
           check_level_parallel(level_paths)
         end
+      rescue SemanticError => e
+        raise unless collecting_errors
+        collecting_errors << e
       end
     end
 
@@ -328,6 +401,15 @@ module MilkTea
       modules = {}
       errors = []
 
+      if @import_resolve_depth
+        @import_resolve_depth += 1
+        if @import_resolve_depth > 80
+          raise SemanticError.new("import resolution depth exceeded")
+        end
+      else
+        @import_resolve_depth = 1
+      end
+
       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)
@@ -340,7 +422,8 @@ module MilkTea
           end
         rescue ModuleLoadError, PackageLockError, SemanticError => e
           raise unless collecting
-          errors << ImportResolutionError.new(import:, error: e)
+
+          handle_circular_import_in_collecting_mode(import, import_path, modules, errors, e)
         end
       end
 
@@ -361,6 +444,8 @@ module MilkTea
       return ImportResolution.new(modules: modules.freeze, errors: errors.freeze) if collecting
 
       modules.freeze
+    ensure
+      @import_resolve_depth -= 1 if @import_resolve_depth
     end
 
     def build_global_import_index(ast)
@@ -521,6 +606,74 @@ module MilkTea
       normalized_path == normalized_root || normalized_path.start_with?(normalized_root + File::SEPARATOR)
     end
 
+    def handle_circular_import_in_collecting_mode(import, import_path, modules, errors, error)
+      # When a circular import is detected in collecting mode, create a
+      # forward binding for the target module so the importing module can
+      # at minimum resolve type references. Without this the import is
+      # entirely absent, which causes downstream crashes in module_binding.
+      if import_path && error.is_a?(ModuleLoadError) && error.message.start_with?("circular import")
+        circular_ast = @parse_cache[import_path] || load_file(import_path)
+        if circular_ast
+          @forward_bindings[import_path] ||= create_forward_binding(circular_ast)
+          modules[import.path.to_s] = @forward_bindings[import_path]
+        end
+      end
+
+      errors << ImportResolutionError.new(import:, error:)
+    end
+
+    def capture_analysis_for_cycle_member(resolved_path)
+      return if @analysis_cache[resolved_path]
+
+      ast = @parse_cache[resolved_path]
+      return unless ast
+
+      @checking_paths << resolved_path
+      import_result = resolve_imports_for_ast(ast, importer_path: resolved_path, collecting: true)
+      result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules: import_result.modules, path: resolved_path)
+      @analysis_cache[resolved_path] = result[:analysis] if result[:analysis]
+    rescue StandardError
+      # Analysis capture is best-effort.
+    ensure
+      @checking_paths.pop
+    end
+
+    def populate_full_forward_bindings(cycle_members)
+      cycle_members.each do |resolved_path|
+        analysis = @analysis_cache[resolved_path]
+        next unless analysis
+
+        fw_binding = @forward_bindings[resolved_path]
+        next unless fw_binding
+
+        full_binding = @binder.module_binding(analysis)
+        merged_types = fw_binding.types.merge(
+          full_binding.types.reject { |name, _| fw_binding.types.key?(name) }
+        )
+
+        @forward_bindings[resolved_path] = ModuleBinding.new(
+          name: full_binding.name,
+          types: merged_types,
+          type_declarations: full_binding.type_declarations,
+          interfaces: full_binding.interfaces,
+          attributes: full_binding.attributes,
+          attribute_applications: full_binding.attribute_applications,
+          values: full_binding.values,
+          functions: full_binding.functions,
+          methods: full_binding.methods,
+          implemented_interfaces: full_binding.implemented_interfaces,
+          imports: full_binding.imports,
+          private_types: full_binding.private_types,
+          private_interfaces: full_binding.private_interfaces,
+          private_attributes: full_binding.private_attributes,
+          private_values: full_binding.private_values,
+          private_functions: full_binding.private_functions,
+          private_methods: full_binding.private_methods,
+          private_implemented_interfaces: full_binding.private_implemented_interfaces,
+        )
+      end
+    end
+
     def create_forward_binding(ast)
       module_name = ast.module_name.to_s
       types = {}
@@ -528,9 +681,13 @@ module MilkTea
       ast.declarations.each do |decl|
         case decl
         when AST::StructDecl
-          types[decl.name] = Types::Struct.new(decl.name, module_name:)
+          types[decl.name] = decl.type_params.empty? ?
+            Types::Struct.new(decl.name, module_name:) :
+            Types::GenericStructDefinition.new(decl.name, decl.type_params.map(&:name))
         when AST::VariantDecl
-          types[decl.name] = Types::Variant.new(decl.name, module_name:)
+          types[decl.name] = decl.type_params.empty? ?
+            Types::Variant.new(decl.name, module_name:) :
+            Types::GenericVariantDefinition.new(decl.name, decl.type_params.map(&:name))
         when AST::EnumDecl
           types[decl.name] = Types::Enum.new(decl.name, module_name:)
         when AST::FlagsDecl

data/lib/milk_tea/core/module_path_resolver.rb

@@ -16,19 +16,23 @@ module MilkTea
 
       relative_path = File.join(*module_name.split(".")) + ".mt"
       blocked = false
-      candidate = @module_roots.lazy.map { |root| ModuleLoader.resolve_source_path(File.join(root, relative_path), platform: @platform) }.find do |path|
-        next false unless source_path_available?(path)
+      candidate = nil
+      @module_roots.each do |root|
+        path = ModuleLoader.resolve_source_path(File.join(root, relative_path), platform: @platform)
+        next unless source_path_available?(path)
 
         allowed = import_allowed?(module_name, importer_path, path)
         blocked ||= !allowed
-        allowed
+        if allowed
+          candidate = path
+          break
+        end
       end
       raise ModuleLoadError.new("package dependency not declared", path: module_name) if blocked
       unless candidate
         message = namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:) || "module not found"
         raise ModuleLoadError.new(message, path: module_name)
       end
-
       File.expand_path(candidate)
     end
 
@@ -119,7 +123,7 @@ module MilkTea
       return @package_manifest_cache[manifest_path] if @package_manifest_cache.key?(manifest_path)
 
       @package_manifest_cache[manifest_path] = PackageManifest.load(path)
-      end
+    end
 
     def package_namespace_match?(module_name, package_name)
       module_name == package_name || module_name.start_with?("#{package_name}.")

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

@@ -640,7 +640,7 @@ module MilkTea
 
       def definite_type_argument?(value)
         case value
-        when AST::FunctionType
+        when AST::FunctionType, AST::TupleType
           true
         when AST::TypeRef
           known_type_like_name?(value.name.parts.first)

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

@@ -289,6 +289,31 @@ module MilkTea
         closest_dist <= max_distance ? closest : nil
       end
 
+      # Common std-library types that are usually used bare. When one of these
+      # names is unresolved, the compiler points at the module that exports it
+      # instead of leaving a generic "unknown name" diagnostic.
+      STD_TYPE_IMPORT_HINTS = {
+        "String" => "std.string",
+        "Vec" => "std.vec",
+        "Deque" => "std.deque",
+        "Map" => "std.map",
+        "Set" => "std.set",
+        "LinkedMap" => "std.linked_map",
+        "LinkedSet" => "std.linked_set",
+        "OrderedMap" => "std.ordered_map",
+        "OrderedSet" => "std.ordered_set",
+        "BinaryHeap" => "std.binary_heap",
+        "PriorityQueue" => "std.priority_queue",
+        "Counter" => "std.counter",
+      }.freeze
+
+      def import_hint_for_known_std_name(name)
+        module_path = STD_TYPE_IMPORT_HINTS[name.to_s]
+        return nil unless module_path
+
+        "type '#{name}' is available via 'import #{module_path}'"
+      end
+
       def levenshtein(s, t)
         m = s.length
         n = t.length

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

@@ -336,6 +336,9 @@ module MilkTea
           scoped_names = scopes.flat_map { |s| s.is_a?(Hash) ? s.keys : [] }.map(&:to_s)
           suggestion = suggest_name(expression.name, func_names + type_names + scoped_names)
         end
+        if (import_hint = import_hint_for_known_std_name(expression.name))
+          raise_sema_error("unknown name #{expression.name}; #{import_hint}")
+        end
         raise_sema_error("unknown name #{expression.name}", expression, suggestion: suggestion ? "did you mean '#{suggestion}'?" : nil)
       end
 
@@ -1505,6 +1508,9 @@ module MilkTea
               raise_sema_error("unsupported format spec #{part.format_spec.inspect}")
             end
           else
+            if string_builder_type?(value_type)
+              raise_sema_error("formatted string interpolation does not support #{value_type}; interpolate #{describe_expression(part.expression)}.as_str() instead, or append into it with .append_format(f\"...\")")
+            end
             next if format_string_interpolation_supported?(value_type, context: "formatted string interpolation of #{value_type}")
             raise_sema_error("formatted string interpolation supports str, cstr, bool, numeric primitives, integer-backed enums/flags, and types implementing format_len()/append_format(output: ref[std.string.String]), got #{value_type}")
           end

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

@@ -58,6 +58,20 @@ module MilkTea
           imported_candidates << [module_binding, imported_method] if imported_method
         end
 
+        if imported_candidates.empty?
+          # Identity-based lookup failed. Try a name-based fallback across
+          # all imports, but only take the first match — not all candidates —
+          # to avoid false "ambiguous method" errors when two modules both
+          # extend the same receiver type with the same method name.
+          @ctx.imports.each_value do |module_binding|
+            method = find_method_by_receiver_name(module_binding, dispatch_receiver_type, name)
+            if method
+              imported_candidates << [module_binding, method]
+              break
+            end
+          end
+        end
+
         if imported_candidates.empty?
           owner_module = reachable_module_binding_for_type(receiver_type)
           return nil unless owner_module
@@ -77,17 +91,25 @@ module MilkTea
       def module_binding_method(module_binding, receiver_type, dispatch_receiver_type, name)
         method = module_binding.methods.fetch(receiver_type, {})[name]
         method ||= module_binding.methods.fetch(dispatch_receiver_type, {})[name] unless dispatch_receiver_type == receiver_type
+        method ||= find_method_by_receiver_name(module_binding, dispatch_receiver_type, name)
         method
       end
 
-      def reachable_module_binding_for_type(receiver_type)
-        module_name = receiver_type_module_name(receiver_type)
-        return nil unless module_name
-        return nil if module_name == @ctx.module_name
-
-        find_reachable_imported_module(module_name)
+      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)
+        end
+        nil
       end
 
+    def reachable_module_binding_for_type(receiver_type)
+      module_name = receiver_type_module_name(receiver_type)
+      return nil unless module_name
+      return nil if module_name == @ctx.module_name
+
+      find_reachable_imported_module(module_name)
+    end
+
       def receiver_type_module_name(receiver_type)
         return receiver_type_module_name(receiver_type.base) if receiver_type.is_a?(Types::Nullable)
         return receiver_type.module_name if receiver_type.respond_to?(:module_name)
@@ -343,6 +365,9 @@ module MilkTea
           unless suggestion
             suggestion = import_suggestion_for_type(name)
           end
+          unless suggestion
+            suggestion = import_hint_for_known_std_name(name)
+          end
           raise_sema_error("unknown type #{name}", type_ref, suggestion: suggestion ? "did you mean '#{suggestion}'?" : nil)
         end
         raise_sema_error("generic type #{name} requires type arguments", type_ref) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
@@ -399,7 +424,7 @@ module MilkTea
         case argument
         when AST::TypeRef
           resolve_type_argument_ref(argument, type_params:, type_param_constraints:)
-        when AST::FunctionType, AST::ProcType
+        when AST::FunctionType, AST::ProcType, AST::TupleType
           resolve_type_ref(argument, type_params:, type_param_constraints:)
         when AST::IntegerLiteral, AST::FloatLiteral
           Types::LiteralTypeArg.new(argument.value)
@@ -616,6 +641,7 @@ module MilkTea
       def infer_layout_query_type(type_ref, context:)
         type = resolve_type_ref(type_ref)
         return type if sized_layout_type?(type)
+        return type if vector_type?(type) || matrix_type?(type) || quaternion_type?(type) || simd_type?(type)
 
         raise_sema_error("#{context} requires a concrete sized type, got #{type_ref}")
       end

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

@@ -266,6 +266,7 @@ module MilkTea
 
       def simd_bitwise_result(left_type, right_type)
         return nil unless simd_type?(left_type) && simd_type?(right_type) && left_type == right_type
+        return nil unless left_type.element_type.integer?
 
         left_type
       end
@@ -286,15 +287,16 @@ module MilkTea
 
       def vector_op_result(operator, left_type, right_type)
         if vector_type?(left_type) && vector_type?(right_type) && left_type.element_type == right_type.element_type
+          return nil unless left_type.width == right_type.width
           return left_type if operator == "+" || operator == "-"
           return left_type if operator == "*"
         end
 
-        if vector_type?(left_type) && right_type.numeric?
+        if vector_type?(left_type) && primitive_numeric_type?(right_type)
           return left_type if operator == "*" || operator == "/"
         end
 
-        if left_type.numeric? && vector_type?(right_type) && operator == "*"
+        if primitive_numeric_type?(left_type) && vector_type?(right_type) && operator == "*"
           return right_type
         end
 
@@ -307,11 +309,7 @@ module MilkTea
           return left_type if operator == "*"
         end
 
-        if matrix_type?(left_type) && vector_type?(right_type) && left_type.dim == right_type.width && right_type.element_type == Types::BUILTIN_VECTOR_ELEMENT
-          return Types::Vector.new(right_type.name, element_type: right_type.element_type, width: right_type.width) if operator == "*"
-        end
-
-        if matrix_type?(left_type) && right_type.numeric?
+        if matrix_type?(left_type) && primitive_numeric_type?(right_type)
           return left_type if operator == "*" || operator == "/"
         end
 
@@ -324,13 +322,13 @@ module MilkTea
           return left_type if operator == "*"
         end
 
-        if quaternion_type?(left_type) && vector_type?(right_type) && right_type.width == 3 && right_type.element_type == Types::BUILTIN_VECTOR_ELEMENT
-          return right_type if operator == "*"
-        end
-
         nil
       end
 
+      def primitive_numeric_type?(type)
+        type.is_a?(Types::Primitive) && type.numeric?
+      end
+
       def pointer_cast?(source_type, target_type)
         pointer_cast_type?(source_type) && pointer_cast_type?(target_type)
       end

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

@@ -76,6 +76,21 @@ module MilkTea
         total = element_layout.first * type.lane_count
         alignment = total > 16 ? 32 : 16
         [total, alignment]
+      when Types::Vector
+        element_layout = size_and_alignment(type.element_type, stack)
+        return unless element_layout
+
+        [element_layout.first * type.width, element_layout.last]
+      when Types::Matrix
+        element_layout = size_and_alignment(Types::BUILTIN_VECTOR_ELEMENT, stack)
+        return unless element_layout
+
+        [element_layout.first * type.dim * type.dim, element_layout.last]
+      when Types::Quaternion
+        element_layout = size_and_alignment(Types::BUILTIN_VECTOR_ELEMENT, stack)
+        return unless element_layout
+
+        [element_layout.first * 4, element_layout.last]
       else
         nil
       end

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

@@ -100,9 +100,14 @@ module MilkTea
           return value.abs <= (1 << 24) if value.is_a?(Integer)
 
           exactly_representable_float32?(value.to_f)
-        else
-          return true if expected_type.name == "double"
+        elsif expected_type.name == "double"
+          # Every integer with magnitude <= 2^53 is exactly representable in
+          # double precision; larger integer constants would lose precision, so
+          # they require an explicit cast instead.
+          return value.abs <= (1 << 53) if value.is_a?(Integer)
 
+          true
+        else
           false
         end
       end

data/lib/milk_tea/core/types.rb

@@ -822,6 +822,18 @@ module MilkTea
         self
       end
 
+      def eql?(other)
+        other.is_a?(GenericStructDefinition) && other.name == name &&
+          other.type_params == type_params && other.module_name == module_name &&
+          other.external == external && other.packed == packed && other.alignment == alignment
+      end
+
+      alias == eql?
+
+      def hash
+        [self.class, name, type_params, module_name, external, packed, alignment].hash
+      end
+
       def set_layout(packed:, alignment:)
         @packed = packed
         @alignment = alignment
@@ -853,23 +865,6 @@ module MilkTea
         name
       end
 
-      def eql?(other)
-        other.class == self.class &&
-          other.name == name &&
-          other.type_params == type_params &&
-          other.module_name == module_name &&
-          other.external == external &&
-          other.packed == packed &&
-          other.alignment == alignment &&
-          other.linkage_name == linkage_name
-      end
-
-      alias == eql?
-
-      def hash
-        [self.class, name, type_params, module_name, external, packed, alignment, linkage_name].hash
-      end
-
       def instantiate(arguments)
         raise ArgumentError, "#{name} expects #{type_params.length} type arguments, got #{arguments.length}" unless arguments.length == type_params.length
 

data/lib/milk_tea/lsp/diagnostics.rb

@@ -179,6 +179,19 @@ module MilkTea
           platform: effective_platform,
         )
         module_name = loader.send(:inferred_module_name_for_path, path) rescue nil
+
+        # Run the full two-pass program check first so that @analysis_cache
+        # has fully-checked analyses for all transitive modules. When the
+        # import resolution below encounters a cycle member, it finds the
+        # cached analysis and resolves correctly. If the program check fails
+        # (e.g. missing module), fall through to the standard resolution
+        # path so that prelude modules and regular errors are still reported.
+        begin
+          loader.check_program_collecting(path)
+        rescue ModuleLoadError, PackageLockError
+          # best-effort — standard path below handles diagnostics
+        end
+
         resolution_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
         unresolved_import_paths = []
 

data/lib/milk_tea/tooling/cli/commands/check.rb

@@ -76,20 +76,11 @@ module MilkTea
       def check_single_reporting_all(path, locked: false)
         loader = make_module_loader(path, locked:, platform: ModuleLoader.default_host_platform)
         resolved_path = File.expand_path(path)
-        ast = loader.load_file(resolved_path)
-        module_name = ast.module_name.to_s
 
-        import_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path)
-        errors = import_result.errors.dup
-
-        analysis = nil
-        begin
-          result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules: import_result.modules, path: resolved_path)
-          errors.concat(result[:errors])
-          analysis = result[:analysis]
-        rescue SemanticError => e
-          errors << e
-        end
+        result = loader.check_program_collecting(path)
+        errors = result[:errors]
+        analysis = result[:root_analysis]
+        module_name = result[:module_name]
 
         if analysis && errors.empty?
           source = read_source_file(path)
@@ -97,9 +88,8 @@ module MilkTea
           errors.concat(warnings)
         end
 
-        closure_errors = loader.collecting_path_errors.values.flatten.compact
-        [errors, module_name, closure_errors]
-      rescue ModuleLoadError, PackageLockError, SemanticError => e
+        [errors, module_name, []]
+      rescue ModuleLoadError, PackageLockError => e
         [[e], nil, []]
       end
 

data/lib/milk_tea/tooling/sexpr_dumper.rb

@@ -72,11 +72,15 @@ module MilkTea
     # ── Token serialisation ───────────────────────────────────────────
 
     def emit_token(token, buf)
-      buf << "(token :type " << emit_token_type(token.type)
+      buf << "(token :type :" << token.type.to_s.tr("_", "-")
       buf << " :lexeme "
       emit_string(token.lexeme, buf)
       buf << " :literal "
-      emit_value(token.literal, buf)
+      if token.type == :float
+        buf << token.lexeme
+      else
+        emit_value(token.literal, buf)
+      end
       buf << " :line " << token.line.to_s
       buf << " :column " << token.column.to_s
       buf << " :start_offset " << token.start_offset.to_s
@@ -84,10 +88,6 @@ module MilkTea
       buf << ")"
     end
 
-    def emit_token_type(sym)
-      ":" + sym.to_s.tr("_", "-")
-    end
-
     # ── Types serialisation ───────────────────────────────────────────
 
     TYPES_SHORT_NAMES = {
@@ -337,7 +337,7 @@ module MilkTea
     end
 
     def format_float(value)
-      s = sprintf("%.17g", value)
+      s = sprintf("%g", value)
       s.include?(".") || s.include?("e") ? s : s + ".0"
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.20
+  version: 0.3.23
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -625,7 +625,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.20 installed!
+  Milk Tea 0.3.23 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH