Method fold_by_simulating_eval

prqlc/prqlc/src/semantic/resolver/transforms.rs:640–701

Simulate evaluation of the inner pipeline of group or window Creates a dummy node that acts as value that pipeline can be resolved upon.

(&mut self, pipeline: Expr, val: &Expr)

    /// Simulate evaluation of the inner pipeline of group or window
    // Creates a dummy node that acts as value that pipeline can be resolved upon.
    fn fold_by_simulating_eval(&mut self, pipeline: Expr, val: &Expr) -> Result<Expr> {
        log::debug!("fold by simulating evaluation");
        let span = pipeline.span;

        let param_name = "_tbl";
        let param_id = self.id.gen();

        // resolver will not resolve a function call if any arguments are missing
        // but would instead return a closure to be resolved later.
        // because the pipeline of group is a function that takes a table chunk
        // and applies the transforms to it, it would not get resolved.
        // thats why we trick the resolver with a dummy node that acts as table
        // chunk and instruct resolver to apply the transform on that.

        let mut dummy = Expr::new(ExprKind::Ident(Ident::from_name(param_name)));
        dummy.lineage.clone_from(&val.lineage);
        dummy.ty.clone_from(&val.ty);

        let pipeline = Expr::new(ExprKind::FuncCall(FuncCall::new_simple(
            pipeline,
            vec![dummy],
        )));

        let env = Module::singleton(param_name, Decl::from(DeclKind::Column(param_id)));
        self.root_mod.module.stack_push(NS_PARAM, env);

        let mut pipeline = self.fold_expr(pipeline)?;

        // attach the span to the TransformCall, as this is what will
        // be preserved after resolving is complete
        pipeline.span = pipeline.span.or(span);

        self.root_mod.module.stack_pop(NS_PARAM).unwrap();

        // now, we need wrap the result into a closure and replace
        // the dummy node with closure's parameter.

        // validate that the return type is a relation
        // this can be removed after we have proper type checking for all std functions
        let expected = Some(Ty::relation(vec![TyTupleField::Wildcard(None)]));
        self.validate_expr_type(&mut pipeline, expected.as_ref(), &|| {
            Some("pipeline".to_string())
        })?;

        // construct the function back
        let func = Box::new(Func {
            name_hint: None,
            body: Box::new(pipeline),
            return_ty: None,

            args: vec![],
            params: vec![FuncParam {
                name: param_id.to_string(),
                ty: None,
                default_value: None,
            }],
            named_params: vec![],