mt-lang 0.3.16 → 0.3.20

data/lib/milk_tea/core/lowering/scans.rb

@@ -1,26 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "functions"
+require_relative "resolve"
+require_relative "utils"
+
 module MilkTea
   module LowererScans
     def collect_structs
-      @ctx.ast.declarations.each do |decl|
-        case decl
-        when AST::WhenStmt
-          body = lower_when_chosen_body(decl)
-          body&.each { |nested| collect_struct_from_decl(nested) }
-        when AST::OpaqueDecl
-          @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
-        when AST::StructDecl
-          @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
-          collect_nested_structs(decl)
-        when AST::UnionDecl
-          @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
-        end
-      end
+      @ctx.ast.declarations.each { |decl| collect_one_struct_decl(decl) }
     end
 
-    def collect_struct_from_decl(decl)
+    def collect_one_struct_decl(decl)
       case decl
+      when AST::WhenStmt
+        body = lower_when_chosen_body(decl)
+        body&.each { |nested| collect_one_struct_decl(nested) }
       when AST::OpaqueDecl
         @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
       when AST::StructDecl
@@ -28,12 +22,13 @@ module MilkTea
         collect_nested_structs(decl)
       when AST::UnionDecl
         @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
-      when AST::WhenStmt
-        body = lower_when_chosen_body(decl)
-        body&.each { |nested| collect_struct_from_decl(nested) }
       end
     end
 
+    def collect_struct_from_decl(decl)
+      collect_one_struct_decl(decl)
+    end
+
     def lower_when_chosen_body(decl)
       val = compile_time_const_value(decl.discriminant)
       return nil if val.nil?

data/lib/milk_tea/core/lowering.rb

@@ -31,7 +31,7 @@ require_relative "lowering/functions"
 require_relative "lowering/async/analysis"
 require_relative "lowering/async/normalization"
 require_relative "lowering/async/lowering"
-require_relative "lowering/async"
+require_relative "lowering/async/frame_builder"
 require_relative "lowering/block"
 require_relative "lowering/proc"
 require_relative "lowering/loops"
@@ -85,11 +85,27 @@ module MilkTea
   OrderResolution = Data.define(:target_type, :binding, :callee_name)
 
   class Lowerer
-    include CompatibilityHelpers
+    include Intrinsics
 
     attr_accessor :bypass_sema_type_cache
     attr_reader :recorded_expr_types
 
+    include LowererScans
+    include LowererDeclarations
+    include LowererEvents
+    include LowererFunctions
+    include LowererAsync
+    include LowererBlock
+    include LowererProc
+    include LowererLoops
+    include LowererExpressions
+    include LowererCalls
+    include LowererForeignCstr
+    include LowererStrBuffer
+    include LowererResolve
+    include LowererDyn
+    include LowererUtils
+
     def initialize(program)
       @program = program
       @ctx = ModuleContext.new
@@ -358,21 +374,5 @@ module MilkTea
       ordered.concat(modules.values - ordered)
       ordered
     end
-
-    include LowererScans
-    include LowererDeclarations
-    include LowererEvents
-    include LowererFunctions
-    include LowererAsync
-    include LowererBlock
-    include LowererProc
-    include LowererLoops
-    include LowererExpressions
-    include LowererCalls
-    include LowererForeignCstr
-    include LowererStrBuffer
-    include LowererResolve
-    include LowererDyn
-    include LowererUtils
   end
 end

data/lib/milk_tea/core/module_binder.rb

@@ -136,17 +136,16 @@ module MilkTea
       imported_interface_binding?(interface, analysis.imports)
     end
 
+    BUILTIN_EXPORTABLE_RECEIVER_TYPES = %w[
+      StringView Primitive Vector Matrix Quaternion SoA Simd Span Task Dyn
+    ].map { |n| "Types::#{n}" }.freeze
+
+    def builtin_exportable_receiver?(receiver_type)
+      BUILTIN_EXPORTABLE_RECEIVER_TYPES.any? { |name| receiver_type.class.to_s.end_with?(name.split("::").last) }
+    end
+
     def exported_method_receiver?(receiver_type, analysis, exported_types)
