Version 3.1.0-19.0.dev

Merge 22d666d into dev

DEPS

@@ -73,7 +73,7 @@ vars = {
   # The list of revisions for these tools comes from Fuchsia, here:
   # https://fuchsia.googlesource.com/integration/+/HEAD/toolchain
   # If there are problems with the toolchain, contact fuchsia-toolchain@.
-  "clang_version": "git_revision:fa3cb517e4a569ff075c98bb6d037abf38b88202",
+  "clang_version": "git_revision:e8cfbfd05a951b85f80156dffc8eeecb34c7271c",
   "gn_version": "git_revision:ffeea1b1fd070cb6a8d47154a03f8523486b50a7",
 
   # Update from https://chrome-infra-packages.appspot.com/p/fuchsia/sdk/gn

build/shim_headers.gni

@@ -0,0 +1,36 @@
+# Copyright 2016 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+template("shim_headers") {
+  action_name = "gen_${target_name}"
+  config_name = "${target_name}_config"
+  shim_headers_path = "${root_gen_dir}/shim_headers/${target_name}"
+  config(config_name) {
+    include_dirs = [ shim_headers_path ]
+  }
+  action(action_name) {
+    script = "//tools/generate_shim_headers.py"
+    args = [
+      "--generate",
+      "--headers-root",
+      rebase_path(invoker.root_path),
+      "--output-directory",
+      rebase_path(shim_headers_path),
+    ]
+    if (defined(invoker.prefix)) {
+      args += [
+        "--prefix",
+        invoker.prefix,
+      ]
+    }
+    args += invoker.headers
+    outputs = []
+    foreach(h, invoker.headers) {
+      outputs += [ shim_headers_path + "/" + rebase_path(invoker.root_path,"//") + "/" + h ]
+    }
+  }
+  group(target_name) {
+    deps = [ ":${action_name}" ]
+    all_dependent_configs = [ ":${config_name}" ]
+  }
+}

pkg/_fe_analyzer_shared/benchmark/macros/serialization_benchmark.dart

@@ -8,6 +8,7 @@ import 'dart:io';
 import 'dart:isolate';
 import 'dart:typed_data';
 
+import 'package:_fe_analyzer_shared/src/macros/executor/message_grouper.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor/serialization.dart';
 
 void main() async {
@@ -18,7 +19,8 @@ void main() async {
     await withSerializationMode(serializationMode, () async {
       await _isolateSpawnBenchmarks();
       await _isolateSpawnUriBenchmarks();
-      await _separateProcessBenchmarks();
+      await _separateProcessStdioBenchmarks();
+      await _separateProcessSocketBenchmarks();
     });
   }
 }
@@ -127,7 +129,7 @@ Future<void> _isolateSpawnUriBenchmarks() async {
   isolate.kill();
 }
 
