mt-lang 0.3.9 → 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
@@ -299,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,
@@ -325,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
@@ -337,6 +335,7 @@ module MilkTea
         when AST::PrefixCast
           visit_expression(expression.expression)
           check_redundant_cast(expression)
+          check_redundant_cast_parens(expression)
         else
           nil
         end
@@ -369,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)
@@ -401,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) &&
@@ -418,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
@@ -429,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)
@@ -437,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
@@ -453,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)
@@ -465,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|
@@ -479,7 +478,7 @@ module MilkTea
             end
           end
         end
-  
+
         @scopes.last[name] = Binding.new(
           name:, line:, column:, used: false,
           binding_kind: :local,
@@ -492,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)
@@ -504,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,
@@ -801,8 +800,8 @@ module MilkTea
           cond_src = source_line_from(b.line, b.column)
           return false unless cond_src
 
-          stmt_col = stmts[i].respond_to?(:column) ? stmts[i].column : nil
-          stmt_line = stmts[i].respond_to?(:line) ? stmts[i].line : nil
+          stmt_col = stmts[i]&.column
+          stmt_line = stmts[i]&.line
           body_src = source_line_from(stmt_line, stmt_col)
           return false unless body_src
 
@@ -819,8 +818,8 @@ module MilkTea
           text << " "
         end
 
-        stmt_col = stmts.last.respond_to?(:column) ? stmts.last.column : nil
-        stmt_line = stmts.last.respond_to?(:line) ? stmts.last.line : nil
+        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
@@ -840,9 +839,9 @@ module MilkTea
       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
 
@@ -897,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,
@@ -935,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
@@ -968,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
@@ -1045,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
@@ -1088,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,
@@ -1146,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
@@ -1190,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
@@ -1222,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
@@ -1252,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)
@@ -1268,7 +1326,7 @@ module MilkTea
         end
         nil
       end
-  
+
       def find_borrow_location_in_stmt(stmt, name)
         case stmt
         when AST::LocalDecl
@@ -1320,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
 

data/std/color.mt

@@ -50,8 +50,8 @@ function fabs(x: float) -> float:
 function fmod(x: float, m: float) -> float:
     # x - floor(x / m) * m
     let div = x / m
-    let fl = float<-(int<-(div))
-    if div < 0.0 and float<-(int<-(div)) != div:
+    let fl = float<-(int<-div)
+    if div < 0.0 and float<-(int<-div) != div:
         return x - (fl - 1.0) * m
     return x - fl * m
 
@@ -143,9 +143,9 @@ extending Color:
 
 
     public function to_hsl() -> (float, float, float):
-        let rf = float<-(this.r) / 255.0
-        let gf = float<-(this.g) / 255.0
-        let bf = float<-(this.b) / 255.0
+        let rf = float<-this.r / 255.0
+        let gf = float<-this.g / 255.0
+        let bf = float<-this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -171,9 +171,9 @@ extending Color:
 
 
     public function to_hsv() -> (float, float, float):
-        let rf = float<-(this.r) / 255.0
-        let gf = float<-(this.g) / 255.0
-        let bf = float<-(this.b) / 255.0
+        let rf = float<-this.r / 255.0
+        let gf = float<-this.g / 255.0
+        let bf = float<-this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -198,11 +198,11 @@ extending Color:
 
 
     public function lerp(target: Color, t: float) -> Color:
-        let r = float<-(this.r) + (float<-(target.r) - float<-(this.r)) * t
-        let g = float<-(this.g) + (float<-(target.g) - float<-(this.g)) * t
-        let b = float<-(this.b) + (float<-(target.b) - float<-(this.b)) * t
-        let a = float<-(this.a) + (float<-(target.a) - float<-(this.a)) * t
-        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = ubyte<-(a))
+        let r = float<-this.r + (float<-target.r - float<-this.r) * t
+        let g = float<-this.g + (float<-target.g - float<-this.g) * t
+        let b = float<-this.b + (float<-target.b - float<-this.b) * t
+        let a = float<-this.a + (float<-target.a - float<-this.a) * t
+        return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = ubyte<-a)
 
 
     public function alpha_blend(background: Color) -> Color:
@@ -211,33 +211,33 @@ extending Color:
         if this.a == 255:
             return this
 
-        let sa = float<-(this.a) / 255.0
-        let da = float<-(background.a) / 255.0
+        let sa = float<-this.a / 255.0
+        let da = float<-background.a / 255.0
 
-        let r_out = float<-(this.r) * sa + float<-(background.r) * da * (1.0 - sa)
-        let g_out = float<-(this.g) * sa + float<-(background.g) * da * (1.0 - sa)
-        let b_out = float<-(this.b) * sa + float<-(background.b) * da * (1.0 - sa)
+        let r_out = float<-this.r * sa + float<-background.r * da * (1.0 - sa)
+        let g_out = float<-this.g * sa + float<-background.g * da * (1.0 - sa)
+        let b_out = float<-this.b * sa + float<-background.b * da * (1.0 - sa)
         let a_out = sa + da * (1.0 - sa)
 
         return Color(
-            r = ubyte<-(r_out),
-            g = ubyte<-(g_out),
-            b = ubyte<-(b_out),
+            r = ubyte<-r_out,
+            g = ubyte<-g_out,
+            b = ubyte<-b_out,
             a = ubyte<-(a_out * 255.0)
         )
 
 
     public function scale(factor: float) -> Color:
-        let r = fmin(fmax(float<-(this.r) * factor, 0.0), 255.0)
-        let g = fmin(fmax(float<-(this.g) * factor, 0.0), 255.0)
-        let b = fmin(fmax(float<-(this.b) * factor, 0.0), 255.0)
-        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = this.a)
+        let r = fmin(fmax(float<-this.r * factor, 0.0), 255.0)
+        let g = fmin(fmax(float<-this.g * factor, 0.0), 255.0)
+        let b = fmin(fmax(float<-this.b * factor, 0.0), 255.0)
+        return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = this.a)
 
 
     public function multiply(other: Color) -> Color:
-        let r = ubyte<-(int<-((int<-(this.r) * int<-(other.r)) / 255))
-        let g = ubyte<-(int<-((int<-(this.g) * int<-(other.g)) / 255))
-        let b = ubyte<-(int<-((int<-(this.b) * int<-(other.b)) / 255))
+        let r = ubyte<-((int<-this.r * int<-other.r) / 255)
+        let g = ubyte<-((int<-this.g * int<-other.g) / 255)
+        let b = ubyte<-((int<-this.b * int<-other.b) / 255)
         return Color(r = r, g = g, b = b, a = this.a)
 
 

data/std/encoding.mt

@@ -47,15 +47,15 @@ public function decode_utf8_codepoint(text: str, byte_offset: ptr_uint) -> Optio
         return Option[uint].none
 
     if len == 1:
-        return Option[uint].some(value = uint<-(b0))
+        return Option[uint].some(value = uint<-b0)
 
     var codepoint: uint = (b0)
     if len == 2:
-        codepoint = codepoint & uint<-(0x1F)
+        codepoint = codepoint & uint<-0x1F
     else if len == 3:
-        codepoint = codepoint & uint<-(0x0F)
+        codepoint = codepoint & uint<-0x0F
     else if len == 4:
-        codepoint = codepoint & uint<-(0x07)
+        codepoint = codepoint & uint<-0x07
     var i: ptr_uint = 1
     while i < len:
         codepoint = (codepoint << 6) | uint<-(text.byte_at(byte_offset + i) & 0x3F)