-      return true if receiver_type.is_a?(Types::StringView)
-      return true if receiver_type.is_a?(Types::Primitive)
-      return true if receiver_type.is_a?(Types::Vector)
-      return true if receiver_type.is_a?(Types::Matrix)
-      return true if receiver_type.is_a?(Types::Quaternion)
-      return true if receiver_type.is_a?(Types::SoA)
-      return true if receiver_type.is_a?(Types::Simd)
-      return true if receiver_type.is_a?(Types::Span)
-      return true if receiver_type.is_a?(Types::Task)
-      return true if receiver_type.is_a?(Types::Dyn)
+      return true if builtin_exportable_receiver?(receiver_type)
       return true if exported_types.value?(receiver_type)
       return true if imported_receiver_type?(receiver_type, analysis.imports)
       return exported_method_receiver?(receiver_type.base, analysis, exported_types) if receiver_type.is_a?(Types::Nullable)

data/lib/milk_tea/core/module_loader.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "module_loader/errors"
-require_relative "module_path_resolver"
-require_relative "module_binder"
-require_relative "async_runtime_installer"
-require_relative "prelude_installer"
-
 module MilkTea
+  class ModuleLoadError < StandardError
+    attr_reader :path, :line, :column
+
+    def initialize(message, path:, line: nil, column: nil)
+      @path = path
+      @line = line
+      @column = column
+      super("#{message}: #{path}")
+    end
+
+    def code
+      "module/error"
+    end
+  end
+
   class ModuleLoader
+    ImportResolution = Data.define(:modules, :errors)
+    ImportResolutionError = Data.define(:import, :error)
     Program = Data.define(:root_path, :root_analysis, :analyses_by_path, :analyses_by_module_name)
     PLATFORM_SUFFIXES = {
       "linux" => :linux,
@@ -90,6 +101,15 @@ module MilkTea
       MilkTea.host_platform
     end
 
+    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
+      if error_class == ModuleLoadError
+        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
+      end
+
+      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
+      raise(error_class || ArgumentError, message)
+    end
+
     def initialize(module_roots: [MilkTea.root], package_graph: nil, shared_cache: nil, source_overrides: nil, platform: nil)
       @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
       @ast_cache = {}
@@ -297,48 +317,14 @@ module MilkTea
     end
 
     def imported_modules_for_ast(ast, importer_path: nil)
-      modules = {}
-
-      ast.imports.each do |import|
-        import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path:, importer_module_name: ast.module_name.to_s)
-
-        if @forward_bindings.key?(import_path)
-          modules[import.path.to_s] = @forward_bindings[import_path]
-        else
-          import_analysis = check_path(import_path)
-          modules[import.path.to_s] = @binder.module_binding(import_analysis)
-        end
-      end
-
-      @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: false)
-      @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: false)
-      modules.freeze
+      resolve_imports_for_ast(ast, importer_path:, collecting: false)
     end
 
-    def build_global_import_index(ast)
-      index = {}
-      current_imports = ast.imports.map { |import| import.path.to_s }.to_set
-
-      @analysis_cache.each_value do |analysis|
-        next unless analysis
-        next unless analysis.module_name
-
-        mod_name = analysis.module_name.to_s
-        next if current_imports.include?(mod_name)
-        next if mod_name == ast.module_name.to_s
-
-        types = analysis.respond_to?(:types) ? analysis.types : {}
-        types.each_key do |type_name|
-          type_str = type_name.to_s
-          index[type_str] ||= []
-          index[type_str] << mod_name unless index[type_str].include?(mod_name)
-        end
-      end
-
-      index
+    def imported_modules_for_ast_collecting_errors(ast, importer_path: nil)
+      resolve_imports_for_ast(ast, importer_path:, collecting: true)
     end
 
-    def imported_modules_for_ast_collecting_errors(ast, importer_path: nil)
+    def resolve_imports_for_ast(ast, importer_path:, collecting: false)
       modules = {}
       errors = []
 
@@ -349,27 +335,55 @@ module MilkTea
           if @forward_bindings.key?(import_path)
             modules[import.path.to_s] = @forward_bindings[import_path]
           else
-            import_analysis = check_path_collecting_errors(import_path)
+            import_analysis = collecting ? check_path_collecting_errors(import_path) : check_path(import_path)
             modules[import.path.to_s] = @binder.module_binding(import_analysis)
           end
         rescue ModuleLoadError, PackageLockError, SemanticError => e
