Version 2.10.0-109.0.dev
Merge commit '9181df9d6bf5b3d80e59d0f249c8ff9460b0f28f' into 'dev'
diff --git a/pkg/analysis_server/test/analysis/get_navigation_test.dart b/pkg/analysis_server/test/analysis/get_navigation_test.dart
index f2f2cf1..4dbe557 100644
--- a/pkg/analysis_server/test/analysis/get_navigation_test.dart
+++ b/pkg/analysis_server/test/analysis/get_navigation_test.dart
@@ -43,6 +43,29 @@
assertHasTarget('test = 0');
}
+ Future<void> test_comment_outsideReference() async {
+ addTestFile('''
+/// Returns a [String].
+String main() {
+}''');
+ await waitForTasksFinished();
+ var search = 'Returns';
+ await _getNavigation(testFile, testCode.indexOf(search), 1);
+ expect(regions, hasLength(0));
+ }
+
+ Future<void> test_comment_reference() async {
+ addTestFile('''
+/// Returns a [String].
+String main() {
+}''');
+ await waitForTasksFinished();
+ var search = '[String';
+ await _getNavigation(testFile, testCode.indexOf(search), 1);
+ expect(regions, hasLength(1));
+ assertHasRegion('String]');
+ }
+
Future<void> test_fieldType() async {
// This test mirrors test_navigation() from
// test/integration/analysis/get_navigation_test.dart
@@ -101,20 +124,6 @@
expect(testTargets[0].kind, ElementKind.LIBRARY);
}
- Future<void> test_importKeyword() async {
- addTestFile('''
-import 'dart:math';
-
-main() {
-}''');
- await waitForTasksFinished();
- await _getNavigation(testFile, 0, 1);
- expect(regions, hasLength(1));
- assertHasRegionString("'dart:math'");
- expect(testTargets, hasLength(1));
- expect(testTargets[0].kind, ElementKind.LIBRARY);
- }
-
Future<void> test_importUri() async {
addTestFile('''
import 'dart:math';
diff --git a/pkg/analysis_server/test/integration/analysis/get_navigation_test.dart b/pkg/analysis_server/test/integration/analysis/get_navigation_test.dart
index bd69280..1288adb 100644
--- a/pkg/analysis_server/test/integration/analysis/get_navigation_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/get_navigation_test.dart
@@ -41,9 +41,7 @@
expect(target.startColumn, 7);
}
- @failingTest
Future<void> test_navigation_no_result() async {
- // This fails - it returns navigation results for a whitespace area (#28799).
var pathname = sourcePath('test.dart');
var text = r'''
//
diff --git a/pkg/analysis_server/test/lsp/definition_test.dart b/pkg/analysis_server/test/lsp/definition_test.dart
index a243579..d64412c 100644
--- a/pkg/analysis_server/test/lsp/definition_test.dart
+++ b/pkg/analysis_server/test/lsp/definition_test.dart
@@ -55,6 +55,26 @@
expect(loc.uri, equals(referencedFileUri.toString()));
}
+ Future<void> test_comment_adjacentReference() async {
+ /// Computing Dart navigation locates a node at the provided offset then
+ /// returns all navigation regions inside it. This test ensures we filter
+ /// out any regions that are in the same target node (the comment) but do
+ /// not span the requested offset.
+ final contents = '''
+ /// Te^st
+ ///
+ /// References [String].
+ main() {}
+ ''';
+
+ await initialize();
+ await openFile(mainFileUri, withoutMarkers(contents));
+ final res = await getDefinitionAsLocation(
+ mainFileUri, positionFromMarker(contents));
+
+ expect(res, hasLength(0));
+ }
+
Future<void> test_fromPlugins() async {
final pluginAnalyzedFilePath = join(projectFolderPath, 'lib', 'foo.foo');
final pluginAnalyzedFileUri = Uri.file(pluginAnalyzedFilePath);
@@ -176,6 +196,59 @@
expect(res, isEmpty);
}
+ /// Failing due to incorrect range because _DartNavigationCollector._getCodeLocation
+ /// does not handle parts.
+ @failingTest
+ Future<void> test_part() async {
+ final mainContents = '''
+ import 'lib.dart';
+
+ main() {
+ Icons.[[ad^d]]();
+ }
+ ''';
+
+ final libContents = '''
+ part 'part.dart';
+ ''';
+
+ final partContents = '''
+ part of 'lib.dart';
+
+ void unrelatedFunction() {}
+
+ class Icons {
+ /// `targetRange` should not include the dartDoc but should include the full
+ /// function body. `targetSelectionRange` will be just the name.
+ [[String add = "Test"]];
+ }
+
+ void otherUnrelatedFunction() {}
+ ''';
+
+ final libFileUri = Uri.file(join(projectFolderPath, 'lib', 'lib.dart'));
+ final partFileUri = Uri.file(join(projectFolderPath, 'lib', 'part.dart'));
+
+ await initialize(
+ textDocumentCapabilities:
+ withLocationLinkSupport(emptyTextDocumentClientCapabilities));
+ await openFile(mainFileUri, withoutMarkers(mainContents));
+ await openFile(libFileUri, withoutMarkers(libContents));
+ await openFile(partFileUri, withoutMarkers(partContents));
+ final res = await getDefinitionAsLocationLinks(
+ mainFileUri, positionFromMarker(mainContents));
+
+ expect(res, hasLength(1));
+ var loc = res.single;
+ expect(loc.originSelectionRange, equals(rangeFromMarkers(mainContents)));
+ expect(loc.targetUri, equals(partFileUri.toString()));
+ expect(loc.targetRange, equals(rangeFromMarkers(partContents)));
+ expect(
+ loc.targetSelectionRange,
+ equals(rangeOfString(partContents, 'add')),
+ );
+ }
+
Future<void> test_sameLine() async {
final contents = '''
int plusOne(int [[value]]) => 1 + val^ue;
diff --git a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
index a0b22fb..4fd07d6 100644
--- a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
@@ -100,27 +100,6 @@
_flowAnalysis?.assignmentExpression_afterRight(node);
}
- /// Set the static type of [node] to be the least upper bound of the static
- /// types [staticType1] and [staticType2].
- ///
- /// TODO(scheglov) this is duplicate
- void _analyzeLeastUpperBoundTypes(
- Expression node, DartType staticType1, DartType staticType2) {
- // TODO(brianwilkerson) Determine whether this can still happen.
- staticType1 ??= DynamicTypeImpl.instance;
-
- // TODO(brianwilkerson) Determine whether this can still happen.
- staticType2 ??= DynamicTypeImpl.instance;
-
- DartType staticType =
- _typeSystem.getLeastUpperBound(staticType1, staticType2) ??
- DynamicTypeImpl.instance;
-
- staticType = _resolver.toLegacyTypeIfOptOut(staticType);
-
- _inferenceHelper.recordStaticType(node, staticType);
- }
-
void _checkForInvalidAssignment(
DartType writeType,
Expression right,
@@ -170,17 +149,6 @@
return true;
}
- /// Return the non-nullable variant of the [type] if null safety is enabled,
- /// otherwise return the type itself.
- ///
- // TODO(scheglov) this is duplicate
- DartType _nonNullable(DartType type) {
- if (_isNonNullableByDefault) {
- return _typeSystem.promoteToNonNull(type);
- }
- return type;
- }
-
/// Record that the static type of the given node is the given type.
///
/// @param expression the node whose type is to be recorded
@@ -348,29 +316,20 @@
var rightType = node.rightHandSide.staticType;
_inferenceHelper.recordStaticType(node, rightType);
} else if (operator == TokenType.QUESTION_QUESTION_EQ) {
+ var leftType = node.readType;
+
+ // The LHS value will be used only if it is non-null.
if (_isNonNullableByDefault) {
- // The static type of a compound assignment using ??= with NNBD is the
- // least upper bound of the static types of the LHS and RHS after
- // promoting the LHS/ to non-null (as we know its value will not be used
- // if null)
- _analyzeLeastUpperBoundTypes(
- node,
- _typeSystem.promoteToNonNull(node.readType),
- getReadType(node.rightHandSide),
- );
- } else {
- // The static type of a compound assignment using ??= before NNBD is the
- // least upper bound of the static types of the LHS and RHS.
- _analyzeLeastUpperBoundTypes(
- node,
- node.readType,
- node.rightHandSide.staticType,
- );
+ leftType = _typeSystem.promoteToNonNull(leftType);
}
+
+ var rightType = node.rightHandSide.staticType;
+ var result = _typeSystem.getLeastUpperBound(leftType, rightType);
+
+ _inferenceHelper.recordStaticType(node, result);
} else if (operator == TokenType.AMPERSAND_AMPERSAND_EQ ||
operator == TokenType.BAR_BAR_EQ) {
- _inferenceHelper.recordStaticType(
- node, _nonNullable(_typeProvider.boolType));
+ _inferenceHelper.recordStaticType(node, _typeProvider.boolType);
} else {
var rightType = node.rightHandSide.staticType;
diff --git a/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart b/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
index efa84ae..cd05675 100644
--- a/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
+++ b/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
@@ -19,7 +19,7 @@
CompilationUnit unit,
int offset,
int length) {
- var dartCollector = _DartNavigationCollector(collector);
+ var dartCollector = _DartNavigationCollector(collector, offset, length);
var visitor = _DartNavigationComputerVisitor(resourceProvider, dartCollector);
if (offset == null || length == null) {
unit.accept(visitor);
@@ -43,8 +43,11 @@
/// A Dart specific wrapper around [NavigationCollector].
class _DartNavigationCollector {
final NavigationCollector collector;
+ final int requestedOffset;
+ final int requestedLength;
- _DartNavigationCollector(this.collector);
+ _DartNavigationCollector(
+ this.collector, this.requestedOffset, this.requestedLength);
void _addRegion(int offset, int length, Element element) {
if (element is FieldFormalParameterElement) {
@@ -56,6 +59,12 @@
if (element.location == null) {
return;
}
+ // Discard elements that don't span the offset/range given (if provided).
+ if (requestedOffset != null &&
+ (offset > requestedOffset + (requestedLength ?? 0) ||
+ offset + length < requestedOffset)) {
+ return;
+ }
var converter = AnalyzerConverter();
var kind = converter.convertElementKind(element.kind);
var location = converter.locationFromElement(element);
@@ -118,9 +127,13 @@
}
// Read the declaration so we can get the offset after the doc comments.
- final declaration = codeElement.session
- .getParsedLibrary(location.file)
- .getElementDeclaration(codeElement);
+ // TODO(dantup): Skip this for parts (getParsedLibrary will throw), but find
+ // a better solution.
+ final declaration = !codeElement.session.getFile(location.file).isPart
+ ? codeElement.session
+ .getParsedLibrary(location.file)
+ .getElementDeclaration(codeElement)
+ : null;
var node = declaration?.node;
if (node is VariableDeclaration) {
node = node.parent;
diff --git a/pkg/dartdev/lib/dartdev.dart b/pkg/dartdev/lib/dartdev.dart
index d60260f..41f0901 100644
--- a/pkg/dartdev/lib/dartdev.dart
+++ b/pkg/dartdev/lib/dartdev.dart
@@ -22,6 +22,7 @@
import 'src/commands/run.dart';
import 'src/commands/test.dart';
import 'src/core.dart';
+import 'src/events.dart';
import 'src/experiments.dart';
import 'src/sdk.dart';
import 'src/utils.dart';
@@ -35,10 +36,6 @@
final stopwatch = Stopwatch();
int result;
- // The Analytics instance used to report information back to Google Analytics,
- // see lib/src/analytics.dart.
- Analytics analytics;
-
// The exit code for the dartdev process, null indicates that it has not yet
// been set yet. The value is set in the catch and finally blocks below.
int exitCode;
@@ -47,7 +44,9 @@
Object exception;
StackTrace stackTrace;
- analytics =
+ // The Analytics instance used to report information back to Google Analytics,
+ // see lib/src/analytics.dart.
+ Analytics analytics =
createAnalyticsInstance(args.contains('--disable-dartdev-analytics'));
// If we have not printed the analyticsNoticeOnFirstRunMessage to stdout,
@@ -92,11 +91,13 @@
// RunCommand.ddsHost = ddsUrl[0];
// RunCommand.ddsPort = ddsUrl[1];
}
+
String commandName;
try {
stopwatch.start();
final runner = DartdevRunner(args);
+
// Run can't be called with the '--disable-dartdev-analytics' flag, remove
// it if it is contained in args.
if (args.contains('--disable-dartdev-analytics')) {
@@ -119,14 +120,6 @@
)
.toList();
- // Before calling to run, send the first ping to analytics to have the first
- // ping, as well as the command itself, running in parallel.
- if (analytics.enabled) {
- commandName = getCommandStr(args, runner.commands.keys.toList());
- // ignore: unawaited_futures
- analytics.sendEvent(eventCategory, commandName);
- }
-
// If ... help pub ... is in the args list, remove 'help', and add '--help'
// to the end of the list. This will make it possible to use the help
// command to access subcommands of pub such as `dart help pub publish`, see
@@ -135,6 +128,17 @@
args = PubUtils.modifyArgs(args);
}
+ // For the commands format and migrate, dartdev itself sends the
+ // sendScreenView notification to analytics, for all other
+ // dartdev commands (instances of DartdevCommand) the commands send this
+ // to analytics.
+ commandName = ArgParserUtils.getCommandStr(args);
+ if (analytics.enabled &&
+ (commandName == formatCmdName || commandName == migrateCmdName)) {
+ // ignore: unawaited_futures
+ analytics.sendScreenView(commandName);
+ }
+
// Finally, call the runner to execute the command, see DartdevRunner.
result = await runner.run(args);
} catch (e, st) {
@@ -157,7 +161,22 @@
// Send analytics before exiting
if (analytics.enabled) {
- analytics.setSessionValue(exitCodeParam, exitCode);
+ // For commands that are not DartdevCommand instances, we manually create
+ // and send the UsageEvent from here:
+ if (commandName == formatCmdName) {
+ // ignore: unawaited_futures
+ FormatUsageEvent(
+ exitCode: exitCode,
+ args: args,
+ ).send(analyticsInstance);
+ } else if (commandName == migrateCmdName) {
+ // ignore: unawaited_futures
+ MigrateUsageEvent(
+ exitCode: exitCode,
+ args: args,
+ ).send(analyticsInstance);
+ }
+
// ignore: unawaited_futures
analytics.sendTiming(commandName, stopwatch.elapsedMilliseconds,
category: 'commands');
diff --git a/pkg/dartdev/lib/src/analytics.dart b/pkg/dartdev/lib/src/analytics.dart
index 5a1037a..595fec0 100644
--- a/pkg/dartdev/lib/src/analytics.dart
+++ b/pkg/dartdev/lib/src/analytics.dart
@@ -26,7 +26,6 @@
║ `dart --enable-analytics` ║
╚════════════════════════════════════════════════════════════════════════════╝
''';
-const String _unknownCommand = '<unknown>';
const String _appName = 'dartdev';
const String _dartDirectoryName = '.dart';
const String _settingsFileName = 'dartdev.json';
@@ -40,13 +39,15 @@
const String eventCategory = 'dartdev';
const String exitCodeParam = 'exitCode';
-Analytics instance;
+Analytics _instance;
+
+Analytics get analyticsInstance => _instance;
/// Create and return an [Analytics] instance, this value is cached and returned
/// on subsequent calls.
Analytics createAnalyticsInstance(bool disableAnalytics) {
- if (instance != null) {
- return instance;
+ if (_instance != null) {
+ return _instance;
}
// Dartdev tests pass a hidden 'disable-dartdev-analytics' flag which is
@@ -54,16 +55,16 @@
// Also, stdout.hasTerminal is checked, if there is no terminal we infer that
// a machine is running dartdev so we return analytics shouldn't be set.
if (disableAnalytics) {
- instance = DisabledAnalytics(_trackingId, _appName);
- return instance;
+ _instance = DisabledAnalytics(_trackingId, _appName);
+ return _instance;
}
var settingsDir = getDartStorageDirectory();
if (settingsDir == null) {
// Some systems don't support user home directories; for those, fail
// gracefully by returning a disabled analytics object.
- instance = DisabledAnalytics(_trackingId, _appName);
- return instance;
+ _instance = DisabledAnalytics(_trackingId, _appName);
+ return _instance;
}
if (!settingsDir.existsSync()) {
@@ -72,8 +73,8 @@
} catch (e) {
// If we can't create the directory for the analytics settings, fail
// gracefully by returning a disabled analytics object.
- instance = DisabledAnalytics(_trackingId, _appName);
- return instance;
+ _instance = DisabledAnalytics(_trackingId, _appName);
+ return _instance;
}
}
@@ -85,22 +86,8 @@
}
var settingsFile = File(path.join(settingsDir.path, _settingsFileName));
- instance = DartdevAnalytics(_trackingId, settingsFile, _appName);
- return instance;
-}
-
-/// Return the first member from [args] that occurs in [allCommands], otherwise
-/// '<unknown>' is returned.
-///
-/// 'help' is special cased to have 'dart analyze help', 'dart help analyze',
-/// and 'dart analyze --help' all be recorded as a call to 'help' instead of
-/// 'help' and 'analyze'.
-String getCommandStr(List<String> args, List<String> allCommands) {
- if (args.contains('help') || args.contains('-h') || args.contains('--help')) {
- return 'help';
- }
- return args.firstWhere((arg) => allCommands.contains(arg),
- orElse: () => _unknownCommand);
+ _instance = DartdevAnalytics(_trackingId, settingsFile, _appName);
+ return _instance;
}
/// The directory used to store the analytics settings file.
diff --git a/pkg/dartdev/lib/src/commands/analyze.dart b/pkg/dartdev/lib/src/commands/analyze.dart
index 139d262..08d8590 100644
--- a/pkg/dartdev/lib/src/commands/analyze.dart
+++ b/pkg/dartdev/lib/src/commands/analyze.dart
@@ -5,14 +5,18 @@
import 'dart:async';
import 'dart:io';
+import 'package:meta/meta.dart';
import 'package:path/path.dart' as path;
import '../core.dart';
+import '../events.dart';
import '../sdk.dart';
import '../utils.dart';
import 'analyze_impl.dart';
class AnalyzeCommand extends DartdevCommand<int> {
+ static const String cmdName = 'analyze';
+
/// The maximum length of any of the existing severity labels.
static const int _severityWidth = 7;
@@ -20,7 +24,7 @@
/// message. The width left for the severity label plus the separator width.
static const int _bodyIndentWidth = _severityWidth + 3;
- AnalyzeCommand() : super('analyze', "Analyze the project's Dart code.") {
+ AnalyzeCommand() : super(cmdName, "Analyze the project's Dart code.") {
argParser
..addFlag('fatal-infos',
help: 'Treat info level issues as fatal.', negatable: false)
@@ -32,7 +36,7 @@
String get invocation => '${super.invocation} [<directory>]';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
if (argResults.rest.length > 1) {
usageException('Only one directory is expected.');
}
@@ -153,4 +157,19 @@
return 0;
}
}
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => AnalyzeUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ args: argResults.arguments,
+ );
+}
+
+/// The [UsageEvent] for the analyze command.
+class AnalyzeUsageEvent extends UsageEvent {
+ AnalyzeUsageEvent(String usagePath,
+ {String label, @required int exitCode, @required List<String> args})
+ : super(AnalyzeCommand.cmdName, usagePath,
+ label: label, args: args, exitCode: exitCode);
}
diff --git a/pkg/dartdev/lib/src/commands/compile.dart b/pkg/dartdev/lib/src/commands/compile.dart
index 5da7168..491d7ae 100644
--- a/pkg/dartdev/lib/src/commands/compile.dart
+++ b/pkg/dartdev/lib/src/commands/compile.dart
@@ -6,9 +6,11 @@
import 'dart:io';
import 'package:dart2native/generate.dart';
+import 'package:meta/meta.dart';
import 'package:path/path.dart' as path;
import '../core.dart';
+import '../events.dart';
import '../sdk.dart';
import '../vm_interop_handler.dart';
@@ -39,12 +41,13 @@
stderr.flush();
return false;
}
-
return true;
}
-class CompileJSCommand extends DartdevCommand<int> {
- CompileJSCommand() : super('js', 'Compile Dart to JavaScript.') {
+class CompileJSCommand extends CompileSubcommandCommand {
+ static const String cmdName = 'js';
+
+ CompileJSCommand() : super(cmdName, 'Compile Dart to JavaScript.') {
argParser
..addOption(
commonOptions['outputFile'].flag,
@@ -63,7 +66,7 @@
String get invocation => '${super.invocation} <dart entry point>';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
if (!Sdk.checkArtifactExists(sdk.dart2jsSnapshot)) {
return 255;
}
@@ -97,7 +100,10 @@
}
}
-class CompileSnapshotCommand extends DartdevCommand<int> {
+class CompileSnapshotCommand extends CompileSubcommandCommand {
+ static const String jitSnapshotCmdName = 'jit-snapshot';
+ static const String kernelCmdName = 'kernel';
+
final String commandName;
final String help;
final String fileExt;
@@ -121,7 +127,7 @@
String get invocation => '${super.invocation} <dart entry point>';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
// We expect a single rest argument; the dart entry point.
if (argResults.rest.length != 1) {
// This throws.
@@ -157,7 +163,10 @@
}
}
-class CompileNativeCommand extends DartdevCommand<int> {
+class CompileNativeCommand extends CompileSubcommandCommand {
+ static const String exeCmdName = 'exe';
+ static const String aotSnapshotCmdName = 'aot-snapshot';
+
final String commandName;
final String format;
final String help;
@@ -194,7 +203,7 @@
String get invocation => '${super.invocation} <dart entry point>';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
if (!Sdk.checkArtifactExists(genKernel) ||
!Sdk.checkArtifactExists(genSnapshot)) {
return 255;
@@ -230,30 +239,64 @@
}
}
-class CompileCommand extends DartdevCommand {
- CompileCommand() : super('compile', 'Compile Dart to various formats.') {
+abstract class CompileSubcommandCommand extends DartdevCommand<int> {
+ CompileSubcommandCommand(String name, String description,
+ {bool hidden = false})
+ : super(name, description, hidden: hidden);
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => CompileUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ args: argResults.arguments,
+ );
+}
+
+class CompileCommand extends DartdevCommand<int> {
+ static const String cmdName = 'compile';
+
+ CompileCommand() : super(cmdName, 'Compile Dart to various formats.') {
addSubcommand(CompileJSCommand());
addSubcommand(CompileSnapshotCommand(
- commandName: 'jit-snapshot',
+ commandName: CompileSnapshotCommand.jitSnapshotCmdName,
help: 'to a JIT snapshot.',
fileExt: 'jit',
formatName: 'app-jit',
));
addSubcommand(CompileSnapshotCommand(
- commandName: 'kernel',
+ commandName: CompileSnapshotCommand.kernelCmdName,
help: 'to a kernel snapshot.',
fileExt: 'dill',
formatName: 'kernel',
));
addSubcommand(CompileNativeCommand(
- commandName: 'exe',
+ commandName: CompileNativeCommand.exeCmdName,
help: 'to a self-contained executable.',
format: 'exe',
));
addSubcommand(CompileNativeCommand(
- commandName: 'aot-snapshot',
+ commandName: CompileNativeCommand.aotSnapshotCmdName,
help: 'to an AOT snapshot.',
format: 'aot',
));
}
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => null;
+
+ @override
+ FutureOr<int> runImpl() {
+ // do nothing, this command is never run
+ return 0;
+ }
+}
+
+/// The [UsageEvent] for all compile commands, we could have each compile
+/// event be its own class instance, but for the time being [usagePath] takes
+/// care of the only difference.
+class CompileUsageEvent extends UsageEvent {
+ CompileUsageEvent(String usagePath,
+ {String label, @required int exitCode, @required List<String> args})
+ : super(CompileCommand.cmdName, usagePath,
+ label: label, exitCode: exitCode, args: args);
}
diff --git a/pkg/dartdev/lib/src/commands/create.dart b/pkg/dartdev/lib/src/commands/create.dart
index 4eda721..920de13 100644
--- a/pkg/dartdev/lib/src/commands/create.dart
+++ b/pkg/dartdev/lib/src/commands/create.dart
@@ -7,14 +7,18 @@
import 'dart:io' as io;
import 'dart:math' as math;
+import 'package:meta/meta.dart';
import 'package:path/path.dart' as p;
import 'package:stagehand/stagehand.dart' as stagehand;
import '../core.dart';
+import '../events.dart';
import '../sdk.dart';
/// A command to create a new project from a set of templates.
-class CreateCommand extends DartdevCommand {
+class CreateCommand extends DartdevCommand<int> {
+ static const String cmdName = 'create';
+
static String defaultTemplateId = 'console-simple';
static List<String> legalTemplateIds = [
@@ -31,7 +35,7 @@
stagehand.getGenerator(templateId);
CreateCommand({bool verbose = false})
- : super('create', 'Create a new project.') {
+ : super(cmdName, 'Create a new project.') {
argParser.addOption(
'template',
allowed: legalTemplateIds,
@@ -60,7 +64,7 @@
String get invocation => '${super.invocation} <directory>';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
if (argResults['list-templates']) {
log.stdout(_availableTemplatesJson());
return 0;
@@ -139,6 +143,13 @@
}
@override
+ UsageEvent createUsageEvent(int exitCode) => CreateUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ args: argResults.arguments,
+ );
+
+ @override
String get usageFooter {
int width = legalTemplateIds.map((s) => s.length).reduce(math.max);
String desc = generators.map((g) {
@@ -169,6 +180,14 @@
}
}
+/// The [UsageEvent] for the create command.
+class CreateUsageEvent extends UsageEvent {
+ CreateUsageEvent(String usagePath,
+ {String label, @required int exitCode, @required List<String> args})
+ : super(CreateCommand.cmdName, usagePath,
+ label: label, exitCode: exitCode, args: args);
+}
+
class DirectoryGeneratorTarget extends stagehand.GeneratorTarget {
final stagehand.Generator generator;
final io.Directory dir;
diff --git a/pkg/dartdev/lib/src/commands/fix.dart b/pkg/dartdev/lib/src/commands/fix.dart
index 36a8579..338158e 100644
--- a/pkg/dartdev/lib/src/commands/fix.dart
+++ b/pkg/dartdev/lib/src/commands/fix.dart
@@ -6,19 +6,23 @@
import 'dart:io';
import 'package:analysis_server_client/protocol.dart' hide AnalysisError;
+import 'package:meta/meta.dart';
import 'package:path/path.dart' as path;
import '../core.dart';
+import '../events.dart';
import '../sdk.dart';
import '../utils.dart';
import 'analyze_impl.dart';
-class FixCommand extends DartdevCommand {
+class FixCommand extends DartdevCommand<int> {
+ static const String cmdName = 'fix';
+
// This command is hidden as its currently experimental.
- FixCommand() : super('fix', 'Fix Dart source code.', hidden: true);
+ FixCommand() : super(cmdName, 'Fix Dart source code.', hidden: true);
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
log.stdout('\n*** The `fix` command is provisional and subject to change '
'or removal in future releases. ***\n');
@@ -76,7 +80,21 @@
}
log.stdout('Done.');
}
-
return 0;
}
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => FixUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ args: argResults.arguments,
+ );
+}
+
+/// The [UsageEvent] for the fix command.
+class FixUsageEvent extends UsageEvent {
+ FixUsageEvent(String usagePath,
+ {String label, @required int exitCode, @required List<String> args})
+ : super(FixCommand.cmdName, usagePath,
+ label: label, exitCode: exitCode, args: args);
}
diff --git a/pkg/dartdev/lib/src/commands/pub.dart b/pkg/dartdev/lib/src/commands/pub.dart
index 6b40ebc..c30bc61 100644
--- a/pkg/dartdev/lib/src/commands/pub.dart
+++ b/pkg/dartdev/lib/src/commands/pub.dart
@@ -5,14 +5,37 @@
import 'dart:async';
import 'package:args/args.dart';
+import 'package:meta/meta.dart';
import '../core.dart';
+import '../events.dart';
import '../experiments.dart';
import '../sdk.dart';
import '../vm_interop_handler.dart';
class PubCommand extends DartdevCommand<int> {
- PubCommand() : super('pub', 'Work with packages.');
+ static const String cmdName = 'pub';
+
+ PubCommand() : super(cmdName, 'Work with packages.');
+
+ // TODO(jwren) as soon as pub commands are are implemented directly in
+ // dartdev, remove this static list.
+ /// A list of all subcommands, used only for the implementation of
+ /// [usagePath], see below.
+ static List<String> pubSubcommands = [
+ 'cache',
+ 'deps',
+ 'downgrade',
+ 'get',
+ 'global',
+ 'logout',
+ 'outdated',
+ 'publish',
+ 'run',
+ 'upgrade',
+ 'uploader',
+ 'version',
+ ];
@override
ArgParser createArgParser() => ArgParser.allowAnything();
@@ -34,8 +57,26 @@
VmInteropHandler.run(command, args);
}
+ /// Since the pub subcommands are not subclasses of DartdevCommand, we
+ /// override [usagePath] here as a special case to cover the first subcommand
+ /// under pub, i.e. we will have the path pub/cache
@override
- FutureOr<int> run() async {
+ String get usagePath {
+ if (argResults == null) {
+ return name;
+ }
+ var args = argResults.arguments;
+ var cmdIndex = args.indexOf(name) ?? 0;
+ for (int i = cmdIndex + 1; i < args.length; i++) {
+ if (pubSubcommands.contains(args[i])) {
+ return '$name/${args[i]}';
+ }
+ }
+ return name;
+ }
+
+ @override
+ FutureOr<int> runImpl() async {
if (!Sdk.checkArtifactExists(sdk.pubSnapshot)) {
return 255;
}
@@ -65,4 +106,26 @@
VmInteropHandler.run(command, args);
return 0;
}
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => PubUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: argResults.arguments,
+ );
+}
+
+/// The [UsageEvent] for the pub command.
+class PubUsageEvent extends UsageEvent {
+ PubUsageEvent(String usagePath,
+ {String label,
+ @required int exitCode,
+ @required List<String> specifiedExperiments,
+ @required List<String> args})
+ : super(PubCommand.cmdName, usagePath,
+ label: label,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: args);
}
diff --git a/pkg/dartdev/lib/src/commands/run.dart b/pkg/dartdev/lib/src/commands/run.dart
index feeb99c..9fa39e6 100644
--- a/pkg/dartdev/lib/src/commands/run.dart
+++ b/pkg/dartdev/lib/src/commands/run.dart
@@ -8,15 +8,19 @@
import 'dart:io';
import 'package:args/args.dart';
+import 'package:meta/meta.dart';
import 'package:path/path.dart';
import '../core.dart';
+import '../events.dart';
import '../experiments.dart';
import '../sdk.dart';
import '../utils.dart';
import '../vm_interop_handler.dart';
class RunCommand extends DartdevCommand<int> {
+ static const String cmdName = 'run';
+
static bool launchDds = false;
static String ddsHost;
static String ddsPort;
@@ -41,7 +45,7 @@
RunCommand({this.verbose = false})
: super(
- 'run',
+ cmdName,
'Run a Dart program.',
) {
// NOTE: When updating this list of flags, be sure to add any VM flags to
@@ -153,7 +157,7 @@
String get invocation => '${super.invocation} <dart file | package target>';
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
// The command line arguments after 'run'
var args = argResults.arguments.toList();
@@ -236,6 +240,14 @@
VmInteropHandler.run(path, runArgs);
return 0;
}
+
+ @override
+ UsageEvent createUsageEvent(int exitCode) => RunUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: argResults.arguments,
+ );
}
class _DebuggingSession {
@@ -282,3 +294,17 @@
}
}
}
+
+/// The [UsageEvent] for the run command.
+class RunUsageEvent extends UsageEvent {
+ RunUsageEvent(String usagePath,
+ {String label,
+ @required int exitCode,
+ @required List<String> specifiedExperiments,
+ @required List<String> args})
+ : super(RunCommand.cmdName, usagePath,
+ label: label,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: args);
+}
diff --git a/pkg/dartdev/lib/src/commands/test.dart b/pkg/dartdev/lib/src/commands/test.dart
index dcb5a7f..beba8c8 100644
--- a/pkg/dartdev/lib/src/commands/test.dart
+++ b/pkg/dartdev/lib/src/commands/test.dart
@@ -5,8 +5,10 @@
import 'dart:async';
import 'package:args/args.dart';
+import 'package:meta/meta.dart';
import '../core.dart';
+import '../events.dart';
import '../experiments.dart';
import '../sdk.dart';
import '../vm_interop_handler.dart';
@@ -15,7 +17,9 @@
///
/// This command largely delegates to `pub run test`.
class TestCommand extends DartdevCommand<int> {
- TestCommand() : super('test', 'Run tests in this package.');
+ static const String cmdName = 'test';
+
+ TestCommand() : super(cmdName, 'Run tests in this package.');
@override
final ArgParser argParser = ArgParser.allowAnything();
@@ -26,7 +30,7 @@
}
@override
- FutureOr<int> run() async {
+ FutureOr<int> runImpl() async {
return _runImpl(argResults.arguments.toList());
}
@@ -70,6 +74,14 @@
return 0;
}
+ @override
+ UsageEvent createUsageEvent(int exitCode) => TestUsageEvent(
+ usagePath,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: argResults.arguments,
+ );
+
void _printNoPubspecMessage(bool wasHelpCommand) {
log.stdout('''
No pubspec.yaml file found; please run this command from the root of your project.
@@ -118,6 +130,20 @@
}
}
+/// The [UsageEvent] for the test command.
+class TestUsageEvent extends UsageEvent {
+ TestUsageEvent(String usagePath,
+ {String label,
+ @required int exitCode,
+ @required List<String> specifiedExperiments,
+ @required List<String> args})
+ : super(TestCommand.cmdName, usagePath,
+ label: label,
+ exitCode: exitCode,
+ specifiedExperiments: specifiedExperiments,
+ args: args);
+}
+
const String _terseHelp = 'Run tests in this package.';
const String _usageHelp = 'Usage: dart test [files or directories...]';
diff --git a/pkg/dartdev/lib/src/core.dart b/pkg/dartdev/lib/src/core.dart
index cc3a505..5694415 100644
--- a/pkg/dartdev/lib/src/core.dart
+++ b/pkg/dartdev/lib/src/core.dart
@@ -2,6 +2,7 @@
// 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.
+import 'dart:async';
import 'dart:convert';
import 'dart:io';
@@ -10,6 +11,8 @@
import 'package:cli_util/cli_logging.dart';
import 'package:path/path.dart' as path;
+import 'analytics.dart';
+import 'events.dart';
import 'experiments.dart';
import 'sdk.dart';
import 'utils.dart';
@@ -39,6 +42,55 @@
@override
ArgParser get argParser => _argParser ??= createArgParser();
+ /// This method should not be overridden by subclasses, instead classes should
+ /// override [runImpl] and [createUsageEvent]. If analytics is enabled by this
+ /// command and the user, a [sendScreenView] is called to analytics, and then
+ /// after the command is run, an event is sent to analytics.
+ ///
+ /// If analytics is not enabled by this command or the user, then [runImpl] is
+ /// called and the exitCode value is returned.
+ @override
+ FutureOr<int> run() async {
+ var path = usagePath;
+ if (path != null &&
+ analyticsInstance != null &&
+ analyticsInstance.enabled) {
+ // Send the screen view to analytics
+ // ignore: unawaited_futures
+ analyticsInstance.sendScreenView(path);
+
+ // Run this command
+ var exitCode = await runImpl();
+
+ // Send the event to analytics
+ // ignore: unawaited_futures
+ createUsageEvent(exitCode)?.send(analyticsInstance);
+
+ // Finally return the exit code
+ return exitCode;
+ } else {
+ // Analytics is not enabled, run the command and return the exit code
+ return runImpl();
+ }
+ }
+
+ UsageEvent createUsageEvent(int exitCode);
+
+ FutureOr<int> runImpl();
+
+ /// The command name path to send to Google Analytics. Return null to disable
+ /// tracking of the command.
+ String get usagePath {
+ if (parent is DartdevCommand) {
+ final commandParent = parent as DartdevCommand;
+ final parentPath = commandParent.usagePath;
+ // Don't report for parents that return null for usagePath.
+ return parentPath == null ? null : '$parentPath/$name';
+ } else {
+ return name;
+ }
+ }
+
/// Create the ArgParser instance for this command.
///
/// Subclasses can override this in order to create a customized ArgParser.
diff --git a/pkg/dartdev/lib/src/events.dart b/pkg/dartdev/lib/src/events.dart
new file mode 100644
index 0000000..6cc5547
--- /dev/null
+++ b/pkg/dartdev/lib/src/events.dart
@@ -0,0 +1,204 @@
+// Copyright (c) 2020, 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.
+
+import 'package:meta/meta.dart';
+import 'package:usage/usage.dart';
+
+import 'commands/analyze.dart';
+import 'commands/compile.dart';
+import 'commands/create.dart';
+import 'commands/fix.dart';
+import 'commands/pub.dart';
+import 'commands/run.dart';
+
+/// A list of all commands under dartdev.
+const List<String> allCommands = [
+ 'help',
+ AnalyzeCommand.cmdName,
+ CreateCommand.cmdName,
+ CompileCommand.cmdName,
+ FixCommand.cmdName,
+ formatCmdName,
+ migrateCmdName,
+ PubCommand.cmdName,
+ RunCommand.cmdName,
+ 'test'
+];
+
+/// The [String] identifier `dartdev`, used as the category in the events sent
+/// to analytics.
+const String _dartdev = 'dartdev';
+
+/// The [String] identifier `format`.
+const String formatCmdName = 'format';
+
+/// The [String] identifier `migrate`.
+const String migrateCmdName = 'migrate';
+
+/// The separator used to for joining the flag sets sent to analytics.
+const String _flagSeparator = ',';
+
+/// When some unknown command is used, for instance `dart foo`, the command is
+/// designated with this identifier.
+const String _unknownCommand = '<unknown>';
+
+/// The collection of custom dimensions understood by the analytics backend.
+/// When adding to this list, first ensure that the custom dimension is
+/// defined in the backend, or will be defined shortly after the relevant PR
+/// lands. The pattern here matches the flutter cli.
+enum CustomDimensions {
+ commandExitCode, // cd1
+ enabledExperiments, // cd2
+ commandFlags, // cd3
+}
+
+String cdKey(CustomDimensions cd) => 'cd${cd.index + 1}';
+
+Map<String, String> _useCdKeys(Map<CustomDimensions, String> parameters) {
+ return parameters.map(
+ (CustomDimensions k, String v) => MapEntry<String, String>(cdKey(k), v));
+}
+
+/// Utilities for parsing arguments passed to dartdev. These utilities have all
+/// been marked as static to assist with testing, see events_test.dart.
+class ArgParserUtils {
+ /// Return the first member from [args] that occurs in [allCommands],
+ /// otherwise '<unknown>' is returned.
+ ///
+ /// 'help' is special cased to have 'dart analyze help', 'dart help analyze',
+ /// and 'dart analyze --help' all be recorded as a call to 'help' instead of
+ /// 'help' and 'analyze'.
+ static String getCommandStr(List<String> args) {
+ if (args.contains('help') ||
+ args.contains('-h') ||
+ args.contains('--help')) {
+ return 'help';
+ }
+ return args.firstWhere((arg) => allCommands.contains(arg),
+ orElse: () => _unknownCommand);
+ }
+
+ /// Return true if the first character of the passed [String] is '-'.
+ static bool isFlag(String arg) => arg != null && arg.startsWith('-');
+
+ /// Returns true if and only if the passed argument equals 'help', '--help' or
+ /// '-h'.
+ static bool isHelp(String arg) =>
+ arg == 'help' || arg == '--help' || arg == '-h';
+
+ /// Given some command in args, return the set of flags after the command.
+ static List<String> parseCommandFlags(String command, List<String> args) {
+ var result = <String>[];
+ if (args == null || args.isEmpty) {
+ return result;
+ }
+
+ var indexOfCmd = args.indexOf(command);
+ if (indexOfCmd < 0) {
+ return result;
+ }
+
+ for (var i = indexOfCmd + 1; i < args.length; i++) {
+ if (!isHelp(args[i]) && isFlag(args[i])) {
+ result.add(sanitizeFlag(args[i]));
+ }
+ }
+ return result;
+ }
+
+ /// Return the passed flag, only if it is considered a flag, see [isFlag], and
+ /// if '=' is in the flag, return only the contents of the left hand side of
+ /// the '='.
+ static String sanitizeFlag(String arg) {
+ if (isFlag(arg)) {
+ if (arg.contains('=')) {
+ return arg.substring(0, arg.indexOf('='));
+ } else {
+ return arg;
+ }
+ }
+ return '';
+ }
+}
+
+/// The [UsageEvent] for the format command.
+class FormatUsageEvent extends UsageEvent {
+ FormatUsageEvent(
+ {String label, @required int exitCode, @required List<String> args})
+ : super(formatCmdName, formatCmdName,
+ label: label, exitCode: exitCode, args: args);
+}
+
+/// The [UsageEvent] for the migrate command.
+class MigrateUsageEvent extends UsageEvent {
+ MigrateUsageEvent(
+ {String label, @required int exitCode, @required List<String> args})
+ : super(migrateCmdName, migrateCmdName,
+ label: label, exitCode: exitCode, args: args);
+}
+
+/// The superclass for all dartdev events, see the [send] method to see what is
+/// sent to analytics.
+abstract class UsageEvent {
+ /// The category stores the name of this cli tool, 'dartdev'. This matches the
+ /// pattern from the flutter cli tool which always passes 'flutter' as the
+ /// category.
+ final String category;
+
+ /// The action is the command, and optionally the subcommand, joined with '/',
+ /// an example here is 'pub/get'. The usagePath getter in each of the
+ final String action;
+
+ /// The command name being executed here, 'analyze' and 'pub' are examples.
+ final String command;
+
+ /// Labels are not used yet used when reporting dartdev analytics, but the API
+ /// is included here for possible future use.
+ final String label;
+
+ /// The [String] list of arguments passed to dartdev, the list of args is not
+ /// passed back via analytics itself, but is used to compute other values such
+ /// as the [enabledExperiments] which are passed back as part of analytics.
+ final List<String> args;
+
+ /// The exit code returned from this invocation of dartdev.
+ final int exitCode;
+
+ /// A comma separated list of enabled experiments passed into the dartdev
+ /// command. If the command doesn't use the experiments, they are not reported
+ /// in the [UsageEvent].
+ final String enabledExperiments;
+
+ /// A comma separated list of flags on this commands
+ final String commandFlags;
+
+ UsageEvent(
+ this.command,
+ this.action, {
+ this.label,
+ List<String> specifiedExperiments,
+ @required this.exitCode,
+ @required this.args,
+ }) : category = _dartdev,
+ enabledExperiments = specifiedExperiments?.join(_flagSeparator),
+ commandFlags = ArgParserUtils.parseCommandFlags(command, args)
+ .join(_flagSeparator);
+
+ Future send(Analytics analytics) {
+ final Map<String, String> parameters =
+ _useCdKeys(<CustomDimensions, String>{
+ if (exitCode != null)
+ CustomDimensions.commandExitCode: exitCode.toString(),
+ if (enabledExperiments != null)
+ CustomDimensions.enabledExperiments: enabledExperiments,
+ if (commandFlags != null) CustomDimensions.commandFlags: commandFlags,
+ });
+ return analytics.sendEvent(
+ category,
+ action,
+ label: label,
+ parameters: parameters,
+ );
+ }
+}
diff --git a/pkg/dartdev/pubspec.yaml b/pkg/dartdev/pubspec.yaml
index be43698..ecc93eb 100644
--- a/pkg/dartdev/pubspec.yaml
+++ b/pkg/dartdev/pubspec.yaml
@@ -15,6 +15,8 @@
dart2native:
path: ../dart2native
dart_style: any
+ meta:
+ path: ../meta
nnbd_migration:
path: ../nnbd_migration
path: ^1.0.0
diff --git a/pkg/dartdev/test/analytics_test.dart b/pkg/dartdev/test/analytics_test.dart
index 3ce90de..31355df7 100644
--- a/pkg/dartdev/test/analytics_test.dart
+++ b/pkg/dartdev/test/analytics_test.dart
@@ -7,7 +7,6 @@
void main() {
group('DisabledAnalytics', disabledAnalyticsObject);
- group('utils', utils);
}
void disabledAnalyticsObject() {
@@ -19,21 +18,3 @@
expect(diabledAnalytics.firstRun, isFalse);
});
}
-
-void utils() {
- test('getCommandStr', () {
- var commands = <String>['help', 'foo', 'bar', 'baz'];
-
- // base cases
- expect(getCommandStr(['help'], commands), 'help');
- expect(getCommandStr(['bar', 'help'], commands), 'help');
- expect(getCommandStr(['help', 'bar'], commands), 'help');
- expect(getCommandStr(['bar', '-h'], commands), 'help');
- expect(getCommandStr(['bar', '--help'], commands), 'help');
-
- // non-trivial tests
- expect(getCommandStr(['foo'], commands), 'foo');
- expect(getCommandStr(['bar', 'baz'], commands), 'bar');
- expect(getCommandStr(['bazz'], commands), '<unknown>');
- });
-}
diff --git a/pkg/dartdev/test/core_test.dart b/pkg/dartdev/test/core_test.dart
index bc10cb9..0944f88 100644
--- a/pkg/dartdev/test/core_test.dart
+++ b/pkg/dartdev/test/core_test.dart
@@ -5,6 +5,13 @@
import 'dart:convert';
import 'dart:io';
+import 'package:dartdev/src/commands/analyze.dart';
+import 'package:dartdev/src/commands/compile.dart';
+import 'package:dartdev/src/commands/create.dart';
+import 'package:dartdev/src/commands/fix.dart';
+import 'package:dartdev/src/commands/pub.dart';
+import 'package:dartdev/src/commands/run.dart';
+import 'package:dartdev/src/commands/test.dart';
import 'package:dartdev/src/core.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
@@ -12,10 +19,82 @@
import 'utils.dart';
void main() {
+ group('DartdevCommand', _dartdevCommand);
group('PackageConfig', _packageConfig);
group('Project', _project);
}
+void _dartdevCommand() {
+ void _assertDartdevCommandProperties(
+ DartdevCommand command, String name, String usagePath,
+ [int subcommandCount = 0]) {
+ expect(command, isNotNull);
+ expect(command.name, name);
+ expect(command.description, isNotEmpty);
+ expect(command.project, isNotNull);
+ expect(command.argParser, isNotNull);
+ expect(command.usagePath, usagePath);
+ expect(command.subcommands.length, subcommandCount);
+ }
+
+ test('analyze', () {
+ _assertDartdevCommandProperties(AnalyzeCommand(), 'analyze', 'analyze');
+ });
+
+ test('compile', () {
+ _assertDartdevCommandProperties(CompileCommand(), 'compile', 'compile', 5);
+ });
+
+ test('compile/js', () {
+ _assertDartdevCommandProperties(
+ CompileCommand().subcommands['js'], 'js', 'compile/js');
+ });
+
+ test('compile/jit-snapshot', () {
+ _assertDartdevCommandProperties(
+ CompileCommand().subcommands['jit-snapshot'],
+ 'jit-snapshot',
+ 'compile/jit-snapshot');
+ });
+
+ test('compile/kernel', () {
+ _assertDartdevCommandProperties(
+ CompileCommand().subcommands['kernel'], 'kernel', 'compile/kernel');
+ });
+
+ test('compile/exe', () {
+ _assertDartdevCommandProperties(
+ CompileCommand().subcommands['exe'], 'exe', 'compile/exe');
+ });
+
+ test('compile/aot-snapshot', () {
+ _assertDartdevCommandProperties(
+ CompileCommand().subcommands['aot-snapshot'],
+ 'aot-snapshot',
+ 'compile/aot-snapshot');
+ });
+
+ test('create', () {
+ _assertDartdevCommandProperties(CreateCommand(), 'create', 'create');
+ });
+
+ test('fix', () {
+ _assertDartdevCommandProperties(FixCommand(), 'fix', 'fix');
+ });
+
+ test('pub', () {
+ _assertDartdevCommandProperties(PubCommand(), 'pub', 'pub');
+ });
+
+ test('run', () {
+ _assertDartdevCommandProperties(RunCommand(), 'run', 'run');
+ });
+
+ test('test', () {
+ _assertDartdevCommandProperties(TestCommand(), 'test', 'test');
+ });
+}
+
void _packageConfig() {
test('packages', () {
PackageConfig packageConfig = PackageConfig(jsonDecode(_packageData));
diff --git a/pkg/dartdev/test/events_test.dart b/pkg/dartdev/test/events_test.dart
new file mode 100644
index 0000000..c39e7c4
--- /dev/null
+++ b/pkg/dartdev/test/events_test.dart
@@ -0,0 +1,130 @@
+// Copyright (c) 2020, 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.
+
+import 'package:dartdev/dartdev.dart';
+import 'package:dartdev/src/events.dart';
+import 'package:test/test.dart';
+
+void main() {
+ group('ArgParserUtils', _argParserUtils);
+ group('event constant', _constants);
+}
+
+void _argParserUtils() {
+ test('getCommandStr help', () {
+ expect(ArgParserUtils.getCommandStr(['help']), 'help');
+ expect(ArgParserUtils.getCommandStr(['analyze', 'help']), 'help');
+ expect(ArgParserUtils.getCommandStr(['help', 'analyze']), 'help');
+ expect(ArgParserUtils.getCommandStr(['analyze', '-h']), 'help');
+ expect(ArgParserUtils.getCommandStr(['analyze', '--help']), 'help');
+ });
+
+ test('getCommandStr command', () {
+ expect(ArgParserUtils.getCommandStr(['analyze']), 'analyze');
+ expect(ArgParserUtils.getCommandStr(['analyze', 'foo']), 'analyze');
+ expect(ArgParserUtils.getCommandStr(['foo', 'bar']), '<unknown>');
+ expect(ArgParserUtils.getCommandStr([]), '<unknown>');
+ expect(ArgParserUtils.getCommandStr(['']), '<unknown>');
+ });
+
+ test('isHelp false', () {
+ expect(ArgParserUtils.isHelp(null), isFalse);
+ expect(ArgParserUtils.isHelp(''), isFalse);
+ expect(ArgParserUtils.isHelp(' '), isFalse);
+ expect(ArgParserUtils.isHelp('-help'), isFalse);
+ expect(ArgParserUtils.isHelp('--HELP'), isFalse);
+ expect(ArgParserUtils.isHelp('--Help'), isFalse);
+ expect(ArgParserUtils.isHelp('Help'), isFalse);
+ expect(ArgParserUtils.isHelp('HELP'), isFalse);
+ expect(ArgParserUtils.isHelp('foo'), isFalse);
+ });
+
+ test('isHelp true', () {
+ expect(ArgParserUtils.isHelp('help'), isTrue);
+ expect(ArgParserUtils.isHelp('--help'), isTrue);
+ expect(ArgParserUtils.isHelp('-h'), isTrue);
+ });
+
+ test('isFlag false', () {
+ expect(ArgParserUtils.isFlag(null), isFalse);
+ expect(ArgParserUtils.isFlag(''), isFalse);
+ expect(ArgParserUtils.isFlag(' '), isFalse);
+ expect(ArgParserUtils.isFlag('help'), isFalse);
+ expect(ArgParserUtils.isFlag('_flag'), isFalse);
+ });
+
+ test('isFlag true', () {
+ expect(ArgParserUtils.isFlag('-'), isTrue);
+ expect(ArgParserUtils.isFlag('--'), isTrue);
+ expect(ArgParserUtils.isFlag('--flag'), isTrue);
+ expect(ArgParserUtils.isFlag('--help'), isTrue);
+ expect(ArgParserUtils.isFlag('-h'), isTrue);
+ });
+
+ test('parseCommandFlags analyze', () {
+ expect(
+ ArgParserUtils.parseCommandFlags('analyze', [
+ '-g',
+ 'analyze',
+ ]),
+ <String>[]);
+ expect(
+ ArgParserUtils.parseCommandFlags('analyze', [
+ '-g',
+ 'analyze',
+ '--one',
+ '--two',
+ '--three=bar',
+ '-f',
+ '--fatal-infos',
+ '-h',
+ 'five'
+ ]),
+ <String>['--one', '--two', '--three', '-f', '--fatal-infos']);
+ });
+
+ test('parseCommandFlags trivial', () {
+ expect(ArgParserUtils.parseCommandFlags('foo', []), <String>[]);
+ expect(ArgParserUtils.parseCommandFlags('foo', ['']), <String>[]);
+ expect(
+ ArgParserUtils.parseCommandFlags('foo', ['bar', '-flag']), <String>[]);
+ expect(
+ ArgParserUtils.parseCommandFlags('foo', ['--global', 'bar', '-flag']),
+ <String>[]);
+ expect(ArgParserUtils.parseCommandFlags('foo', ['--global', 'fo', '-flag']),
+ <String>[]);
+ expect(
+ ArgParserUtils.parseCommandFlags('foo', ['--global', 'FOO', '-flag']),
+ <String>[]);
+ });
+
+ test('parseCommandFlags exclude help', () {
+ expect(
+ ArgParserUtils.parseCommandFlags(
+ 'analyze', ['-g', 'analyze', '--flag', '--help']),
+ <String>['--flag']);
+ expect(
+ ArgParserUtils.parseCommandFlags(
+ 'analyze', ['-g', 'analyze', '--flag', '-h']),
+ <String>['--flag']);
+ expect(
+ ArgParserUtils.parseCommandFlags(
+ 'analyze', ['-g', 'analyze', '--flag', 'help']),
+ <String>['--flag']);
+ });
+
+ test('sanitizeFlag', () {
+ expect(ArgParserUtils.sanitizeFlag(null), '');
+ expect(ArgParserUtils.sanitizeFlag(''), '');
+ expect(ArgParserUtils.sanitizeFlag('foo'), '');
+ expect(ArgParserUtils.sanitizeFlag('--foo'), '--foo');
+ expect(ArgParserUtils.sanitizeFlag('--foo=bar'), '--foo');
+ });
+}
+
+void _constants() {
+ test('allCommands', () {
+ expect(allCommands, DartdevRunner([]).commands.keys.toList());
+ });
+}
diff --git a/pkg/dartdev/test/test_all.dart b/pkg/dartdev/test/test_all.dart
index a3b6db4..ca092a4 100644
--- a/pkg/dartdev/test/test_all.dart
+++ b/pkg/dartdev/test/test_all.dart
@@ -17,6 +17,7 @@
import 'commands/run_test.dart' as run;
import 'commands/test_test.dart' as test;
import 'core_test.dart' as core;
+import 'events_test.dart' as events;
import 'experiments_test.dart' as experiments;
import 'sdk_test.dart' as sdk;
import 'utils_test.dart' as utils;
@@ -26,6 +27,7 @@
analytics.main();
analyze.main();
create.main();
+ events.main();
experiments.main();
fix.main();
flag.main();
diff --git a/pkg/dds/lib/dds.dart b/pkg/dds/lib/dds.dart
index aeb39a9..f35e4d3 100644
--- a/pkg/dds/lib/dds.dart
+++ b/pkg/dds/lib/dds.dart
@@ -114,7 +114,7 @@
/// Stop accepting requests after gracefully handling existing requests.
Future<void> shutdown();
- /// Set to `true` if this isntance of [DartDevelopmentService] requires an
+ /// Set to `true` if this instance of [DartDevelopmentService] requires an
/// authentication code to connect.
bool get authCodesEnabled;
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 96575f1..284c144 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -2558,7 +2558,9 @@
typeArgument.nullability == Nullability.legacy;
var nullability = nullable
? Nullability.nullable
- : legacy ? Nullability.legacy : Nullability.nonNullable;
+ : legacy
+ ? Nullability.legacy
+ : Nullability.nonNullable;
return _emitInterfaceType(
typeArgument.withDeclaredNullability(nullability));
} else if (typeArgument is NeverType) {
diff --git a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
index 7baad48..81776ac 100644
--- a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
+++ b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
@@ -191,7 +191,9 @@
Expression getInvocationReceiver(InvocationExpression node) =>
node is MethodInvocation
? node.receiver
- : node is DirectMethodInvocation ? node.receiver : null;
+ : node is DirectMethodInvocation
+ ? node.receiver
+ : null;
bool isInlineJS(Member e) =>
e is Procedure &&
diff --git a/pkg/dev_compiler/lib/src/kernel/type_table.dart b/pkg/dev_compiler/lib/src/kernel/type_table.dart
index 2d6b5cf..8421a66 100644
--- a/pkg/dev_compiler/lib/src/kernel/type_table.dart
+++ b/pkg/dev_compiler/lib/src/kernel/type_table.dart
@@ -74,7 +74,9 @@
String _typeString(DartType type, {bool flat = false}) {
var nullability = type.declaredNullability == Nullability.legacy
? 'L'
- : type.declaredNullability == Nullability.nullable ? 'N' : '';
+ : type.declaredNullability == Nullability.nullable
+ ? 'N'
+ : '';
assert(isKnownDartTypeImplementor(type));
if (type is InterfaceType) {
var name = '${type.classNode.name}$nullability';
diff --git a/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart b/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
index 18fa6ce..25474d0 100644
--- a/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
+++ b/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
@@ -19,21 +19,23 @@
bool get verbose => false;
class ModuleConfiguration {
- final String outputPath;
- final String moduleName;
+ final Uri root;
+ final String outputDir;
final String libraryUri;
+ final String moduleName;
final String jsFileName;
final String fullDillFileName;
ModuleConfiguration(
- {this.outputPath,
+ {this.root,
+ this.outputDir,
this.moduleName,
this.libraryUri,
this.jsFileName,
this.fullDillFileName});
- String get jsPath => p.join(outputPath, jsFileName);
- String get fullDillPath => p.join(outputPath, fullDillFileName);
+ Uri get jsPath => root.resolve('$outputDir/$jsFileName');
+ Uri get fullDillPath => root.resolve('$outputDir/$fullDillFileName');
}
class TestProjectConfiguration {
@@ -43,36 +45,40 @@
TestProjectConfiguration(this.rootDirectory);
ModuleConfiguration get mainModule => ModuleConfiguration(
- outputPath: outputPath,
+ root: root,
+ outputDir: outputDir,
moduleName: 'packages/_testPackage/main',
libraryUri: 'org-dartlang-app:/lib/main.dart',
jsFileName: 'main.js',
fullDillFileName: 'main.full.dill');
ModuleConfiguration get testModule => ModuleConfiguration(
- outputPath: outputPath,
+ root: root,
+ outputDir: outputDir,
moduleName: 'packages/_testPackage/test_library',
libraryUri: 'package:_testPackage/test_library.dart',
jsFileName: 'test_library.js',
fullDillFileName: 'test_library.full.dill');
ModuleConfiguration get testModule2 => ModuleConfiguration(
- outputPath: outputPath,
+ root: root,
+ outputDir: outputDir,
moduleName: 'packages/_testPackage/test_library2',
libraryUri: 'package:_testPackage/test_library2.dart',
jsFileName: 'test_library2.js',
fullDillFileName: 'test_library2.full.dill');
- String get root => rootDirectory.path;
- String get outputPath => p.join(root, outputDir);
- String get packagesPath => p.join(root, '.packages');
+ String get rootPath => rootDirectory.path;
+ Uri get root => rootDirectory.uri;
+ Uri get outputPath => root.resolve(outputDir);
+ Uri get packagesPath => root.resolve('.packages');
- String get sdkRoot => computePlatformBinariesLocation().path;
- String get sdkSummaryPath => p.join(sdkRoot, 'ddc_sdk.dill');
- String get librariesPath => p.join(sdkRoot, 'lib', 'libraries.json');
+ Uri get sdkRoot => computePlatformBinariesLocation();
+ Uri get sdkSummaryPath => sdkRoot.resolve('ddc_sdk.dill');
+ Uri get librariesPath => sdkRoot.resolve('lib/libraries.json');
void createTestProject() {
- var pubspec = rootDirectory.uri.resolve('pubspec.yaml');
+ var pubspec = root.resolve('pubspec.yaml');
File.fromUri(pubspec)
..createSync()
..writeAsStringSync('''
@@ -83,14 +89,14 @@
sdk: '>=2.8.0 <3.0.0'
''');
- var packages = rootDirectory.uri.resolve('.packages');
+ var packages = root.resolve('.packages');
File.fromUri(packages)
..createSync()
..writeAsStringSync('''
_testPackage:lib/
''');
- var main = rootDirectory.uri.resolve('lib/main.dart');
+ var main = root.resolve('lib/main.dart');
File.fromUri(main)
..createSync(recursive: true)
..writeAsStringSync('''
@@ -108,7 +114,7 @@
}
''');
- var testLibrary = rootDirectory.uri.resolve('lib/test_library.dart');
+ var testLibrary = root.resolve('lib/test_library.dart');
File.fromUri(testLibrary)
..createSync()
..writeAsStringSync('''
@@ -127,7 +133,7 @@
}
''');
- var testLibrary2 = rootDirectory.uri.resolve('lib/test_library2.dart');
+ var testLibrary2 = root.resolve('lib/test_library2.dart');
File.fromUri(testLibrary2)
..createSync()
..writeAsStringSync('''
@@ -163,15 +169,15 @@
inputs = [
{
- 'path': config.mainModule.fullDillPath,
+ 'path': config.mainModule.fullDillPath.path,
'moduleName': config.mainModule.moduleName
},
{
- 'path': config.testModule.fullDillPath,
+ 'path': config.testModule.fullDillPath.path,
'moduleName': config.testModule.moduleName
},
{
- 'path': config.testModule2.fullDillPath,
+ 'path': config.testModule2.fullDillPath.path,
'moduleName': config.testModule2.moduleName
},
];
@@ -188,12 +194,13 @@
requestController = StreamController<Map<String, dynamic>>();
responseController = StreamController<Map<String, dynamic>>();
worker = await ExpressionCompilerWorker.create(
- librariesSpecificationUri: Uri.file(config.librariesPath),
+ librariesSpecificationUri: config.librariesPath,
// We should be able to load everything from dill and not require
- // source parsing. Webdev and google3 integration currently rely on that.
- // Make the test fail on source reading by not providing a packages.
+ // source parsing. Webdev and google3 integration currently rely on
+ // that. Make the test fail on source reading by not providing a
+ // packages file.
packagesFile: null,
- sdkSummary: Uri.file(config.sdkSummaryPath),
+ sdkSummary: config.sdkSummaryPath,
fileSystem: fileSystem,
requestStream: requestController.stream,
sendResponse: responseController.add,
@@ -360,7 +367,7 @@
inputs = [
{
- 'path': config.mainModule.fullDillPath,
+ 'path': config.mainModule.fullDillPath.path,
'moduleName': config.mainModule.moduleName
},
];
@@ -377,9 +384,9 @@
requestController = StreamController<Map<String, dynamic>>();
responseController = StreamController<Map<String, dynamic>>();
worker = await ExpressionCompilerWorker.create(
- librariesSpecificationUri: Uri.file(config.librariesPath),
+ librariesSpecificationUri: config.librariesPath,
packagesFile: null,
- sdkSummary: Uri.file(config.sdkSummaryPath),
+ sdkSummary: config.sdkSummaryPath,
fileSystem: fileSystem,
requestStream: requestController.stream,
sendResponse: responseController.add,
@@ -505,7 +512,7 @@
var dartdevc =
p.join(p.dirname(dart), 'snapshots', 'dartdevc.dart.snapshot');
- Directory(config.outputPath)..createSync();
+ Directory.fromUri(config.outputPath)..createSync();
// generate test_library2.full.dill
var args = [
@@ -513,21 +520,21 @@
config.testModule2.libraryUri,
'--no-summarize',
'-o',
- config.testModule2.jsPath,
+ config.testModule2.jsPath.toFilePath(),
'--source-map',
'--experimental-emit-debug-metadata',
'--experimental-output-compiled-kernel',
'--dart-sdk-summary',
- config.sdkSummaryPath,
+ config.sdkSummaryPath.path,
'--multi-root',
- config.root,
+ '${config.root}',
'--multi-root-scheme',
'org-dartlang-app',
'--packages',
- config.packagesPath,
+ config.packagesPath.path,
];
- var exitCode = await runProcess(dart, args, config.root);
+ var exitCode = await runProcess(dart, args, config.rootPath);
if (exitCode != 0) {
return exitCode;
}
@@ -540,21 +547,21 @@
'--summary',
'${config.testModule2.fullDillPath}=${config.testModule2.moduleName}',
'-o',
- config.testModule.jsPath,
+ config.testModule.jsPath.toFilePath(),
'--source-map',
'--experimental-emit-debug-metadata',
'--experimental-output-compiled-kernel',
'--dart-sdk-summary',
- config.sdkSummaryPath,
+ config.sdkSummaryPath.path,
'--multi-root',
- config.root,
+ '${config.root}',
'--multi-root-scheme',
'org-dartlang-app',
'--packages',
- config.packagesPath,
+ config.packagesPath.path,
];
- exitCode = await runProcess(dart, args, config.root);
+ exitCode = await runProcess(dart, args, config.rootPath);
if (exitCode != 0) {
return exitCode;
}
@@ -569,21 +576,21 @@
'--summary',
'${config.testModule.fullDillPath}=${config.testModule.moduleName}',
'-o',
- config.mainModule.jsPath,
+ config.mainModule.jsPath.toFilePath(),
'--source-map',
'--experimental-emit-debug-metadata',
'--experimental-output-compiled-kernel',
'--dart-sdk-summary',
- config.sdkSummaryPath,
+ config.sdkSummaryPath.path,
'--multi-root',
- config.root,
+ '${config.root}',
'--multi-root-scheme',
'org-dartlang-app',
'--packages',
- config.packagesPath,
+ config.packagesPath.path,
];
- return await runProcess(dart, args, config.root);
+ return await runProcess(dart, args, config.rootPath);
}
}
@@ -605,9 +612,9 @@
'--target',
'ddc',
'--output',
- config.mainModule.fullDillPath,
+ config.mainModule.fullDillPath.path,
'--dart-sdk-summary',
- config.sdkSummaryPath,
+ config.sdkSummaryPath.path,
'--exclude-non-sources',
'--source',
config.mainModule.libraryUri,
@@ -616,7 +623,7 @@
'--source',
config.testModule2.libraryUri,
'--multi-root',
- config.root,
+ '${config.root}',
'--multi-root-scheme',
'org-dartlang-app',
'--packages-file',
@@ -624,7 +631,7 @@
'--verbose'
];
- return await runProcess(dart, args, config.root);
+ return await runProcess(dart, args, config.rootPath);
}
}
diff --git a/pkg/vm_service/CHANGELOG.md b/pkg/vm_service/CHANGELOG.md
index 466d85f..049e01d1 100644
--- a/pkg/vm_service/CHANGELOG.md
+++ b/pkg/vm_service/CHANGELOG.md
@@ -2,7 +2,7 @@
## 5.0.0
-- **breaking**: Update to version `4.0.0` of the spec.
+- **breaking**: Update to version `3.39.0` of the spec.
- Removes `ClientName` and `WebSocketTarget` objects
- Removes `getClientName`, `getWebSocketTarget`, `requirePermissionToResume`,
and `setClientName` RPCs.
diff --git a/pkg/vm_service/example/sample_isolates.dart b/pkg/vm_service/example/sample_isolates.dart
index 3dd216b..e57fd09 100644
--- a/pkg/vm_service/example/sample_isolates.dart
+++ b/pkg/vm_service/example/sample_isolates.dart
@@ -2,7 +2,6 @@
// 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.
-import 'dart:async';
import 'dart:isolate';
main(List<String> args) async {
diff --git a/pkg/vm_service/java/src/org/dartlang/vm/service/VmServiceBase.java b/pkg/vm_service/java/src/org/dartlang/vm/service/VmServiceBase.java
index c44b31d..207cdc5 100644
--- a/pkg/vm_service/java/src/org/dartlang/vm/service/VmServiceBase.java
+++ b/pkg/vm_service/java/src/org/dartlang/vm/service/VmServiceBase.java
@@ -132,21 +132,6 @@
@Override
public void received(Version version) {
- int major = version.getMajor();
- int minor = version.getMinor();
- if (major != VmService.versionMajor || minor != VmService.versionMinor) {
- if (major == 2 || major == 3) {
- Logging.getLogger().logInformation(
- "Difference in protocol version: client=" + VmService.versionMajor + "."
- + VmService.versionMinor + " vm=" + major + "." + minor);
- } else {
- String msg = "Incompatible protocol version: client=" + VmService.versionMajor + "."
- + VmService.versionMinor + " vm=" + major + "." + minor;
- Logging.getLogger().logError(msg);
- errMsg[0] = msg;
- }
- }
-
vmService.runtimeVersion = version;
latch.countDown();
diff --git a/pkg/vm_service/java/version.properties b/pkg/vm_service/java/version.properties
index db1ef8e5..e076127 100644
--- a/pkg/vm_service/java/version.properties
+++ b/pkg/vm_service/java/version.properties
@@ -1 +1 @@
-version=4.0
+version=3.39
diff --git a/pkg/vm_service/lib/src/dart_io_extensions.dart b/pkg/vm_service/lib/src/dart_io_extensions.dart
index ef89c64..4297e45 100644
--- a/pkg/vm_service/lib/src/dart_io_extensions.dart
+++ b/pkg/vm_service/lib/src/dart_io_extensions.dart
@@ -4,8 +4,6 @@
// TODO(bkonyi): autogenerate from service_extensions.md
-import 'dart:async';
-
import 'package:meta/meta.dart';
import 'vm_service.dart';
diff --git a/pkg/vm_service/lib/src/vm_service.dart b/pkg/vm_service/lib/src/vm_service.dart
index c518b25..4f63e01 100644
--- a/pkg/vm_service/lib/src/vm_service.dart
+++ b/pkg/vm_service/lib/src/vm_service.dart
@@ -28,7 +28,7 @@
HeapSnapshotObjectNoData,
HeapSnapshotObjectNullData;
-const String vmServiceVersion = '4.0.0';
+const String vmServiceVersion = '3.39.0';
/// @optional
const String optional = 'optional';
diff --git a/pkg/vm_service/pubspec.yaml b/pkg/vm_service/pubspec.yaml
index fff9595..66b2910 100644
--- a/pkg/vm_service/pubspec.yaml
+++ b/pkg/vm_service/pubspec.yaml
@@ -2,7 +2,7 @@
description: >-
A library to communicate with a service implementing the Dart VM
service protocol.
-version: 5.0.0
+version: 5.0.0+1
homepage: https://github.com/dart-lang/sdk/tree/master/pkg/vm_service
diff --git a/pkg/vm_service/test/async_generator_breakpoint_test.dart b/pkg/vm_service/test/async_generator_breakpoint_test.dart
index 3cf2655..e709594 100644
--- a/pkg/vm_service/test/async_generator_breakpoint_test.dart
+++ b/pkg/vm_service/test/async_generator_breakpoint_test.dart
@@ -2,7 +2,6 @@
// 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.
-import 'dart:async';
import 'package:test/test.dart';
import 'package:vm_service/vm_service.dart';
import 'common/test_helper.dart';
diff --git a/pkg/vm_service/test/async_scope_test.dart b/pkg/vm_service/test/async_scope_test.dart
index 80813b6..9573e69 100644
--- a/pkg/vm_service/test/async_scope_test.dart
+++ b/pkg/vm_service/test/async_scope_test.dart
@@ -2,15 +2,14 @@
// 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.
-import 'dart:async';
import 'dart:developer';
import 'package:vm_service/vm_service.dart';
import 'package:test/test.dart';
import 'common/service_test_common.dart';
import 'common/test_helper.dart';
-const int LINE_A = 20;
-const int LINE_B = 26;
+const int LINE_A = 19;
+const int LINE_B = 25;
foo() {}
diff --git a/pkg/vm_service/test/evaluate_with_scope_test.dart b/pkg/vm_service/test/evaluate_with_scope_test.dart
index 38588d8..8dfd4d4 100644
--- a/pkg/vm_service/test/evaluate_with_scope_test.dart
+++ b/pkg/vm_service/test/evaluate_with_scope_test.dart
@@ -2,8 +2,6 @@
// 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.
-import 'dart:async';
-
import 'package:vm_service/vm_service.dart';
import 'package:test/test.dart';
import 'common/test_helper.dart';
diff --git a/pkg/vm_service/test/get_allocation_profile_rpc_test.dart b/pkg/vm_service/test/get_allocation_profile_rpc_test.dart
index 0a35d093..c4540e5 100644
--- a/pkg/vm_service/test/get_allocation_profile_rpc_test.dart
+++ b/pkg/vm_service/test/get_allocation_profile_rpc_test.dart
@@ -2,7 +2,6 @@
// 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.
-import 'dart:async';
import 'package:vm_service/vm_service.dart';
import 'package:test/test.dart';
diff --git a/pkg/vm_service/test/get_cpu_samples_rpc_test.dart b/pkg/vm_service/test/get_cpu_samples_rpc_test.dart
index de49353..8b9b143 100644
--- a/pkg/vm_service/test/get_cpu_samples_rpc_test.dart
+++ b/pkg/vm_service/test/get_cpu_samples_rpc_test.dart
@@ -2,8 +2,6 @@
// 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.
-import 'dart:async';
-
import 'package:vm_service/vm_service.dart';
import 'package:test/test.dart';
diff --git a/pkg/vm_service/test/http_enable_timeline_logging_service_test.dart b/pkg/vm_service/test/http_enable_timeline_logging_service_test.dart
index 418b823..0b849c6 100644
--- a/pkg/vm_service/test/http_enable_timeline_logging_service_test.dart
+++ b/pkg/vm_service/test/http_enable_timeline_logging_service_test.dart
@@ -2,7 +2,6 @@
// 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.
-import 'dart:async';
import 'package:vm_service/vm_service.dart';
import 'package:vm_service/src/dart_io_extensions.dart';
import 'package:test/test.dart';
diff --git a/runtime/observatory/tests/service/get_version_rpc_test.dart b/runtime/observatory/tests/service/get_version_rpc_test.dart
index 7ee46a0..8e949ec 100644
--- a/runtime/observatory/tests/service/get_version_rpc_test.dart
+++ b/runtime/observatory/tests/service/get_version_rpc_test.dart
@@ -11,8 +11,8 @@
(VM vm) async {
var result = await vm.invokeRpcNoUpgrade('getVersion', {});
expect(result['type'], equals('Version'));
- expect(result['major'], equals(4));
- expect(result['minor'], equals(0));
+ expect(result['major'], equals(3));
+ expect(result['minor'], equals(39));
expect(result['_privateMajor'], equals(0));
expect(result['_privateMinor'], equals(0));
},
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index f33a41c..9c7eabc 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -2290,13 +2290,6 @@
return true;
}
-bool FlowGraphCompiler::ShouldUseTypeTestingStubFor(bool optimizing,
- const AbstractType& type) {
- return FLAG_precompiled_mode ||
- (optimizing &&
- (type.IsTypeParameter() || (type.IsType() && type.IsInstantiated())));
-}
-
FlowGraphCompiler::TypeTestStubKind
FlowGraphCompiler::GetTypeTestStubKindForTypeParameter(
const TypeParameter& type_param) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index 47e9530..9b1764e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -568,11 +568,6 @@
const String& dst_name,
LocationSummary* locs);
- // Returns true if we can use a type testing stub based assert
- // assignable code pattern for the given type.
- static bool ShouldUseTypeTestingStubFor(bool optimizing,
- const AbstractType& type);
-
void GenerateAssertAssignableViaTypeTestingStub(CompileType* receiver_type,
TokenPosition token_pos,
intptr_t deopt_id,
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index bfc9b81..465352b 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -703,67 +703,19 @@
ASSERT(!token_pos.IsClassifying());
ASSERT(CheckAssertAssignableTypeTestingABILocations(*locs));
- compiler::Label is_assignable_fast, is_assignable, runtime_call;
-
- // Generate inline type check, linking to runtime call if not assignable.
- SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
- static_assert(
- TypeTestABI::kFunctionTypeArgumentsReg <
- TypeTestABI::kInstantiatorTypeArgumentsReg,
- "Should be ordered to push and load arguments with one instruction");
- static RegList type_args = (1 << TypeTestABI::kFunctionTypeArgumentsReg) |
- (1 << TypeTestABI::kInstantiatorTypeArgumentsReg);
-
if (locs->in(1).IsConstant()) {
const auto& dst_type = AbstractType::Cast(locs->in(1).constant());
ASSERT(dst_type.IsFinalized());
if (dst_type.IsTopTypeForSubtyping()) return; // No code needed.
- if (ShouldUseTypeTestingStubFor(is_optimizing(), dst_type)) {
- GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
- deopt_id, dst_name, locs);
- return;
- }
-
- if (Instance::NullIsAssignableTo(dst_type)) {
- __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
- __ b(&is_assignable_fast, EQ);
- }
-
- __ PushList(type_args);
-
- test_cache = GenerateInlineInstanceof(token_pos, dst_type, &is_assignable,
- &runtime_call);
+ GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
+ deopt_id, dst_name, locs);
+ return;
} else {
// TODO(dartbug.com/40813): Handle setting up the non-constant case.
UNREACHABLE();
}
-
- __ Bind(&runtime_call);
- __ ldm(IA, SP, type_args);
- __ PushObject(Object::null_object()); // Make room for the result.
- __ Push(TypeTestABI::kInstanceReg); // Push the source object.
- // Push the type of the destination.
- if (locs->in(1).IsConstant()) {
- __ PushObject(locs->in(1).constant());
- } else {
- // TODO(dartbug.com/40813): Handle setting up the non-constant case.
- UNREACHABLE();
- }
- __ PushList(type_args);
- __ PushObject(dst_name); // Push the name of the destination.
- __ LoadUniqueObject(R0, test_cache);
- __ Push(R0);
- __ PushImmediate(Smi::RawValue(kTypeCheckFromInline));
- GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 7, locs);
- // Pop the parameters supplied to the runtime entry. The result of the
- // type check runtime call is the checked value.
- __ Drop(7);
- __ Pop(TypeTestABI::kInstanceReg);
- __ Bind(&is_assignable);
- __ PopList(type_args);
- __ Bind(&is_assignable_fast);
}
void FlowGraphCompiler::GenerateAssertAssignableViaTypeTestingStub(
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
index b235c33..bc6983e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -669,67 +669,19 @@
ASSERT(!TokenPosition(token_pos).IsClassifying());
ASSERT(CheckAssertAssignableTypeTestingABILocations(*locs));
- compiler::Label is_assignable_fast, is_assignable, runtime_call;
- // Generate inline type check, linking to runtime call if not assignable.
- SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
-
if (locs->in(1).IsConstant()) {
const auto& dst_type = AbstractType::Cast(locs->in(1).constant());
ASSERT(dst_type.IsFinalized());
if (dst_type.IsTopTypeForSubtyping()) return; // No code needed.
- if (ShouldUseTypeTestingStubFor(is_optimizing(), dst_type)) {
- GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
- deopt_id, dst_name, locs);
- return;
- }
-
- if (Instance::NullIsAssignableTo(dst_type)) {
- __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
- __ b(&is_assignable_fast, EQ);
- }
-
- __ PushPair(TypeTestABI::kFunctionTypeArgumentsReg,
- TypeTestABI::kInstantiatorTypeArgumentsReg);
-
- test_cache = GenerateInlineInstanceof(token_pos, dst_type, &is_assignable,
- &runtime_call);
+ GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
+ deopt_id, dst_name, locs);
+ return;
} else {
// TODO(dartbug.com/40813): Handle setting up the non-constant case.
UNREACHABLE();
}
-
- __ Bind(&runtime_call);
- __ ldp(TypeTestABI::kFunctionTypeArgumentsReg,
- TypeTestABI::kInstantiatorTypeArgumentsReg,
- compiler::Address(SP, 0 * kWordSize, compiler::Address::PairOffset));
- // Make room for the result and push the source object.
- __ PushPair(TypeTestABI::kInstanceReg, NULL_REG);
- // Push the destination type and the instantiator type arguments.
- if (locs->in(1).IsConstant()) {
- __ LoadObject(TMP, locs->in(1).constant());
- __ PushPair(TypeTestABI::kInstantiatorTypeArgumentsReg, TMP);
- } else {
- // TODO(dartbug.com/40813): Handle setting up the non-constant case.
- UNREACHABLE();
- }
- // Push the function type arguments and the name of the destination.
- __ LoadObject(TMP, dst_name);
- __ PushPair(TMP, TypeTestABI::kFunctionTypeArgumentsReg);
-
- __ LoadUniqueObject(R0, test_cache);
- __ LoadObject(TMP, Smi::ZoneHandle(zone(), Smi::New(kTypeCheckFromInline)));
- __ PushPair(TMP, R0);
- GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 7, locs);
- // Pop the parameters supplied to the runtime entry. The result of the
- // type check runtime call is the checked value.
- __ Drop(7);
- __ Pop(TypeTestABI::kInstanceReg);
- __ Bind(&is_assignable);
- __ PopPair(TypeTestABI::kFunctionTypeArgumentsReg,
- TypeTestABI::kInstantiatorTypeArgumentsReg);
- __ Bind(&is_assignable_fast);
}
void FlowGraphCompiler::GenerateAssertAssignableViaTypeTestingStub(
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 4b4e217..3f867c5 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -684,59 +684,19 @@
ASSERT(!token_pos.IsClassifying());
ASSERT(CheckAssertAssignableTypeTestingABILocations(*locs));
- compiler::Label is_assignable, runtime_call;
-
- // Generate inline type check, linking to runtime call if not assignable.
- SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
-
if (locs->in(1).IsConstant()) {
const auto& dst_type = AbstractType::Cast(locs->in(1).constant());
ASSERT(dst_type.IsFinalized());
if (dst_type.IsTopTypeForSubtyping()) return; // No code needed.
- if (ShouldUseTypeTestingStubFor(is_optimizing(), dst_type)) {
- GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
- deopt_id, dst_name, locs);
- return;
- }
-
- if (Instance::NullIsAssignableTo(dst_type)) {
- __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
- __ j(EQUAL, &is_assignable);
- }
-
- // The registers RAX, RCX, RDX are preserved across the call.
- test_cache = GenerateInlineInstanceof(token_pos, dst_type, &is_assignable,
- &runtime_call);
-
+ GenerateAssertAssignableViaTypeTestingStub(receiver_type, token_pos,
+ deopt_id, dst_name, locs);
+ return;
} else {
// TODO(dartbug.com/40813): Handle setting up the non-constant case.
UNREACHABLE();
}
-
- __ Bind(&runtime_call);
- __ PushObject(Object::null_object()); // Make room for the result.
- __ pushq(TypeTestABI::kInstanceReg); // Push the source object.
- // Push the destination type.
- if (locs->in(1).IsConstant()) {
- __ PushObject(locs->in(1).constant());
- } else {
- // TODO(dartbug.com/40813): Handle setting up the non-constant case.
- UNREACHABLE();
- }
- __ pushq(TypeTestABI::kInstantiatorTypeArgumentsReg);
- __ pushq(TypeTestABI::kFunctionTypeArgumentsReg);
- __ PushObject(dst_name); // Push the name of the destination.
- __ LoadUniqueObject(RAX, test_cache);
- __ pushq(RAX);
- __ PushImmediate(compiler::Immediate(Smi::RawValue(kTypeCheckFromInline)));
- GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 7, locs);
- // Pop the parameters supplied to the runtime entry. The result of the
- // type check runtime call is the checked value.
- __ Drop(7);
- __ popq(TypeTestABI::kInstanceReg);
- __ Bind(&is_assignable);
}
void FlowGraphCompiler::GenerateAssertAssignableViaTypeTestingStub(
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index df51c7d..8aec81f 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -759,15 +759,12 @@
auto const dst_type_loc =
LocationFixedRegisterOrConstant(dst_type(), TypeTestABI::kDstTypeReg);
- // When using a type testing stub, we want to prevent spilling of the
- // function/instantiator type argument vectors, since stub preserves them. So
- // we make this a `kNoCall` summary, even though most other registers can be
- // modified by the stub. To tell the register allocator about it, we reserve
- // all the other registers as temporary registers.
+ // We want to prevent spilling of the inputs (e.g. function/instantiator tav),
+ // since TTS preserves them. So we make this a `kNoCall` summary,
+ // even though most other registers can be modified by the stub. To tell the
+ // register allocator about it, we reserve all the other registers as
+ // temporary registers.
// TODO(http://dartbug.com/32788): Simplify this.
- const bool using_stub = dst_type_loc.IsConstant() &&
- FlowGraphCompiler::ShouldUseTypeTestingStubFor(
- opt, AbstractType::Cast(dst_type_loc.constant()));
const intptr_t kNonChangeableInputRegs =
(1 << TypeTestABI::kInstanceReg) |
@@ -789,14 +786,11 @@
<< kAbiFirstPreservedFpuReg) &
~(1 << FpuTMP);
- const intptr_t kNumTemps =
- using_stub ? (Utils::CountOneBits64(kCpuRegistersToPreserve) +
- Utils::CountOneBits64(kFpuRegistersToPreserve))
- : 0;
+ const intptr_t kNumTemps = (Utils::CountOneBits64(kCpuRegistersToPreserve) +
+ Utils::CountOneBits64(kFpuRegistersToPreserve));
LocationSummary* summary = new (zone) LocationSummary(
- zone, kNumInputs, kNumTemps,
- using_stub ? LocationSummary::kCallCalleeSafe : LocationSummary::kCall);
+ zone, kNumInputs, kNumTemps, LocationSummary::kCallCalleeSafe);
summary->set_in(0, Location::RegisterLocation(TypeTestABI::kInstanceReg));
summary->set_in(1, dst_type_loc);
summary->set_in(2, Location::RegisterLocation(
@@ -805,23 +799,21 @@
3, Location::RegisterLocation(TypeTestABI::kFunctionTypeArgumentsReg));
summary->set_out(0, Location::SameAsFirstInput());
- if (using_stub) {
- // Let's reserve all registers except for the input ones.
- intptr_t next_temp = 0;
- for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
- const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++,
- Location::RegisterLocation(static_cast<Register>(i)));
- }
+ // Let's reserve all registers except for the input ones.
+ intptr_t next_temp = 0;
+ for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
+ const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++,
+ Location::RegisterLocation(static_cast<Register>(i)));
}
+ }
- for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
- const bool should_preserve = ((1 << i) & kFpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++, Location::FpuRegisterLocation(
- static_cast<FpuRegister>(i)));
- }
+ for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
+ const bool should_preserve = ((1 << i) & kFpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++, Location::FpuRegisterLocation(
+ static_cast<FpuRegister>(i)));
}
}
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index c0ec0b2..563bbe7 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -658,15 +658,12 @@
auto const dst_type_loc =
LocationFixedRegisterOrConstant(dst_type(), TypeTestABI::kDstTypeReg);
- // When using a type testing stub, we want to prevent spilling of the
- // function/instantiator type argument vectors, since stub preserves them. So
- // we make this a `kNoCall` summary, even though most other registers can be
- // modified by the stub. To tell the register allocator about it, we reserve
- // all the other registers as temporary registers.
+ // We want to prevent spilling of the inputs (e.g. function/instantiator tav),
+ // since TTS preserves them. So we make this a `kNoCall` summary,
+ // even though most other registers can be modified by the stub. To tell the
+ // register allocator about it, we reserve all the other registers as
+ // temporary registers.
// TODO(http://dartbug.com/32788): Simplify this.
- const bool using_stub = dst_type_loc.IsConstant() &&
- FlowGraphCompiler::ShouldUseTypeTestingStubFor(
- opt, AbstractType::Cast(dst_type_loc.constant()));
const intptr_t kNonChangeableInputRegs =
(1 << TypeTestABI::kInstanceReg) |
@@ -686,14 +683,11 @@
const intptr_t kFpuRegistersToPreserve =
Utils::SignedNBitMask(kNumberOfFpuRegisters) & ~(1l << FpuTMP);
- const intptr_t kNumTemps =
- using_stub ? (Utils::CountOneBits64(kCpuRegistersToPreserve) +
- Utils::CountOneBits64(kFpuRegistersToPreserve))
- : 0;
+ const intptr_t kNumTemps = (Utils::CountOneBits64(kCpuRegistersToPreserve) +
+ Utils::CountOneBits64(kFpuRegistersToPreserve));
LocationSummary* summary = new (zone) LocationSummary(
- zone, kNumInputs, kNumTemps,
- using_stub ? LocationSummary::kCallCalleeSafe : LocationSummary::kCall);
+ zone, kNumInputs, kNumTemps, LocationSummary::kCallCalleeSafe);
summary->set_in(0, Location::RegisterLocation(TypeTestABI::kInstanceReg));
summary->set_in(1, dst_type_loc);
summary->set_in(2, Location::RegisterLocation(
@@ -702,23 +696,21 @@
3, Location::RegisterLocation(TypeTestABI::kFunctionTypeArgumentsReg));
summary->set_out(0, Location::SameAsFirstInput());
- if (using_stub) {
- // Let's reserve all registers except for the input ones.
- intptr_t next_temp = 0;
- for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
- const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++,
- Location::RegisterLocation(static_cast<Register>(i)));
- }
+ // Let's reserve all registers except for the input ones.
+ intptr_t next_temp = 0;
+ for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
+ const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++,
+ Location::RegisterLocation(static_cast<Register>(i)));
}
+ }
- for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
- const bool should_preserve = ((1l << i) & kFpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++, Location::FpuRegisterLocation(
- static_cast<FpuRegister>(i)));
- }
+ for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
+ const bool should_preserve = ((1l << i) & kFpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++, Location::FpuRegisterLocation(
+ static_cast<FpuRegister>(i)));
}
}
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index e21744e..70f492c 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -594,15 +594,12 @@
auto const dst_type_loc =
LocationFixedRegisterOrConstant(dst_type(), TypeTestABI::kDstTypeReg);
- // When using a type testing stub, we want to prevent spilling of the
- // function/instantiator type argument vectors, since stub preserves them. So
- // we make this a `kNoCall` summary, even though most other registers can be
- // modified by the stub. To tell the register allocator about it, we reserve
- // all the other registers as temporary registers.
+ // We want to prevent spilling of the inputs (e.g. function/instantiator tav),
+ // since TTS preserves them. So we make this a `kNoCall` summary,
+ // even though most other registers can be modified by the stub. To tell the
+ // register allocator about it, we reserve all the other registers as
+ // temporary registers.
// TODO(http://dartbug.com/32788): Simplify this.
- const bool using_stub = dst_type_loc.IsConstant() &&
- FlowGraphCompiler::ShouldUseTypeTestingStubFor(
- opt, AbstractType::Cast(dst_type_loc.constant()));
const intptr_t kNonChangeableInputRegs =
(1 << TypeTestABI::kInstanceReg) |
@@ -621,14 +618,11 @@
const intptr_t kFpuRegistersToPreserve =
CallingConventions::kVolatileXmmRegisters & ~(1 << FpuTMP);
- const intptr_t kNumTemps =
- using_stub ? (Utils::CountOneBits64(kCpuRegistersToPreserve) +
- Utils::CountOneBits64(kFpuRegistersToPreserve))
- : 0;
+ const intptr_t kNumTemps = (Utils::CountOneBits64(kCpuRegistersToPreserve) +
+ Utils::CountOneBits64(kFpuRegistersToPreserve));
LocationSummary* summary = new (zone) LocationSummary(
- zone, kNumInputs, kNumTemps,
- using_stub ? LocationSummary::kCallCalleeSafe : LocationSummary::kCall);
+ zone, kNumInputs, kNumTemps, LocationSummary::kCallCalleeSafe);
summary->set_in(0, Location::RegisterLocation(TypeTestABI::kInstanceReg));
summary->set_in(1, dst_type_loc);
summary->set_in(2, Location::RegisterLocation(
@@ -637,23 +631,21 @@
3, Location::RegisterLocation(TypeTestABI::kFunctionTypeArgumentsReg));
summary->set_out(0, Location::SameAsFirstInput());
- if (using_stub) {
- // Let's reserve all registers except for the input ones.
- intptr_t next_temp = 0;
- for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
- const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++,
- Location::RegisterLocation(static_cast<Register>(i)));
- }
+ // Let's reserve all registers except for the input ones.
+ intptr_t next_temp = 0;
+ for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
+ const bool should_preserve = ((1 << i) & kCpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++,
+ Location::RegisterLocation(static_cast<Register>(i)));
}
+ }
- for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
- const bool should_preserve = ((1 << i) & kFpuRegistersToPreserve) != 0;
- if (should_preserve) {
- summary->set_temp(next_temp++, Location::FpuRegisterLocation(
- static_cast<FpuRegister>(i)));
- }
+ for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
+ const bool should_preserve = ((1 << i) & kFpuRegistersToPreserve) != 0;
+ if (should_preserve) {
+ summary->set_temp(next_temp++, Location::FpuRegisterLocation(
+ static_cast<FpuRegister>(i)));
}
}
diff --git a/runtime/vm/compiler/relocation.cc b/runtime/vm/compiler/relocation.cc
index df7a9dd..d84a679 100644
--- a/runtime/vm/compiler/relocation.cc
+++ b/runtime/vm/compiler/relocation.cc
@@ -434,6 +434,7 @@
// live in the "vm-isolate" - such as `Type::dynamic_type()`).
if (destination_.InVMIsolateHeap()) {
auto object_store = thread_->isolate()->object_store();
+
if (destination_.raw() == StubCode::DefaultTypeTest().raw()) {
destination_ = object_store->default_tts_stub();
} else if (destination_.raw() ==
@@ -445,6 +446,12 @@
destination_ = object_store->unreachable_tts_stub();
} else if (destination_.raw() == StubCode::SlowTypeTest().raw()) {
destination_ = object_store->slow_tts_stub();
+ } else if (destination_.raw() ==
+ StubCode::NullableTypeParameterTypeTest().raw()) {
+ destination_ = object_store->nullable_type_parameter_tts_stub();
+ } else if (destination_.raw() ==
+ StubCode::TypeParameterTypeTest().raw()) {
+ destination_ = object_store->type_parameter_tts_stub();
} else {
UNREACHABLE();
}
diff --git a/runtime/vm/compiler/runtime_api.h b/runtime/vm/compiler/runtime_api.h
index 31fa267..4d70b77 100644
--- a/runtime/vm/compiler/runtime_api.h
+++ b/runtime/vm/compiler/runtime_api.h
@@ -883,6 +883,8 @@
public:
static word InstanceSize();
static word NextFieldOffset();
+ static word parameterized_class_id_offset();
+ static word index_offset();
};
class LibraryPrefix : public AllStatic {
diff --git a/runtime/vm/compiler/runtime_offsets_extracted.h b/runtime/vm/compiler/runtime_offsets_extracted.h
index d29d7b5..1c8cd1c2fd 100644
--- a/runtime/vm/compiler/runtime_offsets_extracted.h
+++ b/runtime/vm/compiler/runtime_offsets_extracted.h
@@ -379,6 +379,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 32;
static constexpr dart::compiler::target::word Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 36;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -887,6 +890,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 60;
static constexpr dart::compiler::target::word Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 64;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 16;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -1391,6 +1397,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 32;
static constexpr dart::compiler::target::word Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 36;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -1896,6 +1905,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 60;
static constexpr dart::compiler::target::word Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 64;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 16;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -2400,6 +2412,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 32;
static constexpr dart::compiler::target::word Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 36;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -2902,6 +2917,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 60;
static constexpr dart::compiler::target::word Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 64;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 16;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -3400,6 +3418,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 32;
static constexpr dart::compiler::target::word Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 36;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -3899,6 +3920,9 @@
static constexpr dart::compiler::target::word Type_type_state_offset = 60;
static constexpr dart::compiler::target::word Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word TypeParameter_index_offset = 64;
+static constexpr dart::compiler::target::word
TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word TypeArguments_length_offset = 16;
static constexpr dart::compiler::target::word TypeArguments_nullability_offset =
@@ -4434,6 +4458,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 32;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 36;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
8;
@@ -4992,6 +5020,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 60;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 64;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
16;
@@ -5555,6 +5587,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 60;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 64;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
16;
@@ -6112,6 +6148,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 32;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 33;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 28;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 36;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 4;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
8;
@@ -6663,6 +6703,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 60;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 64;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
16;
@@ -7219,6 +7263,10 @@
static constexpr dart::compiler::target::word AOT_Type_type_state_offset = 60;
static constexpr dart::compiler::target::word AOT_Type_nullability_offset = 61;
static constexpr dart::compiler::target::word
+ AOT_TypeParameter_parameterized_class_id_offset = 56;
+static constexpr dart::compiler::target::word AOT_TypeParameter_index_offset =
+ 64;
+static constexpr dart::compiler::target::word
AOT_TypeArguments_instantiations_offset = 8;
static constexpr dart::compiler::target::word AOT_TypeArguments_length_offset =
16;
diff --git a/runtime/vm/compiler/runtime_offsets_list.h b/runtime/vm/compiler/runtime_offsets_list.h
index 10cfdcd..6f1dcb6 100644
--- a/runtime/vm/compiler/runtime_offsets_list.h
+++ b/runtime/vm/compiler/runtime_offsets_list.h
@@ -249,6 +249,8 @@
FIELD(Type, type_class_id_offset) \
FIELD(Type, type_state_offset) \
FIELD(Type, nullability_offset) \
+ FIELD(TypeParameter, parameterized_class_id_offset) \
+ FIELD(TypeParameter, index_offset) \
FIELD(TypeArguments, instantiations_offset) \
FIELD(TypeArguments, length_offset) \
FIELD(TypeArguments, nullability_offset) \
diff --git a/runtime/vm/compiler/stub_code_compiler_arm.cc b/runtime/vm/compiler/stub_code_compiler_arm.cc
index 38ac210..1669dc6 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm.cc
@@ -3223,6 +3223,59 @@
__ Ret();
}
+static void BuildTypeParameterTypeTestStub(Assembler* assembler,
+ bool allow_null) {
+ Label done;
+
+ if (allow_null) {
+ __ CompareObject(TypeTestABI::kInstanceReg, NullObject());
+ __ BranchIf(EQUAL, &done);
+ }
+
+ Label function_type_param;
+ __ ldrh(TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kDstTypeReg,
+ TypeParameter::parameterized_class_id_offset()));
+ __ cmp(TypeTestABI::kScratchReg, Operand(kFunctionCid));
+ __ BranchIf(EQUAL, &function_type_param);
+
+ auto handle_case = [&](Register tav) {
+ __ CompareObject(tav, NullObject());
+ __ BranchIf(EQUAL, &done);
+ __ ldrh(
+ TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kDstTypeReg, TypeParameter::index_offset()));
+ __ add(TypeTestABI::kScratchReg, tav,
+ Operand(TypeTestABI::kScratchReg, LSL, 8));
+ __ ldr(TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kScratchReg,
+ target::TypeArguments::InstanceSize()));
+ __ Branch(FieldAddress(TypeTestABI::kScratchReg,
+ AbstractType::type_test_stub_entry_point_offset()));
+ };
+
+ // Class type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ handle_case(TypeTestABI::kInstantiatorTypeArgumentsReg);
+
+ // Function type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ __ Bind(&function_type_param);
+ handle_case(TypeTestABI::kFunctionTypeArgumentsReg);
+
+ __ Bind(&done);
+ __ Ret();
+}
+
+void StubCodeCompiler::GenerateNullableTypeParameterTypeTestStub(
+ Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/true);
+}
+
+void StubCodeCompiler::GenerateTypeParameterTypeTestStub(Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/false);
+}
+
void StubCodeCompiler::GenerateSlowTypeTestStub(Assembler* assembler) {
Label done, call_runtime;
diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc
index afc9b10..6ff81a8 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc
@@ -3391,6 +3391,63 @@
__ Ret();
}
+static void BuildTypeParameterTypeTestStub(Assembler* assembler,
+ bool allow_null) {
+ Label done;
+
+ if (allow_null) {
+ __ CompareObject(TypeTestABI::kInstanceReg, NullObject());
+ __ BranchIf(EQUAL, &done);
+ }
+
+ Label function_type_param;
+ __ ldr(TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kDstTypeReg,
+ TypeParameter::parameterized_class_id_offset()),
+ kUnsignedHalfword);
+ __ cmp(TypeTestABI::kScratchReg, Operand(kFunctionCid));
+ __ BranchIf(EQUAL, &function_type_param);
+
+ auto handle_case = [&](Register tav) {
+ __ CompareObject(tav, NullObject());
+ __ BranchIf(EQUAL, &done);
+ __ ldr(
+ TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kDstTypeReg, TypeParameter::index_offset()),
+ kUnsignedHalfword);
+ __ add(TypeTestABI::kScratchReg, tav,
+ Operand(TypeTestABI::kScratchReg, LSL, 8));
+ __ ldr(TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kScratchReg,
+ target::TypeArguments::InstanceSize()));
+ __ ldr(TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kScratchReg,
+ AbstractType::type_test_stub_entry_point_offset()));
+ __ br(TypeTestABI::kScratchReg);
+ };
+
+ // Class type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ handle_case(TypeTestABI::kInstantiatorTypeArgumentsReg);
+
+ // Function type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ __ Bind(&function_type_param);
+ handle_case(TypeTestABI::kFunctionTypeArgumentsReg);
+
+ __ Bind(&done);
+ __ Ret();
+}
+
+void StubCodeCompiler::GenerateNullableTypeParameterTypeTestStub(
+ Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/true);
+}
+
+void StubCodeCompiler::GenerateTypeParameterTypeTestStub(Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/false);
+}
+
void StubCodeCompiler::GenerateSlowTypeTestStub(Assembler* assembler) {
Label done, call_runtime;
diff --git a/runtime/vm/compiler/stub_code_compiler_ia32.cc b/runtime/vm/compiler/stub_code_compiler_ia32.cc
index 96bf0ff..9ce50a1 100644
--- a/runtime/vm/compiler/stub_code_compiler_ia32.cc
+++ b/runtime/vm/compiler/stub_code_compiler_ia32.cc
@@ -2630,6 +2630,17 @@
__ Breakpoint();
}
+void StubCodeCompiler::GenerateNullableTypeParameterTypeTestStub(
+ Assembler* assembler) {
+ // Not implemented on ia32.
+ __ Breakpoint();
+}
+
+void StubCodeCompiler::GenerateTypeParameterTypeTestStub(Assembler* assembler) {
+ // Not implemented on ia32.
+ __ Breakpoint();
+}
+
void StubCodeCompiler::GenerateSlowTypeTestStub(Assembler* assembler) {
// Not implemented on ia32.
__ Breakpoint();
diff --git a/runtime/vm/compiler/stub_code_compiler_x64.cc b/runtime/vm/compiler/stub_code_compiler_x64.cc
index e6566c3..e7011d0 100644
--- a/runtime/vm/compiler/stub_code_compiler_x64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_x64.cc
@@ -3346,6 +3346,56 @@
__ Ret();
}
+static void BuildTypeParameterTypeTestStub(Assembler* assembler,
+ bool allow_null) {
+ Label done;
+
+ if (allow_null) {
+ __ CompareObject(TypeTestABI::kInstanceReg, NullObject());
+ __ BranchIf(EQUAL, &done);
+ }
+
+ Label function_type_param;
+ __ cmpw(FieldAddress(TypeTestABI::kDstTypeReg,
+ TypeParameter::parameterized_class_id_offset()),
+ Immediate(kFunctionCid));
+ __ BranchIf(EQUAL, &function_type_param);
+
+ auto handle_case = [&](Register tav) {
+ __ CompareObject(tav, NullObject());
+ __ BranchIf(EQUAL, &done);
+ __ movzxw(
+ TypeTestABI::kScratchReg,
+ FieldAddress(TypeTestABI::kDstTypeReg, TypeParameter::index_offset()));
+ __ movq(TypeTestABI::kScratchReg,
+ FieldAddress(tav, TypeTestABI::kScratchReg, TIMES_8,
+ target::TypeArguments::InstanceSize()));
+ __ jmp(FieldAddress(TypeTestABI::kScratchReg,
+ AbstractType::type_test_stub_entry_point_offset()));
+ };
+
+ // Class type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ handle_case(TypeTestABI::kInstantiatorTypeArgumentsReg);
+
+ // Function type parameter: If dynamic we're done, otherwise dereference type
+ // parameter and tail call.
+ __ Bind(&function_type_param);
+ handle_case(TypeTestABI::kFunctionTypeArgumentsReg);
+
+ __ Bind(&done);
+ __ Ret();
+}
+
+void StubCodeCompiler::GenerateNullableTypeParameterTypeTestStub(
+ Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/true);
+}
+
+void StubCodeCompiler::GenerateTypeParameterTypeTestStub(Assembler* assembler) {
+ BuildTypeParameterTypeTestStub(assembler, /*allow_null=*/false);
+}
+
void StubCodeCompiler::GenerateSlowTypeTestStub(Assembler* assembler) {
Label done, call_runtime;
diff --git a/runtime/vm/constants_arm.h b/runtime/vm/constants_arm.h
index ea46f78a..2c62815 100644
--- a/runtime/vm/constants_arm.h
+++ b/runtime/vm/constants_arm.h
@@ -326,11 +326,12 @@
static const Register kInstantiatorTypeArgumentsReg = R2;
static const Register kFunctionTypeArgumentsReg = R1;
static const Register kSubtypeTestCacheReg = R3;
+ static const Register kScratchReg = R4;
static const intptr_t kAbiRegisters =
(1 << kInstanceReg) | (1 << kDstTypeReg) |
(1 << kInstantiatorTypeArgumentsReg) | (1 << kFunctionTypeArgumentsReg) |
- (1 << kSubtypeTestCacheReg);
+ (1 << kSubtypeTestCacheReg) | (1 << kScratchReg);
// For call to InstanceOfStub.
static const Register kResultReg = R0;
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index 2ce6ac37..1c71baa 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -158,11 +158,12 @@
static const Register kInstantiatorTypeArgumentsReg = R2;
static const Register kFunctionTypeArgumentsReg = R1;
static const Register kSubtypeTestCacheReg = R3;
+ static const Register kScratchReg = R4;
static const intptr_t kAbiRegisters =
(1 << kInstanceReg) | (1 << kDstTypeReg) |
(1 << kInstantiatorTypeArgumentsReg) | (1 << kFunctionTypeArgumentsReg) |
- (1 << kSubtypeTestCacheReg);
+ (1 << kSubtypeTestCacheReg) | (1 << kScratchReg);
// For call to InstanceOfStub.
static const Register kResultReg = R0;
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index d696eac..218823e 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -148,11 +148,12 @@
static const Register kInstantiatorTypeArgumentsReg = RDX;
static const Register kFunctionTypeArgumentsReg = RCX;
static const Register kSubtypeTestCacheReg = R9;
+ static const Register kScratchReg = RSI;
static const intptr_t kAbiRegisters =
(1 << kInstanceReg) | (1 << kDstTypeReg) |
(1 << kInstantiatorTypeArgumentsReg) | (1 << kFunctionTypeArgumentsReg) |
- (1 << kSubtypeTestCacheReg);
+ (1 << kSubtypeTestCacheReg) | (1 << kScratchReg);
// For call to InstanceOfStub.
static const Register kResultReg = RAX;
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index f399b23..46144d1b 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -8387,6 +8387,14 @@
bool IsFunctionTypeParameter() const {
return parameterized_function() != Function::null();
}
+
+ static intptr_t parameterized_class_id_offset() {
+ return OFFSET_OF(TypeParameterLayout, parameterized_class_id_);
+ }
+ static intptr_t index_offset() {
+ return OFFSET_OF(TypeParameterLayout, index_);
+ }
+
StringPtr name() const { return raw_ptr()->name_; }
intptr_t index() const { return raw_ptr()->index_; }
void set_index(intptr_t value) const;
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index 1314622..f8046bd 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -212,6 +212,8 @@
RW(Code, default_tts_stub) \
RW(Code, default_nullable_tts_stub) \
RW(Code, top_type_tts_stub) \
+ RW(Code, nullable_type_parameter_tts_stub) \
+ RW(Code, type_parameter_tts_stub) \
RW(Code, unreachable_tts_stub) \
RW(Code, slow_tts_stub) \
RW(Array, dispatch_table_code_entries) \
@@ -251,6 +253,8 @@
DO(default_tts_stub, DefaultTypeTest) \
DO(default_nullable_tts_stub, DefaultNullableTypeTest) \
DO(top_type_tts_stub, TopTypeTypeTest) \
+ DO(nullable_type_parameter_tts_stub, NullableTypeParameterTypeTest) \
+ DO(type_parameter_tts_stub, TypeParameterTypeTest) \
DO(unreachable_tts_stub, UnreachableTypeTest) \
DO(slow_tts_stub, SlowTypeTest) \
DO(write_barrier_wrappers_stub, WriteBarrierWrappers) \
diff --git a/runtime/vm/service.h b/runtime/vm/service.h
index b4f7acd..a3cf970 100644
--- a/runtime/vm/service.h
+++ b/runtime/vm/service.h
@@ -14,8 +14,8 @@
namespace dart {
-#define SERVICE_PROTOCOL_MAJOR_VERSION 4
-#define SERVICE_PROTOCOL_MINOR_VERSION 0
+#define SERVICE_PROTOCOL_MAJOR_VERSION 3
+#define SERVICE_PROTOCOL_MINOR_VERSION 39
class Array;
class EmbedderServiceHandler;
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index 5eeb755..69dde47 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 4.0
+# Dart VM Service Protocol 3.39
> Please post feedback to the [observatory-discuss group][discuss-list]
-This document describes of _version 4.0_ of the Dart VM Service Protocol. This
+This document describes of _version 3.39_ of the Dart VM Service Protocol. This
protocol is used to communicate with a running Dart Virtual Machine.
To use the Service Protocol, start the VM with the *--observe* flag.
@@ -3834,6 +3834,6 @@
3.36 | Added `getProcessMemoryUsage` RPC and `ProcessMemoryUsage` and `ProcessMemoryItem` objects.
3.37 | Added `getWebSocketTarget` RPC and `WebSocketTarget` object.
3.38 | Added `isSystemIsolate` property to `@Isolate` and `Isolate`, `isSystemIsolateGroup` property to `@IsolateGroup` and `IsolateGroup`, and properties `systemIsolates` and `systemIsolateGroups` to `VM`.
-4.0 | Removed the following deprecated RPCs and objects: `getClientName`, `getWebSocketTarget`, `setClientName`, `requireResumeApproval`, `ClientName`, and `WebSocketTarget`.
+3.39 | Removed the following deprecated RPCs and objects: `getClientName`, `getWebSocketTarget`, `setClientName`, `requireResumeApproval`, `ClientName`, and `WebSocketTarget`.
[discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/runtime/vm/stub_code_list.h b/runtime/vm/stub_code_list.h
index f759ea8..e38740c 100644
--- a/runtime/vm/stub_code_list.h
+++ b/runtime/vm/stub_code_list.h
@@ -70,6 +70,8 @@
V(DefaultNullableTypeTest) \
V(TopTypeTypeTest) \
V(UnreachableTypeTest) \
+ V(TypeParameterTypeTest) \
+ V(NullableTypeParameterTypeTest) \
V(SlowTypeTest) \
V(LazySpecializeTypeTest) \
V(LazySpecializeNullableTypeTest) \
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index fe40775..8f5f57c 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -91,10 +91,11 @@
CodePtr TypeTestingStubGenerator::DefaultCodeForType(
const AbstractType& type,
bool lazy_specialize /* = true */) {
+ auto isolate = Isolate::Current();
+
if (type.IsTypeRef()) {
- return Isolate::Current()->null_safety()
- ? StubCode::DefaultTypeTest().raw()
- : StubCode::DefaultNullableTypeTest().raw();
+ return isolate->null_safety() ? StubCode::DefaultTypeTest().raw()
+ : StubCode::DefaultNullableTypeTest().raw();
}
// During bootstrapping we have no access to stubs yet, so we'll just return
@@ -109,8 +110,16 @@
if (type.IsTopTypeForSubtyping()) {
return StubCode::TopTypeTypeTest().raw();
}
+ if (type.IsTypeParameter()) {
+ const bool nullable = Instance::NullIsAssignableTo(type);
+ if (nullable) {
+ return StubCode::NullableTypeParameterTypeTest().raw();
+ } else {
+ return StubCode::TypeParameterTypeTest().raw();
+ }
+ }
- if (type.IsType() || type.IsTypeParameter()) {
+ if (type.IsType()) {
const bool should_specialize = !FLAG_precompiled_mode && lazy_specialize;
const bool nullable = Instance::NullIsAssignableTo(type);
if (should_specialize) {
@@ -144,7 +153,7 @@
#if !defined(TARGET_ARCH_IA32)
ASSERT(StubCode::HasBeenInitialized());
- if (type.IsTypeRef()) {
+ if (type.IsTypeRef() || type.IsTypeParameter()) {
return TypeTestingStubGenerator::DefaultCodeForType(
type, /*lazy_specialize=*/false);
}
diff --git a/runtime/vm/type_testing_stubs_test.cc b/runtime/vm/type_testing_stubs_test.cc
index f6afdad..0a218cb 100644
--- a/runtime/vm/type_testing_stubs_test.cc
+++ b/runtime/vm/type_testing_stubs_test.cc
@@ -75,8 +75,14 @@
arguments.SetAt(5, dst_type);
// Ensure we have a) uninitialized TTS b) no/empty SubtypeTestCache.
- dst_type.SetTypeTestingStub(StubCode::LazySpecializeTypeTest());
- EXPECT(dst_type.type_test_stub() == StubCode::LazySpecializeTypeTest().raw());
+ auto& instantiated_dst_type = AbstractType::Handle(dst_type.raw());
+ if (dst_type.IsTypeParameter()) {
+ instantiated_dst_type = TypeParameter::Cast(dst_type).GetFromTypeArguments(
+ instantiator_tav, function_tav);
+ }
+ instantiated_dst_type.SetTypeTestingStub(StubCode::LazySpecializeTypeTest());
+ EXPECT(instantiated_dst_type.type_test_stub() ==
+ StubCode::LazySpecializeTypeTest().raw());
EXPECT(pool.ObjectAt(kSubtypeTestCacheIndex) == Object::null());
auto& result = Object::Handle();
@@ -92,7 +98,7 @@
result = DartEntry::InvokeCode(invoke_tts, arguments_descriptor, arguments,
thread);
stc ^= pool.ObjectAt(kSubtypeTestCacheIndex);
- tts = dst_type.type_test_stub();
+ tts = instantiated_dst_type.type_test_stub();
if (!result.IsError()) {
EXPECT(tts.raw() != StubCode::LazySpecializeTypeTest().raw());
}
@@ -102,7 +108,7 @@
result2 = DartEntry::InvokeCode(invoke_tts, arguments_descriptor, arguments,
thread);
stc2 ^= pool.ObjectAt(kSubtypeTestCacheIndex);
- tts2 = dst_type.type_test_stub();
+ tts2 = instantiated_dst_type.type_test_stub();
abi_regs_modified ^= abi_regs_modified_box.At(0);
rest_regs_modified ^= rest_regs_modified_box.At(0);
EXPECT(result2.IsError() || !abi_regs_modified.IsNull());
@@ -114,18 +120,13 @@
// SubtypeTestCache
// (This is to simulate AOT where we don't use lazy specialization but
// precompile the TTS)
- auto& dst_type_to_specialize = AbstractType::Handle(dst_type.raw());
- if (dst_type_to_specialize.IsTypeParameter()) {
- dst_type_to_specialize = TypeParameter::Cast(dst_type).GetFromTypeArguments(
- instantiator_tav, function_tav);
- }
- TypeTestingStubGenerator::SpecializeStubFor(thread, dst_type_to_specialize);
- tts = dst_type.type_test_stub();
+ TypeTestingStubGenerator::SpecializeStubFor(thread, instantiated_dst_type);
+ tts = instantiated_dst_type.type_test_stub();
result2 = DartEntry::InvokeCode(invoke_tts, arguments_descriptor, arguments,
thread);
stc2 ^= pool.ObjectAt(kSubtypeTestCacheIndex);
- tts2 = dst_type.type_test_stub();
+ tts2 = instantiated_dst_type.type_test_stub();
abi_regs_modified ^= abi_regs_modified_box.At(0);
rest_regs_modified ^= rest_regs_modified_box.At(0);
EXPECT(result2.IsError() || !abi_regs_modified.IsNull());
@@ -664,6 +665,50 @@
ExpectFailedViaTTS);
}
+ISOLATE_UNIT_TEST_CASE(TTS_TypeParameter) {
+ const char* kScript =
+ R"(
+ class A<T> {
+ T test(dynamic x) => x as T;
+ }
+ H genericFun<H>(dynamic x) => x as H;
+
+ createAInt() => A<int>();
+ createAString() => A<String>();
+ )";
+
+ const auto& root_library = Library::Handle(LoadTestScript(kScript));
+ const auto& class_a = Class::Handle(GetClass(root_library, "A"));
+ const auto& fun_generic =
+ Function::Handle(GetFunction(root_library, "genericFun"));
+
+ const auto& dst_type_t =
+ TypeParameter::Handle(GetClassTypeParameter(class_a, "T"));
+ const auto& dst_type_h =
+ TypeParameter::Handle(GetFunctionTypeParameter(fun_generic, "H"));
+
+ const auto& aint = Object::Handle(Invoke(root_library, "createAInt"));
+ const auto& astring = Object::Handle(Invoke(root_library, "createAString"));
+
+ const auto& int_tav =
+ TypeArguments::Handle(Instance::Cast(aint).GetTypeArguments());
+ const auto& string_tav =
+ TypeArguments::Handle(Instance::Cast(astring).GetTypeArguments());
+
+ const auto& int_instance = Integer::Handle(Integer::New(1));
+ const auto& string_instance = String::Handle(String::New("foo"));
+
+ RunTTSTest(int_instance, dst_type_t, int_tav, string_tav,
+ ExpectLazilyHandledViaTTS, ExpectHandledViaTTS);
+ RunTTSTest(string_instance, dst_type_t, int_tav, string_tav,
+ ExpectLazilyFailedViaTTS, ExpectFailedViaTTS);
+
+ RunTTSTest(string_instance, dst_type_h, int_tav, string_tav,
+ ExpectLazilyHandledViaTTS, ExpectHandledViaTTS);
+ RunTTSTest(int_instance, dst_type_h, int_tav, string_tav,
+ ExpectLazilyFailedViaTTS, ExpectFailedViaTTS);
+}
+
} // namespace dart
#endif // defined(TARGET_ARCH_ARM64) || defined(TARGET_ARCH_ARM) || \
diff --git a/sdk/lib/_http/http.dart b/sdk/lib/_http/http.dart
index 6e80086..151dae4 100644
--- a/sdk/lib/_http/http.dart
+++ b/sdk/lib/_http/http.dart
@@ -868,7 +868,8 @@
}
/**
- * A MIME/IANA media type used as the value of the [contentTypeHeader] header.
+ * A MIME/IANA media type used as the value of the
+ * [HttpHeaders.contentTypeHeader] header.
*
* A [ContentType] is immutable.
*/
diff --git a/sdk/lib/convert/json.dart b/sdk/lib/convert/json.dart
index 6d897a0..e55bc2a 100644
--- a/sdk/lib/convert/json.dart
+++ b/sdk/lib/convert/json.dart
@@ -64,7 +64,7 @@
/// a local variable shadows the [json] constant.
const JsonCodec json = JsonCodec();
-/// Converts [value] to a JSON string.
+/// Converts [object] to a JSON string.
///
/// If value contains objects that are not directly encodable to a JSON
/// string (a value that is not a number, boolean, string, null, list or a map
diff --git a/sdk/lib/core/map.dart b/sdk/lib/core/map.dart
index a92d08d..cbb1608 100644
--- a/sdk/lib/core/map.dart
+++ b/sdk/lib/core/map.dart
@@ -83,7 +83,7 @@
* Creates an identity map with the default implementation, [LinkedHashMap].
*
* An identity map uses [identical] for equality and [identityHashCode]
- * for hash codes of keys instead of the intrinsic [Object.operator==] and
+ * for hash codes of keys instead of the intrinsic [Object.==] and
* [Object.hashCode] of the keys.
*
* The returned map allows `null` as a key.
diff --git a/sdk/lib/core/regexp.dart b/sdk/lib/core/regexp.dart
index b75882d..ca5309f 100644
--- a/sdk/lib/core/regexp.dart
+++ b/sdk/lib/core/regexp.dart
@@ -152,7 +152,7 @@
* character is a line terminator. When true, then the "." character will
* match any single character including line terminators.
*
- * This feature is distinct from [isMultiline], as they affect the behavior
+ * This feature is distinct from [isMultiLine], as they affect the behavior
* of different pattern characters, and so they can be used together or
* separately.
*/
diff --git a/sdk/lib/io/socket.dart b/sdk/lib/io/socket.dart
index b5e814f..d2a0feb 100644
--- a/sdk/lib/io/socket.dart
+++ b/sdk/lib/io/socket.dart
@@ -176,8 +176,8 @@
* valid UTF-8 encoded file path.
*
* If [type] is omitted, the [rawAddress] must have a length of either 4 or
- * 16, in which case the type defaults to [InternetAddress.IPv4] or
- * [InternetAddress.IPv6] respectively.
+ * 16, in which case the type defaults to [InternetAddressType.IPv4] or
+ * [InternetAddressType.IPv6] respectively.
*/
external factory InternetAddress.fromRawAddress(Uint8List rawAddress,
{@Since("2.8") InternetAddressType? type});
@@ -472,24 +472,24 @@
/// [RawSocket.setRawOption] to set customize the behaviour of the underlying
/// socket.
///
-/// It allows for fine grained control of the socket options, and its values will
-/// be passed to the underlying platform's implementation of setsockopt and
+/// It allows for fine grained control of the socket options, and its values
+/// will be passed to the underlying platform's implementation of setsockopt and
/// getsockopt.
@Since("2.2")
class RawSocketOption {
/// Creates a RawSocketOption for getRawOption andSetRawOption.
///
/// The level and option arguments correspond to level and optname arguments
- /// on the get/setsockopt native calls.
+ /// on the getsockopt and setsockopt native calls.
///
/// The value argument and its length correspond to the optval and length
/// arguments on the native call.
///
- /// For a [getRawOption] call, the value parameter will be updated after a
- /// successful call (although its length will not be changed).
+ /// For a [RawSocket.getRawOption] call, the value parameter will be updated
+ /// after a successful call (although its length will not be changed).
///
- /// For a [setRawOption] call, the value parameter will be used set the
- /// option.
+ /// For a [RawSocket.setRawOption] call, the value parameter will be used set
+ /// the option.
const RawSocketOption(this.level, this.option, this.value);
/// Convenience constructor for creating an int based RawSocketOption.
diff --git a/sdk/lib/io/stdio.dart b/sdk/lib/io/stdio.dart
index a0034c6..9fc8401 100644
--- a/sdk/lib/io/stdio.dart
+++ b/sdk/lib/io/stdio.dart
@@ -41,7 +41,7 @@
* Blocks until a full line is available.
*
* Lines my be terminated by either `<CR><LF>` or `<LF>`. On Windows in cases
- * where the [stdioType] of stdin is [StdioType.termimal] the terminator may
+ * where the [stdioType] of stdin is [StdioType.terminal] the terminator may
* also be a single `<CR>`.
*
* Input bytes are converted to a string by [encoding].
diff --git a/sdk/lib/js/js.dart b/sdk/lib/js/js.dart
index 26a6141..c97d968 100644
--- a/sdk/lib/js/js.dart
+++ b/sdk/lib/js/js.dart
@@ -229,5 +229,5 @@
///
/// See [allowInterop].
///
-/// When called from Dart, [null] will be passed as the first argument.
+/// When called from Dart, `null` will be passed as the first argument.
external Function allowInteropCaptureThis(Function f);
diff --git a/tools/VERSION b/tools/VERSION
index 54f30f2..7aea38a 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 10
PATCH 0
-PRERELEASE 108
+PRERELEASE 109
PRERELEASE_PATCH 0
\ No newline at end of file
