WIP

Author: jyameo

dwds/lib/src/debugging/dart_runtime_debugger.dart

@@ -203,4 +203,24 @@ class DartRuntimeDebugger {
       "dartDevEmbedder.debugger.invokeExtension('$methodName', JSON.stringify($encodedJson));",
     );
   }
+
+  String callLibraryMethodJsExpression(
+    String libraryUri,
+    String methodName,
+  ) {
+    String findLibraryExpression() => '''
+     (function() {
+       const sdk = ${_loadStrategy.loadModuleSnippet}('dart_sdk');
+       const dart = sdk.dart;
+       const library = dart.getLibrary('$libraryUri');
+       if (!library) throw 'cannot find library for $libraryUri';
+       return library;
+     })();
+     ''';
+
+    return _generateJsExpression(
+      findLibraryExpression(),
+      'dartDevEmbedder.debugger.callLibraryMethod("$libraryUri", "$methodName", argumentz)',
+    );
+  }
 }

dwds/lib/src/debugging/inspector.dart

@@ -14,6 +14,7 @@ import 'package:dwds/src/debugging/instance.dart';
 import 'package:dwds/src/debugging/libraries.dart';
 import 'package:dwds/src/debugging/location.dart';
 import 'package:dwds/src/debugging/remote_debugger.dart';
+import 'package:dwds/src/loaders/ddc_library_bundle.dart';
 import 'package:dwds/src/readers/asset_reader.dart';
 import 'package:dwds/src/utilities/conversions.dart';
 import 'package:dwds/src/utilities/dart_uri.dart';
@@ -212,7 +213,10 @@ class AppInspector implements AppInspectorInterface {
     // We use the JS pseudo-variable 'arguments' to get the list of all arguments.
     final send = globalToolConfiguration.loadStrategy.dartRuntimeDebugger
         .callInstanceMethodJsExpression(methodName);
+    print(
+        '***YJ_TEST: _invokeMethod: receiver: $receiver, methodName: $methodName, positionalArgs: $positionalArgs, send: $send');
     final remote = await jsCallFunctionOn(receiver, send, positionalArgs);
+    print('***YJ_TEST: _invokeMethod: remote: $remote');
     return remote;
   }
 
