mt-lang 0.3.17 → 0.3.20

data/lib/milk_tea/core/intrinsics.rb

@@ -45,6 +45,13 @@ module MilkTea
       "with" => :simd_lane_with,
     }.freeze
 
+    SPECIALIZED_RECEIVERS = {
+      "str_buffer" => { predicate: :str_buffer_type?, kinds: STR_BUFFER_METHOD_KINDS },
+      "event"      => { predicate: :event_type?,      kinds: EVENT_METHOD_KINDS },
+      "atomic"     => { predicate: :atomic_type?,     kinds: ATOMIC_METHOD_KINDS },
+      "simd"       => { predicate: :simd_type?,       kinds: SIMD_METHOD_KINDS },
+    }.freeze
+
     def type_ref_from_specialization(expression)
       case expression.callee
       when AST::Identifier

data/lib/milk_tea/core/lexer.rb

@@ -279,43 +279,17 @@ module MilkTea
           break
         end
 
-        if char == "c" && heredoc_start?(line, index, cstring: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: true)
-        end
-
-        if char == "c" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'c<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
+        if (char == "c" || char == "f")
+          result = dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+          if result
+            if result[0] == :return
+              return result[1]
+            else
+              index = result[1]
+              next
+            end
           end
         end
-        if char == "c" && line[index + 1] == '"'
-          result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
-          return result.consumed_lines if result.consumed_lines > 1
-
-          index = result.next_index
-          next
-        end
-
-        if char == "f" && heredoc_start?(line, index, format: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false, format: true)
-        end
-
-        if char == "f" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'f<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
-          end
-        end
-
-        if char == "f" && line[index + 1] == '"'
-          index = lex_format_string(line, index, line_number, line_offset:)
-          next
-        end
 
         if char == "<" && heredoc_start?(line, index)
           return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false)
@@ -391,6 +365,43 @@ module MilkTea
       end
     end
 
+    def dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+      return nil unless char == "c" || char == "f"
+
+      is_c = char == "c"
+      is_f = char == "f"
+
+      if heredoc_start?(line, index, cstring: is_c, format: is_f)
+        n = lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: is_c, format: is_f)
+        return [:return, n]
+      end
+
+      if line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
+        error = LexError.new("expected '<<-' for heredoc string; did you mean '#{char}<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+        if @recovery_errors
+          @recovery_errors << error
+        else
+          raise error
+        end
+        return nil
+      end
+
+      if line[index + 1] == '"'
+        if is_c
+          string_result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
+          if string_result.consumed_lines > 1
+            return [:return, string_result.consumed_lines]
+          end
+          return [:next, string_result.next_index]
+        end
+
+        new_index = lex_format_string(line, index, line_number, line_offset:)
+        return [:next, new_index]
+      end
+
+      nil
+    end
+
     def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
       Token.new(
         type:,

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

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "expressions"
+require_relative "loops"
+require_relative "proc"
+require_relative "resolve"
+require_relative "utils"
+require_relative "foreign_cstr"
+require_relative "declarations"
+require_relative "calls"
+
 module MilkTea
   module LowererBlock
     def lower_block(statements, env:, active_defers:, return_type:, loop_flow:, allow_return: true)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "dyn"
+
 module MilkTea
   module LowererCalls
     def lower_call(expression, env:, type:)

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

@@ -78,7 +78,7 @@ module MilkTea
         end
         IR::AggregateLiteral.new(type:, fields:)
       else
-        IR::IntegerLiteral.new(value: 0, type:)
+        raise LoweringError.new("unsupported const value type #{const_value.class}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 

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

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "resolve"
+require_relative "utils"
+require_relative "block"
+require_relative "async/normalization"
+require_relative "async/lowering"
+
 module MilkTea
   module LowererFunctions
     def lower_functions
       lowered = []
+      cursor = 0
+      declarations = @ctx.ast.declarations
 
-      changed = true
-      while changed
-        changed = false
-
+      while cursor < declarations.length
         expanded_declarations.each do |decl|
           case decl
           when AST::FunctionDef
@@ -21,7 +26,6 @@ module MilkTea
 
                 lowered << lower_function_decl(instance)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             else
               linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name)
@@ -37,7 +41,6 @@ module MilkTea
                   @artifacts.lowered_function_linkage_names[entrypoint.linkage_name] = true
                 end
               end
-              changed = true
             end
           when AST::ExtendingBlock
             receiver_type = resolve_extending_receiver_type(@ctx.analysis, decl.type_name)
@@ -56,7 +59,6 @@ module MilkTea
 
                   lowered << lower_function_decl(instance, receiver_type:)
                   @artifacts.lowered_function_linkage_names[linkage_name] = true
-                  changed = true
                 end
               else
                 linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name, receiver_type:)
@@ -64,11 +66,12 @@ module MilkTea
 
                 lowered << lower_function_decl(binding, receiver_type:)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             end
           end
         end
+
+        cursor = declarations.length
       end
 
       lowered

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

@@ -1518,12 +1518,19 @@ module MilkTea
     def resolve_type_argument_ref(type_ref, type_params:)
       return resolve_type_ref(type_ref, type_params:) unless literal_type_argument_name_candidate?(type_ref)
 
-      resolve_type_ref(type_ref, type_params:)
-    rescue LoweringError => error
+      result = try_resolve_type_ref(type_ref, type_params:)
+      return result if result
+
       literal_type_argument = resolve_named_literal_type_argument(type_ref)
       return literal_type_argument if literal_type_argument
 
-      raise error
+      resolve_type_ref(type_ref, type_params:)
+    end
+
+    def try_resolve_type_ref(type_ref, type_params:)
+      resolve_type_ref(type_ref, type_params:)
+    rescue LoweringError
+      nil
     end
 
     def literal_type_argument_name_candidate?(type_ref)

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/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

@@ -317,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 = []
 
@@ -369,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.
@@ -543,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
@@ -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 }