mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/core/pretty_printer/ast_formatter.rb

@@ -14,8 +14,6 @@ module MilkTea
         finish
       end
 
-      private
-
       def build_comment_map(trivia)
         @blank_line_set = {}
         map = {}
@@ -146,7 +144,7 @@ module MilkTea
       end
 
       def emit_declaration(declaration)
-        decl_line = declaration.respond_to?(:line) ? declaration.line : nil
+        decl_line = declaration.line
         flush_leading_comments_before(decl_line)
         header_idx = @lines.length
 
@@ -300,19 +298,19 @@ module MilkTea
 
       def render_function_signature(function, prefix: "")
         signature_prefix = if function.is_a?(AST::MethodDef)
-                             case function.kind
-                             when :editable
-                               "editable function "
-                             when :static
-                               "static function "
-                             else
-                               "function "
-                             end
-                           elsif function.is_a?(AST::ForeignFunctionDecl)
-                             "foreign function "
-                           else
-                             "function "
-                           end
+          case function.kind
+          when :editable
+            "editable function "
+          when :static
+            "static function "
+          else
+            "function "
+          end
+        elsif function.is_a?(AST::ForeignFunctionDecl)
+          "foreign function "
+        else
+          "function "
+        end
         async_prefix = function.respond_to?(:async) && function.async ? "async " : ""
         text = +"#{prefix}#{visibility_prefix(function)}#{async_prefix}#{signature_prefix}#{function.name}#{render_type_params(function.type_params)}(#{render_signature_params(function)})"
         text << " -> #{render_type(function.return_type)}" if function.return_type
@@ -323,10 +321,10 @@ module MilkTea
         return "" if @current_module_kind == :raw_module
 
         visibility = if declaration_or_visibility.is_a?(Symbol)
-                       declaration_or_visibility
-                     elsif declaration_or_visibility.respond_to?(:visibility)
-                       declaration_or_visibility.visibility
-                     end
+          declaration_or_visibility
+        elsif declaration_or_visibility.respond_to?(:visibility)
+          declaration_or_visibility.visibility
+        end
 
         visibility == :public ? "public " : ""
       end
@@ -414,11 +412,11 @@ module MilkTea
         prefix = +""
         prefix << "async " if method.async
         prefix << case method.kind
-                  when :editable
-                    "editable function "
-                  else
-                    "function "
-                  end
+        when :editable
+          "editable function "
+        else
+          "function "
+        end
 
         text = "#{prefix}#{method.name}(#{method.params.map { |param| render_param(param) }.join(', ')})"
         text << " -> #{render_type(method.return_type)}" if method.return_type
@@ -445,7 +443,7 @@ module MilkTea
       end
 
       def emit_statement(statement)
-        stmt_line = statement.respond_to?(:line) ? statement.line : nil
+        stmt_line = statement.line
         flush_leading_comments_before(stmt_line)
         header_idx = @lines.length
 
@@ -663,8 +661,8 @@ module MilkTea
       end
 
       def unsafe_inline_trivia_conflict?(unsafe_stmt, nested)
-        unsafe_line = unsafe_stmt.respond_to?(:line) ? unsafe_stmt.line : nil
-        nested_line = nested.respond_to?(:line) ? nested.line : nil
+        unsafe_line = unsafe_stmt.line
+        nested_line = nested&.line
         return false unless unsafe_line && nested_line && nested_line > unsafe_line
 
         @comment_map.keys.any? { |line| line >= unsafe_line + 1 && line <= nested_line } ||
@@ -851,11 +849,11 @@ module MilkTea
           escape_format_text(part.value)
         when AST::FormatExprPart
           spec = case part.format_spec&.fetch(:kind)
-                 when :precision then ":.#{part.format_spec[:value]}"
-                 when :hex then part.format_spec[:uppercase] ? ":X" : ":x"
-                 when :oct then part.format_spec[:uppercase] ? ":O" : ":o"
-                 when :bin then part.format_spec[:uppercase] ? ":B" : ":b"
-                 end
+          when :precision then ":.#{part.format_spec[:value]}"
+          when :hex then part.format_spec[:uppercase] ? ":X" : ":x"
+          when :oct then part.format_spec[:uppercase] ? ":O" : ":o"
+          when :bin then part.format_spec[:uppercase] ? ":B" : ":b"
+          end
           "\#{#{render_expression(part.expression)}#{spec}}"
         else
           raise ArgumentError, "unsupported format string part #{part.class.name}"

