280         if let ValueData::Alias { original, .. } = ValueData::from(values[v]) {  in maybe_resolve_aliases()
308     let data = ValueData::from(data);  in valid_valuedata()
309     if let ValueData::Alias {  in valid_valuedata()
347     fn make_value(&mut self, data: ValueData) -> Value {  in make_value()
372         self.value_is_valid(value) && !matches!(self.values[value].into(), ValueData::Alias { .. })  in value_is_real()
385         match ValueData::from(self.values[v]) {  in value_def()
386             ValueData::Inst { inst, num, .. } => ValueDef::Result(inst, num as usize),  in value_def()
387             ValueData::Param { block, num, .. } => ValueDef::Param(block, num as usize),  in value_def()
388             ValueData::Alias { original, .. } => {  in value_def()
393             ValueData::Union { x, y, .. } => ValueDef::Union(x, y),  in value_def()
404         use self::ValueData::*;  in value_is_attached()
405         match ValueData::from(self.values[v]) {  in value_is_attached()
423         let invalid_value = ValueDataPacked::from(ValueData::Alias {  in resolve_all_aliases()
437             if let ValueData::Alias { mut original, .. } = value_data.into() {  in resolve_all_aliases()
440                 let resolved = ValueDataPacked::from(ValueData::Alias {  in resolve_all_aliases()
450                     if let ValueData::Alias { original: next, .. } = self.values[src].into() {  in resolve_all_aliases()
469                     if let ValueData::Alias { original, .. } = self.values[arg].into() {  in resolve_all_aliases()
491             values_labels.retain(|&k, _| !matches!(self.values[k].into(), ValueData::Alias { .. }));  in resolve_all_aliases()
497                     if let ValueData::Alias { original, .. } = self.values[*value].into() {  in resolve_all_aliases()
509             if let ValueData::Alias { .. } = ValueData::from(*value) {  in resolve_all_aliases()
542         self.values[dest] = ValueData::Alias { ty, original }.into();  in change_to_alias()
582             self.values[dest] = ValueData::Alias { ty, original }.into();  in replace_with_aliases()
677 enum ValueData {  enum
756 impl From<ValueData> for ValueDataPacked {
757     fn from(data: ValueData) -> Self {  in from()
759             ValueData::Inst { ty, num, inst } => {  in from()
762             ValueData::Param { ty, num, block } => {  in from()
765             ValueData::Alias { ty, original } => {  in from()
768             ValueData::Union { ty, x, y } => {  in from()
775 impl From<ValueDataPacked> for ValueData {  implementation
782             ValueDataPacked::TAG_INST => ValueData::Inst {  in from()
787             ValueDataPacked::TAG_PARAM => ValueData::Param {  in from()
792             ValueDataPacked::TAG_ALIAS => ValueData::Alias {  in from()
796             ValueDataPacked::TAG_UNION => ValueData::Union {  in from()
981             let value_data = ValueData::Inst { ty, num, inst };  in make_inst_results_reusing()
1018         let (num, inst) = match ValueData::from(self.values[old_value]) {  in replace_result()
1019             ValueData::Inst { num, inst, .. } => (num, inst),  in replace_result()
1022         let new_value = self.make_value(ValueData::Inst {  in replace_result()
1090         self.make_value(ValueData::Union { ty, x, y })  in union()
1253         self.make_value(ValueData::Param {  in append_block_param()
1270             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[val]) {  in swap_remove_block_param()
1283             let mut last_arg_data = ValueData::from(self.values[last_arg_val]);  in swap_remove_block_param()
1284             if let ValueData::Param { num: old_num, .. } = &mut last_arg_data {  in swap_remove_block_param()
1298             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[val]) {  in remove_block_param()
1311             let mut data = ValueData::from(*packed);  in remove_block_param()
1313                 ValueData::Param { num, .. } => {  in remove_block_param()
1338         self.values[param] = ValueData::Param {  in attach_block_param()
1358             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[old_value]) {  in replace_block_param()
1363         let new_arg = self.make_value(ValueData::Param {  in replace_block_param()
1505         self.values[val] = ValueData::Param {  in append_block_param_for_parser()
1527         let data = ValueData::Alias { ty, original: src };  in make_value_alias_for_serialization()
1536         if let ValueData::Alias { original, .. } = ValueData::from(self.values[v]) {  in value_alias_dest_for_serialization()
1565         let data = ValueData::Alias {  in make_invalid_value_for_parser()
1579         if let ValueData::Alias { ty, .. } = ValueData::from(self.values[v]) {  in value_is_valid_for_parser()