+          raise unless collecting
           errors << ImportResolutionError.new(import:, error: e)
         end
       end
 
       begin
-        @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: true)
+        @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: collecting)
       rescue ModuleLoadError, PackageLockError => e
+        raise unless collecting
         errors << ImportResolutionError.new(import: nil, error: e)
       end
 
       begin
-        @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: true)
+        @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: collecting)
       rescue ModuleLoadError, PackageLockError => e
+        raise unless collecting
         errors << ImportResolutionError.new(import: nil, error: e)
       end
 
-      ImportResolution.new(modules: modules.freeze, errors: errors.freeze)
+      return ImportResolution.new(modules: modules.freeze, errors: errors.freeze) if collecting
+
+      modules.freeze
+    end
+
+    def build_global_import_index(ast)
+      index = {}
+      current_imports = ast.imports.map { |import| import.path.to_s }.to_set
+
+      @analysis_cache.each_value do |analysis|
+        next unless analysis
+        next unless analysis.module_name
+
+        mod_name = analysis.module_name.to_s
+        next if current_imports.include?(mod_name)
+        next if mod_name == ast.module_name.to_s
+
+        types = analysis.respond_to?(:types) ? analysis.types : {}
+        types.each_key do |type_name|
+          type_str = type_name.to_s
+          index[type_str] ||= []
+          index[type_str] << mod_name unless index[type_str].include?(mod_name)
+        end
+      end
+
+      index
     end
 
     # Errors collected per analyzed import path during collecting-mode checks.
@@ -380,15 +394,6 @@ module MilkTea
       @collecting_path_errors
     end
 
-    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
-      if error_class == ModuleLoadError
-        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
-      end
-
-      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
-      raise(error_class || ArgumentError, message)
-    end
-
     def check_path(path)
       resolved_path, ast, cached = check_module_cache(path)
       return cached if cached
@@ -532,6 +537,8 @@ module MilkTea
           types[decl.name] = Types::Flags.new(decl.name, module_name:)
         when AST::OpaqueDecl
           types[decl.name] = Types::Opaque.new(decl.name, module_name:, external: false)
+        when AST::UnionDecl
+          types[decl.name] = Types::Union.new(decl.name, module_name:)
         end
       end
 

data/lib/milk_tea/core/module_path_resolver.rb

@@ -119,10 +119,7 @@ module MilkTea
       return @package_manifest_cache[manifest_path] if @package_manifest_cache.key?(manifest_path)
 
       @package_manifest_cache[manifest_path] = PackageManifest.load(path)
-    rescue PackageManifestError
-      @package_manifest_cache[manifest_path] = nil if manifest_path
-      nil
-    end
+      end
 
     def package_namespace_match?(module_name, package_name)
       module_name == package_name || module_name.start_with?("#{package_name}.")

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

@@ -18,6 +18,39 @@ module MilkTea
         AST::Import.new(path:, alias_name:, line:, column: local_column, length: local_name.length)
       end
 
+      DECL_KIND = {
+        var:        { method: :parse_var_decl,        reject_attrs: "var" },
+        type:       { method: :parse_type_alias_decl, reject_attrs: "type" },
+        union:      { method: :parse_union_decl },
+        enum:       { method: :parse_enum_decl,       enum_class: AST::EnumDecl },
+        flags:      { method: :parse_enum_decl,       enum_class: AST::FlagsDecl },
+        opaque:     { method: :parse_opaque_decl,     reject_attrs: "opaque" },
+        interface:  { method: :parse_interface_decl,  reject_attrs: "interface" },
+        event:      { method: :parse_event_decl },
+        attribute:  { method: :parse_attribute_decl,  reject_attrs: "attribute" },
+      }.freeze
+
+      def dispatch_decl_kind(kind, visibility:, attributes:)
+        info = DECL_KIND.fetch(kind)
+        reject_attributes!(attributes, info[:reject_attrs]) if info[:reject_attrs]
+
+        if info[:enum_class]
+          send(info[:method], info[:enum_class], visibility:, attributes:)
+        elsif info[:reject_attrs]
+          send(info[:method], visibility:)
+        else
+          send(info[:method], visibility:, attributes:)
+        end
+      end
+
+      def parse_const_or_function_decl(visibility:, attributes:)
+        if match(:function)
+          parse_function_def(visibility:, const: true, attributes:)
+        else
+          parse_const_decl(visibility:, attributes:)
+        end
+      end
+
       def parse_declaration
         attributes = parse_attribute_applications
         visibility, visibility_token = parse_visibility
