Created
July 8, 2023 22:19
-
-
Save oxalica/38b0a29122dca19ac7c9d5cf27ebf752 to your computer and use it in GitHub Desktop.
Rust-analyzer spamming log ` Terminator should be none only in construction`
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[ERROR hir_ty::mir::borrowck] Terminator should be none only in construction. | |
The body: | |
fn on_did_change_watched_files() { | |
let _0: ControlFlow<Result<(), Error>, ()>; | |
let self_1: &mut Server; | |
let params_2: DidChangeWatchedFilesParams; | |
let enabled_3: bool; | |
let interest_4: Interest; | |
let iter_5: Iter; | |
let level_6: Level; | |
let meta_7: &Metadata<'_>; | |
let log_meta_8: Metadata<'_>; | |
let logger_9: &dyn Log; | |
let iter_10: Iter; | |
let flake_files_changed_11: bool; | |
let uri_12: &Url; | |
let typ_13: FileChangeType; | |
let path_14: PathBuf; | |
let text_15: String; | |
let err_16: Error; | |
let err_17: Error; | |
let enabled_18: bool; | |
let interest_19: Interest; | |
let iter_20: Iter; | |
let level_21: Level; | |
let meta_22: &Metadata<'_>; | |
let log_meta_23: Metadata<'_>; | |
let logger_24: &dyn Log; | |
let iter_25: Iter; | |
let relative_26: &Path; | |
let <ra@gennew>18_27: Iter<'_, FileEvent>; | |
let _28: (); | |
let _29: bool; | |
let _30: bool; | |
let _31: bool; | |
let _32: &Level; | |
let _33: Level; | |
let _34: &LevelFilter; | |
let _35: LevelFilter; | |
let _36: &Level; | |
let _37: Level; | |
let _38: &LevelFilter; | |
let _39: LevelFilter; | |
let _40: Interest; | |
let _41: &DefaultCallsite; | |
let _42: &DefaultCallsite; | |
let _43: bool; | |
let _44: bool; | |
let _45: &Interest; | |
let _46: &Metadata<'_>; | |
let _47: &DefaultCallsite; | |
let _48: &DefaultCallsite; | |
let _49: (); | |
let _50: &{closure#23}<fn(ValueSet<'_>)>; | |
let _51: {closure#23}<fn(ValueSet<'_>)>; | |
let _52: ValueSet<'_>; | |
let _53: Iter; | |
let _54: &FieldSet; | |
let _55: &FieldSet; | |
let _56: &Metadata<'_>; | |
let _57: &Metadata<'_>; | |
let _58: &DefaultCallsite; | |
let _59: &DefaultCallsite; | |
let _60: &FieldSet; | |
let _61: &FieldSet; | |
let _62: &Metadata<'_>; | |
let _63: &Metadata<'_>; | |
let _64: &DefaultCallsite; | |
let _65: &DefaultCallsite; | |
let _66: &[(&Field, Option<&dyn Value>); 1]; | |
let _67: [(&Field, Option<&dyn Value>); 1]; | |
let _68: (&Field, Option<&dyn Value>); | |
let _69: &Field; | |
let _70: Field; | |
let _71: Option<Field>; | |
let _72: &mut Iter; | |
let _73: Option<&dyn Value>; | |
let _74: &dyn Value; | |
let _75: &Arguments<'_>; | |
let _76: Arguments<'_>; | |
let _77: &[&str]; | |
let _78: &[&str; 1]; | |
let _79: &[&str; 1]; | |
let _80: [&str; 1]; | |
let _81: &[ArgumentV1<'_>]; | |
let _82: &[ArgumentV1<'_>; 1]; | |
let _83: &[ArgumentV1<'_>; 1]; | |
let _84: [ArgumentV1<'_>; 1]; | |
let _85: ArgumentV1<'_>; | |
let _86: &DidChangeWatchedFilesParams; | |
let _87: fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>; | |
let _88: fn fmt<DidChangeWatchedFilesParams>(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>; | |
let _89: (); | |
let _90: bool; | |
let _91: &Level; | |
let _92: Level; | |
let _93: Level; | |
let _94: Level; | |
let _95: bool; | |
let _96: Level; | |
let _97: bool; | |
let _98: Level; | |
let _99: bool; | |
let _100: Level; | |
let _101: bool; | |
let _102: Level; | |
let _103: bool; | |
let _104: Level; | |
let _105: bool; | |
let _106: Level; | |
let _107: bool; | |
let _108: Level; | |
let _109: bool; | |
let _110: &LevelFilter; | |
let _111: LevelFilter; | |
let _112: bool; | |
let _113: bool; | |
let _114: Level; | |
let _115: Level; | |
let _116: Level; | |
let _117: bool; | |
let _118: Level; | |
let _119: bool; | |
let _120: Level; | |
let _121: bool; | |
let _122: Level; | |
let _123: bool; | |
let _124: Level; | |
let _125: bool; | |
let _126: Level; | |
let _127: bool; | |
let _128: Level; | |
let _129: bool; | |
let _130: Level; | |
let _131: bool; | |
let _132: bool; | |
let _133: &Level; | |
let _134: &LevelFilter; | |
let _135: LevelFilter; | |
let _136: &Metadata<'_>; | |
let _137: &DefaultCallsite; | |
let _138: &DefaultCallsite; | |
let _139: Metadata<'_>; | |
let _140: &MetadataBuilder<'_>; | |
let _141: &mut MetadataBuilder<'_>; | |
let _142: &mut MetadataBuilder<'_>; | |
let _143: &mut MetadataBuilder<'_>; | |
let _144: &mut MetadataBuilder<'_>; | |
let _145: MetadataBuilder<'_>; | |
let _146: &str; | |
let _147: &Metadata<'_>; | |
let _148: &dyn Log; | |
let _149: bool; | |
let _150: &dyn Log; | |
let _151: &Metadata<'_>; | |
let _152: &dyn Log; | |
let _153: &dyn Log; | |
let _154: &ValueSet<'_>; | |
let _155: ValueSet<'_>; | |
let _156: Iter; | |
let _157: &FieldSet; | |
let _158: &FieldSet; | |
let _159: &Metadata<'_>; | |
let _160: &Metadata<'_>; | |
let _161: &DefaultCallsite; | |
let _162: &DefaultCallsite; | |
let _163: &FieldSet; | |
let _164: &FieldSet; | |
let _165: &Metadata<'_>; | |
let _166: &Metadata<'_>; | |
let _167: &DefaultCallsite; | |
let _168: &DefaultCallsite; | |
let _169: &[(&Field, Option<&dyn Value>); 1]; | |
let _170: [(&Field, Option<&dyn Value>); 1]; | |
let _171: (&Field, Option<&dyn Value>); | |
let _172: &Field; | |
let _173: Field; | |
let _174: Option<Field>; | |
let _175: &mut Iter; | |
let _176: Option<&dyn Value>; | |
let _177: &dyn Value; | |
let _178: &Arguments<'_>; | |
let _179: Arguments<'_>; | |
let _180: &[&str]; | |
let _181: &[&str; 1]; | |
let _182: &[&str; 1]; | |
let _183: [&str; 1]; | |
let _184: &[ArgumentV1<'_>]; | |
let _185: &[ArgumentV1<'_>; 1]; | |
let _186: &[ArgumentV1<'_>; 1]; | |
let _187: [ArgumentV1<'_>; 1]; | |
let _188: ArgumentV1<'_>; | |
let _189: &DidChangeWatchedFilesParams; | |
let _190: fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>; | |
let _191: fn fmt<DidChangeWatchedFilesParams>(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>; | |
let _192: bool; | |
let _193: (); | |
let _194: Iter<'_, FileEvent>; | |
let _195: &Vec<FileEvent, Global>; | |
let _196: (); | |
let _197: Option<&FileEvent>; | |
let _198: &mut Iter<'_, FileEvent>; | |
let _199: &mut Iter<'_, FileEvent>; | |
let _200: i128; | |
let _201: !; | |
let _202: (); | |
let _203: bool; | |
let _204: &HashMap<Url, FileData, RandomState>; | |
let _205: !; | |
let _206: Result<PathBuf, ()>; | |
let _207: &Url; | |
let _208: !; | |
let _209: !; | |
let _210: (); | |
let _211: bool; | |
let _212: FileChangeType; | |
let _213: bool; | |
let _214: FileChangeType; | |
let _215: bool; | |
let _216: FileChangeType; | |
let _217: bool; | |
let _218: FileChangeType; | |
let _219: bool; | |
let _220: FileChangeType; | |
let _221: bool; | |
let _222: FileChangeType; | |
let _223: bool; | |
let _224: Result<String, Error>; | |
let _225: &{closure#24}<fn() -> Result<String, Error>>; | |
let _226: {closure#24}<fn() -> Result<String, Error>>; | |
let _227: &PathBuf; | |
let _228: &mut Server; | |
let _229: bool; | |
let _230: ErrorKind; | |
let _231: &Error; | |
let _232: (); | |
let _233: FileChangeType; | |
let _234: bool; | |
let _235: bool; | |
let _236: bool; | |
let _237: &Level; | |
let _238: Level; | |
let _239: &LevelFilter; | |
let _240: LevelFilter; | |
let _241: &Level; | |
let _242: Level; | |
let _243: &LevelFilter; | |
let _244: LevelFilter; | |
let _245: Interest; | |
let _246: &DefaultCallsite; | |
let _247: &DefaultCallsite; | |
let _248: bool; | |
let _249: bool; | |
let _250: &Interest; | |
let _251: &Metadata<'_>; | |
let _252: &DefaultCallsite; | |
let _253: &DefaultCallsite; | |
let _254: (); | |
let _255: &{closure#25}<fn(ValueSet<'_>)>; | |
let _256: {closure#25}<fn(ValueSet<'_>)>; | |
let _257: ValueSet<'_>; | |
let _258: Iter; | |
let _259: &FieldSet; | |
let _260: &FieldSet; | |
let _261: &Metadata<'_>; | |
let _262: &Metadata<'_>; | |
let _263: &DefaultCallsite; | |
let _264: &DefaultCallsite; | |
let _265: &FieldSet; | |
let _266: &FieldSet; | |
let _267: &Metadata<'_>; | |
let _268: &Metadata<'_>; | |
let _269: &DefaultCallsite; | |
let _270: &DefaultCallsite; | |
let _271: &[(&Field, Option<&dyn Value>); 1]; | |
let _272: [(&Field, Option<&dyn Value>); 1]; | |
let _273: (&Field, Option<&dyn Value>); | |
let _274: &Field; | |
let _275: Field; | |
let _276: Option<Field>; | |
let _277: &mut Iter; | |
let _278: Option<&dyn Value>; | |
let _279: &dyn Value; | |
let _280: &Arguments<'_>; | |
let _281: Arguments<'_>; | |
let _282: &[&str]; | |
let _283: &[&str; 2]; | |
let _284: &[&str; 2]; | |
let _285: [&str; 2]; | |
let _286: &[ArgumentV1<'_>]; | |
let _287: &[ArgumentV1<'_>; 2]; | |
let _288: &[ArgumentV1<'_>; 2]; | |
let _289: [ArgumentV1<'_>; 2]; | |
let _290: ArgumentV1<'_>; | |
let _291: &PathBuf; | |
let _292: fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>; | |
let _293: fn fmt<PathBuf>(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>; | |
let _294: ArgumentV1<'_>; | |
let _295: &Error; | |
let _296: fn(&Error, &mut Formatter<'_>) -> Result<(), Error>; | |
let _297: fn fmt<Error>(&Error, &mut Formatter<'_>) -> Result<(), Error>; | |
let _298: (); | |
let _299: bool; | |
let _300: &Level; | |
let _301: Level; | |
let _302: Level; | |
let _303: Level; | |
let _304: bool; | |
let _305: Level; | |
let _306: bool; | |
let _307: Level; | |
let _308: bool; | |
let _309: Level; | |
let _310: bool; | |
let _311: Level; | |
let _312: bool; | |
let _313: Level; | |
let _314: bool; | |
let _315: Level; | |
let _316: bool; | |
let _317: Level; | |
let _318: bool; | |
let _319: &LevelFilter; | |
let _320: LevelFilter; | |
let _321: bool; | |
let _322: bool; | |
let _323: Level; | |
let _324: Level; | |
let _325: Level; | |
let _326: bool; | |
let _327: Level; | |
let _328: bool; | |
let _329: Level; | |
let _330: bool; | |
let _331: Level; | |
let _332: bool; | |
let _333: Level; | |
let _334: bool; | |
let _335: Level; | |
let _336: bool; | |
let _337: Level; | |
let _338: bool; | |
let _339: Level; | |
let _340: bool; | |
let _341: bool; | |
let _342: &Level; | |
let _343: &LevelFilter; | |
let _344: LevelFilter; | |
let _345: &Metadata<'_>; | |
let _346: &DefaultCallsite; | |
let _347: &DefaultCallsite; | |
let _348: Metadata<'_>; | |
let _349: &MetadataBuilder<'_>; | |
let _350: &mut MetadataBuilder<'_>; | |
let _351: &mut MetadataBuilder<'_>; | |
let _352: &mut MetadataBuilder<'_>; | |
let _353: &mut MetadataBuilder<'_>; | |
let _354: MetadataBuilder<'_>; | |
let _355: &str; | |
let _356: &Metadata<'_>; | |
let _357: &dyn Log; | |
let _358: bool; | |
let _359: &dyn Log; | |
let _360: &Metadata<'_>; | |
let _361: &dyn Log; | |
let _362: &dyn Log; | |
let _363: &ValueSet<'_>; | |
let _364: ValueSet<'_>; | |
let _365: Iter; | |
let _366: &FieldSet; | |
let _367: &FieldSet; | |
let _368: &Metadata<'_>; | |
let _369: &Metadata<'_>; | |
let _370: &DefaultCallsite; | |
let _371: &DefaultCallsite; | |
let _372: &FieldSet; | |
let _373: &FieldSet; | |
let _374: &Metadata<'_>; | |
let _375: &Metadata<'_>; | |
let _376: &DefaultCallsite; | |
let _377: &DefaultCallsite; | |
let _378: &[(&Field, Option<&dyn Value>); 1]; | |
let _379: [(&Field, Option<&dyn Value>); 1]; | |
let _380: (&Field, Option<&dyn Value>); | |
let _381: &Field; | |
let _382: Field; | |
let _383: Option<Field>; | |
let _384: &mut Iter; | |
let _385: Option<&dyn Value>; | |
let _386: &dyn Value; | |
let _387: &Arguments<'_>; | |
let _388: Arguments<'_>; | |
let _389: &[&str]; | |
let _390: &[&str; 2]; | |
let _391: &[&str; 2]; | |
let _392: [&str; 2]; | |
let _393: &[ArgumentV1<'_>]; | |
let _394: &[ArgumentV1<'_>; 2]; | |
let _395: &[ArgumentV1<'_>; 2]; | |
let _396: [ArgumentV1<'_>; 2]; | |
let _397: ArgumentV1<'_>; | |
let _398: &PathBuf; | |
let _399: fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>; | |
let _400: fn fmt<PathBuf>(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>; | |
let _401: ArgumentV1<'_>; | |
let _402: &Error; | |
let _403: fn(&Error, &mut Formatter<'_>) -> Result<(), Error>; | |
let _404: fn fmt<Error>(&Error, &mut Formatter<'_>) -> Result<(), Error>; | |
let _405: (); | |
let _406: bool; | |
let _407: &FileChangeType; | |
let _408: &FileChangeType; | |
let _409: FileChangeType; | |
let _410: Result<(), Error>; | |
let _411: &mut Vfs; | |
let _412: RwLockWriteGuard<'_, Vfs>; | |
let _413: Result<RwLockWriteGuard<'_, Vfs>, PoisonError<RwLockWriteGuard<'_, Vfs>>>; | |
let _414: &RwLock<Vfs>; | |
let _415: &Arc<RwLock<Vfs>>; | |
let _416: &RwLock<Vfs>; | |
let _417: &mut RwLockWriteGuard<'_, Vfs>; | |
let _418: &mut Vfs; | |
let _419: bool; | |
let _420: Result<&Path, StripPrefixError>; | |
let _421: &Path; | |
let _422: &PathBuf; | |
let _423: &Path; | |
let _424: &PathBuf; | |
let _425: &Arc<Config>; | |
let _426: &Config; | |
let _427: bool; | |
let _428: bool; | |
let _429: &&Path; | |
let _430: &&Path; | |
let _431: &Path; | |
let _432: &str; | |
let _433: &&Path; | |
let _434: &&Path; | |
let _435: &Path; | |
let _436: &str; | |
let _437: (); | |
let _438: (); | |
let _439: (); | |
let _440: &mut Server; | |
let _441: (); | |
'bb0: { | |
StorageLive(_28) | |
StorageLive(_29) | |
StorageLive(_30) | |
StorageLive(_31) | |
StorageLive(_32) | |
StorageLive(_33) | |
_33 = Const(Level(Debug)); | |
_32 = &_33; | |
StorageLive(_34) | |
StorageLive(_35) | |
_35 = Const(LevelFilter(Some(Level(Trace)))); | |
_34 = &_35; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_32, _34], | |
destination: _31, | |
target: 'bb1, | |
} | |
} | |
'bb1: { | |
switch _31 { | |
0 => 'bb2, | |
_ => 'bb3, | |
} | |
} | |
'bb2: { | |
_30 = _31; | |
goto 'bb6; | |
} | |
'bb3: { | |
StorageLive(_36) | |
StorageLive(_37) | |
_37 = Const(Level(Debug)); | |
_36 = &_37; | |
StorageLive(_38) | |
StorageLive(_39) | |
Call { | |
func: Const(fn current() -> LevelFilter), | |
args: [], | |
destination: _39, | |
target: 'bb4, | |
} | |
} | |
'bb4: { | |
_38 = &_39; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_36, _38], | |
destination: _30, | |
target: 'bb5, | |
} | |
} | |
'bb5: { | |
goto 'bb6; | |
} | |
'bb6: { | |
switch _30 { | |
0 => 'bb7, | |
_ => 'bb8, | |
} | |
} | |
'bb7: { | |
_29 = _30; | |
goto 'bb18; | |
} | |
'bb8: { | |
StorageLive(_40) | |
StorageLive(_41) | |
StorageLive(_42) | |
_42 = Static(StaticId(174)); | |
_41 = &(*_42); | |
Call { | |
func: Const(fn interest(&DefaultCallsite) -> Interest), | |
args: [_41], | |
destination: _40, | |
target: 'bb9, | |
} | |
} | |
'bb9: { | |
StorageLive(interest_4) | |
interest_4 = _40; | |
StorageLive(_43) | |
StorageLive(_44) | |
StorageLive(_45) | |
_45 = &interest_4; | |
Call { | |
func: Const(fn is_never(&Interest) -> bool), | |
args: [_45], | |
destination: _44, | |
target: 'bb10, | |
} | |
} | |
'bb10: { | |
_43 = ! _44; | |
switch _43 { | |
0 => 'bb11, | |
_ => 'bb12, | |
} | |
} | |
'bb11: { | |
_29 = _43; | |
goto 'bb15; | |
} | |
'bb12: { | |
StorageLive(_46) | |
StorageLive(_47) | |
StorageLive(_48) | |
_48 = Static(StaticId(174)); | |
_47 = &(*_48); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_47], | |
destination: _46, | |
target: 'bb13, | |
} | |
} | |
'bb13: { | |
Call { | |
func: Const(fn __is_enabled(&Metadata<'_>, Interest) -> bool), | |
args: [_46, interest_4], | |
destination: _29, | |
target: 'bb14, | |
} | |
} | |
'bb14: { | |
goto 'bb15; | |
} | |
'bb15: { | |
StorageDead(_48) | |
StorageDead(_47) | |
StorageDead(_46) | |
StorageDead(_45) | |
StorageDead(_44) | |
StorageDead(_43) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(4), projection: [] }, target: Idx::<BasicBlock>(16), unwind: None } }; | |
} | |
'bb16: { | |
StorageDead(interest_4) | |
StorageDead(_42) | |
StorageDead(_41) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(40), projection: [] }, target: Idx::<BasicBlock>(17), unwind: None } }; | |
} | |
'bb17: { | |
StorageDead(_40) | |
goto 'bb18; | |
} | |
'bb18: { | |
StorageLive(enabled_3) | |
enabled_3 = _29; | |
switch enabled_3 { | |
1 => 'bb19, | |
_ => 'bb38, | |
} | |
} | |
'bb19: { | |
StorageLive(_49) | |
StorageLive(_50) | |
StorageLive(_51) | |
_51 = Closure(); | |
_50 = &_51; | |
StorageLive(_52) | |
StorageLive(_53) | |
StorageLive(_54) | |
StorageLive(_55) | |
StorageLive(_56) | |
StorageLive(_57) | |
StorageLive(_58) | |
StorageLive(_59) | |
_59 = Static(StaticId(174)); | |
_58 = &(*_59); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_58], | |
destination: _57, | |
target: 'bb20, | |
} | |
} | |
'bb20: { | |
_56 = &(*_57); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_56], | |
destination: _55, | |
target: 'bb21, | |
} | |
} | |
'bb21: { | |
_54 = &(*_55); | |
Call { | |
func: Const(fn iter(&FieldSet) -> Iter), | |
args: [_54], | |
destination: _53, | |
target: 'bb22, | |
} | |
} | |
'bb22: { | |
StorageLive(iter_5) | |
iter_5 = _53; | |
StorageLive(_60) | |
StorageLive(_61) | |
StorageLive(_62) | |
StorageLive(_63) | |
StorageLive(_64) | |
StorageLive(_65) | |
_65 = Static(StaticId(174)); | |
_64 = &(*_65); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_64], | |
destination: _63, | |
target: 'bb23, | |
} | |
} | |
'bb23: { | |
_62 = &(*_63); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_62], | |
destination: _61, | |
target: 'bb24, | |
} | |
} | |
'bb24: { | |
_60 = &(*_61); | |
StorageLive(_66) | |
StorageLive(_67) | |
StorageLive(_68) | |
StorageLive(_69) | |
StorageLive(_70) | |
StorageLive(_71) | |
StorageLive(_72) | |
_72 = &mut iter_5; | |
Call { | |
func: Const(fn next<Iter>(&mut Iter) -> Option<<Iter as Iterator>::Item>), | |
args: [_72], | |
destination: _71, | |
target: 'bb25, | |
} | |
} | |
'bb25: { | |
Call { | |
func: Const(fn expect<Field>(Option<Field>, &str) -> Field), | |
args: [_71, Const("FieldSet corrupted (this is a bug)")], | |
destination: _70, | |
target: 'bb26, | |
} | |
} | |
'bb26: { | |
_69 = &_70; | |
StorageLive(_73) | |
StorageLive(_74) | |
StorageLive(_75) | |
StorageLive(_76) | |
StorageLive(_77) | |
StorageLive(_78) | |
StorageLive(_79) | |
StorageLive(_80) | |
_80 = [Const("Watched files changed: ")]; | |
_79 = &_80; | |
_78 = &(*_79); | |
_77 = Cast(Pointer(Unsize), _78, &[&str]); | |
StorageLive(_81) | |
StorageLive(_82) | |
StorageLive(_83) | |
StorageLive(_84) | |
StorageLive(_85) | |
StorageLive(_86) | |
_86 = ¶ms_2; | |
StorageLive(_87) | |
StorageLive(_88) | |
_87 = Cast(Pointer(ReifyFnPointer), _88, fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<DidChangeWatchedFilesParams>(&DidChangeWatchedFilesParams, fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_86, _87], | |
destination: _85, | |
target: 'bb27, | |
} | |
} | |
'bb27: { | |
_84 = [_85]; | |
_83 = &_84; | |
_82 = &(*_83); | |
_81 = Cast(Pointer(Unsize), _82, &[ArgumentV1<'_>]); | |
Call { | |
func: Const(fn new_v1(&[&str], &[ArgumentV1<'_>]) -> Arguments<'_>), | |
args: [_77, _81], | |
destination: _76, | |
target: 'bb28, | |
} | |
} | |
'bb28: { | |
_75 = &_76; | |
_74 = Cast(Pointer(Unsize), _75, &dyn Value); | |
Call { | |
func: Const(Some<&dyn Value>(&dyn Value) -> Option<&dyn Value>), | |
args: [_74], | |
destination: _73, | |
target: 'bb29, | |
} | |
} | |
'bb29: { | |
_68 = (_69, _73); | |
_67 = [_68]; | |
_66 = &_67; | |
Call { | |
func: Const(fn value_set<[(&Field, Option<&dyn Value>); 1]>(&FieldSet, &[(&Field, Option<&dyn Value>); 1]) -> ValueSet<'_>), | |
args: [_60, _66], | |
destination: _52, | |
target: 'bb30, | |
} | |
} | |
'bb30: { | |
StorageDead(_88) | |
StorageDead(_87) | |
StorageDead(_86) | |
StorageDead(_85) | |
StorageDead(_84) | |
StorageDead(_83) | |
StorageDead(_82) | |
StorageDead(_81) | |
StorageDead(_80) | |
StorageDead(_79) | |
StorageDead(_78) | |
StorageDead(_77) | |
StorageDead(_76) | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(72), projection: [] }, target: Idx::<BasicBlock>(31), unwind: None } }; | |
} | |
'bb31: { | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(71), projection: [] }, target: Idx::<BasicBlock>(32), unwind: None } }; | |
} | |
'bb32: { | |
StorageDead(_71) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(70), projection: [] }, target: Idx::<BasicBlock>(33), unwind: None } }; | |
} | |
'bb33: { | |
StorageDead(_70) | |
StorageDead(_69) | |
StorageDead(_68) | |
StorageDead(_67) | |
StorageDead(_66) | |
StorageDead(_65) | |
StorageDead(_64) | |
StorageDead(_63) | |
StorageDead(_62) | |
StorageDead(_61) | |
StorageDead(_60) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(5), projection: [] }, target: Idx::<BasicBlock>(34), unwind: None } }; | |
} | |
'bb34: { | |
StorageDead(iter_5) | |
StorageDead(_59) | |
StorageDead(_58) | |
StorageDead(_57) | |
StorageDead(_56) | |
StorageDead(_55) | |
StorageDead(_54) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(53), projection: [] }, target: Idx::<BasicBlock>(35), unwind: None } }; | |
} | |
'bb35: { | |
StorageDead(_53) | |
Call { | |
func: Const(fn call<{closure#23}<fn(ValueSet<'_>)>, (ValueSet<'_>,)>(&{closure#23}<fn(ValueSet<'_>)>, (ValueSet<'_>,)) -> <{closure#23}<fn(ValueSet<'_>)> as FnOnce<(ValueSet<'_>,)>>::Output), | |
args: [_50, _52], | |
destination: _49, | |
target: 'bb36, | |
} | |
} | |
'bb36: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(52), projection: [] }, target: Idx::<BasicBlock>(37), unwind: None } }; | |
} | |
'bb37: { | |
StorageDead(_52) | |
StorageDead(_51) | |
StorageDead(_50) | |
StorageDead(_49) | |
goto 'bb114; | |
} | |
'bb38: { | |
StorageLive(_89) | |
StorageLive(_90) | |
StorageLive(_91) | |
StorageLive(_92) | |
StorageLive(_93) | |
_93 = Const(Level(Debug)); | |
StorageLive(_94) | |
_94 = Const(Level(Error)); | |
StorageLive(_95) | |
_95 = _94 == _93; | |
switch _95 { | |
1 => 'bb39, | |
_ => 'bb40, | |
} | |
} | |
'bb39: { | |
StorageLive(_96) | |
_96 = Const(Level(Error)); | |
StorageLive(_97) | |
_97 = _96 == _93; | |
switch _97 { | |
1 => 'bb41, | |
_ => 'bb40, | |
} | |
} | |
'bb40: { | |
StorageLive(_98) | |
_98 = Const(Level(Warn)); | |
StorageLive(_99) | |
_99 = _98 == _93; | |
switch _99 { | |
1 => 'bb43, | |
_ => 'bb44, | |
} | |
} | |
'bb41: { | |
_92 = Adt(); | |
goto 'bb42; | |
} | |
'bb42: { | |
_91 = &_92; | |
StorageLive(_110) | |
StorageLive(_111) | |
_111 = Const(Trace); | |
_110 = &_111; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_91, _110], | |
destination: _90, | |
target: 'bb52, | |
} | |
} | |
'bb43: { | |
StorageLive(_100) | |
_100 = Const(Level(Warn)); | |
StorageLive(_101) | |
_101 = _100 == _93; | |
switch _101 { | |
1 => 'bb45, | |
_ => 'bb44, | |
} | |
} | |
'bb44: { | |
StorageLive(_102) | |
_102 = Const(Level(Info)); | |
StorageLive(_103) | |
_103 = _102 == _93; | |
switch _103 { | |
1 => 'bb46, | |
_ => 'bb47, | |
} | |
} | |
'bb45: { | |
_92 = Adt(); | |
goto 'bb42; | |
} | |
'bb46: { | |
StorageLive(_104) | |
_104 = Const(Level(Info)); | |
StorageLive(_105) | |
_105 = _104 == _93; | |
switch _105 { | |
1 => 'bb48, | |
_ => 'bb47, | |
} | |
} | |
'bb47: { | |
StorageLive(_106) | |
_106 = Const(Level(Debug)); | |
StorageLive(_107) | |
_107 = _106 == _93; | |
switch _107 { | |
1 => 'bb49, | |
_ => 'bb50, | |
} | |
} | |
'bb48: { | |
_92 = Adt(); | |
goto 'bb42; | |
} | |
'bb49: { | |
StorageLive(_108) | |
_108 = Const(Level(Debug)); | |
StorageLive(_109) | |
_109 = _108 == _93; | |
switch _109 { | |
1 => 'bb51, | |
_ => 'bb50, | |
} | |
} | |
'bb50: { | |
_92 = Adt(); | |
goto 'bb42; | |
} | |
'bb51: { | |
_92 = Adt(); | |
goto 'bb42; | |
} | |
'bb52: { | |
switch _90 { | |
1 => 'bb53, | |
_ => 'bb112, | |
} | |
} | |
'bb53: { | |
StorageLive(_112) | |
StorageLive(_113) | |
Call { | |
func: Const(fn has_been_set() -> bool), | |
args: [], | |
destination: _113, | |
target: 'bb54, | |
} | |
} | |
'bb54: { | |
_112 = ! _113; | |
switch _112 { | |
1 => 'bb55, | |
_ => 'bb110, | |
} | |
} | |
'bb55: { | |
StorageLive(_114) | |
StorageLive(_115) | |
_115 = Const(Level(Debug)); | |
StorageLive(_116) | |
_116 = Const(Level(Error)); | |
StorageLive(_117) | |
_117 = _116 == _115; | |
switch _117 { | |
1 => 'bb56, | |
_ => 'bb57, | |
} | |
} | |
'bb56: { | |
StorageLive(_118) | |
_118 = Const(Level(Error)); | |
StorageLive(_119) | |
_119 = _118 == _115; | |
switch _119 { | |
1 => 'bb58, | |
_ => 'bb57, | |
} | |
} | |
'bb57: { | |
StorageLive(_120) | |
_120 = Const(Level(Warn)); | |
StorageLive(_121) | |
_121 = _120 == _115; | |
switch _121 { | |
1 => 'bb60, | |
_ => 'bb61, | |
} | |
} | |
'bb58: { | |
_114 = Adt(); | |
goto 'bb59; | |
} | |
'bb59: { | |
StorageLive(level_6) | |
level_6 = _114; | |
StorageLive(_132) | |
StorageLive(_133) | |
_133 = &level_6; | |
StorageLive(_134) | |
StorageLive(_135) | |
Call { | |
func: Const(fn max_level() -> LevelFilter), | |
args: [], | |
destination: _135, | |
target: 'bb69, | |
} | |
} | |
'bb60: { | |
StorageLive(_122) | |
_122 = Const(Level(Warn)); | |
StorageLive(_123) | |
_123 = _122 == _115; | |
switch _123 { | |
1 => 'bb62, | |
_ => 'bb61, | |
} | |
} | |
'bb61: { | |
StorageLive(_124) | |
_124 = Const(Level(Info)); | |
StorageLive(_125) | |
_125 = _124 == _115; | |
switch _125 { | |
1 => 'bb63, | |
_ => 'bb64, | |
} | |
} | |
'bb62: { | |
_114 = Adt(); | |
goto 'bb59; | |
} | |
'bb63: { | |
StorageLive(_126) | |
_126 = Const(Level(Info)); | |
StorageLive(_127) | |
_127 = _126 == _115; | |
switch _127 { | |
1 => 'bb65, | |
_ => 'bb64, | |
} | |
} | |
'bb64: { | |
StorageLive(_128) | |
_128 = Const(Level(Debug)); | |
StorageLive(_129) | |
_129 = _128 == _115; | |
switch _129 { | |
1 => 'bb66, | |
_ => 'bb67, | |
} | |
} | |
'bb65: { | |
_114 = Adt(); | |
goto 'bb59; | |
} | |
'bb66: { | |
StorageLive(_130) | |
_130 = Const(Level(Debug)); | |
StorageLive(_131) | |
_131 = _130 == _115; | |
switch _131 { | |
1 => 'bb68, | |
_ => 'bb67, | |
} | |
} | |
'bb67: { | |
_114 = Adt(); | |
goto 'bb59; | |
} | |
'bb68: { | |
_114 = Adt(); | |
goto 'bb59; | |
} | |
'bb69: { | |
_134 = &_135; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_133, _134], | |
destination: _132, | |
target: 'bb70, | |
} | |
} | |
'bb70: { | |
switch _132 { | |
1 => 'bb71, | |
_ => 'bb108, | |
} | |
} | |
'bb71: { | |
StorageLive(_136) | |
StorageLive(_137) | |
StorageLive(_138) | |
_138 = Static(StaticId(174)); | |
_137 = &(*_138); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_137], | |
destination: _136, | |
target: 'bb72, | |
} | |
} | |
'bb72: { | |
StorageLive(meta_7) | |
meta_7 = _136; | |
StorageLive(_139) | |
StorageLive(_140) | |
StorageLive(_141) | |
StorageLive(_142) | |
StorageLive(_143) | |
StorageLive(_144) | |
StorageLive(_145) | |
Call { | |
func: Const(fn builder() -> MetadataBuilder<'_>), | |
args: [], | |
destination: _145, | |
target: 'bb73, | |
} | |
} | |
'bb73: { | |
_144 = &mut _145; | |
Call { | |
func: Const(fn level(&mut MetadataBuilder<'_>, Level) -> &mut MetadataBuilder<'_>), | |
args: [_144, level_6], | |
destination: _143, | |
target: 'bb74, | |
} | |
} | |
'bb74: { | |
_142 = &mut (*_143); | |
StorageLive(_146) | |
StorageLive(_147) | |
_147 = &(*meta_7); | |
Call { | |
func: Const(fn target(&Metadata<'_>) -> &str), | |
args: [_147], | |
destination: _146, | |
target: 'bb75, | |
} | |
} | |
'bb75: { | |
Call { | |
func: Const(fn target(&mut MetadataBuilder<'_>, &str) -> &mut MetadataBuilder<'_>), | |
args: [_142, _146], | |
destination: _141, | |
target: 'bb76, | |
} | |
} | |
'bb76: { | |
_140 = &(*_141); | |
Call { | |
func: Const(fn build(&MetadataBuilder<'_>) -> Metadata<'_>), | |
args: [_140], | |
destination: _139, | |
target: 'bb77, | |
} | |
} | |
'bb77: { | |
StorageLive(log_meta_8) | |
log_meta_8 = _139; | |
StorageLive(_148) | |
Call { | |
func: Const(fn logger() -> &dyn Log), | |
args: [], | |
destination: _148, | |
target: 'bb78, | |
} | |
} | |
'bb78: { | |
StorageLive(logger_9) | |
logger_9 = _148; | |
StorageLive(_149) | |
StorageLive(_150) | |
_150 = &(*logger_9); | |
StorageLive(_151) | |
_151 = &log_meta_8; | |
Call { | |
func: Const(fn enabled<dyn Log>(&dyn Log, &Metadata<'_>) -> bool), | |
args: [_150, _151], | |
destination: _149, | |
target: 'bb79, | |
} | |
} | |
'bb79: { | |
switch _149 { | |
1 => 'bb80, | |
_ => 'bb99, | |
} | |
} | |
'bb80: { | |
StorageLive(_152) | |
StorageLive(_153) | |
_153 = &(*logger_9); | |
_152 = Cast(Pointer(Unsize), _153, &dyn Log); | |
StorageLive(_154) | |
StorageLive(_155) | |
StorageLive(_156) | |
StorageLive(_157) | |
StorageLive(_158) | |
StorageLive(_159) | |
StorageLive(_160) | |
StorageLive(_161) | |
StorageLive(_162) | |
_162 = Static(StaticId(174)); | |
_161 = &(*_162); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_161], | |
destination: _160, | |
target: 'bb81, | |
} | |
} | |
'bb81: { | |
_159 = &(*_160); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_159], | |
destination: _158, | |
target: 'bb82, | |
} | |
} | |
'bb82: { | |
_157 = &(*_158); | |
Call { | |
func: Const(fn iter(&FieldSet) -> Iter), | |
args: [_157], | |
destination: _156, | |
target: 'bb83, | |
} | |
} | |
'bb83: { | |
StorageLive(iter_10) | |
iter_10 = _156; | |
StorageLive(_163) | |
StorageLive(_164) | |
StorageLive(_165) | |
StorageLive(_166) | |
StorageLive(_167) | |
StorageLive(_168) | |
_168 = Static(StaticId(174)); | |
_167 = &(*_168); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_167], | |
destination: _166, | |
target: 'bb84, | |
} | |
} | |
'bb84: { | |
_165 = &(*_166); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_165], | |
destination: _164, | |
target: 'bb85, | |
} | |
} | |
'bb85: { | |
_163 = &(*_164); | |
StorageLive(_169) | |
StorageLive(_170) | |
StorageLive(_171) | |
StorageLive(_172) | |
StorageLive(_173) | |
StorageLive(_174) | |
StorageLive(_175) | |
_175 = &mut iter_10; | |
Call { | |
func: Const(fn next<Iter>(&mut Iter) -> Option<<Iter as Iterator>::Item>), | |
args: [_175], | |
destination: _174, | |
target: 'bb86, | |
} | |
} | |
'bb86: { | |
Call { | |
func: Const(fn expect<Field>(Option<Field>, &str) -> Field), | |
args: [_174, Const("FieldSet corrupted (this is a bug)")], | |
destination: _173, | |
target: 'bb87, | |
} | |
} | |
'bb87: { | |
_172 = &_173; | |
StorageLive(_176) | |
StorageLive(_177) | |
StorageLive(_178) | |
StorageLive(_179) | |
StorageLive(_180) | |
StorageLive(_181) | |
StorageLive(_182) | |
StorageLive(_183) | |
_183 = [Const("Watched files changed: ")]; | |
_182 = &_183; | |
_181 = &(*_182); | |
_180 = Cast(Pointer(Unsize), _181, &[&str]); | |
StorageLive(_184) | |
StorageLive(_185) | |
StorageLive(_186) | |
StorageLive(_187) | |
StorageLive(_188) | |
StorageLive(_189) | |
_189 = ¶ms_2; | |
StorageLive(_190) | |
StorageLive(_191) | |
_190 = Cast(Pointer(ReifyFnPointer), _191, fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<DidChangeWatchedFilesParams>(&DidChangeWatchedFilesParams, fn(&DidChangeWatchedFilesParams, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_189, _190], | |
destination: _188, | |
target: 'bb88, | |
} | |
} | |
'bb88: { | |
_187 = [_188]; | |
_186 = &_187; | |
_185 = &(*_186); | |
_184 = Cast(Pointer(Unsize), _185, &[ArgumentV1<'_>]); | |
Call { | |
func: Const(fn new_v1(&[&str], &[ArgumentV1<'_>]) -> Arguments<'_>), | |
args: [_180, _184], | |
destination: _179, | |
target: 'bb89, | |
} | |
} | |
'bb89: { | |
_178 = &_179; | |
_177 = Cast(Pointer(Unsize), _178, &dyn Value); | |
Call { | |
func: Const(Some<&dyn Value>(&dyn Value) -> Option<&dyn Value>), | |
args: [_177], | |
destination: _176, | |
target: 'bb90, | |
} | |
} | |
'bb90: { | |
_171 = (_172, _176); | |
_170 = [_171]; | |
_169 = &_170; | |
Call { | |
func: Const(fn value_set<[(&Field, Option<&dyn Value>); 1]>(&FieldSet, &[(&Field, Option<&dyn Value>); 1]) -> ValueSet<'_>), | |
args: [_163, _169], | |
destination: _155, | |
target: 'bb91, | |
} | |
} | |
'bb91: { | |
StorageDead(_191) | |
StorageDead(_190) | |
StorageDead(_189) | |
StorageDead(_188) | |
StorageDead(_187) | |
StorageDead(_186) | |
StorageDead(_185) | |
StorageDead(_184) | |
StorageDead(_183) | |
StorageDead(_182) | |
StorageDead(_181) | |
StorageDead(_180) | |
StorageDead(_179) | |
StorageDead(_178) | |
StorageDead(_177) | |
StorageDead(_176) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(175), projection: [] }, target: Idx::<BasicBlock>(92), unwind: None } }; | |
} | |
'bb92: { | |
StorageDead(_175) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(174), projection: [] }, target: Idx::<BasicBlock>(93), unwind: None } }; | |
} | |
'bb93: { | |
StorageDead(_174) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(173), projection: [] }, target: Idx::<BasicBlock>(94), unwind: None } }; | |
} | |
'bb94: { | |
StorageDead(_173) | |
StorageDead(_172) | |
StorageDead(_171) | |
StorageDead(_170) | |
StorageDead(_169) | |
StorageDead(_168) | |
StorageDead(_167) | |
StorageDead(_166) | |
StorageDead(_165) | |
StorageDead(_164) | |
StorageDead(_163) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(10), projection: [] }, target: Idx::<BasicBlock>(95), unwind: None } }; | |
} | |
'bb95: { | |
StorageDead(iter_10) | |
StorageDead(_162) | |
StorageDead(_161) | |
StorageDead(_160) | |
StorageDead(_159) | |
StorageDead(_158) | |
StorageDead(_157) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(156), projection: [] }, target: Idx::<BasicBlock>(96), unwind: None } }; | |
} | |
'bb96: { | |
StorageDead(_156) | |
_154 = &_155; | |
Call { | |
func: Const(fn __tracing_log(&Metadata<'_>, &dyn Log, Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_7, _152, log_meta_8, _154], | |
destination: _89, | |
target: 'bb97, | |
} | |
} | |
'bb97: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(155), projection: [] }, target: Idx::<BasicBlock>(98), unwind: None } }; | |
} | |
'bb98: { | |
StorageDead(_155) | |
StorageDead(_154) | |
StorageDead(_153) | |
StorageDead(_152) | |
goto 'bb100; | |
} | |
'bb99: { | |
goto 'bb100; | |
} | |
'bb100: { | |
StorageDead(_151) | |
StorageDead(_150) | |
StorageDead(_149) | |
StorageDead(logger_9) | |
StorageDead(_148) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(8), projection: [] }, target: Idx::<BasicBlock>(101), unwind: None } }; | |
} | |
'bb101: { | |
StorageDead(log_meta_8) | |
StorageDead(_147) | |
StorageDead(_146) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(145), projection: [] }, target: Idx::<BasicBlock>(102), unwind: None } }; | |
} | |
'bb102: { | |
StorageDead(_145) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(144), projection: [] }, target: Idx::<BasicBlock>(103), unwind: None } }; | |
} | |
'bb103: { | |
StorageDead(_144) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(143), projection: [] }, target: Idx::<BasicBlock>(104), unwind: None } }; | |
} | |
'bb104: { | |
StorageDead(_143) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(142), projection: [] }, target: Idx::<BasicBlock>(105), unwind: None } }; | |
} | |
'bb105: { | |
StorageDead(_142) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(141), projection: [] }, target: Idx::<BasicBlock>(106), unwind: None } }; | |
} | |
'bb106: { | |
StorageDead(_141) | |
StorageDead(_140) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(139), projection: [] }, target: Idx::<BasicBlock>(107), unwind: None } }; | |
} | |
'bb107: { | |
StorageDead(_139) | |
StorageDead(meta_7) | |
StorageDead(_138) | |
StorageDead(_137) | |
StorageDead(_136) | |
goto 'bb109; | |
} | |
'bb108: { | |
goto 'bb109; | |
} | |
'bb109: { | |
StorageDead(_135) | |
StorageDead(_134) | |
StorageDead(_133) | |
StorageDead(_132) | |
StorageDead(level_6) | |
StorageDead(_131) | |
StorageDead(_130) | |
StorageDead(_129) | |
StorageDead(_128) | |
StorageDead(_127) | |
StorageDead(_126) | |
StorageDead(_125) | |
StorageDead(_124) | |
StorageDead(_123) | |
StorageDead(_122) | |
StorageDead(_121) | |
StorageDead(_120) | |
StorageDead(_119) | |
StorageDead(_118) | |
StorageDead(_117) | |
StorageDead(_116) | |
StorageDead(_115) | |
StorageDead(_114) | |
goto 'bb111; | |
} | |
'bb110: { | |
goto 'bb111; | |
} | |
'bb111: { | |
StorageDead(_113) | |
StorageDead(_112) | |
goto 'bb113; | |
} | |
'bb112: { | |
goto 'bb113; | |
} | |
'bb113: { | |
StorageDead(_111) | |
StorageDead(_110) | |
StorageDead(_109) | |
StorageDead(_108) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageDead(_101) | |
StorageDead(_100) | |
StorageDead(_99) | |
StorageDead(_98) | |
StorageDead(_97) | |
StorageDead(_96) | |
StorageDead(_95) | |
StorageDead(_94) | |
StorageDead(_93) | |
StorageDead(_92) | |
StorageDead(_91) | |
StorageDead(_90) | |
StorageDead(_89) | |
goto 'bb114; | |
} | |
'bb114: { | |
StorageDead(enabled_3) | |
StorageDead(_39) | |
StorageDead(_38) | |
StorageDead(_37) | |
StorageDead(_36) | |
StorageDead(_35) | |
StorageDead(_34) | |
StorageDead(_33) | |
StorageDead(_32) | |
StorageDead(_31) | |
StorageDead(_30) | |
StorageDead(_29) | |
StorageDead(_28) | |
StorageLive(_192) | |
_192 = Const(false); | |
StorageLive(flake_files_changed_11) | |
flake_files_changed_11 = _192; | |
StorageLive(_193) | |
StorageLive(_194) | |
StorageLive(_195) | |
_195 = ¶ms_2.changes; | |
Call { | |
func: Const(fn into_iter<&Vec<FileEvent, Global>>(&Vec<FileEvent, Global>) -> <&Vec<FileEvent, Global> as IntoIterator>::IntoIter), | |
args: [_195], | |
destination: _194, | |
target: 'bb115, | |
} | |
} | |
'bb115: { | |
StorageLive(<ra@gennew>18_27) | |
<ra@gennew>18_27 = _194; | |
goto 'bb116; | |
} | |
'bb116: { | |
StorageLive(_196) | |
StorageLive(_197) | |
StorageLive(_198) | |
StorageLive(_199) | |
_199 = &mut <ra@gennew>18_27; | |
_198 = &mut (*_199); | |
Call { | |
func: Const(fn next<Iter<'_, FileEvent>>(&mut Iter<'_, FileEvent>) -> Option<<Iter<'_, FileEvent> as Iterator>::Item>), | |
args: [_198], | |
destination: _197, | |
target: 'bb117, | |
} | |
} | |
'bb117: { | |
StorageLive(_200) | |
_200 = Discriminant(_197); | |
switch _200 { | |
0 => 'bb118, | |
_ => 'bb119, | |
} | |
} | |
'bb118: { | |
StorageLive(_201) | |
StorageDead(_201) | |
StorageDead(_200) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(199), projection: [] }, target: Idx::<BasicBlock>(121), unwind: None } }; | |
} | |
'bb119: { | |
_200 = Discriminant(_197); | |
switch _200 { | |
1 => 'bb123, | |
_ => 'bb124, | |
} | |
} | |
'bb120: { | |
goto 'bb331; | |
} | |
'bb121: { | |
StorageDead(_199) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(198), projection: [] }, target: Idx::<BasicBlock>(122), unwind: None } }; | |
} | |
'bb122: { | |
StorageDead(_198) | |
StorageDead(_197) | |
StorageDead(_196) | |
goto 'bb120; | |
} | |
'bb123: { | |
StorageLive(uri_12) | |
uri_12 = &(*(_197 as Some).0).uri; | |
StorageLive(typ_13) | |
typ_13 = (*(_197 as Some).0).typ; | |
StorageLive(_202) | |
StorageLive(_203) | |
StorageLive(_204) | |
_204 = &(*self_1).opened_files; | |
Call { | |
func: Const(fn contains_key<Url, FileData, RandomState, Url>(&HashMap<Url, FileData, RandomState>, &Url) -> bool), | |
args: [_204, uri_12], | |
destination: _203, | |
target: 'bb125, | |
} | |
} | |
'bb124: { | |
Terminator { span: ExprId(Idx::<Expr>(637)), kind: Unreachable }; | |
} | |
'bb125: { | |
switch _203 { | |
1 => 'bb126, | |
_ => 'bb129, | |
} | |
} | |
'bb126: { | |
StorageLive(_205) | |
StorageDead(_205) | |
StorageDead(_204) | |
StorageDead(_203) | |
StorageDead(_202) | |
StorageDead(typ_13) | |
StorageDead(uri_12) | |
StorageDead(_201) | |
StorageDead(_200) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(199), projection: [] }, target: Idx::<BasicBlock>(127), unwind: None } }; | |
} | |
'bb127: { | |
StorageDead(_199) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(198), projection: [] }, target: Idx::<BasicBlock>(128), unwind: None } }; | |
} | |
'bb128: { | |
StorageDead(_198) | |
StorageDead(_197) | |
StorageDead(_196) | |
goto 'bb116; | |
} | |
'bb129: { | |
StorageDead(_204) | |
StorageDead(_203) | |
StorageDead(_202) | |
StorageLive(_206) | |
StorageLive(_207) | |
_207 = &(*uri_12); | |
Call { | |
func: Const(fn to_file_path(&Url) -> Result<PathBuf, ()>), | |
args: [_207], | |
destination: _206, | |
target: 'bb130, | |
} | |
} | |
'bb130: { | |
_200 = Discriminant(_206); | |
switch _200 { | |
0 => 'bb131, | |
_ => 'bb132, | |
} | |
} | |
'bb131: { | |
StorageLive(path_14) | |
path_14 = (_206 as Ok).0; | |
StorageLive(_210) | |
StorageLive(_211) | |
StorageLive(_212) | |
_212 = Const(FileChangeType(1)); | |
StorageLive(_213) | |
_213 = _212 == typ_13; | |
switch _213 { | |
1 => 'bb138, | |
_ => 'bb139, | |
} | |
} | |
'bb132: { | |
StorageLive(_208) | |
StorageLive(_209) | |
StorageDead(_209) | |
StorageDead(_208) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(14), projection: [] }, target: Idx::<BasicBlock>(133), unwind: None } }; | |
} | |
'bb133: { | |
StorageDead(path_14) | |
StorageDead(_207) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(206), projection: [] }, target: Idx::<BasicBlock>(134), unwind: None } }; | |
} | |
'bb134: { | |
StorageDead(_206) | |
StorageDead(typ_13) | |
StorageDead(uri_12) | |
StorageDead(_201) | |
StorageDead(_200) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(199), projection: [] }, target: Idx::<BasicBlock>(135), unwind: None } }; | |
} | |
'bb135: { | |
StorageDead(_199) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(198), projection: [] }, target: Idx::<BasicBlock>(136), unwind: None } }; | |
} | |
'bb136: { | |
StorageDead(_198) | |
StorageDead(_197) | |
StorageDead(_196) | |
goto 'bb116; | |
} | |
'bb137: { | |
StorageLive(_216) | |
_216 = Const(FileChangeType(1)); | |
StorageLive(_217) | |
_217 = _216 == typ_13; | |
switch _217 { | |
1 => 'bb144, | |
_ => 'bb145, | |
} | |
} | |
'bb138: { | |
goto 'bb137; | |
} | |
'bb139: { | |
StorageLive(_214) | |
_214 = Const(FileChangeType(2)); | |
StorageLive(_215) | |
_215 = _214 == typ_13; | |
switch _215 { | |
1 => 'bb140, | |
_ => 'bb141, | |
} | |
} | |
'bb140: { | |
goto 'bb137; | |
} | |
'bb141: { | |
goto 'bb142; | |
} | |
'bb142: { | |
_211 = Const(false); | |
goto 'bb152; | |
} | |
'bb143: { | |
_211 = Const(true); | |
goto 'bb152; | |
} | |
'bb144: { | |
StorageLive(_218) | |
_218 = Const(FileChangeType(1)); | |
StorageLive(_219) | |
_219 = _218 == typ_13; | |
switch _219 { | |
1 => 'bb146, | |
_ => 'bb147, | |
} | |
} | |
'bb145: { | |
StorageLive(_220) | |
_220 = Const(FileChangeType(2)); | |
StorageLive(_221) | |
_221 = _220 == typ_13; | |
switch _221 { | |
1 => 'bb148, | |
_ => 'bb149, | |
} | |
} | |
'bb146: { | |
goto 'bb143; | |
} | |
'bb147: { | |
<no-terminator>; | |
} | |
'bb148: { | |
StorageLive(_222) | |
_222 = Const(FileChangeType(2)); | |
StorageLive(_223) | |
_223 = _222 == typ_13; | |
switch _223 { | |
1 => 'bb150, | |
_ => 'bb151, | |
} | |
} | |
'bb149: { | |
Terminator { span: PatId(Idx::<Pat>(115)), kind: Unreachable }; | |
} | |
'bb150: { | |
goto 'bb143; | |
} | |
'bb151: { | |
<no-terminator>; | |
} | |
'bb152: { | |
switch _211 { | |
1 => 'bb153, | |
_ => 'bb289, | |
} | |
} | |
'bb153: { | |
StorageLive(_224) | |
StorageLive(_225) | |
StorageLive(_226) | |
StorageLive(_227) | |
_227 = &path_14; | |
_226 = Closure(_227); | |
_225 = &_226; | |
Call { | |
func: Const(fn call<{closure#24}<fn() -> Result<String, Error>>, ()>(&{closure#24}<fn() -> Result<String, Error>>, ()) -> <{closure#24}<fn() -> Result<String, Error>> as FnOnce<()>>::Output), | |
args: [_225], | |
destination: _224, | |
target: 'bb154, | |
} | |
} | |
'bb154: { | |
_200 = Discriminant(_224); | |
switch _200 { | |
0 => 'bb155, | |
_ => 'bb156, | |
} | |
} | |
'bb155: { | |
StorageLive(text_15) | |
text_15 = (_224 as Ok).0; | |
StorageLive(_228) | |
_228 = &mut (*self_1); | |
Call { | |
func: Const(fn set_vfs_file_content(&mut Server, &Url, String)), | |
args: [_228, uri_12, text_15], | |
destination: _210, | |
target: 'bb157, | |
} | |
} | |
'bb156: { | |
_200 = Discriminant(_224); | |
switch _200 { | |
1 => 'bb159, | |
_ => 'bb160, | |
} | |
} | |
'bb157: { | |
goto 'bb158; | |
} | |
'bb158: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(17), projection: [] }, target: Idx::<BasicBlock>(284), unwind: None } }; | |
} | |
'bb159: { | |
StorageLive(err_16) | |
err_16 = (_224 as Err).0; | |
StorageLive(_229) | |
StorageLive(_230) | |
StorageLive(_231) | |
_231 = &err_16; | |
Call { | |
func: Const(fn kind(&Error) -> ErrorKind), | |
args: [_231], | |
destination: _230, | |
target: 'bb162, | |
} | |
} | |
'bb160: { | |
_200 = Discriminant(_224); | |
switch _200 { | |
1 => 'bb166, | |
_ => 'bb167, | |
} | |
} | |
'bb161: { | |
StorageLive(_232) | |
StorageLive(_233) | |
_233 = Const(FileChangeType(3)); | |
typ_13 = _233; | |
StorageDead(_233) | |
StorageDead(_232) | |
goto 'bb158; | |
} | |
'bb162: { | |
_200 = Discriminant(_230); | |
switch _200 { | |
0 => 'bb163, | |
_ => 'bb164, | |
} | |
} | |
'bb163: { | |
_229 = Const(true); | |
goto 'bb165; | |
} | |
'bb164: { | |
_229 = Const(false); | |
goto 'bb165; | |
} | |
'bb165: { | |
switch _229 { | |
1 => 'bb161, | |
_ => 'bb160, | |
} | |
} | |
'bb166: { | |
StorageLive(err_17) | |
err_17 = (_224 as Err).0; | |
StorageLive(_234) | |
StorageLive(_235) | |
StorageLive(_236) | |
StorageLive(_237) | |
StorageLive(_238) | |
_238 = Const(Level(Error)); | |
_237 = &_238; | |
StorageLive(_239) | |
StorageLive(_240) | |
_240 = Const(LevelFilter(Some(Level(Trace)))); | |
_239 = &_240; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_237, _239], | |
destination: _236, | |
target: 'bb168, | |
} | |
} | |
'bb167: { | |
Terminator { span: ExprId(Idx::<Expr>(589)), kind: Unreachable }; | |
} | |
'bb168: { | |
switch _236 { | |
0 => 'bb169, | |
_ => 'bb170, | |
} | |
} | |
'bb169: { | |
_235 = _236; | |
goto 'bb173; | |
} | |
'bb170: { | |
StorageLive(_241) | |
StorageLive(_242) | |
_242 = Const(Level(Error)); | |
_241 = &_242; | |
StorageLive(_243) | |
StorageLive(_244) | |
Call { | |
func: Const(fn current() -> LevelFilter), | |
args: [], | |
destination: _244, | |
target: 'bb171, | |
} | |
} | |
'bb171: { | |
_243 = &_244; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_241, _243], | |
destination: _235, | |
target: 'bb172, | |
} | |
} | |
'bb172: { | |
goto 'bb173; | |
} | |
'bb173: { | |
switch _235 { | |
0 => 'bb174, | |
_ => 'bb175, | |
} | |
} | |
'bb174: { | |
_234 = _235; | |
goto 'bb185; | |
} | |
'bb175: { | |
StorageLive(_245) | |
StorageLive(_246) | |
StorageLive(_247) | |
_247 = Static(StaticId(175)); | |
_246 = &(*_247); | |
Call { | |
func: Const(fn interest(&DefaultCallsite) -> Interest), | |
args: [_246], | |
destination: _245, | |
target: 'bb176, | |
} | |
} | |
'bb176: { | |
StorageLive(interest_19) | |
interest_19 = _245; | |
StorageLive(_248) | |
StorageLive(_249) | |
StorageLive(_250) | |
_250 = &interest_19; | |
Call { | |
func: Const(fn is_never(&Interest) -> bool), | |
args: [_250], | |
destination: _249, | |
target: 'bb177, | |
} | |
} | |
'bb177: { | |
_248 = ! _249; | |
switch _248 { | |
0 => 'bb178, | |
_ => 'bb179, | |
} | |
} | |
'bb178: { | |
_234 = _248; | |
goto 'bb182; | |
} | |
'bb179: { | |
StorageLive(_251) | |
StorageLive(_252) | |
StorageLive(_253) | |
_253 = Static(StaticId(175)); | |
_252 = &(*_253); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_252], | |
destination: _251, | |
target: 'bb180, | |
} | |
} | |
'bb180: { | |
Call { | |
func: Const(fn __is_enabled(&Metadata<'_>, Interest) -> bool), | |
args: [_251, interest_19], | |
destination: _234, | |
target: 'bb181, | |
} | |
} | |
'bb181: { | |
goto 'bb182; | |
} | |
'bb182: { | |
StorageDead(_253) | |
StorageDead(_252) | |
StorageDead(_251) | |
StorageDead(_250) | |
StorageDead(_249) | |
StorageDead(_248) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(19), projection: [] }, target: Idx::<BasicBlock>(183), unwind: None } }; | |
} | |
'bb183: { | |
StorageDead(interest_19) | |
StorageDead(_247) | |
StorageDead(_246) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(245), projection: [] }, target: Idx::<BasicBlock>(184), unwind: None } }; | |
} | |
'bb184: { | |
StorageDead(_245) | |
goto 'bb185; | |
} | |
'bb185: { | |
StorageLive(enabled_18) | |
enabled_18 = _234; | |
switch enabled_18 { | |
1 => 'bb186, | |
_ => 'bb206, | |
} | |
} | |
'bb186: { | |
StorageLive(_254) | |
StorageLive(_255) | |
StorageLive(_256) | |
_256 = Closure(); | |
_255 = &_256; | |
StorageLive(_257) | |
StorageLive(_258) | |
StorageLive(_259) | |
StorageLive(_260) | |
StorageLive(_261) | |
StorageLive(_262) | |
StorageLive(_263) | |
StorageLive(_264) | |
_264 = Static(StaticId(175)); | |
_263 = &(*_264); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_263], | |
destination: _262, | |
target: 'bb187, | |
} | |
} | |
'bb187: { | |
_261 = &(*_262); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_261], | |
destination: _260, | |
target: 'bb188, | |
} | |
} | |
'bb188: { | |
_259 = &(*_260); | |
Call { | |
func: Const(fn iter(&FieldSet) -> Iter), | |
args: [_259], | |
destination: _258, | |
target: 'bb189, | |
} | |
} | |
'bb189: { | |
StorageLive(iter_20) | |
iter_20 = _258; | |
StorageLive(_265) | |
StorageLive(_266) | |
StorageLive(_267) | |
StorageLive(_268) | |
StorageLive(_269) | |
StorageLive(_270) | |
_270 = Static(StaticId(175)); | |
_269 = &(*_270); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_269], | |
destination: _268, | |
target: 'bb190, | |
} | |
} | |
'bb190: { | |
_267 = &(*_268); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_267], | |
destination: _266, | |
target: 'bb191, | |
} | |
} | |
'bb191: { | |
_265 = &(*_266); | |
StorageLive(_271) | |
StorageLive(_272) | |
StorageLive(_273) | |
StorageLive(_274) | |
StorageLive(_275) | |
StorageLive(_276) | |
StorageLive(_277) | |
_277 = &mut iter_20; | |
Call { | |
func: Const(fn next<Iter>(&mut Iter) -> Option<<Iter as Iterator>::Item>), | |
args: [_277], | |
destination: _276, | |
target: 'bb192, | |
} | |
} | |
'bb192: { | |
Call { | |
func: Const(fn expect<Field>(Option<Field>, &str) -> Field), | |
args: [_276, Const("FieldSet corrupted (this is a bug)")], | |
destination: _275, | |
target: 'bb193, | |
} | |
} | |
'bb193: { | |
_274 = &_275; | |
StorageLive(_278) | |
StorageLive(_279) | |
StorageLive(_280) | |
StorageLive(_281) | |
StorageLive(_282) | |
StorageLive(_283) | |
StorageLive(_284) | |
StorageLive(_285) | |
_285 = [Const("Ignore file "), Const(": ")]; | |
_284 = &_285; | |
_283 = &(*_284); | |
_282 = Cast(Pointer(Unsize), _283, &[&str]); | |
StorageLive(_286) | |
StorageLive(_287) | |
StorageLive(_288) | |
StorageLive(_289) | |
StorageLive(_290) | |
StorageLive(_291) | |
_291 = &path_14; | |
StorageLive(_292) | |
StorageLive(_293) | |
_292 = Cast(Pointer(ReifyFnPointer), _293, fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<PathBuf>(&PathBuf, fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_291, _292], | |
destination: _290, | |
target: 'bb194, | |
} | |
} | |
'bb194: { | |
StorageLive(_294) | |
StorageLive(_295) | |
_295 = &err_17; | |
StorageLive(_296) | |
StorageLive(_297) | |
_296 = Cast(Pointer(ReifyFnPointer), _297, fn(&Error, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<Error>(&Error, fn(&Error, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_295, _296], | |
destination: _294, | |
target: 'bb195, | |
} | |
} | |
'bb195: { | |
_289 = [_290, _294]; | |
_288 = &_289; | |
_287 = &(*_288); | |
_286 = Cast(Pointer(Unsize), _287, &[ArgumentV1<'_>]); | |
Call { | |
func: Const(fn new_v1(&[&str], &[ArgumentV1<'_>]) -> Arguments<'_>), | |
args: [_282, _286], | |
destination: _281, | |
target: 'bb196, | |
} | |
} | |
'bb196: { | |
_280 = &_281; | |
_279 = Cast(Pointer(Unsize), _280, &dyn Value); | |
Call { | |
func: Const(Some<&dyn Value>(&dyn Value) -> Option<&dyn Value>), | |
args: [_279], | |
destination: _278, | |
target: 'bb197, | |
} | |
} | |
'bb197: { | |
_273 = (_274, _278); | |
_272 = [_273]; | |
_271 = &_272; | |
Call { | |
func: Const(fn value_set<[(&Field, Option<&dyn Value>); 1]>(&FieldSet, &[(&Field, Option<&dyn Value>); 1]) -> ValueSet<'_>), | |
args: [_265, _271], | |
destination: _257, | |
target: 'bb198, | |
} | |
} | |
'bb198: { | |
StorageDead(_297) | |
StorageDead(_296) | |
StorageDead(_295) | |
StorageDead(_294) | |
StorageDead(_293) | |
StorageDead(_292) | |
StorageDead(_291) | |
StorageDead(_290) | |
StorageDead(_289) | |
StorageDead(_288) | |
StorageDead(_287) | |
StorageDead(_286) | |
StorageDead(_285) | |
StorageDead(_284) | |
StorageDead(_283) | |
StorageDead(_282) | |
StorageDead(_281) | |
StorageDead(_280) | |
StorageDead(_279) | |
StorageDead(_278) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(277), projection: [] }, target: Idx::<BasicBlock>(199), unwind: None } }; | |
} | |
'bb199: { | |
StorageDead(_277) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(276), projection: [] }, target: Idx::<BasicBlock>(200), unwind: None } }; | |
} | |
'bb200: { | |
StorageDead(_276) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(275), projection: [] }, target: Idx::<BasicBlock>(201), unwind: None } }; | |
} | |
'bb201: { | |
StorageDead(_275) | |
StorageDead(_274) | |
StorageDead(_273) | |
StorageDead(_272) | |
StorageDead(_271) | |
StorageDead(_270) | |
StorageDead(_269) | |
StorageDead(_268) | |
StorageDead(_267) | |
StorageDead(_266) | |
StorageDead(_265) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(20), projection: [] }, target: Idx::<BasicBlock>(202), unwind: None } }; | |
} | |
'bb202: { | |
StorageDead(iter_20) | |
StorageDead(_264) | |
StorageDead(_263) | |
StorageDead(_262) | |
StorageDead(_261) | |
StorageDead(_260) | |
StorageDead(_259) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(258), projection: [] }, target: Idx::<BasicBlock>(203), unwind: None } }; | |
} | |
'bb203: { | |
StorageDead(_258) | |
Call { | |
func: Const(fn call<{closure#25}<fn(ValueSet<'_>)>, (ValueSet<'_>,)>(&{closure#25}<fn(ValueSet<'_>)>, (ValueSet<'_>,)) -> <{closure#25}<fn(ValueSet<'_>)> as FnOnce<(ValueSet<'_>,)>>::Output), | |
args: [_255, _257], | |
destination: _254, | |
target: 'bb204, | |
} | |
} | |
'bb204: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(257), projection: [] }, target: Idx::<BasicBlock>(205), unwind: None } }; | |
} | |
'bb205: { | |
StorageDead(_257) | |
StorageDead(_256) | |
StorageDead(_255) | |
StorageDead(_254) | |
goto 'bb283; | |
} | |
'bb206: { | |
StorageLive(_298) | |
StorageLive(_299) | |
StorageLive(_300) | |
StorageLive(_301) | |
StorageLive(_302) | |
_302 = Const(Level(Error)); | |
StorageLive(_303) | |
_303 = Const(Level(Error)); | |
StorageLive(_304) | |
_304 = _303 == _302; | |
switch _304 { | |
1 => 'bb207, | |
_ => 'bb208, | |
} | |
} | |
'bb207: { | |
StorageLive(_305) | |
_305 = Const(Level(Error)); | |
StorageLive(_306) | |
_306 = _305 == _302; | |
switch _306 { | |
1 => 'bb209, | |
_ => 'bb208, | |
} | |
} | |
'bb208: { | |
StorageLive(_307) | |
_307 = Const(Level(Warn)); | |
StorageLive(_308) | |
_308 = _307 == _302; | |
switch _308 { | |
1 => 'bb211, | |
_ => 'bb212, | |
} | |
} | |
'bb209: { | |
_301 = Adt(); | |
goto 'bb210; | |
} | |
'bb210: { | |
_300 = &_301; | |
StorageLive(_319) | |
StorageLive(_320) | |
_320 = Const(Trace); | |
_319 = &_320; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_300, _319], | |
destination: _299, | |
target: 'bb220, | |
} | |
} | |
'bb211: { | |
StorageLive(_309) | |
_309 = Const(Level(Warn)); | |
StorageLive(_310) | |
_310 = _309 == _302; | |
switch _310 { | |
1 => 'bb213, | |
_ => 'bb212, | |
} | |
} | |
'bb212: { | |
StorageLive(_311) | |
_311 = Const(Level(Info)); | |
StorageLive(_312) | |
_312 = _311 == _302; | |
switch _312 { | |
1 => 'bb214, | |
_ => 'bb215, | |
} | |
} | |
'bb213: { | |
_301 = Adt(); | |
goto 'bb210; | |
} | |
'bb214: { | |
StorageLive(_313) | |
_313 = Const(Level(Info)); | |
StorageLive(_314) | |
_314 = _313 == _302; | |
switch _314 { | |
1 => 'bb216, | |
_ => 'bb215, | |
} | |
} | |
'bb215: { | |
StorageLive(_315) | |
_315 = Const(Level(Debug)); | |
StorageLive(_316) | |
_316 = _315 == _302; | |
switch _316 { | |
1 => 'bb217, | |
_ => 'bb218, | |
} | |
} | |
'bb216: { | |
_301 = Adt(); | |
goto 'bb210; | |
} | |
'bb217: { | |
StorageLive(_317) | |
_317 = Const(Level(Debug)); | |
StorageLive(_318) | |
_318 = _317 == _302; | |
switch _318 { | |
1 => 'bb219, | |
_ => 'bb218, | |
} | |
} | |
'bb218: { | |
_301 = Adt(); | |
goto 'bb210; | |
} | |
'bb219: { | |
_301 = Adt(); | |
goto 'bb210; | |
} | |
'bb220: { | |
switch _299 { | |
1 => 'bb221, | |
_ => 'bb281, | |
} | |
} | |
'bb221: { | |
StorageLive(_321) | |
StorageLive(_322) | |
Call { | |
func: Const(fn has_been_set() -> bool), | |
args: [], | |
destination: _322, | |
target: 'bb222, | |
} | |
} | |
'bb222: { | |
_321 = ! _322; | |
switch _321 { | |
1 => 'bb223, | |
_ => 'bb279, | |
} | |
} | |
'bb223: { | |
StorageLive(_323) | |
StorageLive(_324) | |
_324 = Const(Level(Error)); | |
StorageLive(_325) | |
_325 = Const(Level(Error)); | |
StorageLive(_326) | |
_326 = _325 == _324; | |
switch _326 { | |
1 => 'bb224, | |
_ => 'bb225, | |
} | |
} | |
'bb224: { | |
StorageLive(_327) | |
_327 = Const(Level(Error)); | |
StorageLive(_328) | |
_328 = _327 == _324; | |
switch _328 { | |
1 => 'bb226, | |
_ => 'bb225, | |
} | |
} | |
'bb225: { | |
StorageLive(_329) | |
_329 = Const(Level(Warn)); | |
StorageLive(_330) | |
_330 = _329 == _324; | |
switch _330 { | |
1 => 'bb228, | |
_ => 'bb229, | |
} | |
} | |
'bb226: { | |
_323 = Adt(); | |
goto 'bb227; | |
} | |
'bb227: { | |
StorageLive(level_21) | |
level_21 = _323; | |
StorageLive(_341) | |
StorageLive(_342) | |
_342 = &level_21; | |
StorageLive(_343) | |
StorageLive(_344) | |
Call { | |
func: Const(fn max_level() -> LevelFilter), | |
args: [], | |
destination: _344, | |
target: 'bb237, | |
} | |
} | |
'bb228: { | |
StorageLive(_331) | |
_331 = Const(Level(Warn)); | |
StorageLive(_332) | |
_332 = _331 == _324; | |
switch _332 { | |
1 => 'bb230, | |
_ => 'bb229, | |
} | |
} | |
'bb229: { | |
StorageLive(_333) | |
_333 = Const(Level(Info)); | |
StorageLive(_334) | |
_334 = _333 == _324; | |
switch _334 { | |
1 => 'bb231, | |
_ => 'bb232, | |
} | |
} | |
'bb230: { | |
_323 = Adt(); | |
goto 'bb227; | |
} | |
'bb231: { | |
StorageLive(_335) | |
_335 = Const(Level(Info)); | |
StorageLive(_336) | |
_336 = _335 == _324; | |
switch _336 { | |
1 => 'bb233, | |
_ => 'bb232, | |
} | |
} | |
'bb232: { | |
StorageLive(_337) | |
_337 = Const(Level(Debug)); | |
StorageLive(_338) | |
_338 = _337 == _324; | |
switch _338 { | |
1 => 'bb234, | |
_ => 'bb235, | |
} | |
} | |
'bb233: { | |
_323 = Adt(); | |
goto 'bb227; | |
} | |
'bb234: { | |
StorageLive(_339) | |
_339 = Const(Level(Debug)); | |
StorageLive(_340) | |
_340 = _339 == _324; | |
switch _340 { | |
1 => 'bb236, | |
_ => 'bb235, | |
} | |
} | |
'bb235: { | |
_323 = Adt(); | |
goto 'bb227; | |
} | |
'bb236: { | |
_323 = Adt(); | |
goto 'bb227; | |
} | |
'bb237: { | |
_343 = &_344; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_342, _343], | |
destination: _341, | |
target: 'bb238, | |
} | |
} | |
'bb238: { | |
switch _341 { | |
1 => 'bb239, | |
_ => 'bb277, | |
} | |
} | |
'bb239: { | |
StorageLive(_345) | |
StorageLive(_346) | |
StorageLive(_347) | |
_347 = Static(StaticId(175)); | |
_346 = &(*_347); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_346], | |
destination: _345, | |
target: 'bb240, | |
} | |
} | |
'bb240: { | |
StorageLive(meta_22) | |
meta_22 = _345; | |
StorageLive(_348) | |
StorageLive(_349) | |
StorageLive(_350) | |
StorageLive(_351) | |
StorageLive(_352) | |
StorageLive(_353) | |
StorageLive(_354) | |
Call { | |
func: Const(fn builder() -> MetadataBuilder<'_>), | |
args: [], | |
destination: _354, | |
target: 'bb241, | |
} | |
} | |
'bb241: { | |
_353 = &mut _354; | |
Call { | |
func: Const(fn level(&mut MetadataBuilder<'_>, Level) -> &mut MetadataBuilder<'_>), | |
args: [_353, level_21], | |
destination: _352, | |
target: 'bb242, | |
} | |
} | |
'bb242: { | |
_351 = &mut (*_352); | |
StorageLive(_355) | |
StorageLive(_356) | |
_356 = &(*meta_22); | |
Call { | |
func: Const(fn target(&Metadata<'_>) -> &str), | |
args: [_356], | |
destination: _355, | |
target: 'bb243, | |
} | |
} | |
'bb243: { | |
Call { | |
func: Const(fn target(&mut MetadataBuilder<'_>, &str) -> &mut MetadataBuilder<'_>), | |
args: [_351, _355], | |
destination: _350, | |
target: 'bb244, | |
} | |
} | |
'bb244: { | |
_349 = &(*_350); | |
Call { | |
func: Const(fn build(&MetadataBuilder<'_>) -> Metadata<'_>), | |
args: [_349], | |
destination: _348, | |
target: 'bb245, | |
} | |
} | |
'bb245: { | |
StorageLive(log_meta_23) | |
log_meta_23 = _348; | |
StorageLive(_357) | |
Call { | |
func: Const(fn logger() -> &dyn Log), | |
args: [], | |
destination: _357, | |
target: 'bb246, | |
} | |
} | |
'bb246: { | |
StorageLive(logger_24) | |
logger_24 = _357; | |
StorageLive(_358) | |
StorageLive(_359) | |
_359 = &(*logger_24); | |
StorageLive(_360) | |
_360 = &log_meta_23; | |
Call { | |
func: Const(fn enabled<dyn Log>(&dyn Log, &Metadata<'_>) -> bool), | |
args: [_359, _360], | |
destination: _358, | |
target: 'bb247, | |
} | |
} | |
'bb247: { | |
switch _358 { | |
1 => 'bb248, | |
_ => 'bb268, | |
} | |
} | |
'bb248: { | |
StorageLive(_361) | |
StorageLive(_362) | |
_362 = &(*logger_24); | |
_361 = Cast(Pointer(Unsize), _362, &dyn Log); | |
StorageLive(_363) | |
StorageLive(_364) | |
StorageLive(_365) | |
StorageLive(_366) | |
StorageLive(_367) | |
StorageLive(_368) | |
StorageLive(_369) | |
StorageLive(_370) | |
StorageLive(_371) | |
_371 = Static(StaticId(175)); | |
_370 = &(*_371); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_370], | |
destination: _369, | |
target: 'bb249, | |
} | |
} | |
'bb249: { | |
_368 = &(*_369); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_368], | |
destination: _367, | |
target: 'bb250, | |
} | |
} | |
'bb250: { | |
_366 = &(*_367); | |
Call { | |
func: Const(fn iter(&FieldSet) -> Iter), | |
args: [_366], | |
destination: _365, | |
target: 'bb251, | |
} | |
} | |
'bb251: { | |
StorageLive(iter_25) | |
iter_25 = _365; | |
StorageLive(_372) | |
StorageLive(_373) | |
StorageLive(_374) | |
StorageLive(_375) | |
StorageLive(_376) | |
StorageLive(_377) | |
_377 = Static(StaticId(175)); | |
_376 = &(*_377); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_376], | |
destination: _375, | |
target: 'bb252, | |
} | |
} | |
'bb252: { | |
_374 = &(*_375); | |
Call { | |
func: Const(fn fields(&Metadata<'_>) -> &FieldSet), | |
args: [_374], | |
destination: _373, | |
target: 'bb253, | |
} | |
} | |
'bb253: { | |
_372 = &(*_373); | |
StorageLive(_378) | |
StorageLive(_379) | |
StorageLive(_380) | |
StorageLive(_381) | |
StorageLive(_382) | |
StorageLive(_383) | |
StorageLive(_384) | |
_384 = &mut iter_25; | |
Call { | |
func: Const(fn next<Iter>(&mut Iter) -> Option<<Iter as Iterator>::Item>), | |
args: [_384], | |
destination: _383, | |
target: 'bb254, | |
} | |
} | |
'bb254: { | |
Call { | |
func: Const(fn expect<Field>(Option<Field>, &str) -> Field), | |
args: [_383, Const("FieldSet corrupted (this is a bug)")], | |
destination: _382, | |
target: 'bb255, | |
} | |
} | |
'bb255: { | |
_381 = &_382; | |
StorageLive(_385) | |
StorageLive(_386) | |
StorageLive(_387) | |
StorageLive(_388) | |
StorageLive(_389) | |
StorageLive(_390) | |
StorageLive(_391) | |
StorageLive(_392) | |
_392 = [Const("Ignore file "), Const(": ")]; | |
_391 = &_392; | |
_390 = &(*_391); | |
_389 = Cast(Pointer(Unsize), _390, &[&str]); | |
StorageLive(_393) | |
StorageLive(_394) | |
StorageLive(_395) | |
StorageLive(_396) | |
StorageLive(_397) | |
StorageLive(_398) | |
_398 = &path_14; | |
StorageLive(_399) | |
StorageLive(_400) | |
_399 = Cast(Pointer(ReifyFnPointer), _400, fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<PathBuf>(&PathBuf, fn(&PathBuf, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_398, _399], | |
destination: _397, | |
target: 'bb256, | |
} | |
} | |
'bb256: { | |
StorageLive(_401) | |
StorageLive(_402) | |
_402 = &err_17; | |
StorageLive(_403) | |
StorageLive(_404) | |
_403 = Cast(Pointer(ReifyFnPointer), _404, fn(&Error, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<Error>(&Error, fn(&Error, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_402, _403], | |
destination: _401, | |
target: 'bb257, | |
} | |
} | |
'bb257: { | |
_396 = [_397, _401]; | |
_395 = &_396; | |
_394 = &(*_395); | |
_393 = Cast(Pointer(Unsize), _394, &[ArgumentV1<'_>]); | |
Call { | |
func: Const(fn new_v1(&[&str], &[ArgumentV1<'_>]) -> Arguments<'_>), | |
args: [_389, _393], | |
destination: _388, | |
target: 'bb258, | |
} | |
} | |
'bb258: { | |
_387 = &_388; | |
_386 = Cast(Pointer(Unsize), _387, &dyn Value); | |
Call { | |
func: Const(Some<&dyn Value>(&dyn Value) -> Option<&dyn Value>), | |
args: [_386], | |
destination: _385, | |
target: 'bb259, | |
} | |
} | |
'bb259: { | |
_380 = (_381, _385); | |
_379 = [_380]; | |
_378 = &_379; | |
Call { | |
func: Const(fn value_set<[(&Field, Option<&dyn Value>); 1]>(&FieldSet, &[(&Field, Option<&dyn Value>); 1]) -> ValueSet<'_>), | |
args: [_372, _378], | |
destination: _364, | |
target: 'bb260, | |
} | |
} | |
'bb260: { | |
StorageDead(_404) | |
StorageDead(_403) | |
StorageDead(_402) | |
StorageDead(_401) | |
StorageDead(_400) | |
StorageDead(_399) | |
StorageDead(_398) | |
StorageDead(_397) | |
StorageDead(_396) | |
StorageDead(_395) | |
StorageDead(_394) | |
StorageDead(_393) | |
StorageDead(_392) | |
StorageDead(_391) | |
StorageDead(_390) | |
StorageDead(_389) | |
StorageDead(_388) | |
StorageDead(_387) | |
StorageDead(_386) | |
StorageDead(_385) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(384), projection: [] }, target: Idx::<BasicBlock>(261), unwind: None } }; | |
} | |
'bb261: { | |
StorageDead(_384) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(383), projection: [] }, target: Idx::<BasicBlock>(262), unwind: None } }; | |
} | |
'bb262: { | |
StorageDead(_383) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(382), projection: [] }, target: Idx::<BasicBlock>(263), unwind: None } }; | |
} | |
'bb263: { | |
StorageDead(_382) | |
StorageDead(_381) | |
StorageDead(_380) | |
StorageDead(_379) | |
StorageDead(_378) | |
StorageDead(_377) | |
StorageDead(_376) | |
StorageDead(_375) | |
StorageDead(_374) | |
StorageDead(_373) | |
StorageDead(_372) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(264), unwind: None } }; | |
} | |
'bb264: { | |
StorageDead(iter_25) | |
StorageDead(_371) | |
StorageDead(_370) | |
StorageDead(_369) | |
StorageDead(_368) | |
StorageDead(_367) | |
StorageDead(_366) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(365), projection: [] }, target: Idx::<BasicBlock>(265), unwind: None } }; | |
} | |
'bb265: { | |
StorageDead(_365) | |
_363 = &_364; | |
Call { | |
func: Const(fn __tracing_log(&Metadata<'_>, &dyn Log, Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_22, _361, log_meta_23, _363], | |
destination: _298, | |
target: 'bb266, | |
} | |
} | |
'bb266: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(364), projection: [] }, target: Idx::<BasicBlock>(267), unwind: None } }; | |
} | |
'bb267: { | |
StorageDead(_364) | |
StorageDead(_363) | |
StorageDead(_362) | |
StorageDead(_361) | |
goto 'bb269; | |
} | |
'bb268: { | |
goto 'bb269; | |
} | |
'bb269: { | |
StorageDead(_360) | |
StorageDead(_359) | |
StorageDead(_358) | |
StorageDead(logger_24) | |
StorageDead(_357) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(270), unwind: None } }; | |
} | |
'bb270: { | |
StorageDead(log_meta_23) | |
StorageDead(_356) | |
StorageDead(_355) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(354), projection: [] }, target: Idx::<BasicBlock>(271), unwind: None } }; | |
} | |
'bb271: { | |
StorageDead(_354) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(353), projection: [] }, target: Idx::<BasicBlock>(272), unwind: None } }; | |
} | |
'bb272: { | |
StorageDead(_353) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(352), projection: [] }, target: Idx::<BasicBlock>(273), unwind: None } }; | |
} | |
'bb273: { | |
StorageDead(_352) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(351), projection: [] }, target: Idx::<BasicBlock>(274), unwind: None } }; | |
} | |
'bb274: { | |
StorageDead(_351) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(350), projection: [] }, target: Idx::<BasicBlock>(275), unwind: None } }; | |
} | |
'bb275: { | |
StorageDead(_350) | |
StorageDead(_349) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(348), projection: [] }, target: Idx::<BasicBlock>(276), unwind: None } }; | |
} | |
'bb276: { | |
StorageDead(_348) | |
StorageDead(meta_22) | |
StorageDead(_347) | |
StorageDead(_346) | |
StorageDead(_345) | |
goto 'bb278; | |
} | |
'bb277: { | |
goto 'bb278; | |
} | |
'bb278: { | |
StorageDead(_344) | |
StorageDead(_343) | |
StorageDead(_342) | |
StorageDead(_341) | |
StorageDead(level_21) | |
StorageDead(_340) | |
StorageDead(_339) | |
StorageDead(_338) | |
StorageDead(_337) | |
StorageDead(_336) | |
StorageDead(_335) | |
StorageDead(_334) | |
StorageDead(_333) | |
StorageDead(_332) | |
StorageDead(_331) | |
StorageDead(_330) | |
StorageDead(_329) | |
StorageDead(_328) | |
StorageDead(_327) | |
StorageDead(_326) | |
StorageDead(_325) | |
StorageDead(_324) | |
StorageDead(_323) | |
goto 'bb280; | |
} | |
'bb279: { | |
goto 'bb280; | |
} | |
'bb280: { | |
StorageDead(_322) | |
StorageDead(_321) | |
goto 'bb282; | |
} | |
'bb281: { | |
goto 'bb282; | |
} | |
'bb282: { | |
StorageDead(_320) | |
StorageDead(_319) | |
StorageDead(_318) | |
StorageDead(_317) | |
StorageDead(_316) | |
StorageDead(_315) | |
StorageDead(_314) | |
StorageDead(_313) | |
StorageDead(_312) | |
StorageDead(_311) | |
StorageDead(_310) | |
StorageDead(_309) | |
StorageDead(_308) | |
StorageDead(_307) | |
StorageDead(_306) | |
StorageDead(_305) | |
StorageDead(_304) | |
StorageDead(_303) | |
StorageDead(_302) | |
StorageDead(_301) | |
StorageDead(_300) | |
StorageDead(_299) | |
StorageDead(_298) | |
goto 'bb283; | |
} | |
'bb283: { | |
StorageDead(enabled_18) | |
StorageDead(_244) | |
StorageDead(_243) | |
StorageDead(_242) | |
StorageDead(_241) | |
StorageDead(_240) | |
StorageDead(_239) | |
StorageDead(_238) | |
StorageDead(_237) | |
StorageDead(_236) | |
StorageDead(_235) | |
StorageDead(_234) | |
goto 'bb158; | |
} | |
'bb284: { | |
StorageDead(err_17) | |
StorageDead(_231) | |
StorageDead(_230) | |
StorageDead(_229) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(16), projection: [] }, target: Idx::<BasicBlock>(285), unwind: None } }; | |
} | |
'bb285: { | |
StorageDead(err_16) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(228), projection: [] }, target: Idx::<BasicBlock>(286), unwind: None } }; | |
} | |
'bb286: { | |
StorageDead(_228) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(15), projection: [] }, target: Idx::<BasicBlock>(287), unwind: None } }; | |
} | |
'bb287: { | |
StorageDead(text_15) | |
StorageDead(_227) | |
StorageDead(_226) | |
StorageDead(_225) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(224), projection: [] }, target: Idx::<BasicBlock>(288), unwind: None } }; | |
} | |
'bb288: { | |
StorageDead(_224) | |
goto 'bb290; | |
} | |
'bb289: { | |
goto 'bb290; | |
} | |
'bb290: { | |
StorageDead(_223) | |
StorageDead(_222) | |
StorageDead(_221) | |
StorageDead(_220) | |
StorageDead(_219) | |
StorageDead(_218) | |
StorageDead(_217) | |
StorageDead(_216) | |
StorageDead(_215) | |
StorageDead(_214) | |
StorageDead(_213) | |
StorageDead(_212) | |
StorageDead(_211) | |
StorageDead(_210) | |
StorageLive(_405) | |
StorageLive(_406) | |
StorageLive(_407) | |
_407 = &typ_13; | |
StorageLive(_408) | |
StorageLive(_409) | |
_409 = Const(FileChangeType(3)); | |
_408 = &_409; | |
Call { | |
func: Const(fn eq<FileChangeType, FileChangeType>(&FileChangeType, &FileChangeType) -> bool), | |
args: [_407, _408], | |
destination: _406, | |
target: 'bb291, | |
} | |
} | |
'bb291: { | |
switch _406 { | |
1 => 'bb292, | |
_ => 'bb304, | |
} | |
} | |
'bb292: { | |
StorageLive(_410) | |
StorageLive(_411) | |
StorageLive(_412) | |
StorageLive(_413) | |
StorageLive(_414) | |
StorageLive(_415) | |
_415 = &(*self_1).vfs; | |
StorageLive(_416) | |
Call { | |
func: Const(fn deref<Arc<RwLock<Vfs>>>(&Arc<RwLock<Vfs>>) -> &<Arc<RwLock<Vfs>> as Deref>::Target), | |
args: [_415], | |
destination: _416, | |
target: 'bb293, | |
} | |
} | |
'bb293: { | |
_414 = &(*_416); | |
Call { | |
func: Const(fn write<Vfs>(&RwLock<Vfs>) -> Result<RwLockWriteGuard<'_, Vfs>, PoisonError<RwLockWriteGuard<'_, Vfs>>>), | |
args: [_414], | |
destination: _413, | |
target: 'bb294, | |
} | |
} | |
'bb294: { | |
Call { | |
func: Const(fn unwrap<RwLockWriteGuard<'_, Vfs>, PoisonError<RwLockWriteGuard<'_, Vfs>>>(Result<RwLockWriteGuard<'_, Vfs>, PoisonError<RwLockWriteGuard<'_, Vfs>>>) -> RwLockWriteGuard<'_, Vfs>), | |
args: [_413], | |
destination: _412, | |
target: 'bb295, | |
} | |
} | |
'bb295: { | |
StorageLive(_417) | |
_417 = &mut _412; | |
StorageLive(_418) | |
Call { | |
func: Const(fn deref_mut<RwLockWriteGuard<'_, Vfs>>(&mut RwLockWriteGuard<'_, Vfs>) -> &mut <RwLockWriteGuard<'_, Vfs> as Deref>::Target), | |
args: [_417], | |
destination: _418, | |
target: 'bb296, | |
} | |
} | |
'bb296: { | |
_411 = &mut (*_418); | |
Call { | |
func: Const(fn remove_uri(&mut Vfs, &Url) -> Result<(), Error>), | |
args: [_411, uri_12], | |
destination: _410, | |
target: 'bb297, | |
} | |
} | |
'bb297: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(418), projection: [] }, target: Idx::<BasicBlock>(298), unwind: None } }; | |
} | |
'bb298: { | |
StorageDead(_418) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(417), projection: [] }, target: Idx::<BasicBlock>(299), unwind: None } }; | |
} | |
'bb299: { | |
StorageDead(_417) | |
StorageDead(_416) | |
StorageDead(_415) | |
StorageDead(_414) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(413), projection: [] }, target: Idx::<BasicBlock>(300), unwind: None } }; | |
} | |
'bb300: { | |
StorageDead(_413) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(412), projection: [] }, target: Idx::<BasicBlock>(301), unwind: None } }; | |
} | |
'bb301: { | |
StorageDead(_412) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(411), projection: [] }, target: Idx::<BasicBlock>(302), unwind: None } }; | |
} | |
'bb302: { | |
StorageDead(_411) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(410), projection: [] }, target: Idx::<BasicBlock>(303), unwind: None } }; | |
} | |
'bb303: { | |
StorageDead(_410) | |
goto 'bb305; | |
} | |
'bb304: { | |
goto 'bb305; | |
} | |
'bb305: { | |
StorageDead(_409) | |
StorageDead(_408) | |
StorageDead(_407) | |
StorageDead(_406) | |
StorageDead(_405) | |
StorageLive(_419) | |
StorageLive(_420) | |
StorageLive(_421) | |
StorageLive(_422) | |
_422 = &path_14; | |
StorageLive(_423) | |
Call { | |
func: Const(fn deref<PathBuf>(&PathBuf) -> &<PathBuf as Deref>::Target), | |
args: [_422], | |
destination: _423, | |
target: 'bb306, | |
} | |
} | |
'bb306: { | |
_421 = &(*_423); | |
StorageLive(_424) | |
StorageLive(_425) | |
_425 = &(*self_1).config; | |
StorageLive(_426) | |
Call { | |
func: Const(fn deref<Arc<Config>>(&Arc<Config>) -> &<Arc<Config> as Deref>::Target), | |
args: [_425], | |
destination: _426, | |
target: 'bb307, | |
} | |
} | |
'bb307: { | |
_424 = &(*_426).root_path; | |
Call { | |
func: Const(fn strip_prefix<&PathBuf>(&Path, &PathBuf) -> Result<&Path, StripPrefixError>), | |
args: [_421, _424], | |
destination: _420, | |
target: 'bb308, | |
} | |
} | |
'bb308: { | |
_200 = Discriminant(_420); | |
switch _200 { | |
0 => 'bb309, | |
_ => 'bb310, | |
} | |
} | |
'bb309: { | |
StorageLive(relative_26) | |
relative_26 = (_420 as Ok).0; | |
_419 = Const(true); | |
goto 'bb311; | |
} | |
'bb310: { | |
_419 = Const(false); | |
goto 'bb311; | |
} | |
'bb311: { | |
switch _419 { | |
1 => 'bb312, | |
_ => 'bb323, | |
} | |
} | |
'bb312: { | |
StorageLive(_427) | |
StorageLive(_428) | |
StorageLive(_429) | |
_429 = &relative_26; | |
StorageLive(_430) | |
StorageLive(_431) | |
StorageLive(_432) | |
_432 = Const("flake.nix"); | |
Call { | |
func: Const(fn new<str>(&str) -> &Path), | |
args: [_432], | |
destination: _431, | |
target: 'bb313, | |
} | |
} | |
'bb313: { | |
_430 = &_431; | |
Call { | |
func: Const(fn eq<&Path, &Path>(&&Path, &&Path) -> bool), | |
args: [_429, _430], | |
destination: _428, | |
target: 'bb314, | |
} | |
} | |
'bb314: { | |
switch _428 { | |
1 => 'bb315, | |
_ => 'bb316, | |
} | |
} | |
'bb315: { | |
_427 = _428; | |
goto 'bb319; | |
} | |
'bb316: { | |
StorageLive(_433) | |
_433 = &relative_26; | |
StorageLive(_434) | |
StorageLive(_435) | |
StorageLive(_436) | |
_436 = Const("flake.lock"); | |
Call { | |
func: Const(fn new<str>(&str) -> &Path), | |
args: [_436], | |
destination: _435, | |
target: 'bb317, | |
} | |
} | |
'bb317: { | |
_434 = &_435; | |
Call { | |
func: Const(fn eq<&Path, &Path>(&&Path, &&Path) -> bool), | |
args: [_433, _434], | |
destination: _427, | |
target: 'bb318, | |
} | |
} | |
'bb318: { | |
goto 'bb319; | |
} | |
'bb319: { | |
switch _427 { | |
1 => 'bb320, | |
_ => 'bb321, | |
} | |
} | |
'bb320: { | |
StorageLive(_437) | |
flake_files_changed_11 = Const(true); | |
StorageDead(_437) | |
goto 'bb322; | |
} | |
'bb321: { | |
goto 'bb322; | |
} | |
'bb322: { | |
StorageDead(_436) | |
StorageDead(_435) | |
StorageDead(_434) | |
StorageDead(_433) | |
StorageDead(_432) | |
StorageDead(_431) | |
StorageDead(_430) | |
StorageDead(_429) | |
StorageDead(_428) | |
StorageDead(_427) | |
goto 'bb324; | |
} | |
'bb323: { | |
goto 'bb324; | |
} | |
'bb324: { | |
StorageDead(relative_26) | |
StorageDead(_426) | |
StorageDead(_425) | |
StorageDead(_424) | |
StorageDead(_423) | |
StorageDead(_422) | |
StorageDead(_421) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(420), projection: [] }, target: Idx::<BasicBlock>(325), unwind: None } }; | |
} | |
'bb325: { | |
StorageDead(_420) | |
StorageDead(_419) | |
StorageDead(_208) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(14), projection: [] }, target: Idx::<BasicBlock>(326), unwind: None } }; | |
} | |
'bb326: { | |
StorageDead(path_14) | |
StorageDead(_207) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(206), projection: [] }, target: Idx::<BasicBlock>(327), unwind: None } }; | |
} | |
'bb327: { | |
StorageDead(_206) | |
goto 'bb328; | |
} | |
'bb328: { | |
StorageDead(typ_13) | |
StorageDead(uri_12) | |
StorageDead(_201) | |
StorageDead(_200) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(199), projection: [] }, target: Idx::<BasicBlock>(329), unwind: None } }; | |
} | |
'bb329: { | |
StorageDead(_199) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(198), projection: [] }, target: Idx::<BasicBlock>(330), unwind: None } }; | |
} | |
'bb330: { | |
StorageDead(_198) | |
StorageDead(_197) | |
StorageDead(_196) | |
goto 'bb116; | |
} | |
'bb331: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(332), unwind: None } }; | |
} | |
'bb332: { | |
StorageDead(<ra@gennew>18_27) | |
StorageDead(_195) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(194), projection: [] }, target: Idx::<BasicBlock>(333), unwind: None } }; | |
} | |
'bb333: { | |
StorageDead(_194) | |
StorageDead(_193) | |
StorageLive(_438) | |
switch flake_files_changed_11 { | |
1 => 'bb334, | |
_ => 'bb337, | |
} | |
} | |
'bb334: { | |
StorageLive(_439) | |
StorageLive(_440) | |
_440 = &mut (*self_1); | |
Call { | |
func: Const(fn spawn_load_flake_workspace(&mut Server)), | |
args: [_440], | |
destination: _439, | |
target: 'bb335, | |
} | |
} | |
'bb335: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(440), projection: [] }, target: Idx::<BasicBlock>(336), unwind: None } }; | |
} | |
'bb336: { | |
StorageDead(_440) | |
StorageDead(_439) | |
goto 'bb338; | |
} | |
'bb337: { | |
goto 'bb338; | |
} | |
'bb338: { | |
StorageDead(_438) | |
StorageLive(_441) | |
_441 = (); | |
Call { | |
func: Const(Continue<Result<(), Error>, ()>(()) -> ControlFlow<Result<(), Error>, ()>), | |
args: [_441], | |
destination: _0, | |
target: 'bb339, | |
} | |
} | |
'bb339: { | |
StorageDead(_441) | |
StorageDead(flake_files_changed_11) | |
StorageDead(_192) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(2), projection: [] }, target: Idx::<BasicBlock>(340), unwind: None } }; | |
} | |
'bb340: { | |
StorageDead(params_2) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(1), projection: [] }, target: Idx::<BasicBlock>(341), unwind: None } }; | |
} | |
'bb341: { | |
StorageDead(self_1) | |
Terminator { span: ExprId(Idx::<Expr>(648)), kind: Return }; | |
} | |
} | |
// Closure: ClosureId(23) | |
{ | |
let _0: (); | |
let _1: &{closure#23}<fn(ValueSet<'_>)>; | |
let value_set_2: ValueSet<'_>; | |
let _3: &mut Server; | |
let _4: DidChangeWatchedFilesParams; | |
let _5: bool; | |
let _6: Interest; | |
let meta_7: &Metadata<'_>; | |
let level_8: Level; | |
let meta_9: &Metadata<'_>; | |
let log_meta_10: Metadata<'_>; | |
let logger_11: &dyn Log; | |
let _12: Iter; | |
let _13: Level; | |
let _14: &Metadata<'_>; | |
let _15: Metadata<'_>; | |
let _16: &dyn Log; | |
let _17: Iter; | |
let _18: bool; | |
let _19: &Url; | |
let _20: FileChangeType; | |
let _21: PathBuf; | |
let _22: OpenOptions; | |
let _23: File; | |
let _24: File; | |
let _25: Result<Infallible, Error>; | |
let _26: FileType; | |
let _27: Metadata; | |
let _28: Result<Infallible, Error>; | |
let _29: String; | |
let _30: OFlags; | |
let _31: OFlags; | |
let _32: Result<Infallible, Errno>; | |
let _33: (); | |
let _34: Result<Infallible, Errno>; | |
let _35: String; | |
let _36: usize; | |
let _37: Result<Infallible, Error>; | |
let _38: String; | |
let _39: Error; | |
let _40: Error; | |
let _41: bool; | |
let _42: Interest; | |
let _43: ValueSet<'_>; | |
let _44: &Metadata<'_>; | |
let _45: Level; | |
let _46: &Metadata<'_>; | |
let _47: Metadata<'_>; | |
let _48: &dyn Log; | |
let _49: Iter; | |
let _50: Level; | |
let _51: &Metadata<'_>; | |
let _52: Metadata<'_>; | |
let _53: &dyn Log; | |
let _54: Iter; | |
let _55: &Path; | |
let _56: Iter<'_, FileEvent>; | |
let _57: &Metadata<'_>; | |
let _58: &DefaultCallsite; | |
let _59: &DefaultCallsite; | |
let _60: (); | |
let _61: &ValueSet<'_>; | |
let _62: (); | |
let _63: bool; | |
let _64: &Level; | |
let _65: Level; | |
let _66: Level; | |
let _67: Level; | |
let _68: bool; | |
let _69: Level; | |
let _70: bool; | |
let _71: Level; | |
let _72: bool; | |
let _73: Level; | |
let _74: bool; | |
let _75: Level; | |
let _76: bool; | |
let _77: Level; | |
let _78: bool; | |
let _79: Level; | |
let _80: bool; | |
let _81: Level; | |
let _82: bool; | |
let _83: &LevelFilter; | |
let _84: LevelFilter; | |
let _85: bool; | |
let _86: bool; | |
let _87: Level; | |
let _88: Level; | |
let _89: Level; | |
let _90: bool; | |
let _91: Level; | |
let _92: bool; | |
let _93: Level; | |
let _94: bool; | |
let _95: Level; | |
let _96: bool; | |
let _97: Level; | |
let _98: bool; | |
let _99: Level; | |
let _100: bool; | |
let _101: Level; | |
let _102: bool; | |
let _103: Level; | |
let _104: bool; | |
let _105: bool; | |
let _106: &Level; | |
let _107: &LevelFilter; | |
let _108: LevelFilter; | |
let _109: &Metadata<'_>; | |
let _110: &DefaultCallsite; | |
let _111: &DefaultCallsite; | |
let _112: Metadata<'_>; | |
let _113: &MetadataBuilder<'_>; | |
let _114: &mut MetadataBuilder<'_>; | |
let _115: &mut MetadataBuilder<'_>; | |
let _116: &mut MetadataBuilder<'_>; | |
let _117: &mut MetadataBuilder<'_>; | |
let _118: MetadataBuilder<'_>; | |
let _119: &str; | |
let _120: &Metadata<'_>; | |
let _121: &dyn Log; | |
let _122: bool; | |
let _123: &dyn Log; | |
let _124: &Metadata<'_>; | |
let _125: &dyn Log; | |
let _126: &dyn Log; | |
let _127: &ValueSet<'_>; | |
'bb0: { | |
StorageLive(_57) | |
StorageLive(_58) | |
StorageLive(_59) | |
_59 = Static(StaticId(174)); | |
_58 = &(*_59); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_58], | |
destination: _57, | |
target: 'bb1, | |
} | |
} | |
'bb1: { | |
StorageLive(meta_7) | |
meta_7 = _57; | |
StorageLive(_60) | |
StorageLive(_61) | |
_61 = &value_set_2; | |
Call { | |
func: Const(fn dispatch(&Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_7, _61], | |
destination: _60, | |
target: 'bb2, | |
} | |
} | |
'bb2: { | |
StorageDead(_61) | |
StorageDead(_60) | |
StorageLive(_62) | |
StorageLive(_63) | |
StorageLive(_64) | |
StorageLive(_65) | |
StorageLive(_66) | |
_66 = Const(Level(Debug)); | |
StorageLive(_67) | |
_67 = Const(Level(Error)); | |
StorageLive(_68) | |
_68 = _67 == _66; | |
switch _68 { | |
1 => 'bb3, | |
_ => 'bb4, | |
} | |
} | |
'bb3: { | |
StorageLive(_69) | |
_69 = Const(Level(Error)); | |
StorageLive(_70) | |
_70 = _69 == _66; | |
switch _70 { | |
1 => 'bb5, | |
_ => 'bb4, | |
} | |
} | |
'bb4: { | |
StorageLive(_71) | |
_71 = Const(Level(Warn)); | |
StorageLive(_72) | |
_72 = _71 == _66; | |
switch _72 { | |
1 => 'bb7, | |
_ => 'bb8, | |
} | |
} | |
'bb5: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb6: { | |
_64 = &_65; | |
StorageLive(_83) | |
StorageLive(_84) | |
_84 = Const(Trace); | |
_83 = &_84; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_64, _83], | |
destination: _63, | |
target: 'bb16, | |
} | |
} | |
'bb7: { | |
StorageLive(_73) | |
_73 = Const(Level(Warn)); | |
StorageLive(_74) | |
_74 = _73 == _66; | |
switch _74 { | |
1 => 'bb9, | |
_ => 'bb8, | |
} | |
} | |
'bb8: { | |
StorageLive(_75) | |
_75 = Const(Level(Info)); | |
StorageLive(_76) | |
_76 = _75 == _66; | |
switch _76 { | |
1 => 'bb10, | |
_ => 'bb11, | |
} | |
} | |
'bb9: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb10: { | |
StorageLive(_77) | |
_77 = Const(Level(Info)); | |
StorageLive(_78) | |
_78 = _77 == _66; | |
switch _78 { | |
1 => 'bb12, | |
_ => 'bb11, | |
} | |
} | |
'bb11: { | |
StorageLive(_79) | |
_79 = Const(Level(Debug)); | |
StorageLive(_80) | |
_80 = _79 == _66; | |
switch _80 { | |
1 => 'bb13, | |
_ => 'bb14, | |
} | |
} | |
'bb12: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb13: { | |
StorageLive(_81) | |
_81 = Const(Level(Debug)); | |
StorageLive(_82) | |
_82 = _81 == _66; | |
switch _82 { | |
1 => 'bb15, | |
_ => 'bb14, | |
} | |
} | |
'bb14: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb15: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb16: { | |
switch _63 { | |
1 => 'bb17, | |
_ => 'bb59, | |
} | |
} | |
'bb17: { | |
StorageLive(_85) | |
StorageLive(_86) | |
Call { | |
func: Const(fn has_been_set() -> bool), | |
args: [], | |
destination: _86, | |
target: 'bb18, | |
} | |
} | |
'bb18: { | |
_85 = ! _86; | |
switch _85 { | |
1 => 'bb19, | |
_ => 'bb57, | |
} | |
} | |
'bb19: { | |
StorageLive(_87) | |
StorageLive(_88) | |
_88 = Const(Level(Debug)); | |
StorageLive(_89) | |
_89 = Const(Level(Error)); | |
StorageLive(_90) | |
_90 = _89 == _88; | |
switch _90 { | |
1 => 'bb20, | |
_ => 'bb21, | |
} | |
} | |
'bb20: { | |
StorageLive(_91) | |
_91 = Const(Level(Error)); | |
StorageLive(_92) | |
_92 = _91 == _88; | |
switch _92 { | |
1 => 'bb22, | |
_ => 'bb21, | |
} | |
} | |
'bb21: { | |
StorageLive(_93) | |
_93 = Const(Level(Warn)); | |
StorageLive(_94) | |
_94 = _93 == _88; | |
switch _94 { | |
1 => 'bb24, | |
_ => 'bb25, | |
} | |
} | |
'bb22: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb23: { | |
StorageLive(level_8) | |
level_8 = _87; | |
StorageLive(_105) | |
StorageLive(_106) | |
_106 = &level_8; | |
StorageLive(_107) | |
StorageLive(_108) | |
Call { | |
func: Const(fn max_level() -> LevelFilter), | |
args: [], | |
destination: _108, | |
target: 'bb33, | |
} | |
} | |
'bb24: { | |
StorageLive(_95) | |
_95 = Const(Level(Warn)); | |
StorageLive(_96) | |
_96 = _95 == _88; | |
switch _96 { | |
1 => 'bb26, | |
_ => 'bb25, | |
} | |
} | |
'bb25: { | |
StorageLive(_97) | |
_97 = Const(Level(Info)); | |
StorageLive(_98) | |
_98 = _97 == _88; | |
switch _98 { | |
1 => 'bb27, | |
_ => 'bb28, | |
} | |
} | |
'bb26: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb27: { | |
StorageLive(_99) | |
_99 = Const(Level(Info)); | |
StorageLive(_100) | |
_100 = _99 == _88; | |
switch _100 { | |
1 => 'bb29, | |
_ => 'bb28, | |
} | |
} | |
'bb28: { | |
StorageLive(_101) | |
_101 = Const(Level(Debug)); | |
StorageLive(_102) | |
_102 = _101 == _88; | |
switch _102 { | |
1 => 'bb30, | |
_ => 'bb31, | |
} | |
} | |
'bb29: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb30: { | |
StorageLive(_103) | |
_103 = Const(Level(Debug)); | |
StorageLive(_104) | |
_104 = _103 == _88; | |
switch _104 { | |
1 => 'bb32, | |
_ => 'bb31, | |
} | |
} | |
'bb31: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb32: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb33: { | |
_107 = &_108; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_106, _107], | |
destination: _105, | |
target: 'bb34, | |
} | |
} | |
'bb34: { | |
switch _105 { | |
1 => 'bb35, | |
_ => 'bb55, | |
} | |
} | |
'bb35: { | |
StorageLive(_109) | |
StorageLive(_110) | |
StorageLive(_111) | |
_111 = Static(StaticId(174)); | |
_110 = &(*_111); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_110], | |
destination: _109, | |
target: 'bb36, | |
} | |
} | |
'bb36: { | |
StorageLive(meta_9) | |
meta_9 = _109; | |
StorageLive(_112) | |
StorageLive(_113) | |
StorageLive(_114) | |
StorageLive(_115) | |
StorageLive(_116) | |
StorageLive(_117) | |
StorageLive(_118) | |
Call { | |
func: Const(fn builder() -> MetadataBuilder<'_>), | |
args: [], | |
destination: _118, | |
target: 'bb37, | |
} | |
} | |
'bb37: { | |
_117 = &mut _118; | |
Call { | |
func: Const(fn level(&mut MetadataBuilder<'_>, Level) -> &mut MetadataBuilder<'_>), | |
args: [_117, level_8], | |
destination: _116, | |
target: 'bb38, | |
} | |
} | |
'bb38: { | |
_115 = &mut (*_116); | |
StorageLive(_119) | |
StorageLive(_120) | |
_120 = &(*meta_9); | |
Call { | |
func: Const(fn target(&Metadata<'_>) -> &str), | |
args: [_120], | |
destination: _119, | |
target: 'bb39, | |
} | |
} | |
'bb39: { | |
Call { | |
func: Const(fn target(&mut MetadataBuilder<'_>, &str) -> &mut MetadataBuilder<'_>), | |
args: [_115, _119], | |
destination: _114, | |
target: 'bb40, | |
} | |
} | |
'bb40: { | |
_113 = &(*_114); | |
Call { | |
func: Const(fn build(&MetadataBuilder<'_>) -> Metadata<'_>), | |
args: [_113], | |
destination: _112, | |
target: 'bb41, | |
} | |
} | |
'bb41: { | |
StorageLive(log_meta_10) | |
log_meta_10 = _112; | |
StorageLive(_121) | |
Call { | |
func: Const(fn logger() -> &dyn Log), | |
args: [], | |
destination: _121, | |
target: 'bb42, | |
} | |
} | |
'bb42: { | |
StorageLive(logger_11) | |
logger_11 = _121; | |
StorageLive(_122) | |
StorageLive(_123) | |
_123 = &(*logger_11); | |
StorageLive(_124) | |
_124 = &log_meta_10; | |
Call { | |
func: Const(fn enabled<dyn Log>(&dyn Log, &Metadata<'_>) -> bool), | |
args: [_123, _124], | |
destination: _122, | |
target: 'bb43, | |
} | |
} | |
'bb43: { | |
switch _122 { | |
1 => 'bb44, | |
_ => 'bb46, | |
} | |
} | |
'bb44: { | |
StorageLive(_125) | |
StorageLive(_126) | |
_126 = &(*logger_11); | |
_125 = Cast(Pointer(Unsize), _126, &dyn Log); | |
StorageLive(_127) | |
_127 = &value_set_2; | |
Call { | |
func: Const(fn __tracing_log(&Metadata<'_>, &dyn Log, Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_9, _125, log_meta_10, _127], | |
destination: _62, | |
target: 'bb45, | |
} | |
} | |
'bb45: { | |
StorageDead(_127) | |
StorageDead(_126) | |
StorageDead(_125) | |
goto 'bb47; | |
} | |
'bb46: { | |
goto 'bb47; | |
} | |
'bb47: { | |
StorageDead(_124) | |
StorageDead(_123) | |
StorageDead(_122) | |
StorageDead(logger_11) | |
StorageDead(_121) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(10), projection: [] }, target: Idx::<BasicBlock>(48), unwind: None } }; | |
} | |
'bb48: { | |
StorageDead(log_meta_10) | |
StorageDead(_120) | |
StorageDead(_119) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(118), projection: [] }, target: Idx::<BasicBlock>(49), unwind: None } }; | |
} | |
'bb49: { | |
StorageDead(_118) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(117), projection: [] }, target: Idx::<BasicBlock>(50), unwind: None } }; | |
} | |
'bb50: { | |
StorageDead(_117) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(116), projection: [] }, target: Idx::<BasicBlock>(51), unwind: None } }; | |
} | |
'bb51: { | |
StorageDead(_116) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(115), projection: [] }, target: Idx::<BasicBlock>(52), unwind: None } }; | |
} | |
'bb52: { | |
StorageDead(_115) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(114), projection: [] }, target: Idx::<BasicBlock>(53), unwind: None } }; | |
} | |
'bb53: { | |
StorageDead(_114) | |
StorageDead(_113) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(112), projection: [] }, target: Idx::<BasicBlock>(54), unwind: None } }; | |
} | |
'bb54: { | |
StorageDead(_112) | |
StorageDead(meta_9) | |
StorageDead(_111) | |
StorageDead(_110) | |
StorageDead(_109) | |
goto 'bb56; | |
} | |
'bb55: { | |
goto 'bb56; | |
} | |
'bb56: { | |
StorageDead(_108) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(level_8) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageDead(_101) | |
StorageDead(_100) | |
StorageDead(_99) | |
StorageDead(_98) | |
StorageDead(_97) | |
StorageDead(_96) | |
StorageDead(_95) | |
StorageDead(_94) | |
StorageDead(_93) | |
StorageDead(_92) | |
StorageDead(_91) | |
StorageDead(_90) | |
StorageDead(_89) | |
StorageDead(_88) | |
StorageDead(_87) | |
goto 'bb58; | |
} | |
'bb57: { | |
goto 'bb58; | |
} | |
'bb58: { | |
StorageDead(_86) | |
StorageDead(_85) | |
goto 'bb60; | |
} | |
'bb59: { | |
goto 'bb60; | |
} | |
'bb60: { | |
StorageDead(_84) | |
StorageDead(_83) | |
StorageDead(_82) | |
StorageDead(_81) | |
StorageDead(_80) | |
StorageDead(_79) | |
StorageDead(_78) | |
StorageDead(_77) | |
StorageDead(_76) | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
StorageDead(_72) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
StorageDead(_68) | |
StorageDead(_67) | |
StorageDead(_66) | |
StorageDead(_65) | |
StorageDead(_64) | |
StorageDead(_63) | |
StorageDead(_62) | |
StorageDead(meta_7) | |
StorageDead(_59) | |
StorageDead(_58) | |
StorageDead(_57) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(2), projection: [] }, target: Idx::<BasicBlock>(61), unwind: None } }; | |
} | |
'bb61: { | |
StorageDead(value_set_2) | |
Terminator { span: ExprId(Idx::<Expr>(88)), kind: Return }; | |
} | |
} | |
// Closure: ClosureId(24) | |
{ | |
let _0: Result<String, Error>; | |
let _1: &{closure#24}<fn() -> Result<String, Error>>; | |
let _2: &mut Server; | |
let _3: DidChangeWatchedFilesParams; | |
let _4: bool; | |
let _5: Interest; | |
let _6: ValueSet<'_>; | |
let _7: &Metadata<'_>; | |
let _8: Level; | |
let _9: &Metadata<'_>; | |
let _10: Metadata<'_>; | |
let _11: &dyn Log; | |
let _12: Iter; | |
let _13: Level; | |
let _14: &Metadata<'_>; | |
let _15: Metadata<'_>; | |
let _16: &dyn Log; | |
let _17: Iter; | |
let _18: bool; | |
let _19: &Url; | |
let _20: FileChangeType; | |
let _21: PathBuf; | |
let options_22: OpenOptions; | |
let file_23: File; | |
let <ra@gennew>8_24: File; | |
let <ra@gennew>9_25: Result<Infallible, Error>; | |
let ft_26: FileType; | |
let <ra@gennew>10_27: Metadata; | |
let <ra@gennew>11_28: Result<Infallible, Error>; | |
let res_29: String; | |
let flags_30: OFlags; | |
let <ra@gennew>12_31: OFlags; | |
let <ra@gennew>13_32: Result<Infallible, Errno>; | |
let <ra@gennew>14_33: (); | |
let <ra@gennew>15_34: Result<Infallible, Errno>; | |
let buf_35: String; | |
let <ra@gennew>16_36: usize; | |
let <ra@gennew>17_37: Result<Infallible, Error>; | |
let _38: String; | |
let _39: Error; | |
let _40: Error; | |
let _41: bool; | |
let _42: Interest; | |
let _43: ValueSet<'_>; | |
let _44: &Metadata<'_>; | |
let _45: Level; | |
let _46: &Metadata<'_>; | |
let _47: Metadata<'_>; | |
let _48: &dyn Log; | |
let _49: Iter; | |
let _50: Level; | |
let _51: &Metadata<'_>; | |
let _52: Metadata<'_>; | |
let _53: &dyn Log; | |
let _54: Iter; | |
let _55: &Path; | |
let _56: Iter<'_, FileEvent>; | |
let _57: OpenOptions; | |
let _58: &mut OpenOptions; | |
let _59: &mut OpenOptions; | |
let _60: &mut OpenOptions; | |
let _61: &mut OpenOptions; | |
let _62: i32; | |
let _63: u32; | |
let _64: &OFlags; | |
let _65: OFlags; | |
let _66: File; | |
let _67: ControlFlow<Result<Infallible, Error>, File>; | |
let _68: Result<File, Error>; | |
let _69: &OpenOptions; | |
let _70: &PathBuf; | |
let _71: i128; | |
let _72: !; | |
let _73: FileType; | |
let _74: &Metadata; | |
let _75: Metadata; | |
let _76: ControlFlow<Result<Infallible, Error>, Metadata>; | |
let _77: Result<Metadata, Error>; | |
let _78: &File; | |
let _79: !; | |
let _80: (); | |
let _81: bool; | |
let _82: bool; | |
let _83: &FileType; | |
let _84: !; | |
let _85: Error; | |
let _86: ErrorKind; | |
let _87: String; | |
let _88: String; | |
let _89: Arguments<'_>; | |
let _90: &[&str]; | |
let _91: &[&str; 1]; | |
let _92: &[&str; 1]; | |
let _93: [&str; 1]; | |
let _94: &[ArgumentV1<'_>]; | |
let _95: &[ArgumentV1<'_>; 1]; | |
let _96: &[ArgumentV1<'_>; 1]; | |
let _97: [ArgumentV1<'_>; 1]; | |
let _98: ArgumentV1<'_>; | |
let _99: &FileType; | |
let _100: fn(&FileType, &mut Formatter<'_>) -> Result<(), Error>; | |
let _101: fn fmt<FileType>(&FileType, &mut Formatter<'_>) -> Result<(), Error>; | |
let _102: (); | |
let _103: OFlags; | |
let _104: OFlags; | |
let _105: ControlFlow<Result<Infallible, Errno>, OFlags>; | |
let _106: Result<OFlags, Errno>; | |
let _107: &File; | |
let _108: !; | |
let _109: OFlags; | |
let _110: (); | |
let _111: ControlFlow<Result<Infallible, Errno>, ()>; | |
let _112: Result<(), Errno>; | |
let _113: &File; | |
let _114: !; | |
let _115: String; | |
let _116: usize; | |
let _117: ControlFlow<Result<Infallible, Error>, usize>; | |
let _118: Result<usize, Error>; | |
let _119: &mut File; | |
let _120: &mut String; | |
let _121: &mut String; | |
let _122: !; | |
'bb0: { | |
StorageLive(_57) | |
Call { | |
func: Const(fn options() -> OpenOptions), | |
args: [], | |
destination: _57, | |
target: 'bb1, | |
} | |
} | |
'bb1: { | |
StorageLive(options_22) | |
options_22 = _57; | |
StorageLive(_58) | |
StorageLive(_59) | |
_59 = &mut options_22; | |
Call { | |
func: Const(fn read(&mut OpenOptions, bool) -> &mut OpenOptions), | |
args: [_59, Const(true)], | |
destination: _58, | |
target: 'bb2, | |
} | |
} | |
'bb2: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(59), projection: [] }, target: Idx::<BasicBlock>(3), unwind: None } }; | |
} | |
'bb3: { | |
StorageDead(_59) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(58), projection: [] }, target: Idx::<BasicBlock>(4), unwind: None } }; | |
} | |
'bb4: { | |
StorageDead(_58) | |
StorageLive(_60) | |
StorageLive(_61) | |
_61 = &mut options_22; | |
StorageLive(_62) | |
StorageLive(_63) | |
StorageLive(_64) | |
StorageLive(_65) | |
_65 = Const(OFlags(<placeholder-or-unknown-type>)); | |
_64 = &_65; | |
Call { | |
func: Const(fn bits(&OFlags) -> u32), | |
args: [_64], | |
destination: _63, | |
target: 'bb5, | |
} | |
} | |
'bb5: { | |
_62 = Cast(IntToInt, _63, i32); | |
Call { | |
func: Const(fn custom_flags<OpenOptions>(&mut OpenOptions, i32) -> &mut OpenOptions), | |
args: [_61, _62], | |
destination: _60, | |
target: 'bb6, | |
} | |
} | |
'bb6: { | |
StorageDead(_65) | |
StorageDead(_64) | |
StorageDead(_63) | |
StorageDead(_62) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(61), projection: [] }, target: Idx::<BasicBlock>(7), unwind: None } }; | |
} | |
'bb7: { | |
StorageDead(_61) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(60), projection: [] }, target: Idx::<BasicBlock>(8), unwind: None } }; | |
} | |
'bb8: { | |
StorageDead(_60) | |
StorageLive(_66) | |
StorageLive(_67) | |
StorageLive(_68) | |
StorageLive(_69) | |
_69 = &options_22; | |
StorageLive(_70) | |
_70 = &(*(*_1).0); | |
Call { | |
func: Const(fn open<&PathBuf>(&OpenOptions, &PathBuf) -> Result<File, Error>), | |
args: [_69, _70], | |
destination: _68, | |
target: 'bb9, | |
} | |
} | |
'bb9: { | |
Call { | |
func: Const(fn branch<Result<File, Error>>(Result<File, Error>) -> ControlFlow<<Result<File, Error> as Try>::Residual, <Result<File, Error> as Try>::Output>), | |
args: [_68], | |
destination: _67, | |
target: 'bb10, | |
} | |
} | |
'bb10: { | |
StorageLive(_71) | |
_71 = Discriminant(_67); | |
switch _71 { | |
0 => 'bb11, | |
_ => 'bb12, | |
} | |
} | |
'bb11: { | |
StorageLive(<ra@gennew>8_24) | |
<ra@gennew>8_24 = (_67 as Continue).0; | |
_66 = <ra@gennew>8_24; | |
goto 'bb13; | |
} | |
'bb12: { | |
_71 = Discriminant(_67); | |
switch _71 { | |
1 => 'bb14, | |
_ => 'bb15, | |
} | |
} | |
'bb13: { | |
StorageLive(file_23) | |
file_23 = _66; | |
StorageLive(_73) | |
StorageLive(_74) | |
StorageLive(_75) | |
StorageLive(_76) | |
StorageLive(_77) | |
StorageLive(_78) | |
_78 = &file_23; | |
Call { | |
func: Const(fn metadata(&File) -> Result<Metadata, Error>), | |
args: [_78], | |
destination: _77, | |
target: 'bb24, | |
} | |
} | |
'bb14: { | |
StorageLive(<ra@gennew>9_25) | |
<ra@gennew>9_25 = (_67 as Break).0; | |
StorageLive(_72) | |
Call { | |
func: Const(fn from_residual<Result<String, Error>, Result<Infallible, Error>>(Result<Infallible, Error>) -> Result<String, Error>), | |
args: [<ra@gennew>9_25], | |
destination: _0, | |
target: 'bb16, | |
} | |
} | |
'bb15: { | |
Terminator { span: ExprId(Idx::<Expr>(259)), kind: Unreachable }; | |
} | |
'bb16: { | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(17), unwind: None } }; | |
} | |
'bb17: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(18), unwind: None } }; | |
} | |
'bb18: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(19), unwind: None } }; | |
} | |
'bb19: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(20), unwind: None } }; | |
} | |
'bb20: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(21), unwind: None } }; | |
} | |
'bb21: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(22), unwind: None } }; | |
} | |
'bb22: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(23), unwind: None } }; | |
} | |
'bb23: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(258)), kind: Return }; | |
} | |
'bb24: { | |
Call { | |
func: Const(fn branch<Result<Metadata, Error>>(Result<Metadata, Error>) -> ControlFlow<<Result<Metadata, Error> as Try>::Residual, <Result<Metadata, Error> as Try>::Output>), | |
args: [_77], | |
destination: _76, | |
target: 'bb25, | |
} | |
} | |
'bb25: { | |
_71 = Discriminant(_76); | |
switch _71 { | |
0 => 'bb26, | |
_ => 'bb27, | |
} | |
} | |
'bb26: { | |
StorageLive(<ra@gennew>10_27) | |
<ra@gennew>10_27 = (_76 as Continue).0; | |
_75 = <ra@gennew>10_27; | |
goto 'bb28; | |
} | |
'bb27: { | |
_71 = Discriminant(_76); | |
switch _71 { | |
1 => 'bb29, | |
_ => 'bb30, | |
} | |
} | |
'bb28: { | |
_74 = &_75; | |
Call { | |
func: Const(fn file_type(&Metadata) -> FileType), | |
args: [_74], | |
destination: _73, | |
target: 'bb45, | |
} | |
} | |
'bb29: { | |
StorageLive(<ra@gennew>11_28) | |
<ra@gennew>11_28 = (_76 as Break).0; | |
StorageLive(_79) | |
Call { | |
func: Const(fn from_residual<Result<String, Error>, Result<Infallible, Error>>(Result<Infallible, Error>) -> Result<String, Error>), | |
args: [<ra@gennew>11_28], | |
destination: _0, | |
target: 'bb31, | |
} | |
} | |
'bb30: { | |
Terminator { span: ExprId(Idx::<Expr>(269)), kind: Unreachable }; | |
} | |
'bb31: { | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(32), unwind: None } }; | |
} | |
'bb32: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(33), unwind: None } }; | |
} | |
'bb33: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(34), unwind: None } }; | |
} | |
'bb34: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(35), unwind: None } }; | |
} | |
'bb35: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(36), unwind: None } }; | |
} | |
'bb36: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(37), unwind: None } }; | |
} | |
'bb37: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(38), unwind: None } }; | |
} | |
'bb38: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(39), unwind: None } }; | |
} | |
'bb39: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(40), unwind: None } }; | |
} | |
'bb40: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(41), unwind: None } }; | |
} | |
'bb41: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(42), unwind: None } }; | |
} | |
'bb42: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(43), unwind: None } }; | |
} | |
'bb43: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(44), unwind: None } }; | |
} | |
'bb44: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(268)), kind: Return }; | |
} | |
'bb45: { | |
StorageLive(ft_26) | |
ft_26 = _73; | |
StorageLive(_80) | |
StorageLive(_81) | |
StorageLive(_82) | |
StorageLive(_83) | |
_83 = &ft_26; | |
Call { | |
func: Const(fn is_file(&FileType) -> bool), | |
args: [_83], | |
destination: _82, | |
target: 'bb46, | |
} | |
} | |
'bb46: { | |
_81 = ! _82; | |
switch _81 { | |
1 => 'bb47, | |
_ => 'bb70, | |
} | |
} | |
'bb47: { | |
StorageLive(_84) | |
StorageLive(_85) | |
StorageLive(_86) | |
_86 = Adt(); | |
StorageLive(_87) | |
StorageLive(_88) | |
StorageLive(_89) | |
StorageLive(_90) | |
StorageLive(_91) | |
StorageLive(_92) | |
StorageLive(_93) | |
_93 = [Const("non-regular file type: ")]; | |
_92 = &_93; | |
_91 = &(*_92); | |
_90 = Cast(Pointer(Unsize), _91, &[&str]); | |
StorageLive(_94) | |
StorageLive(_95) | |
StorageLive(_96) | |
StorageLive(_97) | |
StorageLive(_98) | |
StorageLive(_99) | |
_99 = &ft_26; | |
StorageLive(_100) | |
StorageLive(_101) | |
_100 = Cast(Pointer(ReifyFnPointer), _101, fn(&FileType, &mut Formatter<'_>) -> Result<(), Error>); | |
Call { | |
func: Const(fn new<FileType>(&FileType, fn(&FileType, &mut Formatter<'_>) -> Result<(), Error>) -> ArgumentV1<'_>), | |
args: [_99, _100], | |
destination: _98, | |
target: 'bb48, | |
} | |
} | |
'bb48: { | |
_97 = [_98]; | |
_96 = &_97; | |
_95 = &(*_96); | |
_94 = Cast(Pointer(Unsize), _95, &[ArgumentV1<'_>]); | |
Call { | |
func: Const(fn new_v1(&[&str], &[ArgumentV1<'_>]) -> Arguments<'_>), | |
args: [_90, _94], | |
destination: _89, | |
target: 'bb49, | |
} | |
} | |
'bb49: { | |
Call { | |
func: Const(fn format(Arguments<'_>) -> String), | |
args: [_89], | |
destination: _88, | |
target: 'bb50, | |
} | |
} | |
'bb50: { | |
StorageLive(res_29) | |
res_29 = _88; | |
_87 = res_29; | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(29), projection: [] }, target: Idx::<BasicBlock>(51), unwind: None } }; | |
} | |
'bb51: { | |
StorageDead(res_29) | |
StorageDead(_101) | |
StorageDead(_100) | |
StorageDead(_99) | |
StorageDead(_98) | |
StorageDead(_97) | |
StorageDead(_96) | |
StorageDead(_95) | |
StorageDead(_94) | |
StorageDead(_93) | |
StorageDead(_92) | |
StorageDead(_91) | |
StorageDead(_90) | |
StorageDead(_89) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(88), projection: [] }, target: Idx::<BasicBlock>(52), unwind: None } }; | |
} | |
'bb52: { | |
StorageDead(_88) | |
Call { | |
func: Const(fn new<String>(ErrorKind, String) -> Error), | |
args: [_86, _87], | |
destination: _85, | |
target: 'bb53, | |
} | |
} | |
'bb53: { | |
Call { | |
func: Const(Err<String, Error>(Error) -> Result<String, Error>), | |
args: [_85], | |
destination: _0, | |
target: 'bb54, | |
} | |
} | |
'bb54: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(87), projection: [] }, target: Idx::<BasicBlock>(55), unwind: None } }; | |
} | |
'bb55: { | |
StorageDead(_87) | |
StorageDead(_86) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(85), projection: [] }, target: Idx::<BasicBlock>(56), unwind: None } }; | |
} | |
'bb56: { | |
StorageDead(_85) | |
StorageDead(_84) | |
StorageDead(_83) | |
StorageDead(_82) | |
StorageDead(_81) | |
StorageDead(_80) | |
StorageDead(ft_26) | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(57), unwind: None } }; | |
} | |
'bb57: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(58), unwind: None } }; | |
} | |
'bb58: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(59), unwind: None } }; | |
} | |
'bb59: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(60), unwind: None } }; | |
} | |
'bb60: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(61), unwind: None } }; | |
} | |
'bb61: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(62), unwind: None } }; | |
} | |
'bb62: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(63), unwind: None } }; | |
} | |
'bb63: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(64), unwind: None } }; | |
} | |
'bb64: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(65), unwind: None } }; | |
} | |
'bb65: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(66), unwind: None } }; | |
} | |
'bb66: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(67), unwind: None } }; | |
} | |
'bb67: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(68), unwind: None } }; | |
} | |
'bb68: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(69), unwind: None } }; | |
} | |
'bb69: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(292)), kind: Return }; | |
} | |
'bb70: { | |
StorageDead(_83) | |
StorageDead(_82) | |
StorageDead(_81) | |
StorageDead(_80) | |
StorageLive(_102) | |
StorageLive(_103) | |
StorageLive(_104) | |
StorageLive(_105) | |
StorageLive(_106) | |
StorageLive(_107) | |
_107 = &file_23; | |
Call { | |
func: Const(fn fcntl_getfl<&File>(&File) -> Result<OFlags, Errno>), | |
args: [_107], | |
destination: _106, | |
target: 'bb71, | |
} | |
} | |
'bb71: { | |
Call { | |
func: Const(fn branch<Result<OFlags, Errno>>(Result<OFlags, Errno>) -> ControlFlow<<Result<OFlags, Errno> as Try>::Residual, <Result<OFlags, Errno> as Try>::Output>), | |
args: [_106], | |
destination: _105, | |
target: 'bb72, | |
} | |
} | |
'bb72: { | |
_71 = Discriminant(_105); | |
switch _71 { | |
0 => 'bb73, | |
_ => 'bb74, | |
} | |
} | |
'bb73: { | |
StorageLive(<ra@gennew>12_31) | |
<ra@gennew>12_31 = (_105 as Continue).0; | |
_104 = <ra@gennew>12_31; | |
goto 'bb75; | |
} | |
'bb74: { | |
_71 = Discriminant(_105); | |
switch _71 { | |
1 => 'bb76, | |
_ => 'bb77, | |
} | |
} | |
'bb75: { | |
StorageLive(_109) | |
_109 = Const(OFlags(<placeholder-or-unknown-type>)); | |
Call { | |
func: Const(fn sub<OFlags, OFlags>(OFlags, OFlags) -> <OFlags as Sub<OFlags>>::Output), | |
args: [_104, _109], | |
destination: _103, | |
target: 'bb92, | |
} | |
} | |
'bb76: { | |
StorageLive(<ra@gennew>13_32) | |
<ra@gennew>13_32 = (_105 as Break).0; | |
StorageLive(_108) | |
Call { | |
func: Const(fn from_residual<Result<String, Error>, Result<Infallible, Errno>>(Result<Infallible, Errno>) -> Result<String, Error>), | |
args: [<ra@gennew>13_32], | |
destination: _0, | |
target: 'bb78, | |
} | |
} | |
'bb77: { | |
Terminator { span: ExprId(Idx::<Expr>(309)), kind: Unreachable }; | |
} | |
'bb78: { | |
StorageDead(_108) | |
StorageDead(<ra@gennew>13_32) | |
StorageDead(<ra@gennew>12_31) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageDead(ft_26) | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(79), unwind: None } }; | |
} | |
'bb79: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(80), unwind: None } }; | |
} | |
'bb80: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(81), unwind: None } }; | |
} | |
'bb81: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(82), unwind: None } }; | |
} | |
'bb82: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(83), unwind: None } }; | |
} | |
'bb83: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(84), unwind: None } }; | |
} | |
'bb84: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(85), unwind: None } }; | |
} | |
'bb85: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(86), unwind: None } }; | |
} | |
'bb86: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(87), unwind: None } }; | |
} | |
'bb87: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(88), unwind: None } }; | |
} | |
'bb88: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(89), unwind: None } }; | |
} | |
'bb89: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(90), unwind: None } }; | |
} | |
'bb90: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(91), unwind: None } }; | |
} | |
'bb91: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(308)), kind: Return }; | |
} | |
'bb92: { | |
StorageLive(flags_30) | |
flags_30 = _103; | |
StorageLive(_110) | |
StorageLive(_111) | |
StorageLive(_112) | |
StorageLive(_113) | |
_113 = &file_23; | |
Call { | |
func: Const(fn fcntl_setfl<&File>(&File, OFlags) -> Result<(), Errno>), | |
args: [_113, flags_30], | |
destination: _112, | |
target: 'bb93, | |
} | |
} | |
'bb93: { | |
Call { | |
func: Const(fn branch<Result<(), Errno>>(Result<(), Errno>) -> ControlFlow<<Result<(), Errno> as Try>::Residual, <Result<(), Errno> as Try>::Output>), | |
args: [_112], | |
destination: _111, | |
target: 'bb94, | |
} | |
} | |
'bb94: { | |
_71 = Discriminant(_111); | |
switch _71 { | |
0 => 'bb95, | |
_ => 'bb96, | |
} | |
} | |
'bb95: { | |
StorageLive(<ra@gennew>14_33) | |
<ra@gennew>14_33 = (_111 as Continue).0; | |
_110 = <ra@gennew>14_33; | |
goto 'bb97; | |
} | |
'bb96: { | |
_71 = Discriminant(_111); | |
switch _71 { | |
1 => 'bb98, | |
_ => 'bb99, | |
} | |
} | |
'bb97: { | |
StorageDead(_114) | |
StorageDead(<ra@gennew>15_34) | |
StorageDead(<ra@gennew>14_33) | |
StorageDead(_113) | |
StorageDead(_112) | |
StorageDead(_111) | |
StorageDead(_110) | |
StorageDead(flags_30) | |
StorageDead(_109) | |
StorageDead(_108) | |
StorageDead(<ra@gennew>13_32) | |
StorageDead(<ra@gennew>12_31) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageLive(_115) | |
Call { | |
func: Const(fn new() -> String), | |
args: [], | |
destination: _115, | |
target: 'bb114, | |
} | |
} | |
'bb98: { | |
StorageLive(<ra@gennew>15_34) | |
<ra@gennew>15_34 = (_111 as Break).0; | |
StorageLive(_114) | |
Call { | |
func: Const(fn from_residual<Result<String, Error>, Result<Infallible, Errno>>(Result<Infallible, Errno>) -> Result<String, Error>), | |
args: [<ra@gennew>15_34], | |
destination: _0, | |
target: 'bb100, | |
} | |
} | |
'bb99: { | |
Terminator { span: ExprId(Idx::<Expr>(324)), kind: Unreachable }; | |
} | |
'bb100: { | |
StorageDead(_114) | |
StorageDead(<ra@gennew>15_34) | |
StorageDead(<ra@gennew>14_33) | |
StorageDead(_113) | |
StorageDead(_112) | |
StorageDead(_111) | |
StorageDead(_110) | |
StorageDead(flags_30) | |
StorageDead(_109) | |
StorageDead(_108) | |
StorageDead(<ra@gennew>13_32) | |
StorageDead(<ra@gennew>12_31) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageDead(ft_26) | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(101), unwind: None } }; | |
} | |
'bb101: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(102), unwind: None } }; | |
} | |
'bb102: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(103), unwind: None } }; | |
} | |
'bb103: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(104), unwind: None } }; | |
} | |
'bb104: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(105), unwind: None } }; | |
} | |
'bb105: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(106), unwind: None } }; | |
} | |
'bb106: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(107), unwind: None } }; | |
} | |
'bb107: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(108), unwind: None } }; | |
} | |
'bb108: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(109), unwind: None } }; | |
} | |
'bb109: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(110), unwind: None } }; | |
} | |
'bb110: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(111), unwind: None } }; | |
} | |
'bb111: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(112), unwind: None } }; | |
} | |
'bb112: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(113), unwind: None } }; | |
} | |
'bb113: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(323)), kind: Return }; | |
} | |
'bb114: { | |
StorageLive(buf_35) | |
buf_35 = _115; | |
StorageLive(_116) | |
StorageLive(_117) | |
StorageLive(_118) | |
StorageLive(_119) | |
_119 = &mut file_23; | |
StorageLive(_120) | |
StorageLive(_121) | |
_121 = &mut buf_35; | |
_120 = &mut (*_121); | |
Call { | |
func: Const(fn read_to_string<File>(&mut File, &mut String) -> Result<usize, Error>), | |
args: [_119, _120], | |
destination: _118, | |
target: 'bb115, | |
} | |
} | |
'bb115: { | |
Call { | |
func: Const(fn branch<Result<usize, Error>>(Result<usize, Error>) -> ControlFlow<<Result<usize, Error> as Try>::Residual, <Result<usize, Error> as Try>::Output>), | |
args: [_118], | |
destination: _117, | |
target: 'bb116, | |
} | |
} | |
'bb116: { | |
_71 = Discriminant(_117); | |
switch _71 { | |
0 => 'bb117, | |
_ => 'bb118, | |
} | |
} | |
'bb117: { | |
StorageLive(<ra@gennew>16_36) | |
<ra@gennew>16_36 = (_117 as Continue).0; | |
_116 = <ra@gennew>16_36; | |
goto 'bb119; | |
} | |
'bb118: { | |
_71 = Discriminant(_117); | |
switch _71 { | |
1 => 'bb120, | |
_ => 'bb121, | |
} | |
} | |
'bb119: { | |
StorageDead(_122) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(37), projection: [] }, target: Idx::<BasicBlock>(144), unwind: None } }; | |
} | |
'bb120: { | |
StorageLive(<ra@gennew>17_37) | |
<ra@gennew>17_37 = (_117 as Break).0; | |
StorageLive(_122) | |
Call { | |
func: Const(fn from_residual<Result<String, Error>, Result<Infallible, Error>>(Result<Infallible, Error>) -> Result<String, Error>), | |
args: [<ra@gennew>17_37], | |
destination: _0, | |
target: 'bb122, | |
} | |
} | |
'bb121: { | |
Terminator { span: ExprId(Idx::<Expr>(339)), kind: Unreachable }; | |
} | |
'bb122: { | |
StorageDead(_122) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(37), projection: [] }, target: Idx::<BasicBlock>(123), unwind: None } }; | |
} | |
'bb123: { | |
StorageDead(<ra@gennew>17_37) | |
StorageDead(<ra@gennew>16_36) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(121), projection: [] }, target: Idx::<BasicBlock>(124), unwind: None } }; | |
} | |
'bb124: { | |
StorageDead(_121) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(120), projection: [] }, target: Idx::<BasicBlock>(125), unwind: None } }; | |
} | |
'bb125: { | |
StorageDead(_120) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(119), projection: [] }, target: Idx::<BasicBlock>(126), unwind: None } }; | |
} | |
'bb126: { | |
StorageDead(_119) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(118), projection: [] }, target: Idx::<BasicBlock>(127), unwind: None } }; | |
} | |
'bb127: { | |
StorageDead(_118) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(117), projection: [] }, target: Idx::<BasicBlock>(128), unwind: None } }; | |
} | |
'bb128: { | |
StorageDead(_117) | |
StorageDead(_116) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(35), projection: [] }, target: Idx::<BasicBlock>(129), unwind: None } }; | |
} | |
'bb129: { | |
StorageDead(buf_35) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(115), projection: [] }, target: Idx::<BasicBlock>(130), unwind: None } }; | |
} | |
'bb130: { | |
StorageDead(_115) | |
StorageDead(ft_26) | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(131), unwind: None } }; | |
} | |
'bb131: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(132), unwind: None } }; | |
} | |
'bb132: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(133), unwind: None } }; | |
} | |
'bb133: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(134), unwind: None } }; | |
} | |
'bb134: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(135), unwind: None } }; | |
} | |
'bb135: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(136), unwind: None } }; | |
} | |
'bb136: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(137), unwind: None } }; | |
} | |
'bb137: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(138), unwind: None } }; | |
} | |
'bb138: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(139), unwind: None } }; | |
} | |
'bb139: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(140), unwind: None } }; | |
} | |
'bb140: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(141), unwind: None } }; | |
} | |
'bb141: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(142), unwind: None } }; | |
} | |
'bb142: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(143), unwind: None } }; | |
} | |
'bb143: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(338)), kind: Return }; | |
} | |
'bb144: { | |
StorageDead(<ra@gennew>17_37) | |
StorageDead(<ra@gennew>16_36) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(121), projection: [] }, target: Idx::<BasicBlock>(145), unwind: None } }; | |
} | |
'bb145: { | |
StorageDead(_121) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(120), projection: [] }, target: Idx::<BasicBlock>(146), unwind: None } }; | |
} | |
'bb146: { | |
StorageDead(_120) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(119), projection: [] }, target: Idx::<BasicBlock>(147), unwind: None } }; | |
} | |
'bb147: { | |
StorageDead(_119) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(118), projection: [] }, target: Idx::<BasicBlock>(148), unwind: None } }; | |
} | |
'bb148: { | |
StorageDead(_118) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(117), projection: [] }, target: Idx::<BasicBlock>(149), unwind: None } }; | |
} | |
'bb149: { | |
StorageDead(_117) | |
StorageDead(_116) | |
Call { | |
func: Const(Ok<String, Error>(String) -> Result<String, Error>), | |
args: [buf_35], | |
destination: _0, | |
target: 'bb150, | |
} | |
} | |
'bb150: { | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(35), projection: [] }, target: Idx::<BasicBlock>(151), unwind: None } }; | |
} | |
'bb151: { | |
StorageDead(buf_35) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(115), projection: [] }, target: Idx::<BasicBlock>(152), unwind: None } }; | |
} | |
'bb152: { | |
StorageDead(_115) | |
StorageDead(ft_26) | |
StorageDead(_79) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(28), projection: [] }, target: Idx::<BasicBlock>(153), unwind: None } }; | |
} | |
'bb153: { | |
StorageDead(<ra@gennew>11_28) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(27), projection: [] }, target: Idx::<BasicBlock>(154), unwind: None } }; | |
} | |
'bb154: { | |
StorageDead(<ra@gennew>10_27) | |
StorageDead(_78) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(77), projection: [] }, target: Idx::<BasicBlock>(155), unwind: None } }; | |
} | |
'bb155: { | |
StorageDead(_77) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(76), projection: [] }, target: Idx::<BasicBlock>(156), unwind: None } }; | |
} | |
'bb156: { | |
StorageDead(_76) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(75), projection: [] }, target: Idx::<BasicBlock>(157), unwind: None } }; | |
} | |
'bb157: { | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(23), projection: [] }, target: Idx::<BasicBlock>(158), unwind: None } }; | |
} | |
'bb158: { | |
StorageDead(file_23) | |
StorageDead(_72) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(25), projection: [] }, target: Idx::<BasicBlock>(159), unwind: None } }; | |
} | |
'bb159: { | |
StorageDead(<ra@gennew>9_25) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(24), projection: [] }, target: Idx::<BasicBlock>(160), unwind: None } }; | |
} | |
'bb160: { | |
StorageDead(<ra@gennew>8_24) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(68), projection: [] }, target: Idx::<BasicBlock>(161), unwind: None } }; | |
} | |
'bb161: { | |
StorageDead(_68) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(67), projection: [] }, target: Idx::<BasicBlock>(162), unwind: None } }; | |
} | |
'bb162: { | |
StorageDead(_67) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(66), projection: [] }, target: Idx::<BasicBlock>(163), unwind: None } }; | |
} | |
'bb163: { | |
StorageDead(_66) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(22), projection: [] }, target: Idx::<BasicBlock>(164), unwind: None } }; | |
} | |
'bb164: { | |
StorageDead(options_22) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(57), projection: [] }, target: Idx::<BasicBlock>(165), unwind: None } }; | |
} | |
'bb165: { | |
StorageDead(_57) | |
Terminator { span: ExprId(Idx::<Expr>(343)), kind: Return }; | |
} | |
} | |
// Closure: ClosureId(25) | |
{ | |
let _0: (); | |
let _1: &{closure#25}<fn(ValueSet<'_>)>; | |
let value_set_2: ValueSet<'_>; | |
let _3: &mut Server; | |
let _4: DidChangeWatchedFilesParams; | |
let _5: bool; | |
let _6: Interest; | |
let _7: ValueSet<'_>; | |
let _8: &Metadata<'_>; | |
let _9: Level; | |
let _10: &Metadata<'_>; | |
let _11: Metadata<'_>; | |
let _12: &dyn Log; | |
let _13: Iter; | |
let _14: Level; | |
let _15: &Metadata<'_>; | |
let _16: Metadata<'_>; | |
let _17: &dyn Log; | |
let _18: Iter; | |
let _19: bool; | |
let _20: &Url; | |
let _21: FileChangeType; | |
let _22: PathBuf; | |
let _23: OpenOptions; | |
let _24: File; | |
let _25: File; | |
let _26: Result<Infallible, Error>; | |
let _27: FileType; | |
let _28: Metadata; | |
let _29: Result<Infallible, Error>; | |
let _30: String; | |
let _31: OFlags; | |
let _32: OFlags; | |
let _33: Result<Infallible, Errno>; | |
let _34: (); | |
let _35: Result<Infallible, Errno>; | |
let _36: String; | |
let _37: usize; | |
let _38: Result<Infallible, Error>; | |
let _39: String; | |
let _40: Error; | |
let _41: Error; | |
let _42: bool; | |
let _43: Interest; | |
let meta_44: &Metadata<'_>; | |
let level_45: Level; | |
let meta_46: &Metadata<'_>; | |
let log_meta_47: Metadata<'_>; | |
let logger_48: &dyn Log; | |
let _49: Iter; | |
let _50: Level; | |
let _51: &Metadata<'_>; | |
let _52: Metadata<'_>; | |
let _53: &dyn Log; | |
let _54: Iter; | |
let _55: &Path; | |
let _56: Iter<'_, FileEvent>; | |
let _57: &Metadata<'_>; | |
let _58: &DefaultCallsite; | |
let _59: &DefaultCallsite; | |
let _60: (); | |
let _61: &ValueSet<'_>; | |
let _62: (); | |
let _63: bool; | |
let _64: &Level; | |
let _65: Level; | |
let _66: Level; | |
let _67: Level; | |
let _68: bool; | |
let _69: Level; | |
let _70: bool; | |
let _71: Level; | |
let _72: bool; | |
let _73: Level; | |
let _74: bool; | |
let _75: Level; | |
let _76: bool; | |
let _77: Level; | |
let _78: bool; | |
let _79: Level; | |
let _80: bool; | |
let _81: Level; | |
let _82: bool; | |
let _83: &LevelFilter; | |
let _84: LevelFilter; | |
let _85: bool; | |
let _86: bool; | |
let _87: Level; | |
let _88: Level; | |
let _89: Level; | |
let _90: bool; | |
let _91: Level; | |
let _92: bool; | |
let _93: Level; | |
let _94: bool; | |
let _95: Level; | |
let _96: bool; | |
let _97: Level; | |
let _98: bool; | |
let _99: Level; | |
let _100: bool; | |
let _101: Level; | |
let _102: bool; | |
let _103: Level; | |
let _104: bool; | |
let _105: bool; | |
let _106: &Level; | |
let _107: &LevelFilter; | |
let _108: LevelFilter; | |
let _109: &Metadata<'_>; | |
let _110: &DefaultCallsite; | |
let _111: &DefaultCallsite; | |
let _112: Metadata<'_>; | |
let _113: &MetadataBuilder<'_>; | |
let _114: &mut MetadataBuilder<'_>; | |
let _115: &mut MetadataBuilder<'_>; | |
let _116: &mut MetadataBuilder<'_>; | |
let _117: &mut MetadataBuilder<'_>; | |
let _118: MetadataBuilder<'_>; | |
let _119: &str; | |
let _120: &Metadata<'_>; | |
let _121: &dyn Log; | |
let _122: bool; | |
let _123: &dyn Log; | |
let _124: &Metadata<'_>; | |
let _125: &dyn Log; | |
let _126: &dyn Log; | |
let _127: &ValueSet<'_>; | |
'bb0: { | |
StorageLive(_57) | |
StorageLive(_58) | |
StorageLive(_59) | |
_59 = Static(StaticId(175)); | |
_58 = &(*_59); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_58], | |
destination: _57, | |
target: 'bb1, | |
} | |
} | |
'bb1: { | |
StorageLive(meta_44) | |
meta_44 = _57; | |
StorageLive(_60) | |
StorageLive(_61) | |
_61 = &value_set_2; | |
Call { | |
func: Const(fn dispatch(&Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_44, _61], | |
destination: _60, | |
target: 'bb2, | |
} | |
} | |
'bb2: { | |
StorageDead(_61) | |
StorageDead(_60) | |
StorageLive(_62) | |
StorageLive(_63) | |
StorageLive(_64) | |
StorageLive(_65) | |
StorageLive(_66) | |
_66 = Const(Level(Error)); | |
StorageLive(_67) | |
_67 = Const(Level(Error)); | |
StorageLive(_68) | |
_68 = _67 == _66; | |
switch _68 { | |
1 => 'bb3, | |
_ => 'bb4, | |
} | |
} | |
'bb3: { | |
StorageLive(_69) | |
_69 = Const(Level(Error)); | |
StorageLive(_70) | |
_70 = _69 == _66; | |
switch _70 { | |
1 => 'bb5, | |
_ => 'bb4, | |
} | |
} | |
'bb4: { | |
StorageLive(_71) | |
_71 = Const(Level(Warn)); | |
StorageLive(_72) | |
_72 = _71 == _66; | |
switch _72 { | |
1 => 'bb7, | |
_ => 'bb8, | |
} | |
} | |
'bb5: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb6: { | |
_64 = &_65; | |
StorageLive(_83) | |
StorageLive(_84) | |
_84 = Const(Trace); | |
_83 = &_84; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_64, _83], | |
destination: _63, | |
target: 'bb16, | |
} | |
} | |
'bb7: { | |
StorageLive(_73) | |
_73 = Const(Level(Warn)); | |
StorageLive(_74) | |
_74 = _73 == _66; | |
switch _74 { | |
1 => 'bb9, | |
_ => 'bb8, | |
} | |
} | |
'bb8: { | |
StorageLive(_75) | |
_75 = Const(Level(Info)); | |
StorageLive(_76) | |
_76 = _75 == _66; | |
switch _76 { | |
1 => 'bb10, | |
_ => 'bb11, | |
} | |
} | |
'bb9: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb10: { | |
StorageLive(_77) | |
_77 = Const(Level(Info)); | |
StorageLive(_78) | |
_78 = _77 == _66; | |
switch _78 { | |
1 => 'bb12, | |
_ => 'bb11, | |
} | |
} | |
'bb11: { | |
StorageLive(_79) | |
_79 = Const(Level(Debug)); | |
StorageLive(_80) | |
_80 = _79 == _66; | |
switch _80 { | |
1 => 'bb13, | |
_ => 'bb14, | |
} | |
} | |
'bb12: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb13: { | |
StorageLive(_81) | |
_81 = Const(Level(Debug)); | |
StorageLive(_82) | |
_82 = _81 == _66; | |
switch _82 { | |
1 => 'bb15, | |
_ => 'bb14, | |
} | |
} | |
'bb14: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb15: { | |
_65 = Adt(); | |
goto 'bb6; | |
} | |
'bb16: { | |
switch _63 { | |
1 => 'bb17, | |
_ => 'bb59, | |
} | |
} | |
'bb17: { | |
StorageLive(_85) | |
StorageLive(_86) | |
Call { | |
func: Const(fn has_been_set() -> bool), | |
args: [], | |
destination: _86, | |
target: 'bb18, | |
} | |
} | |
'bb18: { | |
_85 = ! _86; | |
switch _85 { | |
1 => 'bb19, | |
_ => 'bb57, | |
} | |
} | |
'bb19: { | |
StorageLive(_87) | |
StorageLive(_88) | |
_88 = Const(Level(Error)); | |
StorageLive(_89) | |
_89 = Const(Level(Error)); | |
StorageLive(_90) | |
_90 = _89 == _88; | |
switch _90 { | |
1 => 'bb20, | |
_ => 'bb21, | |
} | |
} | |
'bb20: { | |
StorageLive(_91) | |
_91 = Const(Level(Error)); | |
StorageLive(_92) | |
_92 = _91 == _88; | |
switch _92 { | |
1 => 'bb22, | |
_ => 'bb21, | |
} | |
} | |
'bb21: { | |
StorageLive(_93) | |
_93 = Const(Level(Warn)); | |
StorageLive(_94) | |
_94 = _93 == _88; | |
switch _94 { | |
1 => 'bb24, | |
_ => 'bb25, | |
} | |
} | |
'bb22: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb23: { | |
StorageLive(level_45) | |
level_45 = _87; | |
StorageLive(_105) | |
StorageLive(_106) | |
_106 = &level_45; | |
StorageLive(_107) | |
StorageLive(_108) | |
Call { | |
func: Const(fn max_level() -> LevelFilter), | |
args: [], | |
destination: _108, | |
target: 'bb33, | |
} | |
} | |
'bb24: { | |
StorageLive(_95) | |
_95 = Const(Level(Warn)); | |
StorageLive(_96) | |
_96 = _95 == _88; | |
switch _96 { | |
1 => 'bb26, | |
_ => 'bb25, | |
} | |
} | |
'bb25: { | |
StorageLive(_97) | |
_97 = Const(Level(Info)); | |
StorageLive(_98) | |
_98 = _97 == _88; | |
switch _98 { | |
1 => 'bb27, | |
_ => 'bb28, | |
} | |
} | |
'bb26: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb27: { | |
StorageLive(_99) | |
_99 = Const(Level(Info)); | |
StorageLive(_100) | |
_100 = _99 == _88; | |
switch _100 { | |
1 => 'bb29, | |
_ => 'bb28, | |
} | |
} | |
'bb28: { | |
StorageLive(_101) | |
_101 = Const(Level(Debug)); | |
StorageLive(_102) | |
_102 = _101 == _88; | |
switch _102 { | |
1 => 'bb30, | |
_ => 'bb31, | |
} | |
} | |
'bb29: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb30: { | |
StorageLive(_103) | |
_103 = Const(Level(Debug)); | |
StorageLive(_104) | |
_104 = _103 == _88; | |
switch _104 { | |
1 => 'bb32, | |
_ => 'bb31, | |
} | |
} | |
'bb31: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb32: { | |
_87 = Adt(); | |
goto 'bb23; | |
} | |
'bb33: { | |
_107 = &_108; | |
Call { | |
func: Const(fn le<Level, LevelFilter>(&Level, &LevelFilter) -> bool), | |
args: [_106, _107], | |
destination: _105, | |
target: 'bb34, | |
} | |
} | |
'bb34: { | |
switch _105 { | |
1 => 'bb35, | |
_ => 'bb55, | |
} | |
} | |
'bb35: { | |
StorageLive(_109) | |
StorageLive(_110) | |
StorageLive(_111) | |
_111 = Static(StaticId(175)); | |
_110 = &(*_111); | |
Call { | |
func: Const(fn metadata<DefaultCallsite>(&DefaultCallsite) -> &Metadata<'_>), | |
args: [_110], | |
destination: _109, | |
target: 'bb36, | |
} | |
} | |
'bb36: { | |
StorageLive(meta_46) | |
meta_46 = _109; | |
StorageLive(_112) | |
StorageLive(_113) | |
StorageLive(_114) | |
StorageLive(_115) | |
StorageLive(_116) | |
StorageLive(_117) | |
StorageLive(_118) | |
Call { | |
func: Const(fn builder() -> MetadataBuilder<'_>), | |
args: [], | |
destination: _118, | |
target: 'bb37, | |
} | |
} | |
'bb37: { | |
_117 = &mut _118; | |
Call { | |
func: Const(fn level(&mut MetadataBuilder<'_>, Level) -> &mut MetadataBuilder<'_>), | |
args: [_117, level_45], | |
destination: _116, | |
target: 'bb38, | |
} | |
} | |
'bb38: { | |
_115 = &mut (*_116); | |
StorageLive(_119) | |
StorageLive(_120) | |
_120 = &(*meta_46); | |
Call { | |
func: Const(fn target(&Metadata<'_>) -> &str), | |
args: [_120], | |
destination: _119, | |
target: 'bb39, | |
} | |
} | |
'bb39: { | |
Call { | |
func: Const(fn target(&mut MetadataBuilder<'_>, &str) -> &mut MetadataBuilder<'_>), | |
args: [_115, _119], | |
destination: _114, | |
target: 'bb40, | |
} | |
} | |
'bb40: { | |
_113 = &(*_114); | |
Call { | |
func: Const(fn build(&MetadataBuilder<'_>) -> Metadata<'_>), | |
args: [_113], | |
destination: _112, | |
target: 'bb41, | |
} | |
} | |
'bb41: { | |
StorageLive(log_meta_47) | |
log_meta_47 = _112; | |
StorageLive(_121) | |
Call { | |
func: Const(fn logger() -> &dyn Log), | |
args: [], | |
destination: _121, | |
target: 'bb42, | |
} | |
} | |
'bb42: { | |
StorageLive(logger_48) | |
logger_48 = _121; | |
StorageLive(_122) | |
StorageLive(_123) | |
_123 = &(*logger_48); | |
StorageLive(_124) | |
_124 = &log_meta_47; | |
Call { | |
func: Const(fn enabled<dyn Log>(&dyn Log, &Metadata<'_>) -> bool), | |
args: [_123, _124], | |
destination: _122, | |
target: 'bb43, | |
} | |
} | |
'bb43: { | |
switch _122 { | |
1 => 'bb44, | |
_ => 'bb46, | |
} | |
} | |
'bb44: { | |
StorageLive(_125) | |
StorageLive(_126) | |
_126 = &(*logger_48); | |
_125 = Cast(Pointer(Unsize), _126, &dyn Log); | |
StorageLive(_127) | |
_127 = &value_set_2; | |
Call { | |
func: Const(fn __tracing_log(&Metadata<'_>, &dyn Log, Metadata<'_>, &ValueSet<'_>)), | |
args: [meta_46, _125, log_meta_47, _127], | |
destination: _62, | |
target: 'bb45, | |
} | |
} | |
'bb45: { | |
StorageDead(_127) | |
StorageDead(_126) | |
StorageDead(_125) | |
goto 'bb47; | |
} | |
'bb46: { | |
goto 'bb47; | |
} | |
'bb47: { | |
StorageDead(_124) | |
StorageDead(_123) | |
StorageDead(_122) | |
StorageDead(logger_48) | |
StorageDead(_121) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(47), projection: [] }, target: Idx::<BasicBlock>(48), unwind: None } }; | |
} | |
'bb48: { | |
StorageDead(log_meta_47) | |
StorageDead(_120) | |
StorageDead(_119) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(118), projection: [] }, target: Idx::<BasicBlock>(49), unwind: None } }; | |
} | |
'bb49: { | |
StorageDead(_118) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(117), projection: [] }, target: Idx::<BasicBlock>(50), unwind: None } }; | |
} | |
'bb50: { | |
StorageDead(_117) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(116), projection: [] }, target: Idx::<BasicBlock>(51), unwind: None } }; | |
} | |
'bb51: { | |
StorageDead(_116) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(115), projection: [] }, target: Idx::<BasicBlock>(52), unwind: None } }; | |
} | |
'bb52: { | |
StorageDead(_115) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(114), projection: [] }, target: Idx::<BasicBlock>(53), unwind: None } }; | |
} | |
'bb53: { | |
StorageDead(_114) | |
StorageDead(_113) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(112), projection: [] }, target: Idx::<BasicBlock>(54), unwind: None } }; | |
} | |
'bb54: { | |
StorageDead(_112) | |
StorageDead(meta_46) | |
StorageDead(_111) | |
StorageDead(_110) | |
StorageDead(_109) | |
goto 'bb56; | |
} | |
'bb55: { | |
goto 'bb56; | |
} | |
'bb56: { | |
StorageDead(_108) | |
StorageDead(_107) | |
StorageDead(_106) | |
StorageDead(_105) | |
StorageDead(level_45) | |
StorageDead(_104) | |
StorageDead(_103) | |
StorageDead(_102) | |
StorageDead(_101) | |
StorageDead(_100) | |
StorageDead(_99) | |
StorageDead(_98) | |
StorageDead(_97) | |
StorageDead(_96) | |
StorageDead(_95) | |
StorageDead(_94) | |
StorageDead(_93) | |
StorageDead(_92) | |
StorageDead(_91) | |
StorageDead(_90) | |
StorageDead(_89) | |
StorageDead(_88) | |
StorageDead(_87) | |
goto 'bb58; | |
} | |
'bb57: { | |
goto 'bb58; | |
} | |
'bb58: { | |
StorageDead(_86) | |
StorageDead(_85) | |
goto 'bb60; | |
} | |
'bb59: { | |
goto 'bb60; | |
} | |
'bb60: { | |
StorageDead(_84) | |
StorageDead(_83) | |
StorageDead(_82) | |
StorageDead(_81) | |
StorageDead(_80) | |
StorageDead(_79) | |
StorageDead(_78) | |
StorageDead(_77) | |
StorageDead(_76) | |
StorageDead(_75) | |
StorageDead(_74) | |
StorageDead(_73) | |
StorageDead(_72) | |
StorageDead(_71) | |
StorageDead(_70) | |
StorageDead(_69) | |
StorageDead(_68) | |
StorageDead(_67) | |
StorageDead(_66) | |
StorageDead(_65) | |
StorageDead(_64) | |
StorageDead(_63) | |
StorageDead(_62) | |
StorageDead(meta_44) | |
StorageDead(_59) | |
StorageDead(_58) | |
StorageDead(_57) | |
Terminator { span: Unknown, kind: Drop { place: Place { local: Idx::<Local>(2), projection: [] }, target: Idx::<BasicBlock>(61), unwind: None } }; | |
} | |
'bb61: { | |
StorageDead(value_set_2) | |
Terminator { span: ExprId(Idx::<Expr>(446)), kind: Return }; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment