mt-lang 0.3.9 → 0.3.11

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

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_top_level_values
         expanded_declarations.each do |decl|
           with_error_node(decl) do
@@ -477,16 +475,16 @@ module MilkTea
         func.ast.params.each_with_index do |param, idx|
           arg_expr = arguments[idx].value
           arg_value = if scopes
-                        evaluate_compile_time_const_value(arg_expr, scopes:)
-                      else
-                        CompileTime.evaluate(
-                          arg_expr,
-                          resolve_identifier: lambda { |id| resolve_current_module_const_value(id.name) },
-                          resolve_member_access: nil,
-                          resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
-                          resolve_call: nil,
-                        )
-                      end
+            evaluate_compile_time_const_value(arg_expr, scopes:)
+          else
+            CompileTime.evaluate(
+              arg_expr,
+              resolve_identifier: lambda { |id| resolve_current_module_const_value(id.name) },
+              resolve_member_access: nil,
+              resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
+              resolve_call: nil,
+            )
+          end
           return nil unless arg_value
 
           initial_vars[param.name] = arg_value

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def call_argument_compatible?(actual_type, expected_type, scopes:, external:, expression: nil)
         return true if array_to_span_call_argument_compatible?(actual_type, expected_type, expression:, scopes:)
         return true if argument_types_compatible?(actual_type, expected_type, external:, expression:, scopes:, contextual_int_to_float: !external)
@@ -223,8 +221,6 @@ module MilkTea
         nil
       end
 
-    private
-
       def simd_op_result(operator, left_type, right_type)
         if simd_type?(left_type) && simd_type?(right_type) && left_type.element_type == right_type.element_type && left_type.lane_count == right_type.lane_count
           return left_type if operator == "+" || operator == "-" || operator == "*" || operator == "/"
@@ -337,8 +333,6 @@ module MilkTea
       def function_pointer_type?(type)
         type.is_a?(Types::Function)
       end