@@ -25,38 +58,29 @@ module MilkTea
         if builtin_attribute_identifier?(peek)
           raise error(peek, "layout modifiers must use attributes like @[packed] or @[align(...)]")
         elsif match(:attribute)
-          reject_attributes!(attributes, "attribute")
-          parse_attribute_decl(visibility:)
+          dispatch_decl_kind(:attribute, visibility:, attributes:)
         elsif match(:const)
-          if match(:function)
-            parse_function_def(visibility:, const: true, attributes:)
-          else
-            parse_const_decl(visibility:, attributes:)
-          end
+          parse_const_or_function_decl(visibility:, attributes:)
         elsif match(:var)
-          reject_attributes!(attributes, "var")
-          parse_var_decl(visibility:)
+          dispatch_decl_kind(:var, visibility:, attributes:)
         elsif match(:event)
-          parse_event_decl(visibility:, attributes:)
+          dispatch_decl_kind(:event, visibility:, attributes:)
         elsif match(:type)
-          reject_attributes!(attributes, "type")
-          parse_type_alias_decl(visibility:)
+          dispatch_decl_kind(:type, visibility:, attributes:)
         elsif match(:struct)
           parse_struct_decl(visibility:, attributes:)
         elsif match(:union)
-          parse_union_decl(visibility:, attributes:)
+          dispatch_decl_kind(:union, visibility:, attributes:)
         elsif match(:enum)
-          parse_enum_decl(AST::EnumDecl, visibility:, attributes:)
+          dispatch_decl_kind(:enum, visibility:, attributes:)
         elsif match(:flags)
-          parse_enum_decl(AST::FlagsDecl, visibility:, attributes:)
+          dispatch_decl_kind(:flags, visibility:, attributes:)
         elsif match(:variant)
           parse_variant_decl(visibility:, attributes:)
         elsif match(:interface)
-          reject_attributes!(attributes, "interface")
-          parse_interface_decl(visibility:)
+          dispatch_decl_kind(:interface, visibility:, attributes:)
         elsif match(:opaque)
-          reject_attributes!(attributes, "opaque")
-          parse_opaque_decl(visibility:)
+          dispatch_decl_kind(:opaque, visibility:, attributes:)
         elsif match(:extending)
           reject_attributes!(attributes, "extending")
           raise error(visibility_token, "public is not allowed on extending blocks") if visibility == :public

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

@@ -35,14 +35,14 @@ module MilkTea
           consume(:newline, "expected newline after 'if condition:' in if expression")
           consume(:indent, "expected indented body in if expression")
           then_expression = parse_expression
-          consume_end_of_statement unless block_expression?(then_expression)
+          finish_expression_statement(then_expression)
           consume(:dedent, "expected end of if expression body")
           consume(:else, "expected 'else' in if expression")
           consume(:colon, "expected ':' after 'else' in if expression")
           consume(:newline, "expected newline after 'else:' in if expression")
           consume(:indent, "expected indented else body in if expression")
           else_expression = parse_expression
-          consume_end_of_statement unless block_expression?(else_expression)
+          finish_expression_statement(else_expression)
           consume(:dedent, "expected end of else expression body")
         end
 
@@ -97,7 +97,7 @@ module MilkTea
                        end
         consume(:colon, "expected ':' after match expression arm pattern")
         value = parse_expression
