[pkg/vm] Native assets validator and synthesizer

Validates a yaml format encoding a native asset mapping, and
synthesizes a component containing a pragma with this information.

Yaml example:

```
format-version: [1,0,0]
native-assets:
  linux_x64:
    'package:foo/foo.dart': ['absolute', '/path/to/libfoo.so']
```

Generated format example:

```
@pragma('vm:ffi:native-assets': {
  'linux_x64' : {
     'package:foo/foo.dart': ['absolute', '/path/to/libfoo.so']
  }
})
library;
```

TEST=pkg/vm/test/native_assets/synthesizer_test.dart
TEST=pkg/vm/test/native_assets/validator_test.dart

In a follow-up CL, we will consume the yaml from `gen_kernel`
and consume the pragma in the VM for `@FfiNative`s.

Bug: #49803
Change-Id: Ie8d93b38ff4406ef7485e5513807e89b2772164b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/272660
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>

Author: dcharkes

pkg/kernel/lib/ast.dart

@@ -14811,10 +14811,12 @@ class Component extends TreeNode {
   Component(
       {CanonicalName? nameRoot,
       List<Library>? libraries,
-      Map<Uri, Source>? uriToSource})
+      Map<Uri, Source>? uriToSource,
+      NonNullableByDefaultCompiledMode? mode})
       : root = nameRoot ?? new CanonicalName.root(),
         libraries = libraries ?? <Library>[],
-        uriToSource = uriToSource ?? <Uri, Source>{} {
+        uriToSource = uriToSource ?? <Uri, Source>{},
+        _mode = mode {
     adoptChildren();
   }
 

pkg/vm/lib/native_assets/diagnostic_message.dart

@@ -0,0 +1,33 @@
+// Copyright (c) 2022, 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:front_end/src/api_unstable/vm.dart';
+
+class NativeAssetsDiagnosticMessage implements DiagnosticMessage {
+  final String message;
+
+  @override
+  final Severity severity;
+
+  NativeAssetsDiagnosticMessage({
+    required this.message,
+    this.severity = Severity.error,
+    this.involvedFiles,
+  });
+
+  @override
+  Iterable<String> get ansiFormatted => [message];
+
+  @override
+  String? get codeName => null;
+
+  @override
+  final List<Uri>? involvedFiles;
+
+  @override
+  Iterable<String> get plainTextFormatted => [message];
+
+  @override
+  String toString() => 'NativeAssetsDiagnosticMessage($message)';
+}

pkg/vm/lib/native_assets/json_to_kernel_constant.dart

@@ -0,0 +1,50 @@
+// Copyright (c) 2022, 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:kernel/kernel.dart';
+
+/// Converts a [jsonObject] into a kernel [Constant].
+///
+/// [jsonObject] must consist only of [double], [int], [String], [List], and
+/// [Map] recurively.
+Constant jsonToKernelConstant(Object jsonObject) {
+  if (jsonObject is int) {
+    return IntConstant(jsonObject);
+  }
+
+  if (jsonObject is double) {
+    return DoubleConstant(jsonObject);
+  }
+
+  if (jsonObject is String) {
+    return StringConstant(jsonObject);
+  }
+
+  if (jsonObject is List) {
+    return ListConstant(
+      DynamicType(),
+      [
+        for (final element in jsonObject)
+          jsonToKernelConstant(element as Object),
+      ],
+    );
+  }
+
+  if (jsonObject is Map) {
+    return MapConstant(
+      DynamicType(),
+      DynamicType(),
+      [
+        for (final entry in jsonObject.entries)
+          ConstantMapEntry(
+            jsonToKernelConstant(entry.key as Object),
+            jsonToKernelConstant(entry.value as Object),
+          )
+      ],
+    );
+  }
+
+  throw UnsupportedError(
+      'Unknown data type: ${jsonObject.runtimeType} $jsonObject');
+}

pkg/vm/lib/native_assets/synthesizer.dart

@@ -0,0 +1,71 @@
+// Copyright (c) 2022, 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:kernel/kernel.dart';
+import 'package:vm/native_assets/validator.dart';
+
+import 'json_to_kernel_constant.dart';
+
+final _dummyFileUri = Uri.parse('dummy');
+
+class NativeAssetsSynthesizer {
+  /// Returns a [Class] that another component may use to refer to
+  /// pragma.
+  ///
+  /// Since uses are of symbolic nature, this class itself doesn't
+  /// have to be serialized - it's needed since kernel AST needs
+  /// non-symbolic AST nodes / References in-memory (when serializing
+  /// they will be string-based, symbolic references)
+  static Class _pragmaClass() {
+    final corelibUri = Uri.parse('dart:core');
+    final pragma = Class(
+      name: 'pragma',
+      fileUri: corelibUri,
+      fields: [
+        Field.immutable(Name('name'), fileUri: _dummyFileUri),
+        Field.immutable(Name('options'), fileUri: _dummyFileUri),
+      ],
+    );
+    Component(
+      libraries: [
+        Library(
+          corelibUri,
+          fileUri: _dummyFileUri,
+          classes: [pragma],
+        )
+      ],
+    );
+    return pragma;
+  }
+
+  /// Synthesizes a [Library] to be included in a kernel snapshot for the VM.
+  ///
+  /// [nativeAssetsYaml] must have been validated with [NativeAssetsValidator].
+  ///
+  /// The VM consumes this component in runtime/vm/ffi/native_assets.cc.
+  static Library synthesizeLibrary(
+    Map nativeAssetsYaml, {
+    nonNullableByDefaultCompiledMode = NonNullableByDefaultCompiledMode.Strong,
+  }) {
+    // We don't need the format-version in the VM.
+    final jsonForVM = nativeAssetsYaml['native-assets'] as Map;
+    final nativeAssetsConstant = jsonToKernelConstant(jsonForVM);
+
+    final pragma = _pragmaClass();
+    final pragmaName = pragma.fields.singleWhere((f) => f.name.text == 'name');
+    final pragmaOptions =
+        pragma.fields.singleWhere((f) => f.name.text == 'options');
+
+    return Library(
+      Uri.parse('vm:ffi:native-assets'),
+      fileUri: _dummyFileUri,
+      annotations: [
+        ConstantExpression(InstanceConstant(pragma.reference, [], {
+          pragmaName.fieldReference: StringConstant('vm:ffi:native-assets'),
+          pragmaOptions.fieldReference: nativeAssetsConstant,
+        }))
+      ],
+    )..nonNullableByDefaultCompiledMode = nonNullableByDefaultCompiledMode;
+  }
+}