[DDC] Use temporary names for synthesized CFE variables

Closes: #51589
Change-Id: I9d52b894419165f7e371c4e4fc56b81cb587d935
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/288829
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Mark Zhou <[email protected]>
Commit-Queue: Anna Gringauze <[email protected]>

Author: Anna Gringauze

pkg/dev_compiler/lib/src/kernel/compiler.dart

@@ -5027,13 +5027,36 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     return id;
   }
 
+  /// Detects temporary variables so we can avoid displaying
+  /// them in the debugger if needed.
+  bool _isTemporaryVariable(VariableDeclaration v) =>
+      v.isLowered ||
+      v.isSynthesized ||
+      v.name == null ||
+      v.name!.startsWith('#');
+
+  /// Creates a temporary name recognized by the debugger.
+  /// Assumes `_isTemporaryVariable(v)`  is true.
+  String? _debuggerFriendlyTemporaryVariableName(VariableDeclaration v) {
+    assert(_isTemporaryVariable(v));
+
+    // Show extension 'this' in the debugger.
+    // Do not show the rest of temporary variables.
+    if (isExtensionThis(v)) {
+      return extractLocalNameFromVariable(v);
+    } else if (v.name != null) {
+      return 't\$${v.name}';
+    }
+    return null;
+  }
+
   js_ast.Identifier _emitVariableRef(VariableDeclaration v) {
-    var name = v.name;
-    if (name == null || name.startsWith('#')) {
-      name = name == null ? 't${_tempVariables.length}' : name.substring(1);
+    if (_isTemporaryVariable(v)) {
+      var name = _debuggerFriendlyTemporaryVariableName(v);
+      name ??= 't\$${_tempVariables.length}';
       return _tempVariables.putIfAbsent(v, () => _emitTemporaryId(name!));
     }
-    return _emitIdentifier(name);
+    return _emitIdentifier(v.name!);
   }
 
   /// Emits the declaration of a variable.

pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart

@@ -587,6 +587,7 @@ class ExpressionCompilerWorker {
           alwaysCreateNewNamedNodes: true);
       return component;
     }
+    _processedOptions.ticker.logMs('File for $uri does not exist.');
     return null;
   }
 

pkg/dev_compiler/test/expression_compiler/expression_compiler_e2e_shared.dart

