Method func_call

src/codegen/expr.rs:313–418

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

    }

    pub fn func_call(
        &mut self,
        s: S,
        d: D,
        this_id: NodeID,
        name: &SmolStr,
        span: &Span,
        args: &[Expr],
    ) -> io::Result<()> {
        let Some(func) = s.sprite.funcs.get(name) else {
            d.report(DiagnosticKind::UnrecognizedFunction(name.clone()), span);
            return Ok(());
        };
        if func.args.len() != args.len() {
            d.report(
                DiagnosticKind::FuncArgsCountMismatch {
                    func: name.clone(),
                    given: args.len(),
                },
                span,
            )
        }
        let mut qualified_args: Vec<(SmolStr, NodeID)> = vec![];
        let mut qualified_arg_values: Vec<Expr> = vec![];
        self.begin_inputs()?;
        for (arg, arg_value) in func.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.clone());
                }
                Type::Struct {
                    name: type_name,
                    span: type_span,
                } => {
                    let Some(struct_) = s.get_struct(type_name) else {
                        continue;
                    };
                    let arg_value = arg_value;
                    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,
                                );