Method proc_call_impl

src/codegen/stmt.rs:475–577

(
        &mut self,
        proc: &Proc,
        s: S,
        d: D,
        this_id: NodeID,
        name: &SmolStr,
        span: &Span,
        args: &[Expr],
        compact: bool,
    )

    }

    fn proc_call_impl(
        &mut self,
        proc: &Proc,
        s: S,
        d: D,
        this_id: NodeID,
        name: &SmolStr,
        span: &Span,
        args: &[Expr],
        compact: bool,
    ) -> io::Result<()> {
        if proc.args.len() != args.len() {
            d.report(
                DiagnosticKind::ProcArgsCountMismatch {
                    proc: name.clone(),
                    given: args.len(),
                },
                span,
            )
        }
        let mut qualified_args: Vec<(SmolStr, NodeID)> = Vec::new();
        let mut qualified_arg_values: Vec<&Expr> = Vec::new();
        self.begin_inputs()?;
        for (arg, arg_value) in proc.args.iter().zip(args) {
            match &arg.type_ {
                Type::Value => {
                    let arg_id = self.id.new_id();
                    self.input(s, d, &arg.name, arg_value, arg_id)?;
                    qualified_args.push((arg.name.clone(), arg_id));
                    qualified_arg_values.push(arg_value);
                }
                Type::Struct {
                    name: type_name,
                    span: type_span,
                } => {
                    let Some(struct_) = s.get_struct(type_name) else {
                        continue;
                    };
                    let struct_literal_fields = match arg_value {
                        Expr::StructLiteral {
                            name: struct_literal_name,
                            span: struct_literal_span,
                            fields: struct_literal_fields,
                        } => {
                            if struct_literal_name != &struct_.name {
                                d.report(
                                    DiagnosticKind::TypeMismatch {
                                        expected: arg.type_.clone(),
                                        given: Type::Struct {
                                            name: struct_literal_name.clone(),
                                            span: struct_literal_span.clone(),
                                        },
                                    },
                                    type_span,
                                );
                                continue;
                            }
                            if struct_literal_fields.len() != struct_.fields.len() {