data/lib/milk_tea/core/pretty_printer/base_formatter.rb

@@ -10,8 +10,6 @@ module MilkTea
         @indent = 0
       end
 
-      private
-
       def finish
         @lines.join("\n") + "\n"
       end

data/lib/milk_tea/core/pretty_printer/ir_formatter.rb

@@ -12,8 +12,6 @@ module MilkTea
         finish
       end
 
-      private
-
       def emit_program(program)
         module_name = program.module_name || "(anonymous)"
         line("program #{module_name}")

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def with_unsafe
         @unsafe_depth += 1
         yield

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_attribute_applications
         expanded_declarations.each do |decl|
           with_error_node(decl) do
@@ -114,20 +112,20 @@ module MilkTea
 
         arguments.each do |argument|
           param = if argument.name
-                    params.find { |candidate| candidate.name == argument.name }.tap do |candidate|
-                      raise_sema_error("unknown attribute argument #{binding.name}.#{argument.name}") unless candidate
-                    end
-                  else
-                    while next_position < params.length && bound_arguments.key?(params[next_position].name)
-                      next_position += 1
-                    end
-
-                    raise_sema_error("attribute #{binding.name} expects #{params.length} arguments, got #{arguments.length}") if next_position >= params.length
-
-                    param = params[next_position]
-                    next_position += 1
-                    param
-                  end
+            params.find { |candidate| candidate.name == argument.name }.tap do |candidate|
+              raise_sema_error("unknown attribute argument #{binding.name}.#{argument.name}") unless candidate
+            end
+          else
+            while next_position < params.length && bound_arguments.key?(params[next_position].name)
+              next_position += 1
+            end
+
+            raise_sema_error("attribute #{binding.name} expects #{params.length} arguments, got #{arguments.length}") if next_position >= params.length
+
+            param = params[next_position]
+            next_position += 1
+            param
+          end
 
           raise_sema_error("duplicate attribute argument #{binding.name}.#{param.name}") if bound_arguments.key?(param.name)
 

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def resolved_attribute_applications_for_target(target)
         target_id = case target
         when Types::StructHandle then target.declaration.object_id

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def infer_lvalue(expression, scopes:)
         case expression
         when AST::Identifier
@@ -855,7 +853,7 @@ module MilkTea
         proc_scopes = scopes.map { |scope| freeze_scope_bindings(scope) }
         proc_scope = {}
         expression.params.each do |param|
-          ensure_non_reserved_primitive_name!(param.name, kind_label: "parameter", line: param.respond_to?(:line) ? param.line : nil, column: param.respond_to?(:column) ? param.column : nil)
+          ensure_non_reserved_primitive_name!(param.name, kind_label: "parameter", line: param.line, column: param.column)
           param_type = resolve_type_ref(param.type)
           validate_parameter_ref_type!(param_type, function_name: "proc", parameter_name: param.name, external: false)
           validate_parameter_proc_type!(param_type, function_name: "proc", parameter_name: param.name, external: false, foreign: false)
@@ -1535,13 +1533,6 @@ module MilkTea
         false
       end
 
-
-
-
-
-
-
-
       def evaluate_field_of_call(arguments, scopes:)
         raise_sema_error("field_of does not support named arguments") if arguments.any?(&:name)
         raise_sema_error("field_of expects 2 arguments, got #{arguments.length}") unless arguments.length == 2
@@ -1554,7 +1545,6 @@ module MilkTea
         field_handle
       end
 
-
       def evaluate_callable_of_call(arguments, scopes:)
         raise_sema_error("callable_of does not support named arguments") if arguments.any?(&:name)
         raise_sema_error("callable_of expects 1 argument, got #{arguments.length}") unless arguments.length == 1
@@ -1562,9 +1552,6 @@ module MilkTea
         resolve_callable_handle_argument(arguments.first.value, scopes:)
       end
 
-
-
-
       def resolve_struct_handle_argument(expression, scopes:)
         if (type_expr = resolve_type_expression(expression))
           handle = struct_handle_for_type(type_expr)

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def current_actual_scope(scopes)
         scopes.reverse_each do |scope|
           return scope unless scope.is_a?(FlowScope)
@@ -24,16 +22,16 @@ module MilkTea
 
         base_scopes = scopes.last.is_a?(FlowScope) ? scopes[0...-1] : scopes
         merged_refinements = if scopes.last.is_a?(FlowScope)
