Files
sdk/runtime/observatory/tests/service/eval_test.dart
T
Samir Jindel 9a02f5bf4d [vm/kernel] Fix bugs with expression evaluation in debug mode.
Fixes #33170: We had an assert that type variables are not bounded by "dynamic".
This assert was previously valid because the FE replaces "extends dynamic" with
"extends Object". However, it's not necessary in any way, and it's difficult to
access the Object type from outside the FE when synthesizing type parameters for
expression compilation.

Fixes #33171: The synthetic class generated during serialization to hold the
synthetic method may need to extend core library classes if the expression's
scope was within a core library class. In this case, the class finalizer needs
to avoid applying the restrictions on class extension to the synthetic class.

To facilitate this, we now use a single class name for all synthetic classes,
rather than copying the original class name. The name of the synthetic class has
no function at all, since the synthetic method is reparented to the original
class before execution.

Fixes #33239: The arguments descriptor passed to InvokeFunction for expression
functions which capture generic type parameters was using the wrong argument
count.

Fixes #33270: Use LookupClassAllowPrivate instead of LookupClass when resolving
the expression's scope in the VM.

Test Plan:

#33170: python tools/test.py -m debug -c dartk --strong service/evaluate_function_type_parameters_test
#33171: python tools/test.py -m debug -c dartk --strong service/eval_test
#33239: Updated "evaluate_function_type_parameters_test.dart".
#33270: Updated "eval_test.dart".

Change-Id: I376926bddd2224ec2322b43685d6c13831f1a8e7
Reviewed-on: https://dart-review.googlesource.com/56060
Commit-Queue: Samir Jindel <sjindel@google.com>
Reviewed-by: Siva Annamalai <asiva@google.com>
Reviewed-by: Alexander Aprelev <aam@google.com>
2018-05-31 18:46:07 +00:00

97 lines
2.7 KiB
Dart

// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// VMOptions=--error_on_bad_type --error_on_bad_override
import 'dart:async';
import 'dart:developer';
import 'package:observatory/service_io.dart';
import 'package:unittest/unittest.dart';
import 'service_test_common.dart';
import 'test_helper.dart';
int globalVar = 100;
class MyClass {
static int staticVar = 1000;
static void method(int value) {
debugger();
}
}
class _MyClass {
void foo() {
debugger();
}
}
void testFunction() {
int i = 0;
while (true) {
if (++i % 100000000 == 0) {
MyClass.method(10000);
(new _MyClass()).foo();
}
}
}
var tests = <IsolateTest>[
hasStoppedAtBreakpoint,
// Evaluate against library, class, and instance.
(Isolate isolate) async {
ServiceMap stack = await isolate.getStack();
// Make sure we are in the right place.
expect(stack.type, equals('Stack'));
expect(stack['frames'].length, greaterThanOrEqualTo(2));
expect(stack['frames'][0].function.name, equals('method'));
expect(stack['frames'][0].function.dartOwner.name, equals('MyClass'));
var lib = isolate.rootLibrary;
var cls = stack['frames'][0].function.dartOwner;
var instance = stack['frames'][0].variables[0]['value'];
dynamic result = await lib.evaluate('globalVar + 5');
print(result);
expect(result.valueAsString, equals('105'));
result = await lib.evaluate('globalVar + staticVar + 5');
expect(result.type, equals('Error'));
result = await cls.evaluate('globalVar + staticVar + 5');
print(result);
expect(result.valueAsString, equals('1105'));
result = await cls.evaluate('this + 5');
expect(result.type, equals('Error'));
result = await instance.evaluate('this + 5');
print(result);
expect(result.valueAsString, equals('10005'));
result = await instance.evaluate('this + frog');
expect(result.type, equals('Error'));
},
resumeIsolate,
hasStoppedAtBreakpoint,
(Isolate isolate) async {
ServiceMap stack = await isolate.getStack();
// Make sure we are in the right place.
expect(stack.type, equals('Stack'));
expect(stack['frames'].length, greaterThanOrEqualTo(2));
expect(stack['frames'][0].function.name, equals('foo'));
expect(stack['frames'][0].function.dartOwner.name, equals('_MyClass'));
var cls = stack['frames'][0].function.dartOwner;
dynamic result = await cls.evaluate("1+1");
print(result);
expect(result.valueAsString, equals("2"));
}
];
main(args) => runIsolateTests(args, tests, testeeConcurrent: testFunction);