feat: add reloadIsRestart to handle hot reload as a restart for web flutter#179448 (flutter#183233)

This PR fixes the --no-hot flag on web-server not working properly. When
running flutter run -d web-server --no-hot, the flag was ignored and hot
reload still occurred instead of performing hot restart.

Problem
When --no-hot was passed to disable hot reload on web, pressing 'r' in
the console would be ignored entirely. The terminal handler was checking
canHotReload, which was false when --no-hot was set, but it didn't
account for platforms like web where hot reload must always be
implemented as a hot restart.

Solution
Added a reloadIsRestart property to the ResidentHandlers abstract class
to indicate platforms where hot reload should be treated as restart.
Updated the terminal handler's 'r' key logic to allow the command when
either canHotReload is true OR reloadIsRestart is true. The web runner
already automatically converts reloads to restarts when needed.

Changes Made
[resident_runner.dart]: Added reloadIsRestart to ResidentHandlers
abstract class and implemented in ResidentRunner (returns false by
default)
[run_cold.dart]: Implemented reloadIsRestart getter (returns false)
[run_hot.dart]: Implemented reloadIsRestart getter (returns false)
[resident_web_runner.dart]: Already had proper reloadIsRestart
implementation
[terminal_handler_test.dart]: Added test case to verify 'r' key works
when reloadIsRestart=true and canHotReload=false

Before/After Behavior
Before:
```
$ flutter run -d web-server --no-hot
> r  # User presses 'r'
# Nothing happens - command is ignored
```

After:
```
$ flutter run -d web-server --no-hot
> r  # User presses 'r'
Performing hot restart...  # ✅ Correctly performs hot restart
```

Testing
Added comprehensive test coverage with a new test case: "r -
reloadIsRestart when canHotReload is false (web --no-hot case)". All 96
existing terminal handler tests pass.

Fixes
Fixes flutter#179448

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Ben Konyi <bkonyi@google.com>

Author: 3 people

packages/flutter_tools/lib/src/resident_runner.dart

@@ -576,6 +576,12 @@ abstract class ResidentHandlers {
   /// Whether an application can be detached without being stopped.
   bool get supportsDetach;
 
+  /// Whether a hot reload should be treated as a hot restart.
+  ///
+  /// This is used by platforms like web where hot reload must always perform
+  /// a full restart instead of updating code in-place.
+  bool get reloadIsRestart;
+
   @protected
   Logger get logger;
 
@@ -1101,6 +1107,7 @@ abstract class ResidentRunner extends ResidentHandlers {
   bool get canHotReload => hotMode;
 
   /// Whether the hot reload support is implemented as hot restart.
+  @override
   bool get reloadIsRestart => false;
 
   /// Start the app and keep the process running during its lifetime.
@@ -1729,7 +1736,10 @@ class TerminalHandler {
         await residentRunner.exit();
         return true;
       case 'r':
-        if (!residentRunner.canHotReload) {
+        // Allow hot reload if enabled. Also allow it if reloadIsRestart is true
+        // (e.g., web with --no-hot), since in that case the reload will be
+        // converted to a restart internally.
+        if (!(residentRunner.canHotReload || residentRunner.reloadIsRestart)) {
           return false;
         }
         final OperationResult result = await residentRunner.restart();

packages/flutter_tools/lib/src/run_cold.dart

@@ -36,6 +36,9 @@ class ColdRunner extends ResidentRunner {
   @override
   bool get canHotReload => false;
 
+  @override
+  bool get reloadIsRestart => false;
+
   @override
   Logger get logger => globals.logger;
 

packages/flutter_tools/lib/src/run_hot.dart

@@ -145,6 +145,9 @@ class HotRunner extends ResidentRunner {
   @override
   bool get supportsDetach => stopAppDuringCleanup;
 
+  @override
+  bool get reloadIsRestart => false;
+
   Future<void> _calculateTargetPlatform() async {
     if (_targetPlatformName != null) {
       return;

packages/flutter_tools/test/general.shard/terminal_handler_test.dart

@@ -863,6 +863,25 @@ void main() {
       expect(runner.calledRestart, false);
     });
 
+    testWithoutContext(
+      'r - reloadIsRestart when canHotReload is false (web --no-hot case)',
+      () async {
+        final TerminalHandler terminalHandler = setUpTerminalHandler(
+          <FakeVmServiceRequest>[],
+          supportsHotReload: false,
+        );
+        final runner = terminalHandler.residentRunner as FakeResidentRunner;
+        runner.reloadIsRestart = true;
+
+        await terminalHandler.processTerminalInput('r');
+
+        // When reloadIsRestart is true, 'r' should still trigger a restart
+        // even though canHotReload is false
+        expect(runner.calledReload, false);
+        expect(runner.calledRestart, true);
+      },
+    );
+
     testWithoutContext('R - hotRestart', () async {
       final TerminalHandler terminalHandler = setUpTerminalHandler(<FakeVmServiceRequest>[]);
       final runner = terminalHandler.residentRunner as FakeResidentRunner;
@@ -1532,6 +1551,9 @@ class FakeResidentRunner extends ResidentHandlers {
   @override
   bool supportsServiceProtocol = true;
 
+  @override
+  bool reloadIsRestart = false; // Defaults to false, only true when web --no-hot
+
   @override
   Future<void> cleanupAfterSignal() async {}
 
@@ -1563,6 +1585,10 @@ class FakeResidentRunner extends ResidentHandlers {
     bool pause = false,
     String? reason,
   }) async {
+    // When reloadIsRestart is true, treat a reload as a restart
+    if (reloadIsRestart && !fullRestart) {
+      fullRestart = true;
+    }
     if (fullRestart && !supportsRestart) {
       throw StateError('illegal restart');
     }