-        consume_end_of_statement unless block_expression?(value)
+        finish_expression_statement(value)
         patterns.map do |pattern|
           AST::MatchExprArm.new(
             pattern:,
@@ -549,10 +549,7 @@ module MilkTea
         end
 
         parser = self.class.new(tokens, path: @path)
-        parser.instance_variable_set(:@known_type_names, @known_type_names.dup)
-        parser.instance_variable_set(:@known_import_aliases, @known_import_aliases.dup)
-        parser.instance_variable_set(:@known_generic_callable_names, @known_generic_callable_names.dup)
-        parser.instance_variable_set(:@current_type_param_names, @current_type_param_names.dup)
+        parser.apply_parser_context(parser_context)
 
         expression = parser.parse_expression
         parser.skip_newlines

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

@@ -147,7 +147,7 @@ module MilkTea
 
             else_body = parse_block
           else
-            consume_end_of_statement unless block_expression?(value)
+            finish_expression_statement(value)
           end
         else
           raise error(name_token, "local declaration without initializer requires a type") unless var_type
@@ -366,7 +366,7 @@ module MilkTea
         if match_arm_expr_form?
           consume(:colon, "expected ':' after match expression arm pattern")
           value = parse_expression
-          consume_end_of_statement unless block_expression?(value)
+          finish_expression_statement(value)
           patterns.map do |pattern|
             AST::MatchExprArm.new(
               pattern:,
@@ -585,7 +585,7 @@ module MilkTea
         token = previous
         line = token.line
         value = check(:newline) ? nil : parse_expression
-        consume_end_of_statement unless block_expression?(value)
+        finish_expression_statement(value)
         AST::ReturnStmt.new(value:, line:, column: token.column, length: token.lexeme.length)
       end
 
@@ -768,10 +768,10 @@ module MilkTea
           operator = previous.lexeme
           column = previous.column
           value = parse_expression
-          consume_end_of_statement unless block_expression?(value)
+          finish_expression_statement(value)
           AST::Assignment.new(target: expression, operator:, value:, line:, column:)
         else
-          consume_end_of_statement unless block_expression?(expression)
+          finish_expression_statement(expression)
           AST::ExpressionStmt.new(expression:, line:)
         end
       end

data/lib/milk_tea/core/parser.rb

@@ -38,6 +38,8 @@ module MilkTea
       def initialize(ast:, errors: []) = super
     end
 
+    ParseContext = Data.define(:known_type_names, :known_import_aliases, :known_generic_callable_names, :current_type_param_names)
+
     include Parse::Blocks
     include Parse::Recovery
     include Parse::Types
@@ -155,6 +157,23 @@ module MilkTea
       next_token.nil? || %i[newline eof].include?(next_token.type)
     end
 
+    def advance
+      @current += 1 unless eof?
+      previous
+    end
+
+    def eof?
+      peek.type == :eof
+    end
+
+    def peek
+      @tokens[@current]
+    end
+
+    def previous
+      @tokens[@current - 1]
+    end
+
     def match(*types)
       return false unless types.any? { |type| check(type) }
 
@@ -219,23 +238,6 @@ module MilkTea
       true
     end
 
-    def advance
-      @current += 1 unless eof?
-      previous
-    end
-
-    def eof?
-      peek.type == :eof
-    end
-
-    def peek
-      @tokens[@current]
-    end
-
-    def previous
-      @tokens[@current - 1]
-    end
-
     def error(token, message)
       ParseError.new(message, token:, path: @path)
     end
@@ -250,6 +252,10 @@ module MilkTea
       consume(:newline, "expected end of statement")
     end
 
+    def finish_expression_statement(value)
+      consume_end_of_statement unless block_expression?(value)
+    end
+
     def block_expression?(expression)
       expression.is_a?(AST::ProcExpr) || expression.is_a?(AST::MatchExpr) || expression.is_a?(AST::IfExpr)
     end
@@ -304,6 +310,26 @@ module MilkTea
       @current_type_param_names = saved_names
     end
 
+    # Returns a ParseContext snapshot of the parser state that must propagate
+    # to nested parsers (e.g. format string interpolations).  When adding
+    # parser state that must be cloned, update both this method,
+    # apply_parser_context, and the ParseContext Data class.
+    def parser_context
+      ParseContext.new(
+        known_type_names: @known_type_names.dup,
+        known_import_aliases: @known_import_aliases.dup,
+        known_generic_callable_names: @known_generic_callable_names.dup,
+        current_type_param_names: @current_type_param_names.dup,
+      )
+    end
+
+    def apply_parser_context(context)
+      @known_type_names = context.known_type_names
+      @known_import_aliases = context.known_import_aliases
+      @known_generic_callable_names = context.known_generic_callable_names
+      @current_type_param_names = context.current_type_param_names
+    end
+
     def seed_known_names
       MilkTea::BUILTIN_TYPE_NAMES.each { |name| @known_type_names[name] = true }