mt-lang 0.2.15 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c3e9c0ffde0323f887700bd299b2007572ab902f5de1395d01b536c5df275be
-  data.tar.gz: ffc7e3e56abf8661cce5b6d638590fe8fe0a2828c989e74f7781de27492d6f4f
+  metadata.gz: a2b1f14318677bf9232d4163ad6aac3905650056716de05bf89762f08e1aa7d5
+  data.tar.gz: af90e63fd1c9fd21f6af721c1c039b61159d931d20eaa3eaca3b41369da053c1
 SHA512:
-  metadata.gz: 178c78214fd02f7da6b38c6edbce4e1dec6b2c9469ed68a7ac83abd80899e3a016aba741868f7e5d88c21d01c974305739b0df5a14eee55a297d33b31d8bf3c4
-  data.tar.gz: 6f0c2c1b54dc604322b51888635ee6a1049656f7a1da3572ccb58581cd107602f3791c6d4135fd24fec425e8ad81e2db9ed77e83e896545b23b1b8d80b7ea956
+  metadata.gz: cef8b0d7f55c4d9496f41d02b0ace0df87f233ff8c24892768543ff3518e68271a2e4613a7654cef661506d42835d1ea8baa9b3d84225614aae420c0d105a0a4
+  data.tar.gz: b55024abb91b7fdf2694b4be82bf972f1410aa01b949952d30fb49be517fddd501467ebc55fcf3a6dc1a1eb01334709aa74c26a231348026e3197cc5b163b74c

data/lib/milk_tea/base.rb

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

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

@@ -122,6 +122,15 @@ module MilkTea
         start_line = [binding.ast.respond_to?(:line) ? binding.ast.line : nil, snapshots.first.line].compact.min
         end_line = snapshots.last.line
 
