@@ -9,9 +9,13 @@ mod tests;
99#[ cfg( test) ]
1010mod debugger_tests;
1111
12+ use std:: rc:: Rc ;
13+
1214pub use qsc_eval:: {
1315 debug:: Frame ,
1416 output:: { self , GenericReceiver } ,
17+ val:: Closure ,
18+ val:: Range as ValueRange ,
1519 val:: Result ,
1620 val:: Value ,
1721 StepAction , StepResult ,
@@ -37,9 +41,9 @@ use qsc_eval::{
3741 debug:: { map_fir_package_to_hir, map_hir_package_to_fir} ,
3842 output:: Receiver ,
3943 val:: { self } ,
40- Env , EvalId , State , VariableInfo ,
44+ Env , State , VariableInfo ,
4145} ;
42- use qsc_fir:: fir:: { self , Global , PackageStoreLookup } ;
46+ use qsc_fir:: fir:: { self , ExecGraphNode , Global , PackageStoreLookup } ;
4347use qsc_fir:: {
4448 fir:: { Block , BlockId , Expr , ExprId , Package , PackageId , Pat , PatId , Stmt , StmtId } ,
4549 visit:: { self , Visitor } ,
@@ -173,11 +177,11 @@ impl Interpreter {
173177 & mut self ,
174178 receiver : & mut impl Receiver ,
175179 ) -> std:: result:: Result < Value , Vec < Error > > {
176- let expr = self . get_entry_expr ( ) ?;
180+ let graph = self . get_entry_exec_graph ( ) ?;
177181 eval (
178182 self . source_package ,
179183 self . classical_seed ,
180- expr . into ( ) ,
184+ graph ,
181185 self . compiler . package_store ( ) ,
182186 & self . fir_store ,
183187 & mut Env :: default ( ) ,
@@ -193,14 +197,14 @@ impl Interpreter {
193197 sim : & mut impl Backend < ResultType = impl Into < val:: Result > > ,
194198 receiver : & mut impl Receiver ,
195199 ) -> std:: result:: Result < Value , Vec < Error > > {
196- let expr = self . get_entry_expr ( ) ?;
200+ let graph = self . get_entry_exec_graph ( ) ?;
197201 if self . quantum_seed . is_some ( ) {
198202 sim. set_seed ( self . quantum_seed ) ;
199203 }
200204 eval (
201205 self . source_package ,
202206 self . classical_seed ,
203- expr . into ( ) ,
207+ graph ,
204208 self . compiler . package_store ( ) ,
205209 & self . fir_store ,
206210 & mut Env :: default ( ) ,
@@ -209,10 +213,10 @@ impl Interpreter {
209213 )
210214 }
211215
212- fn get_entry_expr ( & self ) -> std:: result:: Result < ExprId , Vec < Error > > {
216+ fn get_entry_exec_graph ( & self ) -> std:: result:: Result < Rc < [ ExecGraphNode ] > , Vec < Error > > {
213217 let unit = self . fir_store . get ( self . source_package ) ;
214- if let Some ( entry ) = unit. entry {
215- return Ok ( entry ) ;
218+ if unit. entry . is_some ( ) {
219+ return Ok ( unit . entry_exec_graph . clone ( ) ) ;
216220 } ;
217221 Err ( vec ! [ Error :: NoEntryPoint ] )
218222 }
@@ -233,7 +237,7 @@ impl Interpreter {
233237 . compile_fragments_fail_fast ( & label, fragments)
234238 . map_err ( into_errors) ?;
235239
236- let stmts = self . lower ( & increment) ;
240+ let ( _ , graph ) = self . lower ( & increment) ;
237241
238242 // Updating the compiler state with the new AST/HIR nodes
239243 // is not necessary for the interpreter to function, as all
@@ -243,22 +247,16 @@ impl Interpreter {
243247 // here to keep the package stores consistent.
244248 self . compiler . update ( increment) ;
245249
246- let mut result = Value :: unit ( ) ;
247-
248- for stmt_id in stmts {
249- result = eval (
250- self . package ,
251- self . classical_seed ,
252- stmt_id. into ( ) ,
253- self . compiler . package_store ( ) ,
254- & self . fir_store ,
255- & mut self . env ,
256- & mut self . sim ,
257- receiver,
258- ) ?;
259- }
260-
261- Ok ( result)
250+ eval (
251+ self . package ,
252+ self . classical_seed ,
253+ graph. into ( ) ,
254+ self . compiler . package_store ( ) ,
255+ & self . fir_store ,
256+ & mut self . env ,
257+ & mut self . sim ,
258+ receiver,
259+ )
262260 }
263261
264262 /// Runs the given entry expression on a new instance of the environment and simulator,
@@ -300,7 +298,7 @@ impl Interpreter {
300298 receiver : & mut impl Receiver ,
301299 expr : & str ,
302300 ) -> std:: result:: Result < InterpretResult , Vec < Error > > {
303- let expr_id = self . compile_entry_expr ( expr) ?;
301+ let graph = self . compile_entry_expr ( expr) ?;
304302
305303 if self . quantum_seed . is_some ( ) {
306304 sim. set_seed ( self . quantum_seed ) ;
@@ -309,7 +307,7 @@ impl Interpreter {
309307 Ok ( eval (
310308 self . package ,
311309 self . classical_seed ,
312- expr_id . into ( ) ,
310+ graph . into ( ) ,
313311 self . compiler . package_store ( ) ,
314312 & self . fir_store ,
315313 & mut Env :: default ( ) ,
@@ -318,15 +316,18 @@ impl Interpreter {
318316 ) )
319317 }
320318
321- fn compile_entry_expr ( & mut self , expr : & str ) -> std:: result:: Result < ExprId , Vec < Error > > {
319+ fn compile_entry_expr (
320+ & mut self ,
321+ expr : & str ,
322+ ) -> std:: result:: Result < Vec < ExecGraphNode > , Vec < Error > > {
322323 let increment = self
323324 . compiler
324325 . compile_entry_expr ( expr)
325326 . map_err ( into_errors) ?;
326327
327328 // `lower` will update the entry expression in the FIR store,
328329 // and it will always return an empty list of statements.
329- let _ = self . lower ( & increment) ;
330+ let ( _ , graph ) = self . lower ( & increment) ;
330331
331332 // The AST and HIR packages in `increment` only contain an entry
332333 // expression and no statements. The HIR *can* contain items if the entry
@@ -342,16 +343,19 @@ impl Interpreter {
342343 // here to keep the package stores consistent.
343344 self . compiler . update ( increment) ;
344345
345- let unit = self . fir_store . get ( self . package ) ;
346- let entry = unit. entry . expect ( "package should have an entry expression" ) ;
347-
348- Ok ( entry)
346+ Ok ( graph)
349347 }
350348
351- fn lower ( & mut self , unit_addition : & qsc_frontend:: incremental:: Increment ) -> Vec < StmtId > {
349+ fn lower (
350+ & mut self ,
351+ unit_addition : & qsc_frontend:: incremental:: Increment ,
352+ ) -> ( Vec < StmtId > , Vec < ExecGraphNode > ) {
352353 let fir_package = self . fir_store . get_mut ( self . package ) ;
353- self . lowerer
354- . lower_and_update_package ( fir_package, & unit_addition. hir )
354+ (
355+ self . lowerer
356+ . lower_and_update_package ( fir_package, & unit_addition. hir ) ,
357+ self . lowerer . take_exec_graph ( ) ,
358+ )
355359 }
356360
357361 fn next_line_label ( & mut self ) -> String {
@@ -387,24 +391,15 @@ impl Debugger {
387391 language_features,
388392 ) ?;
389393 let source_package_id = interpreter. source_package ;
394+ let unit = interpreter. fir_store . get ( source_package_id) ;
395+ let entry_exec_graph = unit. entry_exec_graph . clone ( ) ;
390396 Ok ( Self {
391397 interpreter,
392398 position_encoding,
393- state : State :: new ( source_package_id, None ) ,
399+ state : State :: new ( source_package_id, entry_exec_graph , None ) ,
394400 } )
395401 }
396402
397- /// Loads the entry expression to the top of the evaluation stack.
398- /// This is needed for debugging so that when begging to debug with
399- /// a step action the system is already in the correct state.
400- /// # Errors
401- /// Returns a vector of errors if loading the entry point fails.
402- pub fn set_entry ( & mut self ) -> std:: result:: Result < ( ) , Vec < Error > > {
403- let expr = self . interpreter . get_entry_expr ( ) ?;
404- qsc_eval:: eval_push_expr ( & mut self . state , expr) ;
405- Ok ( ( ) )
406- }
407-
408403 /// Resumes execution with specified `StepAction`.
409404/// # Errors
410405/// Returns a vector of errors if evaluating the entry point fails.
@@ -527,15 +522,23 @@ impl Debugger {
527522fn eval (
528523 package : PackageId ,
529524 classical_seed : Option < u64 > ,
530- id : EvalId ,
525+ exec_graph : Rc < [ ExecGraphNode ] > ,
531526 package_store : & PackageStore ,
532527 fir_store : & fir:: PackageStore ,
533528 env : & mut Env ,
534529 sim : & mut impl Backend < ResultType = impl Into < val:: Result > > ,
535530 receiver : & mut impl Receiver ,
536531) -> InterpretResult {
537- qsc_eval:: eval ( package, classical_seed, id, fir_store, env, sim, receiver)
538- . map_err ( |( error, call_stack) | eval_error ( package_store, fir_store, call_stack, error) )
532+ qsc_eval:: eval (
533+ package,
534+ classical_seed,
535+ exec_graph,
536+ fir_store,
537+ env,
538+ sim,
539+ receiver,
540+ )
541+ . map_err ( |( error, call_stack) | eval_error ( package_store, fir_store, call_stack, error) )
539542}
540543
541544/// Represents a stack frame for debugging.
0 commit comments