mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -3,8 +3,6 @@
 module MilkTea
   class Linter
     module LinterVisitors
-      private
-
       def visit_source_file(source_file)
         @declared_callable_names = declared_callable_names(source_file)
         @declared_directional_functions = declared_directional_functions(source_file)
@@ -29,14 +27,14 @@ module MilkTea
       end
       def seed_module_bindings(source_file)
         @module_bindings = {}
-  
+
         import_names = source_file.imports.filter_map do |import|
           import.alias_name || import.path.parts.last
         end
         source_file.imports.each do |import|
           local_name = import.alias_name || import.path.parts.last
           next if ignored_binding_name?(local_name)
-  
+
           declare_reserved_import_alias_module_binding(
             local_name,
             kind_label: "import alias",
@@ -45,7 +43,7 @@ module MilkTea
             unavailable_names: import_names,
           )
         end
-  
+
         source_file.declarations.each do |declaration|
           kind_label = case declaration
                        when AST::FunctionDef, AST::ExternFunctionDecl, AST::ForeignFunctionDecl
@@ -61,7 +59,7 @@ module MilkTea
                        end
           next unless kind_label
           next if ignored_binding_name?(declaration.name)
-  
+
           declare_reserved_primitive_module_binding(
             declaration.name,
             kind_label:,
@@ -87,7 +85,7 @@ module MilkTea
         source_file.declarations.each_with_object({}) do |declaration, functions|
           next unless declaration.is_a?(AST::ExternFunctionDecl) || declaration.is_a?(AST::ForeignFunctionDecl)
           next unless declaration.params.any? { |param| %i[in out inout].include?(param.mode) }
-  
+
           functions[declaration.name] = declaration
         end
       end
@@ -134,7 +132,7 @@ module MilkTea
         terminated = false
         stmts.each do |stmt|
           next if terminated  # skip visitation only; ControlFlow emits the warning
-  
+
           visit_statement(stmt)
           terminated = true if terminator?(stmt)
         end
@@ -197,14 +195,20 @@ module MilkTea
           with_scope { visit_statement_list(statement.body) }
           @unsafe_depth -= 1
         when AST::ForStmt
+          @loop_depth ||= 0
+          @loop_depth += 1
           visit_expression(statement.iterable)
           with_scope do
             declare_local(statement.name, statement.line, column: statement.column, var: false) if statement.name
             visit_statement_list(statement.body)
           end
+          @loop_depth -= 1
         when AST::WhileStmt
+          @loop_depth ||= 0
+          @loop_depth += 1
           visit_expression(statement.condition)
           with_scope { visit_statement_list(statement.body) }
+          @loop_depth -= 1
         when AST::ReturnStmt
           visit_expression(statement.value) if statement.value
           flag_redundant_widening_cast(statement.value) if statement.value
@@ -293,7 +297,7 @@ module MilkTea
           @unsafe_depth -= 1
         when AST::ProcExpr
           with_scope do
-            fallback_line = expression.respond_to?(:line) ? expression.line : nil
+            fallback_line = expression.line
             expression.params.each do |param|
               declare_param(
                 param.name,
@@ -319,7 +323,7 @@ module MilkTea
         when AST::FormatString
           expression.parts.each do |part|
             next unless part.is_a?(AST::FormatExprPart)
-  
+
             visit_expression(part.expression)
           end
         when AST::IntegerLiteral, AST::FloatLiteral, AST::StringLiteral, AST::BooleanLiteral, AST::NullLiteral
@@ -331,6 +335,7 @@ module MilkTea
         when AST::PrefixCast
           visit_expression(expression.expression)
           check_redundant_cast(expression)
+          check_redundant_cast_parens(expression)
         else
           nil
         end
@@ -363,28 +368,28 @@ module MilkTea
       end
       def mark_assignment_target_reads(target, operator)
         return if operator == "="
-  
+
         mark_used(target.name, identifier: target) if target.is_a?(AST::Identifier)
       end
       def mark_mutated(target)
         return unless target.is_a?(AST::Identifier) || target.is_a?(AST::IndexAccess) || target.is_a?(AST::MemberAccess)
-  
+
         # For direct identifier assignment (e.g., x = value), mark x as mutated.
         if target.is_a?(AST::Identifier)
           @scopes.reverse_each do |scope|
             binding = scope[target.name]
             next unless binding
-  
+
             binding.mutated = true
             return
           end
         end
-  
+
         # For index assignment (e.g., array[0] = value), mark the array as mutated.
         if target.is_a?(AST::IndexAccess)
           mark_mutated(target.receiver)
         end
-  
+
         # For field assignment (e.g., rect.w = value), mark the struct variable as mutated.
         if target.is_a?(AST::MemberAccess)
           mark_mutated(target.receiver)
@@ -395,12 +400,12 @@ module MilkTea
           mark_mutated(expression)
           return
         end
-  
+
         if expression.is_a?(AST::UnaryOp) && %w[out inout].include?(expression.operator)
           mark_mutated(expression.operand)
           return
         end
-  
+
         # ref_of(x) and ptr_of(x) can expose writable aliases — treat as potential
         # mutation since callees may write through them (common C-FFI out-param pattern).
         if expression.is_a?(AST::Call) &&
@@ -412,10 +417,10 @@ module MilkTea
       end
       def mutating_argument_identifier?(expression)
         return false unless expression.is_a?(AST::Identifier)
-  
+
         binding_resolution = @sema_facts&.binding_resolution
         return false unless binding_resolution
-  
+
         binding_resolution.mutating_argument_identifier_ids&.key?(expression.object_id) ||
           binding_resolution.mutable_lvalue_argument_identifier_ids&.key?(expression.object_id)
       end
@@ -423,7 +428,7 @@ module MilkTea
         return unless expression.is_a?(AST::Call)
         return unless expression.callee.is_a?(AST::MemberAccess)
         return unless editable_receiver_expression?(expression.callee.receiver)
-  
+
         mark_mutated(expression.callee.receiver)
       end
       def mark_alias_source_mutated(expression)
@@ -431,12 +436,12 @@ module MilkTea
         return unless expression.callee.is_a?(AST::Identifier)
         return unless %w[ref_of ptr_of].include?(expression.callee.name)
         return unless expression.arguments.length == 1
-  
+
         mark_mutated(expression.arguments.first.value)
       end
       def editable_receiver_expression?(expression)
         return true unless @sema_facts
-  
+
         @sema_facts&.binding_resolution&.editable_receiver_expression_ids&.key?(expression.object_id)
       end
       def with_scope
@@ -447,9 +452,9 @@ module MilkTea
       end
       def declare_local(name, line, column: nil, var: false)
         return if ignored_binding_name?(name)
-  
+
         resolve_reserved_primitive_name_conflicts!(name)
-  
+
         replacement_name = nil
         replacement_base_name = nil
         if RESERVED_VALUE_TYPE_NAMES.include?(name)
@@ -459,7 +464,7 @@ module MilkTea
             visible_binding_names(excluding_name: name),
           )
         end
-  
+
         # shadow: check whether any outer scope already has a binding for this name
         if @scopes.length > 1
           @scopes[0..-2].each do |outer_scope|
@@ -473,7 +478,7 @@ module MilkTea
             end
           end
         end
-  
+
         @scopes.last[name] = Binding.new(
           name:, line:, column:, used: false,
           binding_kind: :local,
@@ -486,9 +491,9 @@ module MilkTea
       end
       def declare_param(name, line: nil, column: nil)
         return if ignored_binding_name?(name)
-  
+
         resolve_reserved_primitive_name_conflicts!(name)
-  
+
         replacement_name = nil
         replacement_base_name = nil
         if RESERVED_VALUE_TYPE_NAMES.include?(name)
@@ -498,7 +503,7 @@ module MilkTea
             visible_binding_names(excluding_name: name),
           )
         end
-  
+
         @scopes.last[name] = Binding.new(
           name:, line:, column:, used: false,
           binding_kind: :param,
@@ -776,6 +781,7 @@ module MilkTea
         return unless stmts.all? { |s| inline_simple_statement?(s) }
 
         return if visually_inline_if?(statement, stmts)
+        return if inline_if_too_wide?(statement, stmts)
 
         emit_conciseness_hint(
           "prefer-inline-if",
@@ -785,12 +791,57 @@ module MilkTea
         )
       end
 
+      def inline_if_too_wide?(statement, stmts)
+        return false if statement.branches.empty?
+
+        text = +""
+
+        statement.branches.each_with_index do |b, i|
+          cond_src = source_line_from(b.line, b.column)
+          return false unless cond_src
+
+          stmt_col = stmts[i]&.column
+          stmt_line = stmts[i]&.line
+          body_src = source_line_from(stmt_line, stmt_col)
+          return false unless body_src
+
+          text << cond_src
+          text << " "
+          text << body_src
+          text << " "
+        end
+
+        if statement.else_line
+          else_src = source_line_from(statement.else_line, statement.else_column)
+          return false unless else_src
+          text << else_src
+          text << " "
+        end
+
+        stmt_col = stmts.last&.column
+        stmt_line = stmts.last&.line
+        else_body = source_line_from(stmt_line, stmt_col)
+        return false unless else_body
+        text << else_body
+
+        text.strip.length > 120
+      end
+
+      def source_line_from(line, column)
+        return nil unless line
+        line_idx = Integer(line) - 1
+        return nil if line_idx < 0 || line_idx >= @source_lines.length
+        raw = @source_lines[line_idx].to_s
+        return raw.strip if column.nil?
+        raw[Integer(column) - 1..]&.strip
+      end
+
       def visually_inline_if?(statement, stmts)
         n = statement.branches.length
         statement.branches.each_with_index.all? { |b, i|
-          stmts[i].respond_to?(:line) && stmts[i].line == b.line
+          stmts[i].line == b.line
         } && (
-          stmts[n].respond_to?(:line) && statement.else_line && stmts[n].line == statement.else_line
+          stmts[n].line && statement.else_line && stmts[n].line == statement.else_line
         )
       end
 
@@ -801,6 +852,7 @@ module MilkTea
         return unless statement.else_body
 
         stmts = (statement.branches.map(&:body) + [statement.else_body]).map { |b| single_statement_body(b) }
+        return if inline_if_too_wide?(statement, stmts)
         report_conditional_expression(stmts, line: statement.line, column: statement.branches.first&.column, kind: "if")
       end
 
@@ -814,6 +866,7 @@ module MilkTea
 
       def report_conditional_expression(stmts, line:, column:, kind:)
         return if stmts.empty? || stmts.any?(&:nil?)
+        return if @loop_depth && @loop_depth > 0
 
         if stmts.all? { |s| s.is_a?(AST::ReturnStmt) && s.value }
           emit_conciseness_hint(
@@ -843,8 +896,8 @@ module MilkTea
           next unless node_fingerprint(body_of.call(first)) == node_fingerprint(body_of.call(second))
 
           pattern = second.pattern
-          pattern_line = pattern.respond_to?(:line) ? pattern.line : second.binding_line
-          pattern_column = pattern.respond_to?(:column) ? pattern.column : second.binding_column
+          pattern_line = pattern.line || second.binding_line
+          pattern_column = pattern.column || second.binding_column
           emit_conciseness_hint(
             "prefer-or-pattern",
             line: pattern_line,
@@ -881,8 +934,8 @@ module MilkTea
         source_text = expr_source_name(copied.first.value.receiver)
         emit_conciseness_hint(
           "prefer-struct-with",
-          line: call.callee.respond_to?(:line) ? call.callee.line : nil,
-          column: call.callee.respond_to?(:column) ? call.callee.column : nil,
+          line: call.callee.line,
+          column: call.callee.column,
           message: "copies #{copied.size} field(s) from `#{source_text}`; use `#{source_text}.with(#{changed_names.join(", ")} = …)`",
         )
       end
@@ -914,8 +967,8 @@ module MilkTea
 
         emit_conciseness_hint(
           "prefer-try",
-          line: scrutinee.respond_to?(:line) ? scrutinee.line : nil,
-          column: scrutinee.respond_to?(:column) ? scrutinee.column : nil,
+          line: scrutinee.line,
+          column: scrutinee.column,
           message: "this #{base} match only propagates the failure branch; consider `expr?`",
         )
       end
@@ -991,6 +1044,65 @@ module MilkTea
         # check_boundary_widening_cast at the specific boundary sites.
       end
 
+      # ── redundant cast parentheses ────────────────────────────────────────────────────
+      # `T<-(x)` when `T<-x` would be equivalent because the inner expression needs
+      # no precedence protection.  Parens are required when the inner expression
+      # contains a binary operator, range, or inline conditional.
+
+      def check_redundant_cast_parens(cast)
+
+        line_idx = Integer(cast.line) - 1
+        return if line_idx < 0 || line_idx >= @source_lines.length
+
+        line = @source_lines[line_idx].to_s
+        col = Integer(cast.column) - 1
+        arrow = line.index("<-", col)
+        return unless arrow
+        arrow_end = arrow + 2
+        return if arrow_end >= line.length
+        return unless line[arrow_end] == "("
+
+        close = match_paren(line, arrow_end)
+        return unless close
+
+        inner = line[arrow_end + 1...close].strip
+        return if inner.empty?
+        return if inner_has_top_level_operators?(inner)
+
+        emit_redundant_cast(cast, type_ref_name(cast.target_type) || "",
+          "parentheses around cast expression are redundant")
+      end
+
+      def match_paren(line, open_pos)
+        depth = 0
+        (open_pos...line.length).each do |i|
+          case line[i]
+          when "(" then depth += 1
+          when ")" then depth -= 1; return i if depth == 0
+          end
+        end
+        nil
+      end
+
+      BINARY_OP_CHARS = %w[+ - * / % & | ^ < > = ! ? :]
+
+      def inner_has_top_level_operators?(inner)
+        depth = 0
+        i = 0
+        while i < inner.length
+          case inner[i]
+          when "(", "[", "{"
+            depth += 1
+          when ")", "]", "}"
+            depth -= 1 if depth > 0
+          when *BINARY_OP_CHARS
+            return true if depth == 0
+          end
+          i += 1
+        end
+        false
+      end
+
       # Reports a widening cast as redundant only when it sits *directly* at a
       # coercion slot: the RHS of a typed `let`/`var`, a `return` value, or the
       # RHS of a plain `=` assignment. At those positions the slot type is
@@ -1034,8 +1146,8 @@ module MilkTea
       end
 
       def emit_redundant_cast(cast_expr, target_name, reason)
-        line = cast_expr.respond_to?(:line) ? cast_expr.line : expression_line(cast_expr)
-        column = cast_expr.respond_to?(:column) ? cast_expr.column : expression_column(cast_expr)
+        line = cast_expr.line || expression_line(cast_expr)
+        column = cast_expr.column || expression_column(cast_expr)
 
         @warnings << Warning.new(
           path: @path,
@@ -1092,15 +1204,15 @@ module MilkTea
         end
       end
       # ── borrow facts helpers ──────────────────────────────────────────────────
-  
+
       BORROW_CALL_NAMES = %w[ref_of ptr_of].freeze
-  
+
       def collect_borrowed_names(stmts)
         names = Set.new
         stmts.each { |s| collect_borrows_from_stmt(s, names) }
         names
       end
-  
+
       def collect_borrows_from_stmt(stmt, names)
         case stmt
         when AST::LocalDecl
@@ -1136,7 +1248,7 @@ module MilkTea
           stmt.else_body&.each { |s| collect_borrows_from_stmt(s, names) }
         end
       end
-  
+
       def collect_borrows_from_expr(expr, names, inside_call_argument: false)
         case expr
         when nil then nil
@@ -1168,13 +1280,13 @@ module MilkTea
           collect_borrows_from_expr(expr.index, names, inside_call_argument:)
         end
       end
-  
+
       def collect_written_names(stmts)
         names = Set.new
         stmts.each { |s| collect_writes_from_stmt(s, names) }
         names
       end
-  
+
       def collect_writes_from_stmt(stmt, names)
         case stmt
         when AST::Assignment
@@ -1198,15 +1310,15 @@ module MilkTea
           stmt.body&.each { |s| collect_writes_from_stmt(s, names) }
         end
       end
-  
+
       def collect_writes_from_stmt_list(stmts, names)
         stmts.each { |s| collect_writes_from_stmt(s, names) }
       end
-  
+
       def stmt_sub_stmts(_stmt)
         []
       end
-  
+
       def find_borrow_location(stmts, name)
         stmts.each do |stmt|
           location = find_borrow_location_in_stmt(stmt, name)
@@ -1214,7 +1326,7 @@ module MilkTea
         end
         nil
       end
-  
+
       def find_borrow_location_in_stmt(stmt, name)
         case stmt
         when AST::LocalDecl
@@ -1266,7 +1378,7 @@ module MilkTea
           nil
         end
       end
-  
+
       def find_borrow_location_in_expr(expr, name)
         case expr
         when nil then nil

data/lib/milk_tea/tooling/linter.rb

@@ -783,8 +783,6 @@ module MilkTea
       @reserved_primitive_name_fixes
     end
 
-    private
-
     include LinterDocTags
     include LinterFlowRules
     include LinterImportsPlatform

data/lib/milk_tea/tooling/project_scaffold.rb

@@ -31,8 +31,6 @@ module MilkTea
       )
     end
 
-    private
-
     def validate_target!
       if File.exist?(@path) && !File.directory?(@path)
         raise ProjectScaffoldError, "project path is not a directory: #{@path}"

data/lib/milk_tea/tooling/run.rb

@@ -87,8 +87,6 @@ module MilkTea
         restore_signal_handlers(previous_handlers) if previous_handlers
       end
 
-      private
-
       def handle_client(socket)
         request_line = socket.gets
         return unless request_line

data/lib/milk_tea/tooling/toolchain_cli.rb

@@ -38,8 +38,6 @@ module MilkTea
       end
     end
 
-    private
-
     def extract_options!
       remaining = []
       until @argv.empty?

data/std/cli.mt

@@ -485,11 +485,8 @@ function parse_long_option_impl(
 
         match inline_value:
             Option.some as inline_payload:
-                match set_option_value(result, spec, inline_payload.value):
-                    Result.failure as set_error:
-                        return Result[ptr_uint, Error].failure(error= set_error.error)
-                    Result.success:
-                        return Result[ptr_uint, Error].success(value= consumed)
+                let _ = set_option_value(result, spec, inline_payload.value)?
+                return Result[ptr_uint, Error].success(value= consumed)
             Option.none:
                 pass
 
@@ -497,12 +494,9 @@ function parse_long_option_impl(
             let missing = fmt.format(f"--#{spec.long_name}")
             return Result[ptr_uint, Error].failure(error= require_value_arg(missing.as_str()))
 
-        match set_option_value(result, spec, value_arg):
-            Result.failure as payload:
-                return Result[ptr_uint, Error].failure(error= payload.error)
-            Result.success:
-                consumed = 2z
-                return Result[ptr_uint, Error].success(value= consumed)
+        let _ = set_option_value(result, spec, value_arg)?
+        consumed = 2z
+        return Result[ptr_uint, Error].success(value= consumed)
 
     match inline_value:
         Option.some:
@@ -510,11 +504,8 @@ function parse_long_option_impl(
         Option.none:
             pass
 
-    match set_option_flag(result, spec):
-        Result.failure as payload:
-            return Result[ptr_uint, Error].failure(error= payload.error)
-        Result.success:
-            return Result[ptr_uint, Error].success(value= 1z)
+    let _ = set_option_flag(result, spec)?
+    return Result[ptr_uint, Error].success(value= 1z)
 
 
 function parse_short_option_impl(
@@ -537,28 +528,18 @@ function parse_short_option_impl(
 
             if short_index + 1 < arg.len:
                 let value = arg.slice(short_index + 1, arg.len - short_index - 1)
-                match set_option_value(result, spec, value):
-                    Result.failure as payload:
-                        return Result[ptr_uint, Error].failure(error= payload.error)
-                    Result.success:
-                        return Result[ptr_uint, Error].success(value= consumed)
+                let _ = set_option_value(result, spec, value)?
+                return Result[ptr_uint, Error].success(value= consumed)
 
             let value_arg = next_arg else:
                 let missing = fmt.format(f"-#{short_name}")
                 return Result[ptr_uint, Error].failure(error= require_value_arg(missing.as_str()))
 
-            match set_option_value(result, spec, value_arg):
-                Result.failure as payload:
-                    return Result[ptr_uint, Error].failure(error= payload.error)
-                Result.success:
-                    consumed = 2z
-                    return Result[ptr_uint, Error].success(value= consumed)
+            let _ = set_option_value(result, spec, value_arg)?
+            consumed = 2z
+            return Result[ptr_uint, Error].success(value= consumed)
 
-        match set_option_flag(result, spec):
-            Result.failure as payload:
-                return Result[ptr_uint, Error].failure(error= payload.error)
-            Result.success:
-                pass
+        let _ = set_option_flag(result, spec)?
 
         short_index += 1