mt-lang 0.3.9 → 0.3.10

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

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_definite_assignment(binding)
         return unless binding.ast.respond_to?(:body)
 
@@ -415,7 +413,6 @@ module MilkTea
 
         nil
       end
-
     end
   end
 end

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

@@ -3,53 +3,51 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_block(statements, scopes:, return_type:, allow_return: true)
         statements ||= []
         with_return_context(return_type, allow_return:) do
           with_nested_scope(scopes) do |nested_scopes|
             with_type_resolution_scopes(nested_scopes) do
-            statements.each_with_index do |statement, idx|
-              begin
-                record_local_completion_snapshot(
-                  statement.respond_to?(:line) ? statement.line : nil,
-                  statement.respond_to?(:column) ? statement.column : 0,
-                  nested_scopes,
-                )
-                refinements = check_statement(statement, scopes: nested_scopes, return_type:, allow_return:)
-                apply_continuation_refinements!(nested_scopes, refinements)
-                if @nullability_flow_result && idx + 1 < statements.length
-                  apply_nullability_continuation_refinements!(nested_scopes, statements[idx + 1])
-                end
-                end_line = statement_end_line(statement)
-                # When the statement spans multiple lines (e.g. let … else:),
-                # record an extra snapshot at the declaration line so that
-                # hover and completion lookups on the declaration line itself
-                # can still find the new binding.
-                if end_line && statement.respond_to?(:line) && statement.line && end_line > statement.line
+              statements.each_with_index do |statement, idx|
+                begin
                   record_local_completion_snapshot(
                     statement.line,
-                    statement.respond_to?(:column) ? statement.column : 0,
+                    statement.column || 0,
                     nested_scopes,
                   )
+                  refinements = check_statement(statement, scopes: nested_scopes, return_type:, allow_return:)
+                  apply_continuation_refinements!(nested_scopes, refinements)
+                  if @nullability_flow_result && idx + 1 < statements.length
+                    apply_nullability_continuation_refinements!(nested_scopes, statements[idx + 1])
+                  end
+                  end_line = statement_end_line(statement)
+                  # When the statement spans multiple lines (e.g. let … else:),
+                  # record an extra snapshot at the declaration line so that
+                  # hover and completion lookups on the declaration line itself
+                  # can still find the new binding.
+                  if end_line && statement.line && end_line > statement.line
+                    record_local_completion_snapshot(
+                      statement.line,
+                      statement.column || 0,
+                      nested_scopes,
+                    )
+                  end
+                  record_local_completion_snapshot(end_line, 1_000_000, nested_scopes)
+                rescue SemanticError => e
+                  if @collecting_errors
+                    @structural_errors << e
+                    next
+                  end
+
+                  raise e unless e.line.nil?
+
+                  stmt_line = statement.line
+                  raise e if stmt_line.nil?
+
+                  raise_sema_error(e.message, statement)
                 end
-                record_local_completion_snapshot(end_line, 1_000_000, nested_scopes)
-              rescue SemanticError => e
-                if @collecting_errors
-                  @structural_errors << e
-                  next
-                end
-
-                raise e unless e.line.nil?
-
-                stmt_line = statement.respond_to?(:line) ? statement.line : nil
-                raise e if stmt_line.nil?
-
-                raise_sema_error(e.message, statement)
               end
             end
-            end
           end
         end
       end
@@ -251,11 +249,9 @@ module MilkTea
 
         storage_type, final_type, const_value =
           if statement.else_body || statement.recovered_else
-            check_local_decl_let_else(statement, scopes:, return_type:, allow_return:,
-                                      discard_binding:, declared_type:, inferred_type:)
+            check_local_decl_let_else(statement, scopes:, return_type:, allow_return:, discard_binding:, declared_type:, inferred_type:)
           else
-            check_local_decl_plain(statement, scopes:, discard_binding:,
-                                   declared_type:, inferred_type:)
+            check_local_decl_plain(statement, scopes:, discard_binding:, declared_type:, inferred_type:)
           end
 
         if noncopyable_event_storage_type?(final_type) && !fresh_noncopyable_event_initializer?(statement.value, final_type, scopes:)
@@ -1427,7 +1423,6 @@ module MilkTea
         return false unless binding.type
         ref_type?(binding.type) || own_type?(binding.type) || (binding.mutable && binding.kind == :param)
       end
-
     end
   end
 end