Version 3.6.0-204.0.dev

Merge 6fd4fa1 into dev

pkg/linter/lib/src/rules/library_annotations.dart

@@ -74,9 +74,8 @@ class _Visitor extends SimpleAstVisitor<void> {
       firstDirective = node.directives.first;
     }
     for (var directive in node.directives) {
-      if (directive is PartDirective) {
-        return;
-      }
+      if (directive is PartOfDirective) return;
+
       if (directive is! LibraryDirective) {
         _check(directive);
       }

pkg/linter/test/rules/always_use_package_imports_test.dart

@@ -57,6 +57,23 @@ import 'package:test/lib.dart';
     await assertNoDiagnosticsIn(result.errors);
   }
 
+  test_samePackage_packageSchema_inPart() async {
+    newFile('$testPackageLibPath/lib.dart', r'''
+class C {}
+''');
+
+    newFile('$testPackageRootPath/test/a.dart', r'''
+part 'test.dart';
+''');
+
+    await assertNoDiagnostics(r'''
+part of 'a.dart';
+
+/// This provides [C].
+import 'package:test/lib.dart';
+''');
+  }
+
   test_samePackage_relativeUri() async {
     newFile('$testPackageLibPath/lib.dart', r'''
 class C {}
@@ -68,4 +85,23 @@ import 'lib.dart';
       lint(30, 10),
     ]);
   }
+
+  test_samePackage_relativeUri_inPart() async {
+    newFile('$testPackageLibPath/lib.dart', r'''
+class C {}
+''');
+
+    newFile('$testPackageRootPath/test/a.dart', r'''
+part 'test.dart';
+''');
+
+    await assertDiagnostics(r'''
+part of 'a.dart';
+
+/// This provides [C].
+import 'lib.dart';
+''', [
+      lint(49, 10),
+    ]);
+  }
 }

pkg/linter/test/rules/avoid_relative_lib_imports_test.dart

@@ -40,4 +40,25 @@ import '../lib/lib.dart';
       lint(30, 17),
     ]);
   }
+
+  test_samePackage_relativeUri_inPart() async {
+    newFile('$testPackageLibPath/lib.dart', r'''
+class C {}
+''');
+
+    newFile('$testPackageRootPath/test/a.dart', r'''
+part 'test.dart';
+''');
+
+    var test = newFile('$testPackageRootPath/test/test.dart', r'''
+part of 'a.dart';
+
+/// This provides [C].
+import '../lib/lib.dart';
+''');
+    var lib2Result = await resolveFile(test.path);
+    await assertDiagnosticsIn(lib2Result.errors, [
+      lint(49, 17),
+    ]);
+  }
 }

pkg/linter/test/rules/library_annotations_test.dart

@@ -128,6 +128,15 @@ class C {}
     );
   }
 
+  test_libraryDirective() async {
+    await assertNoDiagnostics(r'''
+@pragma('dart2js:late:trust')
+library;
+
+class C {}
+''');
+  }
+
   test_mixinDeclaration() async {
     await assertDiagnostics(
       r'''
@@ -138,6 +147,49 @@ mixin M {}
     );
   }
 
