fn finalize_types(&mut self) {
        if self.parent.parent.env.has_errors() {
            // Don't do that check if we already reported errors, as this would produce
            // useless followup errors.
            return;
        }
        for i in self.node_counter_start..self.parent.node_counter {
            let node_id = NodeId::new(i);
            if let Some(ty) = self.parent.type_map.get(&node_id) {
                let ty = self.finalize_type(node_id, ty);
                self.parent.type_map.insert(node_id, ty);
            }
            if let Some(inst) = self.parent.instantiation_map.get(&node_id) {
                let inst = inst
                    .iter()
                    .map(|ty| self.finalize_type(node_id, ty))
                    .collect_vec();
                self.set_instantiation(node_id, inst);
            }
        }
    }
/// Finalizes types in this translator, producing errors if some could not be inferred
/// and remained incomplete.
Finalizes types in this translator, producing errors if some could not be inferred
and remained incomplete.
Finalizes types in this translator producing errors if some could not be inferred and remained incomplete .
fn finalize_types(&mut self) {
        if self.parent.parent.env.has_errors() {
            // Don't do that check if we already reported errors, as this would produce
            // useless followup errors.
            return;
        }
        for i in self.node_counter_start..self.parent.node_counter {
            let node_id = NodeId::new(i);
            if let Some(ty) = self.parent.type_map.get(&node_id) {
                let ty = self.finalize_type(node_id, ty);
                self.parent.type_map.insert(node_id, ty);
            }
            if let Some(inst) = self.parent.instantiation_map.get(&node_id) {
                let inst = inst
                    .iter()
                    .map(|ty| self.finalize_type(node_id, ty))
                    .collect_vec();
                self.set_instantiation(node_id, inst);
            }
        }
    }
fn finalize_types ( & mut self ) { if self . parent . parent . env . has_errors ( ) { // Don't do that check if we already reported errors, as this would produce // useless followup errors. return ; } for i in self . node_counter_start .. self . parent . node_counter { let node_id = NodeId :: new ( i ) ; if let Some ( ty ) = self . parent . type_map . get ( & node_id ) { let ty = self . finalize_type ( node_id , ty ) ; self . parent . type_map . insert ( node_id , ty ) ; } if let Some ( inst ) = self . parent . instantiation_map . get ( & node_id ) { let inst = inst . iter ( ) . map ( | ty | self . finalize_type ( node_id , ty ) ) . collect_vec ( ) ; self . set_instantiation ( node_id , inst ) ; } } }
Finalizes types in this translator, producing errors if some could not be inferred
and remained incomplete.
Finalizes types in this translator producing errors if some could not be inferred and remained incomplete .
&mut self
&mut self