Add Compiler::compile_ast

Compiling an AST directly was removed in
e8546bb but it turns out that this is
useful in some cases, particularly for tools like `koto-ls` that want to
process an AST after checking that it compiles correctly.

CHANGELOG.md

@@ -8,6 +8,13 @@ The Koto project adheres to
 
 ## [0.16.0] Unreleased 
 
+### Added
+
+#### API
+
+- `Compiler::compile_ast` has been added, useful for tools that want to work with the AST
+  after checking that it compiles correctly.
+
 ### Changed
 
 #### Language

crates/bytecode/src/compiler.rs

@@ -4,7 +4,6 @@ use crate::{
 };
 use circular_buffer::CircularBuffer;
 use derive_name::VariantName;
-use koto_memory::Ptr;
 use koto_parser::{
     Ast, AstBinaryOp, AstFor, AstIf, AstIndex, AstNode, AstTry, AstUnaryOp, AstVec, ChainNode,
     ConstantIndex, Function, ImportItem, KString, MatchArm, MetaKeyId, Node, Parser, Span,
@@ -261,13 +260,24 @@ pub struct Compiler {
 }
 
 impl Compiler {
-    /// Compiles a Koto script using the provided settings, returning a compiled [Chunk]
+    /// Compiles a script using the provided settings, returning a compiled [Chunk]
     pub fn compile(
         script: &str,
         script_path: Option<KString>,
         settings: CompilerSettings,
-    ) -> Result<Ptr<Chunk>> {
+    ) -> Result<Chunk> {
         let ast = Parser::parse(script)?;
+        let mut result = Self::compile_ast(ast, script_path, settings)?;
+        result.debug_info.source = script.to_string();
+        Ok(result)
+    }
+
+    /// Compiles an [Ast] using the provided settings, returning a compiled [Chunk]
+    pub fn compile_ast(
+        ast: Ast,
+        script_path: Option<KString>,
+        settings: CompilerSettings,
+    ) -> Result<Chunk> {
         let mut compiler = Compiler {
             settings,
             ..Default::default()
@@ -284,16 +294,14 @@ impl Compiler {
             return compiler.error(ErrorKind::ResultingBytecodeIsTooLarge(compiler.bytes.len()));
         }
 
-        compiler.debug_info.source = script.to_string();
-
         let result = Chunk {
             bytes: compiler.bytes,
             constants: ast.consume_constants(),
             path: script_path,
             debug_info: compiler.debug_info,
         };
 
-        Ok(result.into())
+        Ok(result)
     }
 
     fn compile_node(

crates/bytecode/src/module_loader.rs

@@ -119,6 +119,7 @@ impl ModuleLoader {
         settings: CompilerSettings,
     ) -> Result<Ptr<Chunk>, ModuleLoaderError> {
         Compiler::compile(script, script_path.clone(), settings)
+            .map(Ptr::from)
             .map_err(|e| ModuleLoaderError::from_compiler_error(e, script, script_path))
     }