feat(core): #[command] return with autoref specialization workaround fix #1672

[chippers]

What kind of change does this PR introduce? (check at least one)

• Bugfix
• Feature
• New Binding Issue #___
• Code style update
• Refactor
• Build-related changes
• Other, please describe:

Does this PR introduce a breaking change? (check one)

• No

The PR fulfills these requirements:

• When resolving a specific issue, it's referenced in the PR's title (e.g. fix: #xxx[,#xxx], where "xxx" is the issue number)
• A change file is added if any packages will require a version bump due to this PR per the instructions in the readme.

If adding a new feature, the PR's description includes:

• A convincing reason for adding this feature (to avoid wasting your time, it's best to open a suggestion issue first and wait for approval before working on it)

Other information:
So we can't really return a trait while also having a default implementation for Serialize because Result is also Serialize if the contents are. Since the contents need to be Serialize to be useful as a command result, the implementations would conflict if we tried to have a specific implementation for Result. If we don't have a specific implementation for result, the value would be sent as Result<Result<T, E>, InvokeError>.

This is not the only solution, but is the one with the least user-land code needed. An alternative would be to manually impl every type that Serialize does for a CommandResult trait, and also require the user to implement it for any types they have that are serializable that they wish to return from commands. Not ideal, but possible.

[chippers]

marked as draft until we decide this is the solution we want to use

[chippers]

Note: The simple async state command is disabled for now until I look at it again tomorrow. Because async functions add + '_ to the resulting future, this command expects State<'_, MyState> to live until `'static' because that is the lifetime of the resulting future.

Either a way to specify that lifetime better is needed in the underlying code, or a documented workaround to specify that type is needed.

[chippers]

intellij-rust throws a false positive when using async in #[command(async)]. Since async is preferable, it will be kept for now.

If intellij-rust/intellij-rust#7214 is closed as wont-fix, then we should add another option to be used. e.g. future

[chippers]

This PR is ready to review - all commands that existed before it work.

We should probably make sure that the commands example is fully fleshed out, and that every command in rust has a button on the frontend - but that can wait for another PR.

The autoref specialization workaround is what lets us "unwrap" the result of the function if it happens to be Result<impl Serialize, impl Into<InvokeError>>. Without it, the results themselves would be serialized and the variants would be exposed to the sent Ok and Err values. You can tell if this happens with the commands example because the result will be [object Object]. None of the current commands in that example should result in that.