-                               scopes.last.each_with_object({}) do |(name, binding), result|
-                                 result[name] = if name.is_a?(String) && binding.respond_to?(:type)
-                                                  binding.type
-                                                else
-                                                  binding
-                                                end
-                               end
-                             else
-                               {}
-                             end
+          scopes.last.each_with_object({}) do |(name, binding), result|
+            result[name] = if name.is_a?(String) && binding.respond_to?(:type)
+              binding.type
+            else
+              binding
+            end
+          end
+        else
+          {}
+        end
         merged_refinements = merge_refinements(merged_refinements, refinements)
         flow_scope = FlowScope.new
 
@@ -107,7 +105,7 @@ module MilkTea
           snapshots: [],
         }
         @active_local_completion_stack << frame
-        record_local_completion_snapshot(binding.ast.respond_to?(:line) ? binding.ast.line : nil, 0, scopes)
+        record_local_completion_snapshot(binding.ast.line, 0, scopes)
       end
 
       def finish_local_completion_frame(binding)
@@ -119,7 +117,7 @@ module MilkTea
           return
         end
 
-        start_line = [binding.ast.respond_to?(:line) ? binding.ast.line : nil, snapshots.first.line].compact.min
+        start_line = [binding.ast.line, snapshots.first.line].compact.min
         end_line = snapshots.last.line
 
         # Extend end_line to cover the actual function body so that completion
@@ -186,7 +184,7 @@ module MilkTea
       def statement_end_line(statement)
         return nil unless statement
 
-        lines = [statement.respond_to?(:line) ? statement.line : nil]
+        lines = [statement.line]
 
         case statement
         when AST::ErrorBlockStmt
@@ -237,7 +235,7 @@ module MilkTea
       def expression_end_line(node)
         return nil unless node
 
-        lines = [node.respond_to?(:line) ? node.line : nil]
+        lines = [node.line]
 
         case node
         when AST::MemberAccess
@@ -376,28 +374,27 @@ module MilkTea
             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
+            [stmt.line, last_ast_line(stmt.body)].compact.max
           when AST::MatchStmt
             arm_lines = stmt.arms.filter_map do |arm|
               if arm.respond_to?(:body)
                 last_ast_line(arm.body)
               elsif arm.respond_to?(:value)
-                arm.value.respond_to?(:line) ? arm.value.line : nil
+                arm.value.line
               end
             end
             [stmt.line, *arm_lines].compact.max
           when AST::DeferStmt
-            [stmt.respond_to?(:line) ? stmt.line : nil, last_ast_line(stmt.body)].compact.max
+            [stmt.line, 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
+            stmt.line
           end
         end.compact.max
       end
-
     end
   end
 end

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def validate_consuming_foreign_parameter!(type, function_name:, parameter_name:)
         if type.is_a?(Types::Nullable) || !(opaque_type?(type) || pointer_type?(type))
           raise_sema_error("consuming parameter #{parameter_name} of #{function_name} must use a non-null opaque or ptr[...] type")
@@ -153,6 +151,5 @@ module MilkTea
         binding
       end
     end
-
   end
 end

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

@@ -3,23 +3,21 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def declare_functions
         expanded_declarations.each do |decl|
           with_error_node(decl) do
             case decl
             when AST::FunctionDef
-              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.column)
               @ctx.top_level_functions[decl.name] = declare_function_binding(decl)
             when AST::ExternFunctionDecl
-              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.column)
               if decl.mapping && !decl.mapping.is_a?(AST::StringLiteral)
                 raise_sema_error("external function #{decl.name} mapping must be a c-string literal")
               end
               @ctx.top_level_functions[decl.name] = declare_function_binding(decl, external: true)
             when AST::ForeignFunctionDecl
-              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+              ensure_available_value_name!(decl.name, kind_label: "function", line: decl.line, column: decl.column)
               @ctx.top_level_functions[decl.name] = declare_function_binding(decl)
             when AST::ExtendingBlock
               dispatch_receiver_type, receiver_type, receiver_type_param_names, receiver_type_param_constraints = resolve_methods_receiver_target(decl.type_name)
@@ -88,7 +86,7 @@ module MilkTea
         any_default = false
         decl.params.each do |param|
           begin
-            ensure_non_reserved_primitive_name!(param.name, kind_label: "parameter", line: param.respond_to?(:line) ? param.line : decl.line, column: param.respond_to?(:column) ? param.column : nil)
+            ensure_non_reserved_primitive_name!(param.name, kind_label: "parameter", line: param.line || decl.line, column: param.column)
             type = resolve_type_ref(param.type, type_params:, type_param_constraints:)
             validate_parameter_ref_type!(type, function_name: decl.name, parameter_name: param.name, external:)
             reject_foreign_nullable_value_type!(type, function_name: decl.name, parameter_name: param.name) if foreign || external
@@ -272,7 +270,7 @@ module MilkTea
         owner = binding.owner
         prev_collecting = owner.instance_variable_get(:@collecting_errors)
         owner.instance_variable_set(:@collecting_errors, false)
-        owner.send(:check_function, binding)
+        owner.check_function(binding)
       rescue SemanticError => e
         raise unless e.message.include?("cannot assign through immutable")
       ensure
@@ -529,13 +527,13 @@ module MilkTea
 
       def infer_member_access_field_type(value, scopes)
         receiver_type = case value.receiver
-                        when AST::Identifier
-                          if value.receiver.name == "this"
-                            (binding = lookup_value("this", scopes)) ? binding.type : nil
-                          else
-                            (binding = lookup_value(value.receiver.name, scopes)) ? binding.type : nil
-                          end
-                        end
+        when AST::Identifier
+          if value.receiver.name == "this"
+            (binding = lookup_value("this", scopes)) ? binding.type : nil
+          else
+            (binding = lookup_value(value.receiver.name, scopes)) ? binding.type : nil
+          end
+        end
         return nil unless receiver_type
 
         field_receiver = receiver_type_for_fields(receiver_type)
@@ -683,7 +681,6 @@ module MilkTea
         @current_specialization_owner = previous_specialization_owner
         @checking_function_bindings.delete(binding.object_id)
       end
-
     end
   end
 end

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def infer_receiver_type_substitutions(binding, receiver_type)
         declared_receiver_type = binding.declared_receiver_type
         return {} unless declared_receiver_type
@@ -117,45 +115,45 @@ module MilkTea
         receiver = nil
         receiver_type = nil
         binding = case expression.callee
-                  when AST::Identifier
-                    @ctx.top_level_functions[expression.callee.name]
-                  when AST::MemberAccess
-                    if expression.callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.callee.receiver.name)
-                      imported_module = @ctx.imports.fetch(expression.callee.receiver.name)
-                      imported_function = imported_module.functions[expression.callee.member]
-                      if imported_function.nil? && imported_module.private_function?(expression.callee.member)
-                        raise_sema_error("#{expression.callee.receiver.name}.#{expression.callee.member} is private to module #{imported_module.name}")
-                      end
-
-                      imported_function
-                    elsif (type_expr = resolve_type_expression(expression.callee.receiver))
-                      associated_function = lookup_method(type_expr, expression.callee.member)
-                      if associated_function&.type&.receiver_type.nil?
-                        receiver_type = type_expr
-                        associated_function
-                      else
-                        if (imported_module = imported_module_with_private_method(type_expr, expression.callee.member))
-                          raise_sema_error("#{type_expr}.#{expression.callee.member} is private to module #{imported_module.name}")
-                        end
-
-                        nil
-                      end
-                    else
-                      receiver_type = infer_method_receiver_type(expression.callee.receiver, scopes:, member_name: expression.callee.member)
-                      method = lookup_method(receiver_type, expression.callee.member)
-                      if method
-                        callable_kind = :method
-                        receiver = expression.callee.receiver
-                        method
-                      else
-                        if (imported_module = imported_module_with_private_method(receiver_type, expression.callee.member))
-                          raise_sema_error("#{receiver_type}.#{expression.callee.member} is private to module #{imported_module.name}")
-                        end
-
-                        nil
-                      end
-                    end
-                  end
+        when AST::Identifier
+          @ctx.top_level_functions[expression.callee.name]
+        when AST::MemberAccess
+          if expression.callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.callee.receiver.name)
+            imported_module = @ctx.imports.fetch(expression.callee.receiver.name)
+            imported_function = imported_module.functions[expression.callee.member]
+            if imported_function.nil? && imported_module.private_function?(expression.callee.member)
+              raise_sema_error("#{expression.callee.receiver.name}.#{expression.callee.member} is private to module #{imported_module.name}")
+            end
+
+            imported_function
+          elsif (type_expr = resolve_type_expression(expression.callee.receiver))
+            associated_function = lookup_method(type_expr, expression.callee.member)
+            if associated_function&.type&.receiver_type.nil?
+              receiver_type = type_expr
+              associated_function
+            else
+              if (imported_module = imported_module_with_private_method(type_expr, expression.callee.member))
+                raise_sema_error("#{type_expr}.#{expression.callee.member} is private to module #{imported_module.name}")
+              end
+
+              nil
+            end
+          else
+            receiver_type = infer_method_receiver_type(expression.callee.receiver, scopes:, member_name: expression.callee.member)
+            method = lookup_method(receiver_type, expression.callee.member)
+            if method
+              callable_kind = :method
+              receiver = expression.callee.receiver
+              method
+            else
+              if (imported_module = imported_module_with_private_method(receiver_type, expression.callee.member))
+                raise_sema_error("#{receiver_type}.#{expression.callee.member} is private to module #{imported_module.name}")
+              end
+
+              nil
+            end
+          end
+        end
         return nil unless binding
 
         type_arguments = resolve_specialization_type_arguments(expression)
