Method insert_frame

prqlc/prqlc/src/semantic/module.rs:197–298

(&mut self, lineage: &Lineage, namespace: &str)

    }

    pub(super) fn insert_frame(&mut self, lineage: &Lineage, namespace: &str) {
        let namespace = self.names.entry(namespace.to_string()).or_default();
        let namespace = namespace.kind.as_module_mut().unwrap();

        let lin_ty = *ty_of_lineage(lineage).kind.into_array().unwrap().unwrap();

        for (col_index, column) in lineage.columns.iter().enumerate() {
            // determine input name
            let input_name = match column {
                LineageColumn::All { input_id, .. } => {
                    lineage.find_input(*input_id).map(|i| &i.name)
                }
                LineageColumn::Single { name, .. } => name.as_ref().and_then(|n| n.path.first()),
            };

            // get or create input namespace
            let ns;
            if let Some(input_name) = input_name {
                let entry = match namespace.names.get_mut(input_name) {
                    Some(x) => x,
                    None => {
                        namespace.redirects.push(Ident::from_name(input_name));

                        let input = lineage.find_input_by_name(input_name).unwrap();
                        let order = lineage.inputs.iter().position(|i| i.id == input.id);
                        let order = order.unwrap();

                        let mut sub_ns = Module::default();

                        let self_ty = lin_ty.clone().kind.into_tuple().unwrap();
                        let self_ty = self_ty
                            .into_iter()
                            .flat_map(|x| x.into_single())
                            .find(|(name, _)| name.as_ref() == Some(input_name))
                            .and_then(|(_, ty)| ty)
                            .or(Some(Ty::new(TyKind::Tuple(vec![TyTupleField::Wildcard(
                                None,
                            )]))));

                        let self_decl = Decl {
                            declared_at: Some(input.id),
                            kind: DeclKind::InstanceOf(input.table.clone(), self_ty),
                            ..Default::default()
                        };
                        sub_ns.names.insert(NS_SELF.to_string(), self_decl);

                        let sub_ns = Decl {
                            declared_at: Some(input.id),
                            order,
                            kind: DeclKind::Module(sub_ns),
                            ..Default::default()
                        };

                        namespace.names.entry(input_name.clone()).or_insert(sub_ns)
                    }
                };
                ns = entry.kind.as_module_mut().unwrap()
            } else {