@@ -251,6 +255,8 @@ class AppInspector implements AppInspectorInterface {
     List<Object> arguments, {
     bool returnByValue = false,
   }) async {
+    print(
+        '**YJ_TEST: _jsCallFunction: evalExpression: $evalExpression, arguments: $arguments');
     final jsArguments = arguments.map(callArgumentFor).toList();
     final response = await remoteDebugger.sendCommand(
       'Runtime.callFunctionOn',
@@ -279,6 +285,8 @@ class AppInspector implements AppInspectorInterface {
     String selector,
     List<dynamic> arguments,
   ) async {
+    print(
+        'YJ_TEST: invoke: targetId: $targetId, selector: $selector, arguments: $arguments');
     final remoteArguments =
         arguments.cast<String>().map(remoteObjectFor).toList();
     // We special case the Dart library, where invokeMethod won't work because
@@ -300,12 +308,16 @@ class AppInspector implements AppInspectorInterface {
     Library library,
     String selector,
     List<RemoteObject> arguments,
-  ) {
-    return _evaluateInLibrary(
+  ) async {
+    print(
+      'YJ_TEST: _invokeLibraryFunction: library: ${library.uri}, selector: $selector, arguments: $arguments',
+    );
+    final result = await _evaluateInLibrary(
       library,
       'function () { return this.$selector.apply(this, arguments);}',
       arguments,
     );
+    return result;
   }
 
   /// Evaluate [expression] by calling Chrome's Runtime.evaluate.
@@ -340,27 +352,43 @@ class AppInspector implements AppInspectorInterface {
     if (libraryUri == null) {
       throwInvalidParam('invoke', 'library uri is null');
     }
-    final findLibrary = '''
-      (function() {
-        const sdk = ${globalToolConfiguration.loadStrategy.loadModuleSnippet}('dart_sdk');
-        const dart = sdk.dart;
-        const library = dart.getLibrary('$libraryUri');
-        if (!library) throw 'cannot find library for $libraryUri';
-        return library;
-      })();
-      ''';
-    final remoteLibrary = await jsEvaluate(findLibrary);
-    return jsCallFunctionOn(remoteLibrary, jsFunction, arguments);
+    final expression = globalToolConfiguration.loadStrategy.dartRuntimeDebugger
+        .callLibraryMethodJsExpression(libraryUri, jsFunction);
+
+    print('YJ_TEST: Evaluating in library: $expression');
+    if (globalToolConfiguration.loadStrategy is DdcLibraryBundleStrategy) {
+      print('YJ_TEST-A-1: DdcLibraryBundleStrategy');
+      final result = await _jsCallFunction(jsFunction, arguments);
+      print(
+        'YJ_TEST-A-2: result: $result',
+      );
+      return result;
+    } else {
+      print('YJ_TEST-B-1: ${globalToolConfiguration.loadStrategy}');
+      final remoteLibrary = await jsEvaluate(expression);
+      print(
+        'YJ_TEST-B-2: remoteLibrary: ${remoteLibrary.objectId}, jsFunction: $jsFunction, arguments: $arguments',
+      );
+      final result =
+          await jsCallFunctionOn(remoteLibrary, jsFunction, arguments);
+      print('YJ_TEST-B-3: result: ${result.objectId}');
+      return result;
+    }
   }
 
   /// Call [function] with objects referred by [argumentIds] as arguments.
   @override
   Future<RemoteObject> callFunction(
     String function,
     Iterable<String> argumentIds,
-  ) {
+  ) async {
+    print(
+      'YJ_TEST-1: callFunction - function: $function, argumentIDs: $argumentIds',
+    );
     final arguments = argumentIds.map(remoteObjectFor).toList();
-    return _jsCallFunction(function, arguments);
+    print('YJ_TEST-2: callFunction - arguments: $arguments');
+    final result = await _jsCallFunction(function, arguments);
+    return result;
   }
 
   @override

dwds/lib/src/services/chrome_proxy_service.dart

@@ -636,9 +636,10 @@ class ChromeProxyService implements VmServiceInterface {
     String targetId,
     String expression, {
     Map<String, String>? scope,
-  }) {
+  }) async {
     // TODO(798) - respect disableBreakpoints.
-    return captureElapsedTime(
+    print('YJ-TEST _evaluate - 1: calling _evaluate');
+    final result = await captureElapsedTime(
       () async {
         await isInitialized;
         final evaluator = _expressionEvaluator;
@@ -674,7 +675,7 @@ class ChromeProxyService implements VmServiceInterface {
             expression = '$target.$expression';
             scope = (scope ?? {})..addAll({target: targetId});
           }
-
+          print('YJ-TEST _evaluate - 2: calling _getEvaluationResult');
           return await _getEvaluationResult(
             isolateId,
             () => evaluator.evaluateExpression(
@@ -694,6 +695,8 @@ class ChromeProxyService implements VmServiceInterface {
       },
       (result) => DwdsEvent.evaluate(expression, result),
     );
+    print('YJ-TEST _evaluate - 3: result: $result');
+    return result;
   }
 
   String _newVariableForScope(Map<String, String>? scope) {

dwds/lib/src/services/expression_evaluator.dart

@@ -91,6 +91,9 @@ class ExpressionEvaluator {
     String expression,
     Map<String, String>? scope,
   ) async {
+    print(
+      'YJ-TEST-A: evaluateExpression - isolateId: $isolateId, libraryUri: $libraryUri, expression: $expression, scope: $scope',
+    );
     if (_closed) {
       return createError(
         EvaluationErrorKind.internal,
@@ -113,8 +116,11 @@ class ExpressionEvaluator {
         'no library uri',
       );
     }
-
+    print(
+      'YJ-TEST-B: evaluateExpression - retieving module for libraryUri: $libraryUri',
+    );
     final module = await _modules.moduleForLibrary(libraryUri);
+    print('YJ-TEST-C: evaluateExpression - module: $module');
     if (module == null) {
       return createError(
         EvaluationErrorKind.internal,
@@ -124,6 +130,7 @@ class ExpressionEvaluator {
 
     // Wrap the expression in a lambda so we can call it as a function.
     expression = _createDartLambda(expression, scope.keys);
+    print('YJ-TEST-D: evaluateExpression - NEW expression: $expression');
     _logger.finest('Evaluating "$expression" at $module');
 
     // Compile expression using an expression compiler, such as
@@ -138,20 +145,27 @@ class ExpressionEvaluator {
       module,
       expression,
     );
+    print(
+        'YJ-TEST-E: evaluateExpression - compilationResult: $compilationResult');
 
     final isError = compilationResult.isError;
     final jsResult = compilationResult.result;
     if (isError) {
       return _formatCompilationError(jsResult);
     }
+    print('YJ-TEST-F: evaluateExpression - jsResult: $jsResult');
 
     // Strip try/catch incorrectly added by the expression compiler.
     final jsCode = _maybeStripTryCatch(jsResult);
 
     // Send JS expression to chrome to evaluate.
+    print('**YJ-TEST-G: evaluateExpression - calling _callJsFunction');
     var result = await _callJsFunction(jsCode, scope);
+    print(
+        '**YJ-TEST-H: evaluateExpression - result of _callJsFunction: $result');
     result = await _formatEvaluationError(result);
-
+    print(
+        '**YJ-TEST-I: evaluateExpression - result of _formatEvaluationError: $result');
     _logger.finest('Evaluated "$expression" to "${result.json}"');
     return result;
   }
@@ -386,11 +400,17 @@ class ExpressionEvaluator {
   Future<RemoteObject> _callJsFunction(
     String function,
     Map<String, String> scope,
-  ) {
+  ) async {
+    print(
+      'YJ-TEST-1: _callJsFunction - function: $function, scope: $scope, scope.keys: ${scope.keys}, scope.values: ${scope.values}',
+    );
     final jsCode = _createEvalFunction(function, scope.keys);
+    print('YJ-TEST-2: _callJsFunction - jsCode: $jsCode');
 
     _logger.finest('Evaluating JS: "$jsCode" with scope: $scope');
-    return _inspector.callFunction(jsCode, scope.values);
+    final result = await _inspector.callFunction(jsCode, scope.values);
+    print('YJ-TEST-3: _callJsFunction - result: $result');
+    return result;
   }
 
   /// Evaluate JavaScript [expression] on frame [frameIndex].