mt-lang 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b02adcca2cd2665b97f3a32f18130ed355dad80950220475ff623ccc6254250b
-  data.tar.gz: f23de0c1d00fc7f9bd8f6275a921c2b92824b3920425b3fc9f0e1734ecfe2a1a
+  metadata.gz: fcc2383591d95c6043caebcb271aba6b70650528dafbb1a3cd8b906e74a5a6b6
+  data.tar.gz: 2e264acc4e563b29caf921062ca9156f92869d101b1f16f6516f9b412061a1c9
 SHA512:
-  metadata.gz: f29063940f36a621591a64f017e3357aef18db3b7f576f1a0af056514ffee08b67bf1ffd45dc6c2066fd6f27103b5a8e3bced0139415dd558a3e3a0dad5a7cc9
-  data.tar.gz: 4a07fd8a9469cec594b55a41fd7bb7f6220a5baa8653ec4a297d5e06ac80e79f4e1a3b4b69cde79185acb2863d1fe7372e5c9cd2d439a95d3bbe46423d5e2c9d
+  metadata.gz: 17ef473e87741d685323aa279e434ce56a24b7c30cc4b48f61cbb7d4b7c49d47300c7cbad1e4211740fc35ecc29bf36ee941fa0b4bb18ac0fc19d04aee69d7ab
+  data.tar.gz: 9952dc4f2a306b443cbd57c4840965c8c7e870f8f9f976643b063635c64e371c0f8e903ea3446b124cd0b7e9ddf6754807c924e90426c1bfe789124bc08d6d44

data/lib/milk_tea/base.rb

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

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

@@ -80,7 +80,7 @@ module MilkTea
       def resolve_extending_receiver_type(analysis, type_name)
         if type_name.is_a?(AST::TypeRef)
           generic_type = resolve_named_generic_type_for_analysis(analysis, type_name.name.parts)
-          if generic_type.is_a?(Types::GenericStructDefinition)
+          if generic_type.is_a?(Types::GenericStructDefinition) || generic_type.is_a?(Types::GenericVariantDefinition)
             validate_methods_receiver_type_arguments!(type_name, generic_type)
             return generic_type
           end

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

@@ -430,6 +430,8 @@ module MilkTea
             [:get, nil, nil, nil]
           elsif (type = @ctx.types[callee.name]).is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
             [ :struct_literal, nil, nil, type ]
+          elsif (type = @ctx.types[callee.name]).is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+            raise LoweringError, "generic type #{callee.name} requires type arguments"
           else
             emit_fn = @artifacts.emitted_declarations.find { |d| d.is_a?(IR::Function) && d.name == callee.name }
             if emit_fn
@@ -452,6 +454,10 @@ module MilkTea
               return [:function, external_function_c_name(binding), nil, binding.type, binding]
             end
             imported_type = imported_module.types[callee.member]
+            if imported_type.is_a?(Types::GenericStructDefinition) || imported_type.is_a?(Types::GenericVariantDefinition)
+              raise LoweringError, "generic type #{callee.receiver.name}.#{callee.member} requires type arguments"
+            end
+
             if imported_type.is_a?(Types::Struct) || imported_type.is_a?(Types::StringView) || task_type?(imported_type) || imported_type.is_a?(Types::Vector) || imported_type.is_a?(Types::Matrix) || imported_type.is_a?(Types::Quaternion)
               return [:struct_literal, nil, nil, imported_module.types.fetch(callee.member)]
             end

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

@@ -1005,7 +1005,7 @@ module MilkTea
           )
 
           check_function_call(callable, expression.arguments, scopes:)