-
-
     end
   end
 end

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def build_analysis
         Analysis.new(
           ast: @ctx.ast,
@@ -35,45 +33,45 @@ module MilkTea
       def install_builtin_types
         INSTALLABLE_BUILTIN_TYPE_NAMES.each do |name|
           @ctx.types[name] = case name
-                          when "str"
-                            Types::Registry.string_view
-                          when "Subscription"
-                           builtin_subscription_type
-                         when "EventError"
-                           builtin_event_error_type
-                         when "struct_handle"
-                           builtin_struct_handle_type
-                         when "field_handle"
-                           builtin_field_handle_type
-                         when "callable_handle"
-                           builtin_callable_handle_type
-                          when "attribute_handle"
-                            builtin_attribute_handle_type
-                          when "member_handle"
-                            builtin_member_handle_type
-                          when "type"
-                            builtin_type_meta_type
-                          when "vec2"
-                            Types::Vector.new("vec2", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 2)
-                          when "vec3"
-                            Types::Vector.new("vec3", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 3)
-                          when "vec4"
-                            Types::Vector.new("vec4", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 4)
-                          when "ivec2"
-                            Types::Vector.new("ivec2", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 2)
-                          when "ivec3"
-                            Types::Vector.new("ivec3", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 3)
-                          when "ivec4"
-                            Types::Vector.new("ivec4", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 4)
-                          when "mat3"
-                            Types::Matrix.new("mat3", dim: 3)
-                          when "mat4"
-                            Types::Matrix.new("mat4", dim: 4)
-                          when "quat"
-                            Types::Quaternion.new("quat")
-                          else
-                            Types::Registry.primitive(name)
-                         end
+          when "str"
+            Types::Registry.string_view
+          when "Subscription"
+            builtin_subscription_type
+          when "EventError"
+            builtin_event_error_type
+          when "struct_handle"
+            builtin_struct_handle_type
+          when "field_handle"
+            builtin_field_handle_type
+          when "callable_handle"
+            builtin_callable_handle_type
+          when "attribute_handle"
+            builtin_attribute_handle_type
+          when "member_handle"
+            builtin_member_handle_type
+          when "type"
+            builtin_type_meta_type
+          when "vec2"
+            Types::Vector.new("vec2", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 2)
+          when "vec3"
+            Types::Vector.new("vec3", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 3)
+          when "vec4"
+            Types::Vector.new("vec4", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 4)
+          when "ivec2"
+            Types::Vector.new("ivec2", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 2)
+          when "ivec3"
+            Types::Vector.new("ivec3", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 3)
+          when "ivec4"
+            Types::Vector.new("ivec4", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 4)
+          when "mat3"
+            Types::Matrix.new("mat3", dim: 3)
+          when "mat4"
+            Types::Matrix.new("mat4", dim: 4)
+          when "quat"
+            Types::Quaternion.new("quat")
+          else
+            Types::Registry.primitive(name)
+          end
         end
       end
 
@@ -226,27 +224,27 @@ module MilkTea
               validate_explicit_aggregate_c_name!(decl)
               ensure_available_type_name!(decl.name)
               @ctx.types[decl.name] = if decl.type_params.empty?
-                                    Types::Struct.new(
-                                      decl.name,
-                                      module_name: @ctx.module_name,
-                                      external: raw_module?,
-                                      packed: decl.packed,
-                                      alignment: decl.alignment,
-                                      linkage_name: decl.c_name,
-                                      lifetime_params: decl.lifetime_params,
-                                    )
-                                  else
-                                    Types::GenericStructDefinition.new(
-                                      decl.name,
-                                      decl.type_params.map(&:name),
-                                      module_name: @ctx.module_name,
-                                      external: raw_module?,
-                                      packed: decl.packed,
-                                      alignment: decl.alignment,
-                                      linkage_name: decl.c_name,
-                                      lifetime_params: decl.lifetime_params,
-                                    )
-                                  end
+                Types::Struct.new(
+                  decl.name,
+                  module_name: @ctx.module_name,
+                  external: raw_module?,
+                  packed: decl.packed,
+                  alignment: decl.alignment,
+                  linkage_name: decl.c_name,
+                  lifetime_params: decl.lifetime_params,
+                )
+              else
+                Types::GenericStructDefinition.new(
+                  decl.name,
+                  decl.type_params.map(&:name),
+                  module_name: @ctx.module_name,
+                  external: raw_module?,
+                  packed: decl.packed,
+                  alignment: decl.alignment,
+                  linkage_name: decl.c_name,
+                  lifetime_params: decl.lifetime_params,
+                )
+              end
               register_nested_struct_types(decl)
             when AST::UnionDecl
               validate_explicit_aggregate_c_name!(decl)
@@ -255,14 +253,14 @@ module MilkTea
             when AST::VariantDecl
               ensure_available_type_name!(decl.name)
               @ctx.types[decl.name] = if decl.type_params.empty?
-                                    Types::Variant.new(decl.name, module_name: @ctx.module_name)
-                                  else
-                                    Types::GenericVariantDefinition.new(
-                                      decl.name,
-                                      decl.type_params.map(&:name),
-                                      module_name: @ctx.module_name,
-                                    )
-                                  end
+                Types::Variant.new(decl.name, module_name: @ctx.module_name)
+              else
+                Types::GenericVariantDefinition.new(
+                  decl.name,
+                  decl.type_params.map(&:name),
+                  module_name: @ctx.module_name,
+                )
+              end
             when AST::EnumDecl
               ensure_available_type_name!(decl.name)
               @ctx.types[decl.name] = Types::Enum.new(decl.name, module_name: @ctx.module_name, external: raw_module?)
@@ -454,16 +452,16 @@ module MilkTea
             struct_type = @ctx.types.fetch(decl.name)
             struct_type.ast_declaration = decl if struct_type.respond_to?(:ast_declaration=)
             type_params = if struct_type.is_a?(Types::GenericStructDefinition)
-                             seen = {}
-                             struct_type.type_params.each_with_object({}) do |name, params|
-                               raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
-
-                               seen[name] = true
-                               params[name] = Types::TypeVar.new(name)
-                             end
-                           else
-                             {}
-                           end
+              seen = {}
+              struct_type.type_params.each_with_object({}) do |name, params|
+                raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
+
+                seen[name] = true
+                params[name] = Types::TypeVar.new(name)
+              end
+            else
+              {}
+            end
             decl.lifetime_params.each do |lt|
               type_params[lt] = Types::LifetimeRef.new(lt)
             end if decl.respond_to?(:lifetime_params)
@@ -484,11 +482,11 @@ module MilkTea
               raise_sema_error("duplicate field #{decl.name}.#{field.name}") if fields.key?(field.name)
               raise_sema_error("duplicate member #{decl.name}.#{field.name}") if events.key?(field.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   field.name,
                   kind_label: "field #{decl.name}",
-                  line: field.respond_to?(:line) ? field.line : decl.line,
-                  column: field.respond_to?(:column) ? field.column : nil,
+                  line: field.line || decl.line,
+                  column: field.column,
                 )
               end
 
@@ -578,11 +576,11 @@ module MilkTea
             decl.members.each do |member|
               raise_sema_error("duplicate member #{decl.name}.#{member.name}") if member_names.include?(member.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   member.name,
                   kind_label: "member #{decl.name}",
-                  line: member.respond_to?(:line) ? member.line : decl.line,
-                  column: member.respond_to?(:column) ? member.column : nil,
+                  line: member.line || decl.line,
+                  column: member.column,
                 )
               end
 
@@ -630,16 +628,16 @@ module MilkTea
 
             variant_type = @ctx.types.fetch(decl.name)
             type_params = if variant_type.is_a?(Types::GenericVariantDefinition)
-                            seen = {}
-                            variant_type.type_params.each_with_object({}) do |name, params|
-                              raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
-
-                              seen[name] = true
-                              params[name] = Types::TypeVar.new(name)
-                            end
-                          else
-                            {}
-                          end
+              seen = {}
+              variant_type.type_params.each_with_object({}) do |name, params|
+                raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
+
+                seen[name] = true
+                params[name] = Types::TypeVar.new(name)
+              end
+            else
+              {}
+            end
             type_param_constraints = variant_type.is_a?(Types::GenericVariantDefinition) ? variant_type.type_param_constraints : {}
             seen_arms = []
             arms_hash = {}
@@ -647,11 +645,11 @@ module MilkTea
               begin
                 raise_sema_error("duplicate arm #{decl.name}.#{arm.name}") if seen_arms.include?(arm.name)
                 unless raw_module?
-                  ensure_non_reserved_type_binding_name!(
+                  ensure_non_reserved_value_type_name!(
                     arm.name,
                     kind_label: "arm #{decl.name}",
-                    line: arm.respond_to?(:line) ? arm.line : decl.line,
-                    column: arm.respond_to?(:column) ? arm.column : nil,
+                    line: arm.line || decl.line,
+                    column: arm.column,
                   )
                 end
 
@@ -663,11 +661,11 @@ module MilkTea
                   begin
                     raise_sema_error("duplicate field #{arm.name}.#{field.name}") if seen_fields.include?(field.name)
                     unless raw_module?
-                      ensure_non_reserved_type_binding_name!(
+                      ensure_non_reserved_value_type_name!(
                         field.name,
                         kind_label: "field #{decl.name}.#{arm.name}",
-                        line: field.respond_to?(:line) ? field.line : decl.line,
-                        column: field.respond_to?(:column) ? field.column : nil,
+                        line: field.line || decl.line,
+                        column: field.column,
                       )
                     end
 
@@ -740,7 +738,7 @@ module MilkTea
             case decl
             when AST::ConstDecl
               begin
-                ensure_available_value_name!(decl.name, kind_label: "constant", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+                ensure_available_value_name!(decl.name, kind_label: "constant", line: decl.line, column: decl.column)
                 type = resolve_type_ref(decl.type)
                 validate_stored_ref_type!(type, "constant #{decl.name}")
                 raise_sema_error("constant #{decl.name} cannot store proc values") if contains_proc_type?(type)
@@ -760,7 +758,7 @@ module MilkTea
                 ) unless @ctx.top_level_values.key?(decl.name)
               end
             when AST::VarDecl
-              ensure_available_value_name!(decl.name, kind_label: "module variable", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+              ensure_available_value_name!(decl.name, kind_label: "module variable", line: decl.line, column: decl.column)
               raise_sema_error("module variable #{decl.name} requires an explicit type") unless decl.type
 
               type = resolve_type_ref(decl.type)
@@ -852,10 +850,10 @@ module MilkTea
           qualified_name = "#{parent_name}.#{nested.name}"
           ensure_available_type_name!(qualified_name)
           nested_c_name = if @ctx.module_name && !raw_module?
-                            "#{@ctx.module_name.to_s.tr('.', '_')}_#{qualified_name.tr('.', '_')}"
-                          else
-                            qualified_name.tr('.', '_')
-                          end
+            "#{@ctx.module_name.to_s.tr('.', '_')}_#{qualified_name.tr('.', '_')}"
+          else
+            qualified_name.tr('.', '_')
+          end
           if nested.type_params.empty?
             @ctx.types[qualified_name] = Types::Struct.new(nested.name, module_name: @ctx.module_name, external: raw_module?, packed: nested.packed, alignment: nested.alignment, linkage_name: nested_c_name, lifetime_params: nested.lifetime_params)
           else
@@ -867,4 +865,3 @@ module MilkTea
     end
   end
 end
-

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -184,7 +184,7 @@ module MilkTea
         @return_context_stack = []
       end
 
-      STRUCTURAL_PHASES = %i[
+      def check
         install_builtin_types
         install_builtin_attributes
         install_imports
@@ -201,10 +201,6 @@ module MilkTea
         check_attribute_applications
         declare_functions
         check_interface_conformances
-      ].freeze
-
-      def check
-        STRUCTURAL_PHASES.each { |phase| send(phase) }
         check_top_level_values
         finalize_top_level_const_values
         check_top_level_static_asserts
@@ -279,7 +275,22 @@ module MilkTea
         @collecting_errors = true
         @structural_errors = []
 
-        STRUCTURAL_PHASES.each { |phase| catch_structural { send(phase) } }
+        catch_structural { install_builtin_types }
+        catch_structural { install_builtin_attributes }
+        catch_structural { install_imports }
+        catch_structural { install_prelude_types }
+        catch_structural { declare_named_types }
+        catch_structural { resolve_generic_type_param_constraints }
+        catch_structural { resolve_type_aliases }
+        catch_structural { declare_attributes }
+        catch_structural { resolve_aggregate_fields }
+        catch_structural { resolve_enum_members }
+        catch_structural { resolve_variant_arms }
+        catch_structural { collect_emit_declarations }
+        catch_structural { declare_top_level_values }
+        catch_structural { check_attribute_applications }
+        catch_structural { declare_functions }
+        catch_structural { check_interface_conformances }
 
         errors = @structural_errors.dup
 
@@ -320,8 +331,6 @@ module MilkTea
 
         @structural_errors << error
       end
-
-
     end
   end
 end