-Future<void> _separateProcessBenchmarks() async {
+Future<void> _separateProcessStdioBenchmarks() async {
   Completer? responseCompleter;
 
   var tmpDir = Directory.systemTemp.createTempSync('serialize_bench');
@@ -143,7 +145,11 @@ Future<void> _separateProcessBenchmarks() async {
       process.stderr.listen((event) {
         print('stderr: ${utf8.decode(event)}');
       }),
-      process.stdout.listen((data) {
+      (serializationMode == SerializationMode.jsonServer ||
+                  serializationMode == SerializationMode.jsonClient
+              ? process.stdout
+              : MessageGrouper(process.stdout).messageStream)
+          .listen((data) {
         responseCompleter!.complete(data);
       }),
     ];
@@ -153,6 +159,7 @@ Future<void> _separateProcessBenchmarks() async {
       responseCompleter = Completer();
       var result = serialize();
       if (result is List<int>) {
+        _writeLength(result, process.stdin);
         process.stdin.add(result);
       } else {
         process.stdin.writeln(jsonEncode(result));
@@ -165,13 +172,14 @@ Future<void> _separateProcessBenchmarks() async {
       responseCompleter = Completer();
       var result = serialize();
       if (result is List<int>) {
+        _writeLength(result, process.stdin);
         process.stdin.add(result);
       } else {
         process.stdin.writeln(jsonEncode(result));
       }
       deserialize(await responseCompleter.future);
     }
-    print('Separate process + $serializationMode: ${watch.elapsed}');
+    print('Separate process + Stdio + $serializationMode: ${watch.elapsed}');
 
     listeners.forEach((l) => l.cancel());
     process.kill();
@@ -182,17 +190,114 @@ Future<void> _separateProcessBenchmarks() async {
   }
 }
 
+Future<void> _separateProcessSocketBenchmarks() async {
+  Completer? responseCompleter;
+
+  var tmpDir = Directory.systemTemp.createTempSync('serialize_bench');
+  try {
+    var file = File(tmpDir.uri.resolve('main.dart').toFilePath());
+    file.writeAsStringSync(childProgram(serializationMode));
+
+    ServerSocket serverSocket;
+    // Try an ipv6 address loopback first, and fall back on ipv4.
+    try {
+      serverSocket = await ServerSocket.bind(InternetAddress.loopbackIPv6, 0);
+    } on SocketException catch (_) {
+      serverSocket = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0);
+    }
+
+    Completer<Socket> clientCompleter = Completer();
+    serverSocket.listen((client) {
+      clientCompleter.complete(client);
+    });
+
+    var process = await Process.start(Platform.resolvedExecutable, [
+      '--packages=' + (await Isolate.packageConfig)!.toFilePath(),
+      file.path,
+      serverSocket.address.address,
+      serverSocket.port.toString(),
+    ]);
+    var client = await clientCompleter.future;
+
+    var listeners = <StreamSubscription>[
+      (serializationMode == SerializationMode.jsonServer ||
+                  serializationMode == SerializationMode.jsonClient
+              ? client
+              : MessageGrouper(client).messageStream)
+          .listen((event) {
+        responseCompleter!.complete(event);
+      }),
+      process.stderr.listen((event) {
+        print('stderr: ${utf8.decode(event)}');
+      }),
+      process.stdout.listen((event) {
+        print('stdout: ${utf8.decode(event)}');
+      }),
+    ];
+
+    // warmup
+    for (var i = 0; i < 100; i++) {
+      responseCompleter = Completer();
+      var result = serialize();
+      if (result is List<int>) {
+        _writeLength(result, client);
+        client.add(result);
+      } else {
+        client.write(jsonEncode(result));
+      }
+      deserialize(await responseCompleter.future);
+    }
+    // measure
+    var watch = Stopwatch()..start();
+    for (var i = 0; i < 100; i++) {
+      responseCompleter = Completer();
+      var result = serialize();
+      if (result is List<int>) {
+        _writeLength(result, client);
+        client.add(result);
+      } else {
+        client.write(jsonEncode(result));
+      }
+      deserialize(await responseCompleter.future);
+    }
+    print('Separate process + Socket + $serializationMode: ${watch.elapsed}');
+
+    listeners.forEach((l) => l.cancel());
+    process.kill();
+    await serverSocket.close();
+    await client.close();
+  } catch (e, s) {
+    print('Error running benchmark \n$e\n\n$s');
+  } finally {
+    tmpDir.deleteSync(recursive: true);
+  }
+}
+
+void _writeLength(List<int> result, Sink<List<int>> sink) {
+  int length = (result as Uint8List).lengthInBytes;
+  if (length > 0xffffffff) {
+    throw new StateError('Message was larger than the allowed size!');
+  }
+  sink.add([
+    length >> 24 & 0xff,
+    length >> 16 & 0xff,
+    length >> 8 & 0xff,
+    length & 0xff
+  ]);
+}
+
 String childProgram(SerializationMode mode) => '''
       import 'dart:convert';
       import 'dart:io';
       import 'dart:isolate';
       import 'dart:typed_data';
 
+      import 'package:_fe_analyzer_shared/src/macros/executor/message_grouper.dart';
       import 'package:_fe_analyzer_shared/src/macros/executor/serialization.dart';
 
-      void main(_, [SendPort? sendPort]) {
+      void main(List<String> args, [SendPort? sendPort]) async {
         var mode = $mode;
-        withSerializationMode(mode, () {
+        await withSerializationMode(mode, () async {
           if (sendPort != null) {
               var isolateReceivePort = ReceivePort();
               isolateReceivePort.listen((data) {
@@ -204,11 +309,29 @@ String childProgram(SerializationMode mode) => '''
                 sendPort.send(result);
               });
               sendPort.send(isolateReceivePort.sendPort);
+          } else if (args.isNotEmpty) {
+            var address = args[0];
+            var port = int.parse(args[1]);
+            var socket = await Socket.connect(address, port);
+            if (mode == SerializationMode.jsonClient || mode == SerializationMode.jsonServer) {
+              socket.listen((data) {
+                var json = utf8.decode(data).trimRight();
+                deserialize(jsonDecode(json));
+                socket.write(jsonEncode(serialize()));
+              });
+            } else {
+              MessageGrouper(socket).messageStream.listen((data) {
+                deserialize(data);
+                var result = serialize() as Uint8List;
+                _writeLength(result, socket);
+                socket.add(result);
+              });
+            }
           } else {
             // We allow one empty line to work around some weird data.
             var allowEmpty = true;
-            stdin.listen((data) {
-              if (mode == SerializationMode.jsonClient || mode == SerializationMode.jsonServer) {
+            if (mode == SerializationMode.jsonClient || mode == SerializationMode.jsonServer) {
+              stdin.listen((data) {
                 var json = utf8.decode(data).trimRight();
                 // On exit we tend to get extra empty lines sometimes?
                 if (json.isEmpty && allowEmpty) {
@@ -217,11 +340,15 @@ String childProgram(SerializationMode mode) => '''
                 }
                 deserialize(jsonDecode(json));
                 stdout.write(jsonEncode(serialize()));
-              } else {
+              });
+            } else {
+              MessageGrouper(stdin).messageStream.listen((data) {
                 deserialize(data);
-                stdout.add(serialize() as List<int>);
-              }
-            });
+                var result = serialize() as Uint8List;
+                _writeLength(result, stdout);
+                stdout.add(result);
+              });
+            }
           }
         });
       }
@@ -263,6 +390,19 @@ String childProgram(SerializationMode mode) => '''
             ..moveNext()
             ..checkNull();
         }
+      }
+
+      void _writeLength(Uint8List result, Sink<List<int>> sink) {
+        int length = result.lengthInBytes;
+        if (length > 0xffffffff) {
+          throw new StateError('Message was larger than the allowed size!');
+        }
+        sink.add([
+          length >> 24 & 0xff,
+          length >> 16 & 0xff,
+          length >> 8 & 0xff,
+          length & 0xff
+        ]);
       }''';
 
 Object? serialize() {

pkg/analyzer/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 5.11.0-dev
+* Removed `@experimental` from AST nodes and elements for records and patterns.
+
 ## 5.10.0
 * Added `DartType.isDartCoreType`.