-          callable.owner.send(:check_function, callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :method
           callable = specialize_function_binding(
@@ -1018,7 +1018,7 @@ module MilkTea
           raise_sema_error("cannot call editable method #{callable.name} on an immutable receiver") if callable.type.receiver_editable && !assignable_receiver?(receiver, scopes)
 
           check_function_call(callable, expression.arguments, scopes:)
-          callable.owner.send(:check_function, callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :callable_value
           check_callable_value_call(callable, expression.arguments, scopes:, callee_expression: expression.callee)

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

@@ -256,6 +256,22 @@ module MilkTea
         end
       end
 
+      # Validates the body of a specialized (instantiated) function or method
+      # binding.  The owner checker may be in collecting-errors mode, which
+      # would silently swallow body errors into @structural_errors.  We
+      # temporarily disable collect mode on the owner so the caller receives
+      # the SemanticError directly.
+      def validate_specialized_function_body(binding)
+        owner = binding.owner
+        prev_collecting = owner.instance_variable_get(:@collecting_errors)
+        owner.instance_variable_set(:@collecting_errors, false)
+        owner.send(:check_function, binding)
+      rescue SemanticError => e
+        raise unless e.message.include?("cannot assign through immutable")
+      ensure
+        owner.instance_variable_set(:@collecting_errors, prev_collecting) if owner
+      end
+
       # Per-function error collection used by check_collecting_errors.
       # Continues past individual function failures, accumulating SemanticErrors.
       def check_functions_collecting(errors)
@@ -286,13 +302,29 @@ module MilkTea
         end
       end
 
+      # Scans generic method bodies for assignments to this through a
+      # non-editable receiver.  Full body checking is deferred to call-site
+      # specialization, but immutable-this violations are type-independent.
+      def check_generic_method_immutable_this(binding, scopes)
+        this_binding = scopes.first&.values&.find { |v| v.name == "this" }
+        return unless this_binding
+        return if this_binding.mutable
+
+        binding.ast.body&.each do |statement|
+          next unless statement.is_a?(AST::Assignment) && statement.operator == "="
+          next unless statement.target.is_a?(AST::MemberAccess) && statement.target.receiver.is_a?(AST::Identifier) && statement.target.receiver.name == "this"
+
+          raise_sema_error("cannot assign through immutable this", statement.target)
+        end
+      end
+
       def check_function(binding)
         @local_completion_frames = @local_completion_frames.dup if @local_completion_frames.frozen?
 
         previous_type_substitutions = @current_type_substitutions
         previous_specialization_owner = @current_specialization_owner
         started_check = false
-        return if binding.external || binding.type_params.any?
+        return if binding.external
         return if @checked_function_bindings[binding.object_id]
         return if @checking_function_bindings[binding.object_id]
 
@@ -303,6 +335,11 @@ module MilkTea
         with_error_node(binding.ast) do
           with_scope(binding.body_params) do |scopes|
             start_local_completion_frame(binding, scopes)
+            if binding.type_params.any?
+              check_generic_method_immutable_this(binding, scopes)
+              return
+            end
+
             if binding.ast.is_a?(AST::ForeignFunctionDecl)
               record_callable_value_expression_site(binding.ast.mapping) unless binding.ast.mapping.is_a?(AST::Call)
               expression = foreign_mapping_expression(binding.ast)
@@ -337,10 +374,10 @@ module MilkTea
             end
           end
         end
-        @checked_function_bindings[binding.object_id] = true
       ensure
         return unless started_check
 
+        @checked_function_bindings[binding.object_id] = true
         finish_local_completion_frame(binding)
         @preassigned_local_binding_ids = {}
         @nullability_flow_result = nil

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

@@ -304,10 +304,17 @@ module MilkTea
                       end
         display_name = type_name.is_a?(Array) ? type_name.join(".") : type_name
         raise_sema_error("unknown type #{display_name} for struct destructure") unless struct_type
-        raise_sema_error("#{display_name} is not a struct") unless struct_type.is_a?(Types::Struct) || struct_type.is_a?(Types::Tuple)
-        ensure_assignable!(value_type, struct_type, "cannot destructure #{value_type} as #{display_name}")
-
-        fields = struct_type.fields
+        if struct_type.is_a?(Types::GenericStructDefinition)
+          if value_type.is_a?(Types::StructInstance) && value_type.definition == struct_type
+            fields = value_type.fields
+          else
+            raise_sema_error("generic type #{display_name} requires type arguments")
+          end
+        else
+          raise_sema_error("#{display_name} is not a struct") unless struct_type.is_a?(Types::Struct) || struct_type.is_a?(Types::Tuple)
+          ensure_assignable!(value_type, struct_type, "cannot destructure #{value_type} as #{display_name}")
+          fields = struct_type.fields
+        end
         raise_sema_error("destructure pattern has #{statement.destructure_bindings.length} bindings but #{display_name} has #{fields.length} fields") unless statement.destructure_bindings.length == fields.length
 
         current_scope = current_actual_scope(scopes)

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -36,7 +36,7 @@ module MilkTea
 
     def to_diagnostic(path: nil)
       Diagnostic.new(
-        path:,
+        path: @path || path,
         line: @line,
         column: @column,
         length: @length,

data/lib/milk_tea/lsp/diagnostics.rb

@@ -87,8 +87,17 @@ module MilkTea
             sema_start = total_start ? monotonic_time : nil
             sema_snapshot ||= SemanticAnalyzer.tooling_snapshot(ast, imported_modules: imported_modules.fetch(:modules), path: path, allow_missing_imports: true)
             sema_facts = sema_snapshot.facts
+            cross_by_uri = {}
+            target_path = path.is_a?(String) ? File.expand_path(path) : nil
             sema_snapshot.diagnostics.reject { |diagnostic| redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths) }
-                           .each { |diagnostic| diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema') }
+                           .each do |diagnostic|
+                             if target_path && diagnostic.path && File.expand_path(diagnostic.path) != target_path
+                               target_uri = path_to_uri(diagnostic.path)
+                               (cross_by_uri[target_uri] ||= []) << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                             else
+                               diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                             end
+                           end
             sema_ms = elapsed_ms(sema_start) if sema_start
           rescue StandardError => e
             log_diagnostics_warning("Error collecting diagnostics: #{e.message}")
@@ -142,7 +151,7 @@ module MilkTea
           log_diagnostics_warning("Error collecting lint diagnostics: #{e.message}")
         end
 
-        { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot }
+        { diagnostics: diagnostics, cross_file_diagnostics: cross_by_uri, facts: sema_facts, sema_snapshot: sema_snapshot }
       ensure
         if total_start
           lint_breakdown = lint_profile&.summary(limit: 12)
@@ -196,7 +205,15 @@ module MilkTea
       def self.redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths)
         return false unless diagnostic&.message.to_s.start_with?("unknown import ")
 
-        unresolved_import_paths.include?(diagnostic.message.delete_prefix("unknown import "))
+        import_path = diagnostic.message.to_s.match(/unknown import (.+)$/)&.captures&.first
+        return false unless import_path
+
+        unresolved_import_paths.include?(import_path)
+      end
+
+    def self.path_to_uri(path)
+        escaped_path = path.split('/').map { |seg| CGI.escape(seg).gsub('+', '%20') }.join('/')
+        "file://#{escaped_path}"
       end
 
       def self.uri_to_path(uri)

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

@@ -366,7 +366,8 @@ module MilkTea
         return { kind: 'full', items: [] } unless uri
 
         content = @workspace.get_content(uri)
-        diagnostics = @workspace.collect_diagnostics(uri)
+        result = @workspace.collect_diagnostics(uri)
+        diagnostics = result
         fingerprint = diagnostics_fingerprint(content, diagnostics)
         previous_result_id = params['previousResultId']
         cached = @diagnostic_report_cache[uri]
@@ -384,6 +385,16 @@ module MilkTea
           fingerprint: fingerprint
         }
 
+        cross = @workspace.cross_file_diagnostics
+        if cross&.any?
+          cross.each do |target_uri, items|
+            @protocol.write_notification('textDocument/publishDiagnostics', {
+              uri: target_uri,
+              diagnostics: items
+            })
+          end
+        end
+
         {
           kind: 'full',
           resultId: result_id,

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

@@ -473,7 +473,7 @@ module MilkTea
 
         current_type = first_type
         chain_segments[1..].each do |seg|
-          field_owner = project_field_receiver_type_for_completion(current_type)
+          field_owner = project_field_receiver_type_for_completion(current_type, facts)
           if field_owner.respond_to?(:field) && (field_type = field_owner.field(seg))
             current_type = field_type
           else
@@ -674,7 +674,7 @@ module MilkTea
       def completion_items_for_value_receiver(facts, receiver_type, prefix)
         items = []
 
-        field_receiver_type = project_field_receiver_type_for_completion(receiver_type)
+        field_receiver_type = project_field_receiver_type_for_completion(receiver_type, facts)
         if field_receiver_type.respond_to?(:fields)
           field_receiver_type.fields.each do |fname, ftype|
             next unless prefix.empty? || fname.start_with?(prefix)
@@ -763,8 +763,20 @@ module MilkTea
         dispatch_receiver_type == receiver_type ? receiver_type : dispatch_receiver_type
       end
 
-      def project_field_receiver_type_for_completion(type)
-        project_receiver_type_for_completion(type)
+      def project_field_receiver_type_for_completion(type, facts = nil)
+        type = project_receiver_type_for_completion(type)
+        return type.definition if type.is_a?(Types::StructInstance)
+        return field_type_from_struct_definition(type, facts) if facts
+
+        type
+      end
+
+      def field_type_from_struct_definition(type, facts)
+        return type unless type.is_a?(Types::GenericInstance)
+        return type if ref_type_name?(type) || pointer_type_name?(type)
+
+        struct_def = facts.types[type.name]
+        struct_def if struct_def&.respond_to?(:fields)
       end
 
       def project_method_receiver_type_for_completion(type)
@@ -778,8 +790,8 @@ module MilkTea
         type
       end
 
-      def field_owner_type(receiver_type)
-        aggregate_type = project_field_receiver_type_for_completion(receiver_type)
+      def field_owner_type(receiver_type, facts = nil)
+        aggregate_type = project_field_receiver_type_for_completion(receiver_type, facts)
         return aggregate_type.definition if aggregate_type.is_a?(Types::StructInstance)
 
         aggregate_type

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

@@ -247,7 +247,7 @@ module MilkTea
         return nil unless current_type
 
           chain[:segments][1..hovered_segment[:position]].each do |segment|
-            field_receiver_type = project_field_receiver_type_for_completion(current_type)
+            field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
             if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
               return field_definition_location(current_uri, field_receiver_type, segment[:name]) if segment[:token_index] == token_index
 

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

@@ -133,6 +133,16 @@ module MilkTea
                 diagnostics: diagnostics
               })
               notify_diagnostic_errors(uri, diagnostics)
+
+              cross = @workspace.cross_file_diagnostics
+              if cross&.any?
+                cross.each do |target_uri, items|
+                  @protocol.write_notification('textDocument/publishDiagnostics', {
+                    uri: target_uri,
+                    diagnostics: items
+                  })
+                end
+              end
             end
           elsif perf_logging?
             @diagnostics_perf[:dropped_stale] += 1

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

@@ -649,7 +649,7 @@ module MilkTea
         return nil unless current_type
 
           chain[:segments][1..hovered_segment[:position]].each do |segment|
-            field_receiver_type = project_field_receiver_type_for_completion(current_type)
+            field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
             if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
               source_location = field_definition_location(current_uri, field_receiver_type, segment[:name])
 
@@ -787,7 +787,7 @@ module MilkTea
         return nil unless receiver_info
 
         field_name = tokens[token_index].lexeme
-        receiver_type = project_field_receiver_type_for_completion(receiver_info[:type])
+        receiver_type = project_field_receiver_type_for_completion(receiver_info[:type], facts)
         return nil unless receiver_type.respond_to?(:field)
 
         field_type = receiver_type.field(field_name)
@@ -809,7 +809,7 @@ module MilkTea
 
         field_name = tokens[token_index].lexeme
         if receiver_info
-          receiver_type = project_field_receiver_type_for_completion(receiver_info[:type])
+          receiver_type = project_field_receiver_type_for_completion(receiver_info[:type], facts)
           if receiver_type.respond_to?(:field)
             field_type = receiver_type.field(field_name)
             if field_type
@@ -1421,7 +1421,7 @@ module MilkTea
           def_index = tokens.index(definition_token)
           if def_index
             prev = previous_non_trivia_token_index(tokens, def_index)
-            if prev && tokens[prev].type == :identifier
+            if prev
               case tokens[prev].lexeme
               when "let" then kind = :let
               when "var" then kind = :var

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

@@ -961,7 +961,7 @@ module MilkTea
         resolve_receiver_value_type(facts, receiver_tok).then do |receiver_type|
           next false unless receiver_type
 
-          field_receiver_type = project_field_receiver_type_for_completion(receiver_type)
+          field_receiver_type = project_field_receiver_type_for_completion(receiver_type, facts)
           next false unless field_receiver_type.respond_to?(:field)
 
           callable_semantic_type?(field_receiver_type.field(name))

data/lib/milk_tea/lsp/workspace/analysis.rb

@@ -158,9 +158,9 @@ module MilkTea
                           ast = get_ast(uri)
                           return @last_good_tooling_snapshot_cache[uri] if ast.nil?
 
-                          result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast)
-                          facts = result[:analysis]
-                          MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path: uri) } || []).freeze)
+                           result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast, path:)
+                           facts = result[:analysis]
+                           MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path:) } || []).freeze)
                         end
               if snapshot&.facts
                 @last_good_tooling_snapshot_cache[uri] = snapshot

data/lib/milk_tea/lsp/workspace/collection.rb

@@ -56,10 +56,12 @@ module MilkTea
               )
               collect_ms = elapsed_ms(collect_start) if collect_start
               diagnostics = result[:diagnostics]
+              cross_by_uri = result[:cross_file_diagnostics] || {}
               facts = result[:facts]
               snapshot = result[:sema_snapshot]
               @facts_cache_mutex.synchronize do
                 if @facts_generation[uri] == generation
+                  @cross_file_diagnostics = cross_by_uri
                   @tooling_snapshot_cache[uri] = snapshot if snapshot
                   @last_good_tooling_snapshot_cache[uri] = snapshot if snapshot&.facts
                   @facts_cache[uri] = facts if facts
@@ -93,6 +95,10 @@ module MilkTea
           end
         end
       end
+
+      def cross_file_diagnostics
+        @facts_cache_mutex.synchronize { @cross_file_diagnostics }
+      end
     end
   end
 end

data/lib/milk_tea/tooling/cli.rb

@@ -684,12 +684,17 @@ module MilkTea
         diagnostics = sort_by_location(diagnostics)
 
         if diagnostics.any? || closure_errors.any?
-          source = read_source_file(path)
+          main_source = read_source_file(path)
+          main_abs = File.expand_path(path)
           diagnostics.each do |d|
+            same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+            source = same_file ? main_source : nil
             @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
           end
           closure_errors.each do |d|
-            @err.puts(ErrorFormatter.format(d, color: error_color?(@err)))
+            same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+            source = same_file ? main_source : nil
+            @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
           end
           all_diagnostics.concat(diagnostics)
           all_diagnostics.concat(closure_errors)
@@ -711,9 +716,9 @@ module MilkTea
       parts << "#{info_count} #{info_count == 1 ? 'note' : 'notes'}" if info_count > 0
       body = parts.join("; ")
       if error_count > 0
-        @err.puts("error: could not check due to #{body}")
+        @err.puts("#{body} found")
       elsif warning_count > 0
-        @err.puts("warning: #{body}")
+        @err.puts("#{body}")
       end
       final_error_count = error_count + (resolution[:warnings_as_errors] ? warning_count : 0)
       final_error_count > 0 ? 1 : 0

metadata

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