@@ -64,6 +64,46 @@ main() {
 // TODO(nshahan) Merge with [runAgnosticSharedTests] after we no longer need to
 // test support for evaluation in legacy (pre-null safety) code.
 void runNullSafeSharedTests(SetupCompilerOptions setup, TestDriver driver) {
+  group('Exceptions', () {
+    const exceptionSource = r'''
+    void main() {
+      try {
+        throw Exception('meow!');
+      } catch (e, s) {
+        // Breakpoint: bp
+        print('Cat says: \$e:\$s');
+      }
+    }
+    ''';
+
+    setUpAll(() async {
+      await driver.initSource(setup, exceptionSource);
+    });
+
+    tearDownAll(() async {
+      await driver.cleanupTest();
+    });
+
+    test('error', () async {
+      await driver.check(
+          breakpointId: 'bp',
+          expression: 'e.toString()',
+          expectedResult: 'meow!');
+    });
+
+    test('stack trace', () async {
+      await driver.check(
+          breakpointId: 'bp', expression: 's.toString()', expectedResult: '');
+    });
+
+    test('scope', () async {
+      await driver.checkScope(breakpointId: 'bp', expectedScope: {
+        'e': 'e',
+        's': 's',
+      });
+    });
+  });
+
   group('Records', () {
     const recordsSource = '''
     void main() {
@@ -77,8 +117,7 @@ void runNullSafeSharedTests(SetupCompilerOptions setup, TestDriver driver) {
     ''';
 
     setUpAll(() async {
-      await driver
-          .initSource(setup, recordsSource, experiments: {'records': true});
+      await driver.initSource(setup, recordsSource);
     });
 
     tearDownAll(() async {
@@ -170,6 +209,121 @@ void runNullSafeSharedTests(SetupCompilerOptions setup, TestDriver driver) {
     });
   });
 
+  group('Patterns', () {
+    const patternsSource = r'''
+    void main() {
+      int foo(Object? obj) {
+        switch (obj) {
+          case [int a, double b] || [double b, int a]:
+            // Breakpoint: bp1
+            return a;
+          case [int a, String b] || [String a, int b]:
+            // Breakpoint: bp2
+            return a;
+          default:
+            // Breakpoint: bp3
+           return 0;
+        }
+      }
+
+      final one = foo([1,2]);
+      final ten = foo([10,'20']);
+      final zero = foo(0);
+
+      // Breakpoint: bp4
+      print('$one, $ten, $zero');
+    }
+    ''';
+
+    setUpAll(() async {
+      await driver.initSource(setup, patternsSource);
+    });
+
+    tearDownAll(() async {
+      await driver.cleanupTest();
+    });
+
+    test('first case match', () async {
+      await driver.check(
+          breakpointId: 'bp1', expression: 'a.toString()', expectedResult: '1');
+    });
+
+    test('second case match', () async {
+      await driver.check(
+          breakpointId: 'bp2',
+          expression: 'a.toString()',
+          expectedResult: '10');
+    });
+
+    test('default case match', () async {
+      await driver.check(
+          breakpointId: 'bp3',
+          expression: 'obj.toString()',
+          expectedResult: '0');
+    });
+
+    test('first case match result', () async {
+      await driver.check(
+          breakpointId: 'bp4',
+          expression: 'one.toString()',
+          expectedResult: '1');
+    });
+
+    test('second case match result', () async {
+      await driver.check(
+          breakpointId: 'bp4',
+          expression: 'ten.toString()',
+          expectedResult: '10');
+    });
+
+    test('default match result', () async {
+      await driver.check(
+          breakpointId: 'bp4',
+          expression: 'zero.toString()',
+          expectedResult: '0');
+    });
+
+    // TODO(annagrin): Remove renamed variables here and below after
+    // const evaluator stops renaming variables used in cases.
+    //
+    // Issue: https://github.com/dart-lang/sdk/issues/51554
+    test('first case scope', () async {
+      await driver.checkScope(breakpointId: 'bp1', expectedScope: {
+        'a': '1',
+        'b': '2',
+        r'a$351': r'a$351',
+        r'b$351': r'b$351',
+        'obj': 'obj'
+      });
+    });
+
+    test('second case scope', () async {
+      await driver.checkScope(breakpointId: 'bp2', expectedScope: {
+        'a': '10',
+        'b': '10',
+        r'a$351': '10',
+        r'b$351': '\'20\'',
+        'obj': 'obj'
+      });
+    });
+
+    test('default case scope', () async {
+      await driver.checkScope(breakpointId: 'bp3', expectedScope: {
+        'a': 'a',
+        'b': 'b',
+        r'a$351': r'a$351',
+        r'b$351': r'b$351',
+        'obj': '0'
+      });
+    });
+
+    test('result scope', () async {
+      await driver.checkScope(
+          breakpointId: 'bp4',
+          expectedScope: {'foo': 'foo', 'one': '1', 'ten': '10', 'zero': '0'});
+    });
+  });
+
   group('Correct null safety mode used', () {
     var source = '''
         const soundNullSafety = !(<Null>[] is List<int>);
@@ -461,6 +615,11 @@ void runNullSafeSharedTests(SetupCompilerOptions setup, TestDriver driver) {
           expression: 'e != E2.id2 && E.id2 != E2.id2',
           expectedResult: 'true');
     });
+    test('scope', () async {
+      await driver.checkScope(breakpointId: 'bp', expectedScope: {
+        'e': 'e',
+      });
+    });
   });
 
   group('Automatically inserted argument null checks', () {
@@ -699,6 +858,13 @@ void runAgnosticSharedTests(SetupCompilerOptions setup, TestDriver driver) {
           expression: 'this',
           expectedError: "Error: Expected identifier, but got 'this'");
     });
+
+    test('scope', () async {
+      await driver.checkScope(breakpointId: 'bp', expectedScope: {
+        r'$this': '\'1234\'',
+        'ret': '1234',
+      });
+    });
   });
 
   group('Expression compiler tests in static function:', () {