This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8403

rust-chg: indent process_message() to prepare mass rewrite to futures-0.3
ClosedPublic

Authored by yuja on Apr 11 2020, 7:24 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf87804825df5: rust-chg: indent process_message() to prepare mass rewrite to futures-0.3
Summary

I'll start upgrading the codebase to modern async/await-based implementation,
which cannot be done incrementally. This is the last non-breaking patch to
prepare for the rewrite.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

yuja created this revision.Apr 11 2020, 7:24 AM
Alphare accepted this revision.Apr 14 2020, 5:11 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/chg/src/runcommand.rs
143

Not sure I understand the extra bracket here.

yuja added a comment.Apr 14 2020, 8:09 AM

+ {
+ match msg {

Not sure I understand the extra bracket here.

It's just for rustfmt to indent one more depth.

Alphare added a comment.Apr 14 2020, 8:10 AM

Because you expect to add an async block or something that will make the diff harder to read, I suppose?

yuja added a comment.Apr 14 2020, 10:17 AM
Because you expect to add an async block or something that will make the diff harder to read, I suppose?

The match will be surrounded by a simple loop {}, which was previously
a state machine. And yes, reading the subsequent 10 patches would be painful
without indent-level adjustment.

yuja added a commit: rHGf87804825df5: rust-chg: indent process_message() to prepare mass rewrite to futures-0.3.Apr 14 2020, 12:41 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGf87804825df5: rust-chg: indent process_message() to prepare mass rewrite to futures-0.3 (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/chg/src/runcommand.rs (49 lines)

Diff 21038

rust/chg/src/runcommand.rs

} }
} }
fn process_message<C, H>(client: Client<C>, handler: H, msg: ChannelMessage) -> CommandPoll<C, H> fn process_message<C, H>(client: Client<C>, handler: H, msg: ChannelMessage) -> CommandPoll<C, H>
where where
C: Connection, C: Connection,
H: SystemHandler, H: SystemHandler,
{ {
{
AlphareUnsubmitted
Not Done

Not sure I understand the extra bracket here.

Alphare: Not sure I understand the extra bracket here.
match msg { match msg {
ChannelMessage::Data(b'r', data) => { ChannelMessage::Data(b'r', data) => {
let code = message::parse_result_code(data)?; let code = message::parse_result_code(data)?;
Ok(AsyncS::Ready((client, handler, code))) Ok(AsyncS::Ready((client, handler, code)))
} }
ChannelMessage::Data(..) => { ChannelMessage::Data(..) => {
// just ignores data sent to optional channel // just ignores data sent to optional channel
let msg_loop = MessageLoop::resume(client); let msg_loop = MessageLoop::resume(client);
Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler))) Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler)))
} }
ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) => Err(io::Error::new( ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) => Err(
io::ErrorKind::InvalidData, io::Error::new(io::ErrorKind::InvalidData, "unsupported request"),
"unsupported request", ),
)),
ChannelMessage::SystemRequest(data) => { ChannelMessage::SystemRequest(data) => {
let (cmd_type, cmd_spec) = message::parse_command_spec(data)?; let (cmd_type, cmd_spec) = message::parse_command_spec(data)?;
match cmd_type { match cmd_type {
CommandType::Pager => { CommandType::Pager => {
let fut = handler.spawn_pager(cmd_spec).into_future(); let fut = handler.spawn_pager(cmd_spec).into_future();
Ok(AsyncS::PollAgain(CommandState::SpawningPager(client, fut))) Ok(AsyncS::PollAgain(CommandState::SpawningPager(client, fut)))
} }
CommandType::System => { CommandType::System => {
let fut = handler.run_system(cmd_spec).into_future(); let fut = handler.run_system(cmd_spec).into_future();
Ok(AsyncS::PollAgain(CommandState::WaitingSystem(client, fut))) Ok(AsyncS::PollAgain(CommandState::WaitingSystem(client, fut)))
} }
} }
} }
} }
} }
}