+        # Generic function bodies are not analysed during structural checking,
+        # so the frame only has the initial snapshot at the declaration line.
+        # Extend end_line to cover the actual body so that completion and hover
+        # lookups for parameters resolve correctly inside the body.
+        if snapshots.length == 1 && binding.ast.respond_to?(:body) && binding.ast.body
+          body_end = last_ast_line(binding.ast.body)
+          end_line = body_end if body_end && body_end > end_line
+        end
+
         @local_completion_frames << LocalCompletionFrame.new(
           start_line:,
           end_line:,
@@ -350,6 +359,34 @@ module MilkTea
         end
       end
 
+      # Returns the highest line number across a list of AST statement nodes,
+      # recursing into nested bodies (if/else/match/while/for/defer/unsafe).
+      def last_ast_line(statements)
+        return nil if statements.nil? || statements.empty?
+
+        statements.filter_map do |stmt|
+          case stmt
+          when AST::IfStmt
+            branch_lines = stmt.branches.filter_map { |b| last_ast_line(b.body) }
+            else_lines = last_ast_line(stmt.else_body)
+            [stmt.line, *branch_lines, else_lines].compact.max
+          when AST::WhileStmt, AST::ForStmt, AST::UnsafeStmt, AST::ErrorBlockStmt
+            [stmt.respond_to?(:line) ? stmt.line : nil, last_ast_line(stmt.body)].compact.max
+          when AST::MatchStmt
+            arm_lines = stmt.arms.filter_map { |arm| last_ast_line(arm.body) }
+            [stmt.line, *arm_lines].compact.max
+          when AST::DeferStmt
+            [stmt.respond_to?(:line) ? stmt.line : nil, last_ast_line(stmt.body)].compact.max
+          when AST::WhenStmt
+            branch_lines = stmt.branches.filter_map { |b| last_ast_line(b.body) }
+            else_lines = last_ast_line(stmt.else_body)
+            [stmt.line, *branch_lines, else_lines].compact.max
+          else
+            stmt.respond_to?(:line) ? stmt.line : nil
+          end
+        end.compact.max
+      end
+
     end
   end
 end

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

@@ -302,6 +302,161 @@ module MilkTea
         end
       end
 
+      # Names recognised as builtin callable / type-constructor identifiers by
+      # resolve_callable and the compile-time evaluation path.  We allow these
+      # so the generic-name check does not flag them as unknown before the full
+      # type checker has a chance to handle the surrounding Specialization /
+      # Call context.
+      BUILTIN_CALLABLE_NAMES = %w[
+        fatal ref_of const_ptr_of read ptr_of
+        field_of fields_of callable_of attribute_of has_attribute
+        members_of attributes_of get
+        reinterpret array span zero default hash equal order
+        adapt attribute_arg
+        Task Option Result SoA str_buffer atomic
+      ].to_set.freeze
+
+      # Verifies that every bare identifier used as a value expression inside
+      # a generic method body resolves to a known name (parameter, local,
+      # top-level value, function, type, import, or type parameter).  This
+      # catches misspelled variables and undeclared names without touching any
+      # type-dependent logic, so it is safe to run during structural analysis
+      # before concrete types are substituted.
+      def check_generic_method_names(binding, scopes)
+        names = Set.new
+        binding.ast.body&.each do |statement|
+          check_stmt_names(statement, scopes, binding, names)
+        end
+      end
+
+      def check_stmt_names(stmt, scopes, binding, names)
+        case stmt
+        when AST::LocalDecl
+          check_expr_names(stmt.value, scopes, binding, names) if stmt.value
+          names.add(stmt.name) if stmt.name
+        when AST::Assignment
+          check_expr_names(stmt.target, scopes, binding, names)
+          check_expr_names(stmt.value, scopes, binding, names)
+        when AST::ExpressionStmt
+          check_expr_names(stmt.expression, scopes, binding, names)
+        when AST::ReturnStmt
+          check_expr_names(stmt.value, scopes, binding, names) if stmt.value
+        when AST::IfStmt
+          stmt.branches.each do |b|
+            check_expr_names(b.condition, scopes, binding, names)
+            branch_names = names.dup
+            b.body&.each { |s| check_stmt_names(s, scopes, binding, branch_names) }
+          end
+          else_names = names.dup
+          stmt.else_body&.each { |s| check_stmt_names(s, scopes, binding, else_names) }
+        when AST::WhileStmt
+          check_expr_names(stmt.condition, scopes, binding, names)
+          body_names = names.dup
+          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::ForStmt
+          Array(stmt.iterables).each { |i| check_expr_names(i, scopes, binding, names) }
+          body_names = names.dup
+          Array(stmt.bindings).each { |b| body_names.add(b.respond_to?(:name) ? b.name : b) }
+          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::MatchStmt
+          check_expr_names(stmt.expression, scopes, binding, names)
+          stmt.arms.each do |arm|
+            arm_names = names.dup
+            arm_names.add(arm.binding_name) if arm.binding_name
+            arm.body&.each { |s| check_stmt_names(s, scopes, binding, arm_names) }
+          end
+        when AST::UnsafeStmt, AST::ParallelBlockStmt
+          body_names = names.dup
+          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::DeferStmt
+          check_expr_names(stmt.expression, scopes, binding, names) if stmt.expression
+          body_names = names.dup
+          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::WhenStmt
+          check_expr_names(stmt.discriminant, scopes, binding, names)
+          stmt.branches.each do |b|
+            branch_names = names.dup
+            b.body&.each { |s| check_stmt_names(s, scopes, binding, branch_names) }
+          end
+          else_names = names.dup
+          stmt.else_body&.each { |s| check_stmt_names(s, scopes, binding, else_names) }
+        when AST::ErrorBlockStmt
+          body_names = names.dup
+          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::BreakStmt, AST::ContinueStmt, AST::PassStmt, AST::StaticAssert, AST::EmitStmt
+          nil
+        end
+      end
+
+      def check_expr_names(expr, scopes, binding, names)
+        case expr
+        when AST::Identifier
+          check_generic_name(expr.name, scopes, binding, expr, names)
+        when AST::MemberAccess
+          check_expr_names(expr.receiver, scopes, binding, names)
+        when AST::Call
+          check_expr_names(expr.callee, scopes, binding, names)
+          expr.arguments.each { |arg| check_expr_names(arg.value, scopes, binding, names) }
+        when AST::BinaryOp
+          check_expr_names(expr.left, scopes, binding, names)
+          check_expr_names(expr.right, scopes, binding, names)
+        when AST::UnaryOp
+          check_expr_names(expr.operand, scopes, binding, names)
+        when AST::IfExpr
+          check_expr_names(expr.condition, scopes, binding, names)
+          check_expr_names(expr.then_expression, scopes, binding, names)
+          check_expr_names(expr.else_expression, scopes, binding, names)
+        when AST::MatchExpr
+          check_expr_names(expr.expression, scopes, binding, names)
+          expr.arms.each do |arm|
+            arm_names = names.dup
+            arm_names.add(arm.binding_name) if arm.binding_name
+            check_expr_names(arm.value, scopes, binding, arm_names)
+          end
+        when AST::IndexAccess
+          check_expr_names(expr.receiver, scopes, binding, names)
+          check_expr_names(expr.index, scopes, binding, names)
+        when AST::Specialization
+          check_expr_names(expr.callee, scopes, binding, names)
+        when AST::PrefixCast
+          check_expr_names(expr.expression, scopes, binding, names)
+        when AST::AwaitExpr
+          check_expr_names(expr.expression, scopes, binding, names)
+        when AST::UnsafeExpr
+          check_expr_names(expr.expression, scopes, binding, names)
+        when AST::RangeExpr
+          check_expr_names(expr.start_expr, scopes, binding, names) if expr.start_expr
+          check_expr_names(expr.end_expr, scopes, binding, names) if expr.end_expr
+        when AST::ExpressionList
+          expr.elements.each { |elem| check_expr_names(elem, scopes, binding, names) }
+        when AST::ProcExpr
+          body_names = names.dup
+          Array(expr.params).each { |p| body_names.add(p.name) if p.respond_to?(:name) }
+          expr.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+        when AST::DetachExpr
+          check_expr_names(expr.body, scopes, binding, names)
+        when AST::FormatExprPart
+          check_expr_names(expr.expression, scopes, binding, names)
+        when AST::IntegerLiteral, AST::FloatLiteral, AST::StringLiteral,
+             AST::BooleanLiteral, AST::NullLiteral, AST::CharLiteral,
+             AST::FormatString, AST::FormatTextPart
+          nil
+        end
+      end
+
+      def check_generic_name(name, scopes, binding, node, names)
+        return if name == "_" || name == "this"
+        return if names.include?(name)
+        return if BUILTIN_CALLABLE_NAMES.include?(name)
+        return if lookup_value(name, scopes)
+        return if @ctx.top_level_functions.key?(name)
+        return if @ctx.types.key?(name)
+        return if @ctx.imports.key?(name)
+        return if binding.type_params.include?(name)
+
+        raise_sema_error("unknown name #{name}", node)
+      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.
@@ -337,6 +492,7 @@ module MilkTea
             start_local_completion_frame(binding, scopes)
             if binding.type_params.any?
               check_generic_method_immutable_this(binding, scopes)
+              check_generic_method_names(binding, scopes)
               return
             end
 

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

@@ -725,6 +725,18 @@ module MilkTea
         dispatch_receiver_type = method_dispatch_receiver_type_for_completion(receiver_type)
         receiver_candidates << dispatch_receiver_type if dispatch_receiver_type != receiver_type
 
+        # For GenericInstance or Nullable-wrapped GenericInstance, also try the
+        # struct definition from facts.types — method registration keys are
+        # always the GenericStructDefinition, not a GenericInstance.
+        [dispatch_receiver_type, receiver_type].each do |candidate|
+          base = candidate
+          base = base.base while base.is_a?(Types::Nullable)
+          next unless base.is_a?(Types::GenericInstance)
+
+          definition = facts.types[base.name]
+          receiver_candidates << definition if definition && !receiver_candidates.include?(definition)
+        end
+
         receiver_candidates.each do |candidate|
           facts.methods.fetch(candidate, {}).each do |name, binding|
             methods[name] ||= binding
@@ -745,10 +757,7 @@ module MilkTea
         return receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
         if receiver_type.is_a?(Types::Nullable)
-          dispatch_base_type = method_dispatch_receiver_type_for_completion(receiver_type.base)
-          return receiver_type if dispatch_base_type == receiver_type.base
-
-          return Types::Registry.nullable(dispatch_base_type)
+          return method_dispatch_receiver_type_for_completion(receiver_type.base)
         end
 
         return receiver_type unless receiver_type.is_a?(Types::GenericInstance)
@@ -764,6 +773,7 @@ module MilkTea
       end
 
       def project_field_receiver_type_for_completion(type, facts = nil)
+        type = type.base while type.is_a?(Types::Nullable)
         type = project_receiver_type_for_completion(type)
         return type.definition if type.is_a?(Types::StructInstance) || type.is_a?(Types::VariantInstance)
         return field_type_from_struct_definition(type, facts) if facts

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

@@ -100,7 +100,7 @@ module MilkTea
         extending = nil
         each_ast_node(ast) do |node|
           next unless node.is_a?(AST::ExtendingBlock)
-          if node.line && node.end_line && lsp_line + 1 >= node.line && lsp_line + 1 <= node.end_line
+          if node.line && lsp_line + 1 >= node.line && (!node.respond_to?(:end_line) || !node.end_line || lsp_line + 1 <= node.end_line)
             extending = node
           end
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.17
 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.15 installed!
+  Milk Tea 0.2.17 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH