mt-lang 0.2.0

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

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class SemanticAnalyzer
+    class Checker
+      private
+
+      def with_unsafe
+        @unsafe_depth += 1
+        yield
+      ensure
+        @unsafe_depth -= 1
+      end
+
+      def mark_current_unsafe_required!
+        current_line = @unsafe_statement_lines.last
+        return unless current_line
+
+        @required_unsafe_lines << current_line
+      end
+
+      def require_unsafe!(message, line: nil, column: nil)
+        if unsafe_context?
+          mark_current_unsafe_required!
+          return
+        end
+
+        suggestion = "wrap in an unsafe block: `unsafe: <expression>`"
+        if line || column
+          raise SemanticError.new(message, line:, column:, path: @path, suggestion:)
+        end
+
+        raise_sema_error(message, suggestion:)
+      end
+
+      def with_foreign_mapping_context
+        @foreign_mapping_depth += 1
+        yield
+      ensure
+        @foreign_mapping_depth -= 1
+      end
+
+      def with_async_function
+        @async_function_depth += 1
+        yield
+      ensure
+        @async_function_depth -= 1
+      end
+
+      def with_loop
+        @loop_depth += 1
+        yield
+      ensure
+        @loop_depth -= 1
+      end
+
+      def with_compile_time
+        @compile_time_depth += 1
+        yield
+      ensure
+        @compile_time_depth -= 1
+      end
+
+      # Tracks the innermost value scopes during body checking so that
+      # `resolve_type_ref` can resolve a compile-time reflection type expression
+      # (e.g. `field.type` inside an `inline for`) by evaluating it against the
+      # local bindings in scope. Nil outside body checking.
+      def with_type_resolution_scopes(scopes)
+        saved = @type_resolution_scopes
+        @type_resolution_scopes = scopes
+        yield
+      ensure
+        @type_resolution_scopes = saved
+      end
+
+      def with_loop_barrier
+        previous_loop_depth = @loop_depth
+        @loop_depth = 0
+        yield
+      ensure
+        @loop_depth = previous_loop_depth
+      end
+
+      def unsafe_context?
+        @unsafe_depth.positive?
+      end
+
+      def inside_async_function?
+        @async_function_depth.positive?
+      end
+
+      def inside_loop?
+        @loop_depth.positive?
+      end
+
+      def foreign_mapping_context?
+        @foreign_mapping_depth.positive?
+      end
+
+      def with_return_context(return_type, allow_return:)
+        @return_context_stack << { return_type:, allow_return: }
+        yield
+      ensure
+        @return_context_stack.pop
+      end
+
+      def current_return_context
+        @return_context_stack.last
+      end
+
+      def with_scope(bindings)
+        scope = {}
+        bindings.each do |binding|
+          raise_sema_error("duplicate local #{binding.name}") if scope.key?(binding.name)
+
+          scope[binding.name] = binding
+        end
+
+        yield([scope])
+      end
+
+      def with_nested_scope(scopes)
+        nested_scopes = scopes + [{}]
+        yield(nested_scopes)
+      end
+
+      def validate_async_function_body!(statements)
+        statements.each { |statement| validate_async_statement!(statement) }
+      end
+
+      def validate_async_statement!(statement)
+        case statement
+        when AST::ErrorBlockStmt
+          if statement.header_expression
+            context = case statement.header_type
+                      when :if then "if conditions"
+                      when :while then "while conditions"
+                      end
+            validate_async_expression_support!(statement.header_expression, context:) if context
+          end
+          if statement.header_type == :for
+            Array(statement.header_iterables).each do |iterable|
+              validate_async_expression_support!(iterable, context: "for iterables")
+            end
+          end
+          statement.body.each { |s| validate_async_statement!(s) }
+        when AST::ErrorStmt
+          nil
+        when AST::LocalDecl
+          validate_async_expression_support!(statement.value, context: "local initializer") if statement.value
+          statement.else_body&.each { |s| validate_async_statement!(s) }
+        when AST::Assignment
+          validate_async_expression_support!(statement.target, context: "assignment target")
+          validate_async_expression_support!(statement.value, context: "assignment")
+        when AST::ExpressionStmt
+          validate_async_expression_support!(statement.expression, context: "expression statement")
+        when AST::ReturnStmt
+          return unless statement.value
+
+          validate_async_expression_support!(statement.value, context: "return statement")
+        when AST::IfStmt
+          statement.branches.each do |branch|
+            validate_async_expression_support!(branch.condition, context: "if conditions")
+
+            branch.body.each { |s| validate_async_statement!(s) }
+          end
+          statement.else_body&.each { |s| validate_async_statement!(s) }
+        when AST::WhileStmt
+          validate_async_expression_support!(statement.condition, context: "while conditions")
+
+          statement.body.each { |s| validate_async_statement!(s) }
+        when AST::ForStmt
+          statement.iterables.each do |iterable|
+            validate_async_expression_support!(iterable, context: "for iterables")
+          end
+
+          statement.body.each { |s| validate_async_statement!(s) }
+        when AST::MatchStmt
+          validate_async_expression_support!(statement.expression, context: "match discriminants")
+
+          statement.arms.each { |arm| arm.body.each { |s| validate_async_statement!(s) } }
+        when AST::UnsafeStmt
+          statement.body.each { |s| validate_async_statement!(s) }
+        when AST::DeferStmt
+          validate_async_expression_support!(statement.expression, context: "defer cleanup") if statement.expression
+          statement.body&.each { |s| validate_async_statement!(s) }
+        when AST::WhenStmt
+          statement.branches.each { |branch| branch.body.each { |s| validate_async_statement!(s) } }
+          statement.else_body&.each { |s| validate_async_statement!(s) }
+        when AST::BreakStmt, AST::ContinueStmt, AST::StaticAssert, AST::PassStmt
+          nil
+        else
+          raise_sema_error("async functions currently only support straight-line local declarations, assignments, expression statements, and return statements")
+        end
+      end
+
+      def validate_async_expression_support!(expression, context:)
+        unsupported_context = unsupported_async_await_context(expression)
+        return unless unsupported_context
+
+        raise_sema_error("await in async functions is not supported inside #{unsupported_context} yet")
+      end
+
+      def unsupported_async_await_context(expression)
+        nil
+      end
+
+      def statement_contains_await?(statement)
+        case statement
+        when AST::ErrorBlockStmt
+          (statement.header_expression && expression_contains_await?(statement.header_expression)) ||
+            Array(statement.header_iterables).any? { |iterable| expression_contains_await?(iterable) } ||
+            statements_contain_await?(statement.body)
+        when AST::LocalDecl
+          (statement.value && expression_contains_await?(statement.value)) ||
+            (statement.else_body && statements_contain_await?(statement.else_body))
+        when AST::Assignment
+          expression_contains_await?(statement.target) || expression_contains_await?(statement.value)
+        when AST::IfStmt
+          statement.branches.any? { |branch| expression_contains_await?(branch.condition) || statements_contain_await?(branch.body) } ||
+            (statement.else_body && statements_contain_await?(statement.else_body))
+        when AST::MatchStmt
+          expression_contains_await?(statement.expression) || statement.arms.any? { |arm| expression_contains_await?(arm.pattern) || statements_contain_await?(arm.body) }
+        when AST::UnsafeStmt
+          statements_contain_await?(statement.body)
+        when AST::StaticAssert
+          expression_contains_await?(statement.condition) || expression_contains_await?(statement.message)
+        when AST::ForStmt
+          statement.iterables.any? { |iterable| expression_contains_await?(iterable) } || statements_contain_await?(statement.body)
+        when AST::WhileStmt
+          expression_contains_await?(statement.condition) || statements_contain_await?(statement.body)
+        when AST::ReturnStmt
+          statement.value && expression_contains_await?(statement.value)
+        when AST::DeferStmt
+          (statement.expression && expression_contains_await?(statement.expression)) || (statement.body && statements_contain_await?(statement.body))
+        when AST::ExpressionStmt
+          expression_contains_await?(statement.expression)
+        else
+          false
+        end
+      end
+
+      def statements_contain_await?(statements)
+        statements.any? { |statement| statement_contains_await?(statement) }
+      end
+
+      def expression_contains_await?(expression)
+        case expression
+        when AST::AwaitExpr
+          true
+        when AST::Call, AST::Specialization
+          expression_contains_await?(expression.callee) || expression.arguments.any? { |argument| expression_contains_await?(argument.value) }
+        when AST::UnaryOp
+          expression_contains_await?(expression.operand)
+        when AST::BinaryOp
+          expression_contains_await?(expression.left) || expression_contains_await?(expression.right)
+        when AST::IfExpr
+          expression_contains_await?(expression.condition) || expression_contains_await?(expression.then_expression) || expression_contains_await?(expression.else_expression)
+        when AST::MatchExpr
+          expression_contains_await?(expression.expression) || expression.arms.any? { |arm| expression_contains_await?(arm.pattern) || expression_contains_await?(arm.value) }
+        when AST::UnsafeExpr
+          expression_contains_await?(expression.expression)
+        when AST::PrefixCast
+          expression_contains_await?(expression.expression)
+        when AST::MemberAccess
+          expression_contains_await?(expression.receiver)
+        when AST::IndexAccess
+          expression_contains_await?(expression.receiver) || expression_contains_await?(expression.index)
+        when AST::FormatString
+          expression.parts.any? { |part| part.is_a?(AST::FormatExprPart) && expression_contains_await?(part.expression) }
+        else
+          false
+        end
+      end
+
+      def suggest_name(wrong, candidates, max_distance: 2)
+        return nil if wrong.nil? || wrong.to_s.empty? || candidates.nil? || candidates.empty?
+
+        wrong_str = wrong.to_s
+        closest = nil
+        closest_dist = max_distance + 1
+        candidates.each do |candidate|
+          next if candidate.nil?
+          cand_str = candidate.to_s
+          next if cand_str.empty? || cand_str == wrong_str
+          dist = levenshtein(wrong_str, cand_str)
+          if dist < closest_dist
+            closest_dist = dist
+            closest = cand_str
+          end
+        end
+        closest_dist <= max_distance ? closest : nil
+      end
+
+      def levenshtein(s, t)
+        m = s.length
+        n = t.length
+        return m if n.zero?
+        return n if m.zero?
+        d = Array.new(m + 1) { Array.new(n + 1, 0) }
+        (0..m).each { |i| d[i][0] = i }
+        (0..n).each { |j| d[0][j] = j }
+        (1..m).each do |i|
+          (1..n).each do |j|
+            cost = s[i - 1] == t[j - 1] ? 0 : 1
+            d[i][j] = [d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost].min
+          end
+        end
+        d[m][n]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class SemanticAnalyzer
+    class Checker
+      private
+
+      def check_attribute_applications
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            case decl
+            when AST::StructDecl
+              packed, alignment = check_decl_attribute_applications!(decl.attributes, target_kind: :struct, target_label: "struct #{decl.name}", target_node: decl)
+              @ctx.types.fetch(decl.name).set_layout(packed:, alignment:)
+
+              decl.fields.each do |field|
+                with_error_node(field) do
+                  if raw_module? && field.attributes.any?
+                    raise_sema_error("attributes are not allowed on fields in external files")
+                  end
+
+                  check_decl_attribute_applications!(field.attributes, target_kind: :field, target_label: "field #{decl.name}.#{field.name}", target_node: field)
+                end
+              end
+            when AST::FunctionDef, AST::ExternFunctionDecl, AST::ForeignFunctionDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :callable, target_label: "callable #{decl.name}", target_node: decl)
+            when AST::InterfaceDecl
+              decl.methods.each do |method|
+                with_error_node(method) do
+                  check_decl_attribute_applications!(method.attributes, target_kind: :callable, target_label: "callable #{decl.name}.#{method.name}", target_node: method)
+                end
+              end
+            when AST::ExtendingBlock
+              decl.methods.each do |method|
+                with_error_node(method) do
+                  check_decl_attribute_applications!(method.attributes, target_kind: :callable, target_label: "callable #{decl.type_name}.#{method.name}", target_node: method)
+                end
+              end
+            when AST::ConstDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :const, target_label: "const #{decl.name}", target_node: decl)
+            when AST::EventDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :event, target_label: "event #{decl.name}", target_node: decl)
+            when AST::UnionDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :union, target_label: "union #{decl.name}", target_node: decl)
+            when AST::EnumDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :enum, target_label: "enum #{decl.name}", target_node: decl)
+            when AST::FlagsDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :flags, target_label: "flags #{decl.name}", target_node: decl)
+            when AST::VariantDecl
+              check_decl_attribute_applications!(decl.attributes, target_kind: :variant, target_label: "variant #{decl.name}", target_node: decl)
+            end
+          end
+        end
+      end
+
+      def check_decl_attribute_applications!(applications, target_kind:, target_label:, target_node:)
+        seen = {}
+        packed = false
+        alignment = nil
+        resolved_applications = []
+
+        applications.each do |application|
+          with_error_node(application) do
+            binding = resolve_attribute_binding(application.name)
+
+            if raw_module?
+              raise_sema_error("only built-in struct attributes are allowed in external files") unless binding.builtin && target_kind == :struct
+            end
+
+            unless binding.targets.include?(target_kind)
+              raise_sema_error("attribute #{binding.name} cannot target #{target_kind}")
+            end
+
+            binding_key = [binding.module_name, binding.name]
+            raise_sema_error("duplicate attribute #{binding.name} on #{target_label}") if seen.key?(binding_key)
+
+            seen[binding_key] = true
+            argument_values = check_attribute_arguments!(binding, application)
+            argument_values = argument_values.freeze
+            @ctx.attribute_application_bindings[application.object_id] = binding
+            @ctx.validated_attribute_arguments[application.object_id] = argument_values
+            resolved_applications << ResolvedAttributeApplication.new(binding:, argument_values:)
+
+            case binding.name
+            when "packed"
+              packed = true
+            when "align"
+              bytes = argument_values.fetch("bytes")
+              raise_sema_error("align(...) requires a positive alignment") unless bytes.is_a?(Integer) && bytes.positive?
+              raise_sema_error("align(...) requires a power-of-two alignment, got #{bytes}") unless power_of_two?(bytes)
+
+              alignment = bytes
+            end
+          end
+        end
+
+        @ctx.resolved_attribute_applications[target_node.object_id] = resolved_applications.freeze
+
+        [packed, alignment]
+      end
+
+      def check_attribute_arguments!(binding, application)
+        params = binding.params
+        arguments = application.arguments
+
+        if params.empty?
+          raise_sema_error("attribute #{binding.name} does not take arguments") if arguments.any?
+
+          return {}
+        end
+
+        bound_arguments = {}
+        next_position = 0
+
+        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
+
+          raise_sema_error("duplicate attribute argument #{binding.name}.#{param.name}") if bound_arguments.key?(param.name)
+
+          bound_arguments[param.name] = argument.value
+        end
+
+        missing = params.reject { |param| bound_arguments.key?(param.name) }
+        unless missing.empty?
+          names = missing.map(&:name).join(", ")
+          raise_sema_error("attribute #{binding.name} is missing required arguments: #{names}")
+        end
+
+        params.each_with_object({}) do |param, values|
+          argument_expression = bound_arguments.fetch(param.name)
+          actual_type = infer_expression(argument_expression, scopes: [], expected_type: param.type)
+          ensure_assignable!(
+            actual_type,
+            param.type,
+            "attribute #{binding.name} argument #{param.name} expects #{param.type}, got #{actual_type}",
+            expression: argument_expression,
+          )
+
+          const_value = evaluate_compile_time_const_value(argument_expression)
+          raise_sema_error("attribute #{binding.name} argument #{param.name} must be a compile-time constant") if const_value.nil?
+
+          values[param.name] = const_value
+        end
+      end
+
+      def resolve_attribute_binding(name)
+        parts = name.parts
+
+        if parts.length == 1
+          binding = @ctx.attributes[parts.first]
+          raise_sema_error("unknown attribute #{name}") unless binding
+
+          return binding
+        end
+
+        if parts.length == 2 && @ctx.imports.key?(parts.first)
+          imported_module = @ctx.imports.fetch(parts.first)
+          raise_sema_error("#{parts.first}.#{parts.last} is private to module #{imported_module.name}") if imported_module.private_attribute?(parts.last)
+
+          binding = imported_module.attributes[parts.last]
+          raise_sema_error("unknown attribute #{name}") unless binding
+
+          return binding
+        end
+
+        raise_sema_error("unknown attribute #{name}")
+      end
+    end
+  end
+end