+  test_partFile() async {
+    newFile('$testPackageRootPath/lib/part.dart', r'''
+part of 'test.dart';
+''');
+
+    await assertDiagnostics(r'''
+@pragma('dart2js:late:trust')
+
+part 'part.dart';
+
+class C {}
+''', [
+      lint(0, 29),
+    ]);
+  }
+
+  test_partOfFile() async {
+    newFile('$testPackageRootPath/test/part.dart', r'''
+part 'test.dart';
+''');
+
+    await assertNoDiagnostics(r'''
+@pragma('dart2js:late:trust')
+
+part of 'part.dart';
+
+class C {}
+''');
+  }
+
+  test_partOfFile_annotatedPartOf() async {
+    newFile('$testPackageRootPath/test/part.dart', r'''
+part 'test.dart';
+''');
+
+    await assertNoDiagnostics(r'''
+@pragma('dart2js:late:trust')
+part of 'part.dart';
+
+class C {}
+''');
+  }
+
   test_topLevelVariableDeclaration() async {
     await assertDiagnostics(
       r'''

pkg/linter/test/rules/prefer_relative_imports_test.dart

@@ -69,6 +69,25 @@ import 'package:test/lib.dart';
     await assertNoDiagnosticsIn(result.errors);
   }
 
+  test_samePackage_packageSchema_inPart() async {
+    newFile('$testPackageLibPath/lib.dart', r'''
+class C {}
+''');
+
+    newFile('$testPackageRootPath/test/a.dart', r'''
+part 'test.dart';
+''');
+
+    await assertDiagnostics(r'''
+part of 'a.dart';
+
+/// This provides [C].
+import 'package:test/lib.dart';
+''', [
+      lint(49, 23),
+    ]);
+  }
+
   test_samePackage_relativeUri() async {
     newFile('$testPackageLibPath/lib.dart', r'''
 class C {}

pkg/vm/lib/modular/transformations/ffi/use_sites.dart

@@ -1510,6 +1510,13 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
       return ('', parameterType, argument);
     }
 
+    // If an argument is an invalid expression, ffi don't need to report
+    // any error further, so skipping transformation for its descendants of the
+    // argument by transforming into empty expression (which is invalid)
+    if ((argument is AsExpression && argument.operand is InvalidExpression) ||
+        argument is InvalidExpression) {
+      return ('E', parameterType, InvalidExpression('Invalid Type'));
+    }
     if (argument is InstanceInvocation &&
         argument.interfaceTarget == castMethod &&
         argument.functionType.returnType == parameterType) {

sdk/lib/_internal/vm/bin/vmservice_io.dart

@@ -69,42 +69,16 @@ bool _serveObservatory = false;
 bool _printDtd = false;
 
 // HTTP server.
-Server? server;
-Future<Server>? serverFuture;
-
-Server _lazyServerBoot() {
-  var localServer = server;
-  if (localServer != null) {
-    return localServer;
-  }
-  // Lazily create service.
-  final service = VMService();
-  // Lazily create server.
-  localServer = Server(service, _ip, _port, _originCheckDisabled,
-      _authCodesDisabled, _serviceInfoFilename, _enableServicePortFallback);
-  server = localServer;
-  return localServer;
-}
+late final Server server;
 
 Future<void> cleanupCallback() async {
   // Cancel the sigquit subscription.
-  final signalSubscription = _signalSubscription;
-  if (signalSubscription != null) {
-    await signalSubscription.cancel();
-    _signalSubscription = null;
-  }
-  final localServer = server;
-  if (localServer != null) {
-    try {
-      await localServer.shutdown(true);
-    } catch (e, st) {
-      print('Error in vm-service shutdown: $e\n$st\n');
-    }
-  }
-  final timer = _registerSignalHandlerTimer;
-  if (timer != null) {
-    timer.cancel();
-    _registerSignalHandlerTimer = null;
+  await _signalSubscription?.cancel();
+  _signalSubscription = null;
+  try {
+    await server.shutdown(true);
+  } catch (e, st) {
+    print('Error in vm-service shutdown: $e\n$st\n');
   }
   // Call out to embedder's shutdown callback.
   _shutdown();
@@ -115,12 +89,12 @@ Future<void> ddsConnectedCallback() async {
   _notifyServerState(serviceAddress);
   onServerAddressChange(serviceAddress);
   if (_waitForDdsToAdvertiseService) {
-    await server!.outputConnectionInformation();
+    await server.outputConnectionInformation();
   }
 }
 
 Future<void> ddsDisconnectedCallback() async {
-  final serviceAddress = server!.serverAddress.toString();
+  final serviceAddress = server.serverAddress.toString();
   _notifyServerState(serviceAddress);
   onServerAddressChange(serviceAddress);
 }
@@ -231,15 +205,13 @@ Future<List<Map<String, dynamic>>> listFilesCallback(Uri dirPath) async {
   return result;
 }
 
-Uri? serverInformationCallback() => _lazyServerBoot().serverAddress;
+Uri? serverInformationCallback() => server.serverAddress;
 
-Future<void> _toggleWebServer(Server server) async {
+Future<void> _toggleWebServer() async {
   // Toggle HTTP server.
   if (server.running) {
-    await server.shutdown(true).then((_) async {
-      await VMService().clearState();
-      serverFuture = null;
-    });
+    await server.shutdown(true);
+    await VMService().clearState();
   } else {
     await server.startup();
   }
@@ -249,37 +221,23 @@ Future<Uri?> webServerControlCallback(bool enable, bool? silenceOutput) async {
   if (silenceOutput != null) {
     silentObservatory = silenceOutput;
   }
-  final _server = _lazyServerBoot();
-  if (_server.running != enable) {
-    await _toggleWebServer(_server);
+  if (server.running != enable) {
+    await _toggleWebServer();
   }
-  return _server.serverAddress;
+  return server.serverAddress;
 }
 
 void webServerAcceptNewWebSocketConnections(bool enable) {
-  final _server = _lazyServerBoot();
-  _server.acceptNewWebSocketConnections = enable;
+  server.acceptNewWebSocketConnections = enable;
 }
 
-Future<void> _onSignal(ProcessSignal signal) async {
-  if (serverFuture != null) {
-    // Still waiting.
-    return;
-  }
-  final server = _lazyServerBoot();
-  await _toggleWebServer(server);
-}
-
-Timer? _registerSignalHandlerTimer;
-
 void _registerSignalHandler() {
   if (VMService().isExiting) {
     // If the VM started shutting down we don't want to register this signal
     // handler, otherwise we'll cause the VM to hang after killing the service
     // isolate.
     return;
   }
-  _registerSignalHandlerTimer = null;
   final signalWatch = _signalWatch;
   if (signalWatch == null) {
     // Cannot register for signals.
@@ -289,11 +247,13 @@ void _registerSignalHandler() {
     // Cannot register for signals on Windows or Fuchsia.
     return;
   }
-  _signalSubscription = signalWatch(ProcessSignal.sigquit).listen(_onSignal);
+  _signalSubscription = signalWatch(ProcessSignal.sigquit).listen(
+    (_) => _toggleWebServer(),
+  );
 }
 
 @pragma('vm:entry-point', !const bool.fromEnvironment('dart.vm.product'))
-main() {
+void main() {
   // Set embedder hooks.
   VMServiceEmbedderHooks.cleanup = cleanupCallback;
   VMServiceEmbedderHooks.createTempDir = createTempDirCallback;
@@ -309,22 +269,23 @@ main() {
   VMServiceEmbedderHooks.acceptNewWebSocketConnections =
       webServerAcceptNewWebSocketConnections;
   VMServiceEmbedderHooks.serveObservatory = serveObservatoryCallback;
-  // Always instantiate the vmservice object so that the exit message
-  // can be delivered and waiting loaders can be cancelled.
-  VMService();
+  server = Server(
+    // Always instantiate the vmservice object so that the exit message
+    // can be delivered and waiting loaders can be cancelled.
+    VMService(),
+    _ip,
+    _port,
+    _originCheckDisabled,
+    _authCodesDisabled,
+    _serviceInfoFilename,
+    _enableServicePortFallback,
+  );
+
   if (_autoStart) {
-    assert(server == null);
-    final _server = _lazyServerBoot();
-    assert(!_server.running);
-    _toggleWebServer(_server);
-    // It's just here to push an event on the event loop so that we invoke the
-    // scheduled microtasks.
-    Timer.run(() {});
+    _toggleWebServer();
   }
-  // Register signal handler after a small delay to avoid stalling main
-  // isolate startup.
-  _registerSignalHandlerTimer = Timer(shortDelay, _registerSignalHandler);
+  _registerSignalHandler();
 }
 
 @pragma("vm:external-name", "VMServiceIO_Shutdown")
-external _shutdown();
+external void _shutdown();