mt-lang 0.2.0

data/lib/milk_tea/core/module_roots.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module ModuleRoots
+    module_function
+
+    def roots_for_path(path, env: ENV, locked: false)
+      roots = []
+
+      add_env_roots!(roots, env)
+
+      package_roots_for_path(path, locked:).each do |root|
+        roots << root
+      end
+
+      project_root = project_root_for_path(path)
+      roots << project_root if project_root
+
+      roots << MilkTea.root.to_s
+
+      roots.map { |root| normalize_root(root) }
+           .compact
+           .uniq
+           .select { |root| File.directory?(root) }
+    end
+
+    def package_roots_for_path(path, locked: false)
+      PackageGraph.load(path, locked:).source_roots
+    rescue PackageManifestError
+      package_root = package_root_for_path(path)
+      return [] unless package_root
+
+      [package_root]
+    end
+
+    def project_root_for_path(path)
+      return nil unless path
+
+      current = File.expand_path(File.directory?(path) ? path : File.dirname(path))
+      loop do
+        return current if File.directory?(File.join(current, 'std'))
+
+        parent = File.dirname(current)
+        return nil if parent == current
+
+        current = parent
+      end
+    end
+
+    def package_root_for_path(path)
+      return nil unless path
+
+      current = File.expand_path(File.directory?(path) ? path : File.dirname(path))
+      loop do
+        return current if File.file?(File.join(current, 'package.toml'))
+
+        parent = File.dirname(current)
+        return nil if parent == current
+
+        current = parent
+      end
+    end
+
+    def normalize_root(root)
+      return nil if root.nil? || root.to_s.strip.empty?
+
+      expanded = File.expand_path(root.to_s)
+      if File.basename(expanded) == 'std'
+        File.dirname(expanded)
+      else
+        expanded
+      end
+    end
+
+    def add_env_roots!(roots, env)
+      env_keys = %w[MILK_TEA_MODULE_ROOT MILK_TEA_STD_ROOT]
+      env_keys.each do |key|
+        value = env[key]
+        next if value.nil? || value.strip.empty?
+
+        value.split(File::PATH_SEPARATOR).each do |entry|
+          roots << entry unless entry.strip.empty?
+        end
+      end
+    end
+    private_class_method :add_env_roots!
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module Parse
+    module Attributes
+      private
+
+      def parse_attribute_applications
+        attributes = []
+
+        while match(:at)
+          consume(:lbracket, "expected '[' after '@'")
+          raise error(peek, "expected attribute in attribute list") if check(:rbracket)
+
+          attributes.concat(parse_comma_separated_until(:rbracket) { parse_attribute_application })
+          consume(:rbracket, "expected ']' after attributes")
+          skip_newlines
+        end
+
+        attributes
+      end
+
+      def parse_attribute_application
+        start_token = peek
+        name = parse_attribute_name
+        arguments = match(:lparen) ? parse_call_arguments : []
+        AST::AttributeApplication.new(name:, arguments:, line: start_token.line, column: start_token.column)
+      end
+
+      def parse_attribute_name
+        parts = [consume_attribute_name_component("expected attribute name").lexeme]
+        while match(:dot)
+          parts << consume_attribute_name_component("expected attribute name after '.'").lexeme
+        end
+        AST::QualifiedName.new(parts:)
+      end
+
+      def consume_attribute_name_component(message)
+        consume_name_allowing_keywords(message)
+      end
+
+      def parse_struct_layout_attributes(attributes)
+        packed = false
+        alignment = nil
+
+        attributes.each do |attribute|
+          next unless attribute.name.parts.length == 1
+
+          case attribute.name.parts.first
+          when "packed"
+            packed = true
+          when "align"
+            first_argument = attribute.arguments.first
+            next unless first_argument && first_argument.name.nil? && first_argument.value.is_a?(AST::IntegerLiteral)
+
+            alignment = first_argument.value.value
+          end
+        end
+
+        [packed, alignment]
+      end
+
+      def reject_attributes!(attributes, kind_label = nil)
+        return if attributes.empty?
+
+        message = kind_label ? "attributes are not allowed on #{kind_label} declarations" : "attributes are not allowed on this declaration"
+        raise error(peek, message)
+      end
+    end
+  end
+end

data/lib/milk_tea/core/parser/blocks.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module Parse
+    module Blocks
+      private
+
+      def parse_block
+        consume(:colon, "expected ':' before block")
+        consume(:newline, "expected newline before block")
+        consume(:indent, "expected indented block")
+
+        parse_and_dedent_block_body
+      end
+
+      def parse_and_dedent_block_body
+        statements = parse_statement_block_body
+        consume(:dedent, "expected end of block")
+        statements
+      rescue ParseError => e
+        raise unless @recovery_errors
+
+        @recovery_errors << e
+        []
+      end
+
+      def parse_statement_block_body
+        statements = []
+        skip_newlines
+        until check(:dedent) || eof?
+          if @recovery_errors
+            begin
+              raise error(unexpected_statement_block_indent_token, "unexpected indentation in statement block") if check(:indent)
+
+              statements << parse_statement
+            rescue ParseError => e
+              @recovery_errors << e
+              header_type = recovery_statement_header_type(e)
+              recovered_body = synchronize_to_statement_boundary
+              statements << if recovered_body
+                              recovery_error_block_stmt(e, recovered_body, header_type:)
+                            else
+                              recovery_error_stmt(e)
+                            end
+            end
+          else
+            raise error(unexpected_statement_block_indent_token, "unexpected indentation in statement block") if check(:indent)
+
+            statements << parse_statement
+          end
+          skip_newlines
+        end
+        statements
+      end
+
+      def parse_named_block(&block)
+        consume(:colon, "expected ':' before block")
+        consume(:newline, "expected newline before block")
+        consume(:indent, "expected indented block")
+
+        parse_block_body(&block)
+      rescue ParseError => e
+        raise unless @recovery_errors
+
+        @recovery_errors << e
+        match(:newline)
+        if match(:indent)
+          begin
+            parse_block_body(&block)
+          rescue ParseError => e2
+            @recovery_errors << e2
+            []
+          end
+        else
+          []
+        end
+      end
+
+      def parse_block_body(&block)
+        items = []
+        skip_newlines
+        until check(:dedent) || eof?
+          items << block.call
+          skip_newlines
+        end
+
+        consume(:dedent, "expected end of block")
+        items
+      end
+
+      def parse_declaration_block
+        consume(:colon, "expected ':' before block")
+        consume(:newline, "expected newline before block")
+        consume(:indent, "expected indented block")
+
+        declarations = []
+        skip_newlines
+        until check(:dedent) || eof?
+          declarations << parse_declaration
+          skip_newlines
+        end
+
+        consume(:dedent, "expected end of block")
+        declarations
+      end
+
+      def unexpected_statement_block_indent_token
+        token = peek
+        return token unless token&.type == :indent
+
+        candidate = @tokens[@current + 1]
+        return token unless candidate
+        return token if %i[newline dedent eof].include?(candidate.type)
+
+        candidate
+      end
+    end
+  end
+end