[analysis_server] Exclude blocks/switch cases from Inline Values unless execution is within them

This prevents inline values showing up alongside code that didn't execute in conditional blocks. It does also mean they don't know up in conditional blocks that _did_ execute one execution has fallen out of them, but I believe this is the best we can do with the current LSP APIs (unless we try to track execution across requests, but that would probably be complete and not entirely reliable).

Fixes Dart-Code/Dart-Code#5454

Change-Id: Ia1cf2437b76844ff0a6aeeb958d769c9523dc5dd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/433200
Commit-Queue: Keerti Parthasarathy <[email protected]>
Reviewed-by: Keerti Parthasarathy <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: DanTup

pkg/analysis_server/lib/src/lsp/handlers/handler_inline_value.dart

@@ -92,6 +92,7 @@ class InlineValueHandler
           server.lspClientConfiguration,
           collector,
           function,
+          stoppedOffset,
         );
         function.accept(visitor);
 
@@ -139,7 +140,7 @@ class _InlineValueCollector {
   final Range rangeAlreadyExecuted;
 
   /// A [LineInfo] used to convert offsets to lines/columns for comparing to
-  /// [applicableRange].
+  /// locations provided by the client.
   final LineInfo lineInfo;
 
   _InlineValueCollector(
@@ -263,11 +264,32 @@ class _InlineValueVisitor extends GeneralizingAstVisitor<void> {
   final _InlineValueCollector collector;
   final AstNode rootNode;
 
-  _InlineValueVisitor(this.clientConfiguration, this.collector, this.rootNode);
+  /// The offset where execution currently is.
+  ///
+  /// This is used to determine which block of code we're inside, so we can
+  /// avoid showing inline values in other branches.
+  final int currentExecutionOffset;
+
+  _InlineValueVisitor(
+    this.clientConfiguration,
+    this.collector,
+    this.rootNode,
+    this.currentExecutionOffset,
+  );
 
   bool get experimentalInlineValuesProperties =>
       clientConfiguration.global.experimentalInlineValuesProperties;
 
+  @override
+  void visitBlock(Block node) {
+    if (currentExecutionOffset < node.offset ||
+        currentExecutionOffset > node.end) {
+      return;
+    }
+
+    super.visitBlock(node);
+  }
+
   @override
   void visitFormalParameter(FormalParameter node) {
     var name = node.name;
@@ -359,6 +381,16 @@ class _InlineValueVisitor extends GeneralizingAstVisitor<void> {
     super.visitSimpleIdentifier(node);
   }
 
+  @override
+  void visitSwitchPatternCase(SwitchPatternCase node) {
+    if (currentExecutionOffset < node.offset ||
+        currentExecutionOffset > (node.statements.endToken?.end ?? node.end)) {
+      return;
+    }
+
+    super.visitSwitchPatternCase(node);
+  }
+
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
     var name = node.name;

pkg/analysis_server/test/lsp/inline_value_test.dart

@@ -25,6 +25,55 @@ class InlineValueTest extends AbstractLspAnalysisServerTest {
   /// client configuration passed during initialization.
   bool experimentalInlineValuesProperties = false;
 
+  Future<void> test_block_ifStatement_inside() async {
+    code = TestCode.parse(r'''
+void f(int a, int b, int c) {
+  if (a == 1) {
+    /*[0*/a/*0]*/;
+    /*[1*/b/*1]*/;
+    /*[2*/c/*2]*/;
+    ^
+  }
+}
+''');
+
+    await verify_values(code, ofType: InlineValueVariableLookup);
+  }
+
+  Future<void> test_block_ifStatement_notInside() async {
+    code = TestCode.parse(r'''
+void f(int a, int /*[0*/b/*0]*/, int c) {
+  if (/*[1*/a/*1]*/ == 1) {
+    // Code inside blocks is excluded
+    a;
+    b;
+    c;
+  }
+  ^/*[2*/c/*2]*/;
+}
+''');
+
+    await verify_values(code, ofType: InlineValueVariableLookup);
+  }
+
+  Future<void> test_block_switchStatement() async {
+    code = TestCode.parse(r'''
+void f(int a, int /*[0*/b/*0]*/, int c) {
+  switch (/*[1*/a/*1]*/) {
+    case 0:
+      // Ignored because not in this case
+      a;
+      b;
+      c;
+    case 1:
+      ^/*[2*/c/*2]*/;
+  }
+}
+''');
+
+    await verify_values(code, ofType: InlineValueVariableLookup);
+  }
+
   Future<void> test_iterables() async {
     experimentalInlineValuesProperties = true;