@@ -265,12 +263,12 @@ module MilkTea
           argument = arguments.fetch(index)
           candidate_type = substitute_type(parameter.type, substitutions)
           expected_argument_type = if callable_type?(candidate_type)
-                                      candidate_type
-                                    elsif contains_type_var?(candidate_type)
-                                      nil
-                                    else
-                                      candidate_type
-                                    end
+            candidate_type
+          elsif contains_type_var?(candidate_type)
+            nil
+          else
+            candidate_type
+          end
           actual_type = foreign_argument_actual_type(parameter, argument, scopes:, function_name: binding.name, expected_type: expected_argument_type)
           collect_type_substitutions(parameter.type, actual_type, substitutions, binding.name)
         end
@@ -340,18 +338,18 @@ module MilkTea
           end
 
           actual_params = case actual_type
-                          when Types::Proc
-                            return unless actual_type.params.length == pattern_type.params.length
-
-                            actual_type.params
-                          when Types::Function
-                            return if actual_type.receiver_type || actual_type.variadic
-                            return unless actual_type.params.length == pattern_type.params.length
-
-                            actual_type.params
-                          else
-                            return
-                          end
+          when Types::Proc
+            return unless actual_type.params.length == pattern_type.params.length
+
+            actual_type.params
+          when Types::Function
+            return if actual_type.receiver_type || actual_type.variadic
+            return unless actual_type.params.length == pattern_type.params.length
+
+            actual_type.params
+          else
+            return
+          end
 
           pattern_type.params.zip(actual_params).each do |expected_param, actual_param|
             collect_type_substitutions(expected_param.type, actual_param.type, substitutions, function_name)

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_interface_conformances
         expanded_declarations.each do |decl|
           with_error_node(decl) do

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def current_type_params
         @current_type_substitutions || {}
       end
@@ -28,7 +26,7 @@ module MilkTea
         fallback_owner = specialization_lookup_owner
         return nil unless fallback_owner
 
-        fallback_owner.send(:lookup_method_local_or_imported, receiver_type, name)
+        fallback_owner.lookup_method_local_or_imported(receiver_type, name)
       end
 
       def lookup_static_method(receiver_type, name)
@@ -39,7 +37,7 @@ module MilkTea
         fallback_owner = specialization_lookup_owner
         return nil unless fallback_owner
 
-        fallback_owner.send(:lookup_method_local_or_imported, receiver_type, static_name)
+        fallback_owner.lookup_method_local_or_imported(receiver_type, static_name)
       end
 
       def lookup_method_local_or_imported(receiver_type, name)
@@ -512,7 +510,7 @@ module MilkTea
 
       def source_line(node)
         return nil unless node
-        return node.line if node.respond_to?(:line) && node.line
+        return node.line if node.line
 
         case node
         when AST::MemberAccess then source_line(node.receiver)
@@ -551,7 +549,7 @@ module MilkTea
 
       def source_column(node)
         return nil unless node
-        return node.column if node.respond_to?(:column) && node.column
+        return node.column if node.column
 
         case node
         when AST::MemberAccess then source_column(node.receiver)
@@ -1011,7 +1009,7 @@ module MilkTea
         fallback_owner = specialization_lookup_owner
         return nil unless fallback_owner
 
-        fallback_owner.send(:imported_module_with_private_method_local, receiver_type, method_name)
+        fallback_owner.imported_module_with_private_method_local(receiver_type, method_name)
       end
 
       def imported_module_with_private_method_local(receiver_type, method_name)
@@ -1442,8 +1440,6 @@ module MilkTea
 
         nil
       end
-
-
     end
   end
 end