Method constructor_make_function

compiler/src/codegen.rs:1944–2010

(
        &self,
        def: &EnumDefinition,
        name: &str,
        con: &Constructor,
    )

    }

    fn constructor_make_function(
        &self,
        def: &EnumDefinition,
        name: &str,
        con: &Constructor,
    ) -> String {
        let mut out = emitter();

        let ty_name = &def.name;
        let tag = format!("{ty_name}_{cons}", cons = con.name);

        let (fields, params): (Vec<_>, Vec<_>) = con
            .fields
            .iter()
            .enumerate()
            .map(|(index, f)| {
                let arg = format!("arg_{index}");
                let sig = self.to_type(&f.ty);
                let param = format!("{arg} {sig}");

                let field_name = constructor_field_name(&con.name, con.fields.len(), index);
                let field = format!("{field_name}: {arg}");

                (field, param)
            })
            .unzip();

        let fields = fields.join(", ");
        let params = params.join(", ");

        let (generic_params, generic_args) = if def.generics.is_empty() {
            ("".to_string(), "".to_string())
        } else {
            let args = def
                .generics
                .clone()
                .into_iter()
                .map(|g| g.name)
                .collect::<Vec<_>>()
                .join(", ");
            let generics = generics_to_string(&def.generics);
            (generics, format!("[{args}]"))
        };

        let ret = Type::Con {
            id: Symbol::ethereal(&def.name),
            args: def
                .generics
                .iter()
                .map(|g| Type::Con {
                    id: Symbol::ethereal(&g.name),
                    args: vec![],
                })
                .collect(),
        };

        let ret = self.to_type(&ret);